tests for new gatekeeper logic; except materialize function. actual signatures needed

Signed-off-by: Uncle Fatso <uncle.fatso@ghostchain.io>

src/Gatekeeper.sol

@@ -1,106 +1,237 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.20;
 
+import {IStaking} from "./interfaces/IStaking.sol";
 import {IGatekeeper} from "./interfaces/IGatekeeper.sol";
-import {Metadata} from "./types/Metadata.sol";
+import {IStorageHistory} from "./interfaces/IStorageHistory.sol";
+
+import {StorageHistory} from "./types/StorageHistory.sol";
 import {Weaver} from "./types/Weaver.sol";
 
-contract Gatekeeper is IGatekeeper, Metadata, Weaver {
+import {FullMath} from "./libraries/FullMath.sol";
-    uint256 public constant DIVISOR = 1e6;
+import {Checkpoints} from "./libraries/Checkpoints.sol";
+import {ReentrancyGuard} from "@openzeppelin-contracts/utils/ReentrancyGuard.sol";
+
+contract Gatekeeper is IGatekeeper, Weaver, ReentrancyGuard  {
+    using Checkpoints for Checkpoints.Trace256;
+
+    uint256 private constant COMMISSION_DIVISOR = 2**32;
+    uint256 private constant SECP256K1_N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141;
+    uint256 private constant SECP256K1_Q = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141;
+    uint256 private constant SHIFT_FACTOR = (2**128) % SECP256K1_N;
 
-    uint256 public override existentialDeposit;
-    uint256 public override ghostedSupply;
     address public override staking;
+    address public override storageHistory;
+    uint256 public override existentialDeposit;
 
-    uint256 private _aggregatedPublicKey;
+    address public deployer;
-    mapping(uint256 => mapping(uint256 => bool)) private _executedTransaction;
+    address private _previousAddress;
+
+    Checkpoints.Trace256 private _aggregatedPublicKeys;
+    mapping(bytes32 => RotationState) private _publicKeyMetadatas;
 
     constructor(
-        address _staking,
         uint256 _existentialDeposit,
-        address _previousGatekeeper
+        address _previousGatekeeperAddress
-    ) Metadata(_previousGatekeeper) Weaver(_previousGatekeeper) {
+    ) Weaver(_previousGatekeeperAddress) {
         existentialDeposit = _existentialDeposit;
-        if (_previousGatekeeper != address(0)) {
+
-            IGatekeeper previousGatekeeper = IGatekeeper(_previousGatekeeper);
+        if (_previousGatekeeperAddress != address(0)) {
-            ghostedSupply = previousGatekeeper.ghostedSupply();
+            require(_previousGatekeeperAddress != address(0));
-            staking = previousGatekeeper.staking();
+            require(_previousGatekeeperAddress != address(this));
+            _previousAddress = _previousGatekeeperAddress;
+
+            storageHistory = IGatekeeper(_previousGatekeeperAddress).storageHistory();
+            staking = IGatekeeper(_previousGatekeeperAddress).staking();
         } else {
-            staking = _staking;
+            StorageHistory newStorageHistory = new StorageHistory(msg.sender);
+            storageHistory = address(newStorageHistory);
+            staking = msg.sender;
+            deployer = tx.origin;
         }
     }
 
+    function updatePublicKeyMetadata(uint256 exodusSession, bytes32 publicKey, uint8 parity) external {
+        require(msg.sender == deployer);
+        // TODO: uncomment line below, needed only for testing purposes
+        // and should push to hardcoded exodusSession 0 in any case
+        // deployer = address(0);
+
+        RotationState memory rotationState = RotationState({
+            parity: parity,
+            // forge-lint: disable-next-line(unsafe-typecast)
+            session: uint64(exodusSession)
+        });
+
+        _aggregatedPublicKeys.push(exodusSession, uint256(publicKey));
+        _publicKeyMetadatas[publicKey] = rotationState;
+    }
+
+    function previousAddress() external override view returns (address) {
+        return _previousAddress;
+    }
+
+    function ghostedSupply() external override view returns (uint256) {
+        return IStorageHistory(storageHistory).bridgeImbalance();
+    }
+
+    function latestPublicKeyInfo() external override view returns (bytes32, uint8, uint64) {
+        bytes32 latestPublicKey = bytes32(_aggregatedPublicKeys.latest());
+        RotationState memory state = _publicKeyMetadatas[latestPublicKey];
+        return (latestPublicKey, state.parity, state.session);
+    }
+
+    function getRotationInfoAt(uint256 exodusSession) public override view returns (bytes32, uint8, uint64) {
+        bytes32 publicKey = bytes32(_aggregatedPublicKeys.upperLookup(exodusSession));
+        RotationState memory rotationState = _publicKeyMetadatas[publicKey];
+
+        if (exodusSession < rotationState.session) {
+            return IGatekeeper(_previousAddress).getRotationInfoAt(exodusSession);
+        }
+
+        return (publicKey, rotationState.parity, rotationState.session);
+    }
+
+    function verify(
+        bytes calldata call,
+        bytes calldata nonce,
+        bytes32 s
+    ) external nonReentrant returns (bytes memory) {
+        (bytes32 px, uint8 p) = _extractPublicKey(call);
+
+        uint8 v = p == 0 ? 27 : 28;
+        bytes32 e = _challenge(call, nonce, px, p);
+
+        bytes32 sp = bytes32(SECP256K1_Q - mulmod(uint256(s), uint256(px), SECP256K1_Q));
+        bytes32 ep = bytes32(SECP256K1_Q - mulmod(uint256(e), uint256(px), SECP256K1_Q));
+        address recoveredR = ecrecover(sp, v, px, ep);
+
+        if (sp == 0) revert BadSignature();
+        if (recoveredR == address(0)) revert BadSignature();
+        if (recoveredR != _uncompressedPointToAddress(nonce)) revert BadSignature();
+
+        (bool success, bytes memory data) = address(this).call(call);
+        if (!success) revert ExecutionReverted();
+
+        return data;
+    }
+
     function ghost(bytes32 receiver, uint256 amount) external override returns (uint256) {
         if (msg.sender != staking) revert NotStaking();
         if (amount < existentialDeposit) revert NonExistentAmount();
 
-        ghostedSupply += amount;
+        IStorageHistory(storageHistory).increaseBridgeIn(amount);
-        _metadata.amountIn += uint104(amount); // forge-lint: disable-line(unsafe-typecast)
 
         emit Ghosted(receiver, amount);
-
         return _insertTreeNode(receiver, amount);
     }
 
     function materialize(
-        address receiver,
+        uint256 exodusSession,
         uint256 amount,
-        uint256 rx,
+        uint256 commission,
-        uint256 s
+        address receiver
     ) external override {
-        if (msg.sender != staking) revert NotStaking();
+        if (msg.sender != address(this)) revert NotGatekeeper();
-        _checkTransactionExistence(rx, s);
 
-        bytes4 selector = bytes4(keccak256("materialize(address,uint256)"));
+        StorageHistory(storageHistory).trySetTransactionExecuted(exodusSession);
-        bytes32 message;
+        IStorageHistory(storageHistory).tryIncreaseBridgeOut(amount);
-        assembly {
+
-            let ptr := mload(0x40)
+        uint256 commissionAmount = FullMath.mulDiv(amount, commission, COMMISSION_DIVISOR);
-            mstore(ptr, selector)
+        uint256 receiverAmount = amount - commissionAmount;
-            mstore(add(ptr, 4), receiver)
+        IStaking(staking).materialize(receiver, receiverAmount);
-            mstore(add(ptr, 36), amount)
+
-            message := keccak256(ptr, 68)
+        if (commissionAmount > 0) {
+            IStaking(staking).materialize(tx.origin, commission);
         }
 
-        if (_incorrectSignature(rx, s, message)) revert WrongSignature();
-        ghostedSupply -= amount;
-        _metadata.amountOut += uint104(amount); // forge-lint: disable-line(unsafe-typecast)
         emit Materialized(receiver, amount);
     }
 
     function rotate(
-        uint256 aggregatedPublicKey,
+        uint256 exodusSession,
-        uint256 rx,
+        bytes32 newPublicKey,
-        uint256 s
+        uint8 newParity
     ) external override {
-        _checkTransactionExistence(rx, s);
+        if (msg.sender != address(this)) revert NotGatekeeper();
+        StorageHistory(storageHistory).trySetTransactionExecuted(exodusSession);
 
-        bytes4 selector = bytes4(keccak256("rotate(uint256)"));
+        RotationState memory rotationState = RotationState({
-        bytes32 message;
+            parity: newParity,
+            // forge-lint: disable-next-line(unsafe-typecast)
+            session: uint64(exodusSession)
+        });
+
+        _aggregatedPublicKeys.push(exodusSession, uint256(newPublicKey));
+        _publicKeyMetadatas[newPublicKey] = rotationState;
+
+        emit Rotated(newPublicKey, newParity);
+    }
+
+    function _uncompressedPointToAddress(bytes calldata nonce) internal pure returns (address) {
+        if (nonce.length != 65) revert BadSignature();
+        if (nonce[0] != 0x04) revert BadSignature();
+
+        bytes32 rx = bytes32(nonce[1:33]);
+        bytes32 ry = bytes32(nonce[33:65]);
+
+        return address(uint160(uint256(keccak256(abi.encodePacked(rx, ry)))));
+    }
+
+    function _extractPublicKey(bytes calldata call) internal view returns (bytes32, uint8) {
+        if (call.length < 36) revert InvalidCalldata();
+        uint256 exodusSession;
         assembly {
-            let ptr := mload(0x40)
+            exodusSession := calldataload(add(call.offset, 4))
-            mstore(ptr, selector)
-            mstore(add(ptr, 4), aggregatedPublicKey)
-            message := keccak256(ptr, 36)
         }
 
-        if (_incorrectSignature(rx, s, message)) revert WrongSignature();
+        (bytes32 publicKey, uint8 parity,) = getRotationInfoAt(exodusSession);
-        _aggregatedPublicKey = aggregatedPublicKey;
 
-        emit Rotated(aggregatedPublicKey);
+        return (publicKey, parity);
     }
 
-    function _checkTransactionExistence(uint256 rx, uint256 s) private {
+    function _challenge(
-        if (_executedTransaction[rx][s]) revert AlreadyExecuted();
+        bytes calldata call,
-        _executedTransaction[rx][s] = true;
+        bytes calldata r,
+        bytes32 pk,
+        uint8 v
+    ) internal pure returns (bytes32) {
+        if (r.length != 65) revert BadSignature();
+
+        bytes32 rx = bytes32(r[1:33]);
+        bytes1 rv;
+
+        {
+            bytes32 ry = bytes32(r[33:65]);
+            uint8 rParityByte = (uint256(ry) & 1) == 0 ? 0x02 : 0x03;
+            rv = bytes1(rParityByte);
         }
 
-    function _incorrectSignature(uint256 rx, uint256 s, bytes32 m) private pure returns (bool) {
+        uint8 pv = v == 0 ? 0x02 : 0x03;
-        // no logic below, just to suppress warnings from solc
-        uint256 void = rx;
-        void = s;
-        void = uint256(m);
 
-        // always bad signature for now
+        bytes memory message = abi.encodePacked(rv, rx, pv, pk, call);
-        return true;
+        bytes memory domain = "FROST-secp256k1-SHA256-v1chal";
+        uint8 dstlen = uint8(domain.length);
+
+        bytes32 b0 = sha256(abi.encodePacked(
+            bytes32(0),
+            bytes32(0),
+            message,
+            hex"0030",
+            uint8(0),
+            domain,
+            dstlen
+        ));
+
+        bytes32 b1 = sha256(abi.encodePacked(b0, uint8(1), domain, dstlen));
+        bytes32 b2 = sha256(abi.encodePacked(b0 ^ b1, uint8(2), domain, dstlen));
+
+        uint256 high32 = uint256(b1);
+        uint256 lowPart = uint256(b2) >> 128;
+
+        uint256 highReduced = mulmod(high32, SHIFT_FACTOR, SECP256K1_N);
+        uint256 finalChallenge = addmod(highReduced, lowPart, SECP256K1_N);
+
+        return bytes32(finalChallenge);
     }
 }

src/Staking.sol

@@ -5,13 +5,15 @@ import {SafeERC20} from "@openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol
 import {IERC20} from "@openzeppelin-contracts/token/ERC20/IERC20.sol";
 
 import {GhostWarmup} from "./Warmup.sol";
+import {Gatekeeper} from "./Gatekeeper.sol";
 import {GhostAccessControlled} from "./types/GhostAccessControlled.sol";
 
 import {ISTNK} from "./interfaces/ISTNK.sol";
 import {IGHST} from "./interfaces/IGHST.sol";
-import {IDistributor} from "./interfaces/IDistributor.sol";
 import {IStaking} from "./interfaces/IStaking.sol";
 import {IGatekeeper} from "./interfaces/IGatekeeper.sol";
+import {IDistributor} from "./interfaces/IDistributor.sol";
+import {IStorageHistory} from "./interfaces/IStorageHistory.sol";
 import {IGhostAuthority} from "./interfaces/IGhostAuthority.sol";
 import {IGhostWarmup} from "./interfaces/IGhostWarmup.sol";
 
@@ -42,7 +44,8 @@ contract GhostStaking is IStaking, GhostAccessControlled {
         uint48 _epochLength,
         uint48 _firstEpochNumber,
         uint48 _firstEpochTime,
-        address _authority
+        address _authority,
+        uint256 _existentialDeposit
     ) GhostAccessControlled(IGhostAuthority(_authority)) {
         ftso = _ftso;
         stnk = _stnk;
@@ -57,6 +60,10 @@ contract GhostStaking is IStaking, GhostAccessControlled {
 
         GhostWarmup newWarmup = new GhostWarmup(_ghst);
         warmup = address(newWarmup);
+
+        Gatekeeper newGatekeeper = new Gatekeeper(_existentialDeposit, address(0));
+        gatekeeper = address(newGatekeeper);
+
         _lastRebaseBlock = 1;
     }
 
@@ -149,21 +156,13 @@ contract GhostStaking is IStaking, GhostAccessControlled {
         ISTNK(stnk).safeTransfer(to, balance);
     }
 
-    function ghost(
+    function ghost(bytes32 receiver, uint256 amount) external override {
-        bytes32 receiver,
-        uint256 amount
-    ) external override {
         IGHST(ghst).burn(msg.sender, amount);
         IGatekeeper(gatekeeper).ghost(receiver, amount);
     }
 
-    function materialize(
+    function materialize(address receiver, uint256 amount) external override {
-        address receiver,
+        if (gatekeeper != msg.sender) revert NotGatekeeper();
-        uint256 amount,
-        uint256 rx,
-        uint256 s
-    ) external override {
-        IGatekeeper(gatekeeper).materialize(receiver, amount, rx, s);
         IGHST(ghst).mint(receiver, amount);
     }
 
@@ -200,9 +199,13 @@ contract GhostStaking is IStaking, GhostAccessControlled {
         emit WarmupSet(_warmupPeriod);
     }
 
-    function setGatekeeperAddress(address _gatekeeper) external onlyGovernor {
+    function setGatekeeperAddress(uint256 existentialDeposit) external onlyGovernor {
-        gatekeeper = _gatekeeper;
+        Gatekeeper newGatekeeper = new Gatekeeper(existentialDeposit, gatekeeper);
-        emit GatekeeperSet(_gatekeeper);
+        address storageHistory = IGatekeeper(gatekeeper).storageHistory();
+        IStorageHistory(storageHistory).setOwner(address(newGatekeeper));
+
+        gatekeeper = address(newGatekeeper);
+        emit GatekeeperSet(address(newGatekeeper));
     }
 
     function index() public view override returns (uint256) {

src/interfaces/IGatekeeper.sol

@@ -3,18 +3,30 @@ pragma solidity ^0.8.20;
 
 interface IGatekeeper {
     error NotStaking();
-    error WrongSignature();
+    error NotGatekeeper();
+    error BadSignature();
     error AlreadyExecuted();
     error NonExistentAmount();
+    error InvalidCalldata();
+    error ExecutionReverted();
+
+    struct RotationState {
+        uint8 parity;
+        uint64 session;
+    }
 
     event Ghosted(bytes32 indexed receiver, uint256 indexed amount);
     event Materialized(address indexed receiver, uint256 indexed amount);
-    event Rotated(uint256 indexed aggregatedPublicKey);
+    event Rotated(bytes32 indexed aggregatedPublicKey, uint8 indexed parity);
 
+    function staking() external view returns (address);
+    function storageHistory() external view returns (address);
     function ghostedSupply() external view returns (uint256);
     function existentialDeposit() external view returns (uint256);
-    function staking() external view returns (address);
+    function latestPublicKeyInfo() external view returns (bytes32, uint8, uint64);
+    function getRotationInfoAt(uint256 session) external view returns (bytes32, uint8, uint64);
+
+    function materialize(uint256 session, uint256 amount, uint256 commission, address receiver) external;
+    function rotate(uint256 session, bytes32 publicKey, uint8 parity) external;
     function ghost(bytes32 receiver, uint256 amount) external returns (uint256);
-    function materialize(address receiver, uint256 amount, uint256 rx, uint256 s) external;
-    function rotate(uint256 aggregatedPublicKey, uint256 rx, uint256 s) external;
 }

src/interfaces/IMetadata.sol

@@ -1,12 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.20;
-
-interface IMetadata {
-    struct GatekeeperMetadata {
-        uint48 deployedAt;
-        uint104 amountIn;
-        uint104 amountOut;
-    }
-
-    function metadata() external view returns (GatekeeperMetadata memory);
-}

src/interfaces/IStaking.sol

@@ -5,6 +5,7 @@ interface IStaking {
     error ExternalDepositsLocked();
     error ExternalClaimsLocked();
     error InsufficientBalance();
+    error NotGatekeeper();
 
     event Staked(
         address sender,
@@ -67,7 +68,7 @@ interface IStaking {
     function wrap(address _to, uint256 _amount) external returns (uint256 gBalance_);
     function unwrap(address _to, uint256 _amount) external returns (uint256 sBalance_);
     function ghost(bytes32 receiver, uint256 amount) external;
-    function materialize(address receiver, uint256 amount, uint256 rx, uint256 s) external;
+    function materialize(address receiver, uint256 amount) external;
     function rebase() external returns (uint256);
 
     function index() external view returns (uint256);

src/interfaces/IStorageHistory.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+interface IStorageHistory {
+    struct DeploymentSnapshot {
+        uint48 deployedAt;
+        uint104 amountIn;
+        uint104 amountOut;
+    }
+
+    error NotCreator();
+    error NotDeployer();
+    error AlreadyExecuted();
+    error BridgeOutImpossible();
+
+    function isTransactionExecuted(uint256 session) external view returns (bool);
+    function deploymentSnapshot() external view returns (DeploymentSnapshot memory);
+    function bridgeImbalance() external view returns (uint256);
+
+    function trySetTransactionExecuted(uint256 session) external;
+    function tryIncreaseBridgeOut(uint256 amount) external;
+    function increaseBridgeIn(uint256 amount) external;
+    function setOwner(address newOwner) external;
+}

src/interfaces/IWeaver.sol

@@ -2,8 +2,8 @@
 pragma solidity ^0.8.20;
 
 interface IWeaver {
-    function currentSession() external view returns (uint256);
+    function currentWeavingSession() external view returns (uint256);
-    function startSession() external view returns (uint256);
+    function startWeavingSession() external view returns (uint256);
     function getSlotValues(uint256 globalIndex, uint256 session, uint256 atBlock) external view returns (bytes32[] memory);
     function getProof(uint256 globalIndex, uint256 session, uint256 atBlock) external view returns (bytes32[] memory);
     function getRoot(uint256 session, uint256 atBlock) external view returns (bytes32, uint256);

src/mocks/WeaverMock.sol

@@ -4,7 +4,15 @@ pragma solidity ^0.8.20;
 import {Weaver} from "../types/Weaver.sol";
 
 contract WeaverMock is Weaver {
-    constructor(address previousWeaver) Weaver(previousWeaver) {}
+    address private _previousAddress;
+
+    constructor(address previousWeaver) Weaver(previousWeaver) {
+        _previousAddress = previousWeaver;
+    }
+
+    function previousAddress() external override view returns (address) {
+        return _previousAddress;
+    }
 
     function insertTreeNode(bytes32 receiver, uint256 amount) external returns (uint256) {
         return _insertTreeNode(receiver, amount);

src/types/Metadata.sol

@@ -1,29 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.20;
-
-import {IMetadata} from "../interfaces/IMetadata.sol";
-
-abstract contract Metadata is IMetadata {
-    GatekeeperMetadata internal _metadata;
-
-    constructor(address previosMetadata) {
-        if (previosMetadata == address(0)) {
-            _metadata = GatekeeperMetadata({
-                deployedAt: uint48(block.number),
-                amountIn: 0,
-                amountOut: 0
-            });
-        } else {
-            IMetadata.GatekeeperMetadata memory previousMetadata = IMetadata(previosMetadata).metadata();
-            _metadata = GatekeeperMetadata({
-                deployedAt: previousMetadata.deployedAt,
-                amountIn: previousMetadata.amountIn,
-                amountOut: previousMetadata.amountOut
-            });
-        }
-    }
-
-    function metadata() external view returns (GatekeeperMetadata memory) {
-        return _metadata;
-    }
-}

src/types/StorageHistory.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {IStorageHistory} from "../interfaces/IStorageHistory.sol";
+import {BitMaps} from "@openzeppelin-contracts/utils/structs/BitMaps.sol";
+
+contract StorageHistory is IStorageHistory {
+    using BitMaps for BitMaps.BitMap;
+
+    address private _deployer;
+    address private _currentOwner;
+
+    DeploymentSnapshot private _snapshot;
+    BitMaps.BitMap private _executedTransaction;
+
+    constructor(address deployer) {
+        _currentOwner = msg.sender;
+        _deployer = deployer;
+    }
+
+    function deploymentSnapshot() external override view returns (DeploymentSnapshot memory) {
+        return _snapshot;
+    }
+
+    function bridgeImbalance() public override view returns (uint256) {
+        DeploymentSnapshot memory snapshot = _snapshot;
+        return snapshot.amountIn - snapshot.amountOut;
+    }
+
+    function isTransactionExecuted(uint256 session) external override view returns (bool) {
+        return _executedTransaction.get(session);
+    }
+
+    function trySetTransactionExecuted(uint256 session) external override {
+        if (msg.sender != _currentOwner) revert NotCreator();
+        if (_executedTransaction.get(session)) revert AlreadyExecuted();
+        _executedTransaction.set(session);
+    }
+
+    function setOwner(address newOwner) external override {
+        if (msg.sender != _deployer) revert NotDeployer();
+        _currentOwner = newOwner;
+    }
+
+    function increaseBridgeIn(uint256 amount) external override {
+        if (msg.sender != _currentOwner) revert NotCreator();
+
+        // forge-lint: disable-next-line(unsafe-typecast)
+        _snapshot.amountIn += uint104(amount);
+    }
+
+    function tryIncreaseBridgeOut(uint256 amount) external override {
+        if (msg.sender != _currentOwner) revert NotCreator();
+        if (bridgeImbalance() < amount) revert BridgeOutImpossible();
+
+        // forge-lint: disable-next-line(unsafe-typecast)
+        _snapshot.amountOut += uint104(amount);
+    }
+}

src/types/Weaver.sol

@@ -14,31 +14,31 @@ abstract contract Weaver is IWeaver {
     uint256 public constant SLOTS = 2 ** DEPTH;
     uint256 public constant ENTRIES = DEPTH * SLOTS;
 
-    uint256 public override currentSession;
+    uint256 public override currentWeavingSession;
-    uint256 public override startSession;
+    uint256 public override startWeavingSession;
-    address public previousWeaver;
 
     mapping(uint256 => mapping(uint256 => Checkpoints.Trace256)) internal _treeNodes;
     mapping(uint256 => mapping(uint256 => Checkpoints.Trace160)) internal _slotLenghts;
     mapping(uint256 => mapping(uint256 => bytes32[])) internal _slotValues;
     mapping(uint256 => uint256) internal _filledEntries;
 
-    constructor(address _previousWeaver) {
+    constructor(address _previousAddress) {
-        previousWeaver = _previousWeaver;
+        if (_previousAddress != address(0)) {
-        if (_previousWeaver != address(0)) {
+            uint256 newSession = IWeaver(_previousAddress).currentWeavingSession() + 1;
-            uint256 newSession = IWeaver(_previousWeaver).currentSession() + 1;
+            currentWeavingSession = newSession;
-            currentSession = newSession;
+            startWeavingSession = newSession;
-            startSession = newSession;
         }
     }
 
+    function previousAddress() external virtual view returns (address);
+
     function getSlotValues(
         uint256 globalIndex,
         uint256 session,
         uint256 atBlock
     ) external override view returns (bytes32[] memory) {
-        if (session < startSession) {
+        if (session < startWeavingSession) {
-            return IWeaver(previousWeaver).getSlotValues(globalIndex, session, atBlock);
+            return IWeaver(this.previousAddress()).getSlotValues(globalIndex, session, atBlock);
         }
 
         uint256 slotIndex = globalIndex % SLOTS;
@@ -56,8 +56,8 @@ abstract contract Weaver is IWeaver {
     }
 
     function getRoot(uint256 session, uint256 atBlock) public override view returns (bytes32, uint256) {
-        if (session < startSession) {
+        if (session < startWeavingSession) {
-            return IWeaver(previousWeaver).getRoot(session, atBlock);
+            return IWeaver(this.previousAddress()).getRoot(session, atBlock);
         }
 
         uint256 currentLevelCount = SLOTS >> 1;
@@ -89,7 +89,7 @@ abstract contract Weaver is IWeaver {
             }
         }
 
-        if (session < currentSession) {
+        if (session < currentWeavingSession) {
             unchecked { ++session; }
         }
 
@@ -101,8 +101,8 @@ abstract contract Weaver is IWeaver {
         uint256 session,
         uint256 atBlock
     ) external override view returns (bytes32[] memory) {
-        if (session < startSession) {
+        if (session < startWeavingSession) {
-            return IWeaver(previousWeaver).getProof(globalIndex, session, atBlock);
+            return IWeaver(this.previousAddress()).getProof(globalIndex, session, atBlock);
         }
 
         uint256 currentLevelCount = SLOTS;
@@ -143,11 +143,11 @@ abstract contract Weaver is IWeaver {
     }
 
     function _insertTreeNode(bytes32 who, uint256 amount) internal returns (uint256 globalIndex) {
-        uint256 session = currentSession;
+        uint256 session = currentWeavingSession;
         globalIndex = _filledEntries[session];
         if (globalIndex >= ENTRIES) {
             unchecked { ++session; }
-            currentSession = session;
+            currentWeavingSession = session;
             globalIndex = 0;
         }
 

test/bonding/BondDepositorty.t.sol

@@ -9,7 +9,6 @@ import {GhostAuthority} from "../../src/GhostAuthority.sol";
 import {GhostTreasury} from "../../src/Treasury.sol";
 import {GhostStaking} from "../../src/Staking.sol";
 import {GhostBondDepository} from "../../src/BondDepository.sol";
-import {Gatekeeper} from "../../src/Gatekeeper.sol";
 import {ERC20Mock} from "../../src/mocks/ERC20Mock.sol";
 import {WETH9} from "../../src/mocks/WETH9.sol";
 import {GhostBondingCalculator} from "../../src/StandardBondingCalculator.sol";
@@ -76,7 +75,8 @@ contract GhostBondDepositoryTest is Test {
             EPOCH_LENGTH,
             EPOCH_NUMBER,
             EPOCH_END_TIME,
-            address(authority)
+            address(authority),
+            0
         );
         treasury = new GhostTreasury(address(ftso), 69, address(authority));
         calculator = new GhostBondingCalculator(address(ftso), 1, 1);
@@ -324,8 +324,6 @@ contract GhostBondDepositoryTest is Test {
         uint256 amount = 10_000 * 1e18; // 10,000
 
         vm.startPrank(GOVERNOR);
-        Gatekeeper gatekeeper = new Gatekeeper(address(staking), 0, address(0));
-        staking.setGatekeeperAddress(address(gatekeeper));
         staking.setWarmupPeriod(1);
         vm.stopPrank();
 
@@ -509,8 +507,6 @@ contract GhostBondDepositoryTest is Test {
         }
 
         vm.startPrank(GOVERNOR);
-        Gatekeeper gatekeeper = new Gatekeeper(address(staking), 0, address(0));
-        staking.setGatekeeperAddress(address(gatekeeper));
         staking.setWarmupPeriod(10);
         vm.stopPrank();
 

test/gatekeeper/Gatekeeper.t.sol

@@ -14,7 +14,8 @@ contract GatekeeperTest is Test {
     event Ghosted(bytes32 indexed receiver, uint256 indexed amount);
 
     function setUp() public {
-        gatekeeper = new Gatekeeper(ALICE, EXISTENTIAL, address(0));
+        vm.prank(ALICE, ALICE);
+        gatekeeper = new Gatekeeper(EXISTENTIAL, address(0));
     }
 
     function test_correctInitialization() public {
@@ -25,14 +26,15 @@ contract GatekeeperTest is Test {
         vm.prank(ALICE);
         gatekeeper.ghost(receiver, INIT_AMOUNT);
 
-        Gatekeeper anotherGatekeeper = new Gatekeeper(BOB, EXISTENTIAL, address(gatekeeper));
+        vm.prank(BOB);
+        Gatekeeper anotherGatekeeper = new Gatekeeper(EXISTENTIAL, address(gatekeeper));
         assertEq(anotherGatekeeper.staking(), ALICE);
         assertEq(anotherGatekeeper.ghostedSupply(), INIT_AMOUNT);
         assertEq(anotherGatekeeper.existentialDeposit(), EXISTENTIAL);
     }
 
     function test_ghostTokensWork(uint256 ghostAmount) public {
-        vm.assume(ghostAmount >= EXISTENTIAL);
+        vm.assume(ghostAmount >= EXISTENTIAL && ghostAmount < type(uint96).max);
         bytes32 receiver = bytes32(abi.encodePacked(ALICE));
         uint256 ghostedSupply = gatekeeper.ghostedSupply();
 
@@ -61,14 +63,16 @@ contract GatekeeperTest is Test {
         gatekeeper.ghost(receiver, ghostAmount);
     }
 
-    function test_materializeWork(uint256 ghostAmount) public {
+    // TODO: revisit with actual signatures from the cargo test
-        vm.expectRevert();
+    // function test_materializeWork(uint256 ghostAmount) public {
-        gatekeeper.materialize(ALICE, ghostAmount, 0, 0);
+    //     vm.prank(ALICE);
-    }
+    //     gatekeeper.materialize(0, ghostAmount, 0, ALICE);
+    // }
 
-    function test_rotateWork(uint256 aggregatedPublicKey) public {
+    function test_rotateWork(bytes32 aggregatedPublicKey) public {
-        vm.expectRevert();
+        vm.warp(block.timestamp + 1);
-        gatekeeper.rotate(aggregatedPublicKey, 0, 0);
+        vm.prank(address(gatekeeper));
+        gatekeeper.rotate(block.timestamp, aggregatedPublicKey, 0);
     }
 
     function test_couldNotBridgeBelowExistential(uint256 amount) public {
@@ -80,6 +84,78 @@ contract GatekeeperTest is Test {
         gatekeeper.ghost(receiver, amount);
 
         assertEq(gatekeeper.ghostedSupply(), 0);
+    }
 
+    function test_signatureVerificationsWorks() public {
+        assertEq(gatekeeper.deployer(), ALICE);
+        vm.prank(ALICE);
+        gatekeeper.updatePublicKeyMetadata(0, 0x875cdcba4ae5494518fa2602791e667ca0998402b6a69e5b7cb4c72dba4e4669, 0);
+
+        (bytes32 prevPublicKey, uint8 prevParity, uint64 prevSession) = gatekeeper.latestPublicKeyInfo();
+
+        gatekeeper.verify(
+            hex"49f03a670000000000000000000000000000000000000000000000000000000000000000875cdcba4ae5494518fa2602791e667ca0998402b6a69e5b7cb4c72dba4e46690000000000000000000000000000000000000000000000000000000000000000",
+            hex"044d9fa18df9da04381ed256981570a6ef6a0893496ded966fc994662df931ed423b29e2737394b31d8498594caad7b77e36ab31ac79df3796a1b6f26baa5552ae",
+            0x24029a571fcaeadd14f4afe8be62afe3d07876ae270c3caf446ecb6cfc7c08f2
+        );
+
+        (bytes32 publicKey, uint8 parity, uint64 session) = gatekeeper.latestPublicKeyInfo();
+        assertEq(publicKey, prevPublicKey);
+        assertEq(parity, prevParity);
+        assertEq(session, prevSession);
+
+        vm.expectRevert();
+        gatekeeper.verify(
+            hex"49f03a6700000000000000000000000000000000000000000000000000000000000000023492bc8bb10848f1f788496ccadde7d458eac4ac2c1eca2dd2c7a506d8fa2c5b0000000000000000000000000000000000000000000000000000000000000000",
+            hex"042b45a8909a137e7bab5caf4b2870ece0469c6a4149c10074cfdaf2c114a65daefe14179830c95d07fea439ce78d2ad11898578e5e678dbcb98a7576da9e57c77",
+            0x5a61b59cededac4010b89bc6935e0cb7d975f5e2db457227ee473203de5247ed
+        );
+
+        gatekeeper.verify(
+            hex"49f03a6700000000000000000000000000000000000000000000000000000000000000014e8c1fe96d6737cdabbcc96501d6656b9d0b659b3a528ef507f2d52bef29e1570000000000000000000000000000000000000000000000000000000000000000",
+            hex"04d4c4daeb68bf8e40db4b516ddf3be9dd0f56a81809945e30bf06b7e5b26d1b27c83367de842f00c915f06ab1755dc511a3a3fe213308b5e65c6832d9d9bb3b38",
+            0xd93d1b1613277ddb27df66bdea16d7b91adf975eb150e27a872ce035655ec13d
+        );
+
+        (publicKey, parity, session) = gatekeeper.latestPublicKeyInfo();
+        assert(publicKey != prevPublicKey);
+        assertEq(parity, prevParity);
+        assertEq(session, prevSession + 1);
+
+        prevPublicKey = publicKey;
+        prevParity = parity;
+        prevSession = session;
+
+        gatekeeper.verify(
+            hex"49f03a6700000000000000000000000000000000000000000000000000000000000000023492bc8bb10848f1f788496ccadde7d458eac4ac2c1eca2dd2c7a506d8fa2c5b0000000000000000000000000000000000000000000000000000000000000000",
+            hex"042b45a8909a137e7bab5caf4b2870ece0469c6a4149c10074cfdaf2c114a65daefe14179830c95d07fea439ce78d2ad11898578e5e678dbcb98a7576da9e57c77",
+            0x5a61b59cededac4010b89bc6935e0cb7d975f5e2db457227ee473203de5247ed
+        );
+
+        (publicKey, parity, session) = gatekeeper.latestPublicKeyInfo();
+        assert(publicKey != prevPublicKey);
+        assertEq(parity, prevParity);
+        assertEq(session, prevSession + 1);
+
+        vm.expectRevert();
+        gatekeeper.verify(
+            hex"49f03a670000000000000000000000000000000000000000000000000000000000000000875cdcba4ae5494518fa2602791e667ca0998402b6a69e5b7cb4c72dba4e46690000000000000000000000000000000000000000000000000000000000000000",
+            hex"044d9fa18df9da04381ed256981570a6ef6a0893496ded966fc994662df931ed423b29e2737394b31d8498594caad7b77e36ab31ac79df3796a1b6f26baa5552ae",
+            0x24029a571fcaeadd14f4afe8be62afe3d07876ae270c3caf446ecb6cfc7c08f2
+        );
+
+        vm.expectRevert();
+        gatekeeper.verify(
+            hex"49f03a6700000000000000000000000000000000000000000000000000000000000000014e8c1fe96d6737cdabbcc96501d6656b9d0b659b3a528ef507f2d52bef29e1570000000000000000000000000000000000000000000000000000000000000000",
+            hex"04d4c4daeb68bf8e40db4b516ddf3be9dd0f56a81809945e30bf06b7e5b26d1b27c83367de842f00c915f06ab1755dc511a3a3fe213308b5e65c6832d9d9bb3b38",
+            0xd93d1b1613277ddb27df66bdea16d7b91adf975eb150e27a872ce035655ec13d
+        );
+
+        vm.expectRevert();
+        gatekeeper.verify(
+            hex"49f03a6700000000000000000000000000000000000000000000000000000000000000023492bc8bb10848f1f788496ccadde7d458eac4ac2c1eca2dd2c7a506d8fa2c5b0000000000000000000000000000000000000000000000000000000000000000",
+            hex"042b45a8909a137e7bab5caf4b2870ece0469c6a4149c10074cfdaf2c114a65daefe14179830c95d07fea439ce78d2ad11898578e5e678dbcb98a7576da9e57c77",
+            0x5a61b59cededac4010b89bc6935e0cb7d975f5e2db457227ee473203de5247ed
+        );
     }
 }

test/gatekeeper/GatekeeperHistory.t.sol

@@ -0,0 +1,62 @@
+pragma solidity 0.8.20;
+
+import {Test} from "forge-std/Test.sol";
+
+import {Gatekeeper} from "../../src/Gatekeeper.sol";
+import {IStorageHistory} from "../../src/interfaces/IStorageHistory.sol";
+
+contract GatekeeperStorageHistoryTest is Test {
+    address constant ALICE        = 0x0000000000000000000000000000000000000001;
+    address constant BOB          = 0x0000000000000000000000000000000000000002;
+    uint256 constant INIT_AMOUNT  = 69 * 1e18;
+    uint256 constant INIT_GHOSTED = type(uint104).max / 2;
+    uint256 constant EXISTENTIAL  = 0;
+
+    Gatekeeper gatekeeper;
+
+    function setUp() public {
+        vm.prank(ALICE);
+        gatekeeper = new Gatekeeper(EXISTENTIAL, address(0));
+    }
+
+    function test_correctStorageHistoryInitialization() public view {
+        address storageHistory = gatekeeper.storageHistory();
+        IStorageHistory.DeploymentSnapshot memory snapshot = IStorageHistory(storageHistory).deploymentSnapshot();
+
+        assertEq(snapshot.deployedAt, 0);
+        assertEq(snapshot.amountIn, 0);
+        assertEq(snapshot.amountOut, 0);
+        assertEq(gatekeeper.ghostedSupply(), 0);
+    }
+
+    function test_historicalAmountsOnlyIncrease(uint256 ghostAmount) public {
+        vm.assume(ghostAmount > 0 && ghostAmount < INIT_GHOSTED / 2);
+
+        bytes32 receiver = bytes32(abi.encodePacked(ALICE));
+        address storageHistory = gatekeeper.storageHistory();
+
+        IStorageHistory.DeploymentSnapshot memory snapshot = IStorageHistory(storageHistory).deploymentSnapshot();
+        uint104 amountIn = snapshot.amountIn;
+        uint104 amountOut = snapshot.amountOut;
+
+        if (ghostAmount % 2 == 0) {
+            vm.prank(ALICE);
+            gatekeeper.ghost(receiver, ghostAmount);
+            // forge-lint: disable-next-line(unsafe-typecast)
+            amountIn += uint104(ghostAmount);
+        } else {
+            if (IStorageHistory(storageHistory).bridgeImbalance() >= ghostAmount) {
+                vm.prank(ALICE);
+                gatekeeper.materialize(0, ghostAmount, 0, BOB);
+                // forge-lint: disable-next-line(unsafe-typecast)
+                amountOut += uint104(ghostAmount);
+            }
+        }
+
+        IStorageHistory.DeploymentSnapshot memory newSnapshot = IStorageHistory(storageHistory).deploymentSnapshot();
+        assertEq(newSnapshot.amountIn, amountIn);
+        assertEq(newSnapshot.amountOut, amountOut);
+        assertEq(gatekeeper.ghostedSupply(), amountIn - amountOut);
+    }
+
+}

test/gatekeeper/GatekeeperMetadata.t.sol

@@ -1,53 +0,0 @@
-pragma solidity 0.8.20;
-
-import {Test} from "forge-std/Test.sol";
-
-import {Gatekeeper} from "../../src/Gatekeeper.sol";
-
-contract GatekeeperMetadataTest is Test {
-    address constant ALICE        = 0x0000000000000000000000000000000000000001;
-    uint256 constant INIT_AMOUNT  = 69 * 1e18;
-    uint256 constant INIT_GHOSTED = type(uint104).max / 2;
-    uint256 constant EXISTENTIAL  = 0;
-
-    Gatekeeper gatekeeper;
-
-    function setUp() public {
-        gatekeeper = new Gatekeeper(ALICE, EXISTENTIAL, address(0));
-    }
-
-    function test_correctMetadataInitialization() public view {
-        Gatekeeper.GatekeeperMetadata memory metadata = gatekeeper.metadata();
-        assertEq(metadata.deployedAt, block.number);
-        assertEq(metadata.amountIn, 0);
-        assertEq(metadata.amountOut, 0);
-        assertEq(gatekeeper.ghostedSupply(), 0);
-    }
-
-    function test_historicalAmountsOnlyIncrease(uint256 ghostAmount) public {
-        vm.assume(ghostAmount > 0 && ghostAmount < INIT_GHOSTED / 2);
-        bytes32 receiver = bytes32(abi.encodePacked(ALICE));
-        uint256 ghostedSupply = gatekeeper.ghostedSupply();
-
-        Gatekeeper.GatekeeperMetadata memory metadata = gatekeeper.metadata();
-        uint104 amountIn = metadata.amountIn;
-        uint104 amountOut = metadata.amountOut;
-
-        if (ghostAmount % 2 == 0) {
-            vm.prank(ALICE);
-            gatekeeper.ghost(receiver, ghostAmount);
-            amountIn += uint104(ghostAmount); // forge-lint: disable-line(unsafe-typecast)
-            ghostedSupply += ghostAmount;
-        } else {
-            vm.expectRevert();
-            vm.prank(ALICE);
-            gatekeeper.materialize(ALICE, ghostAmount, 0, 0);
-        }
-
-        Gatekeeper.GatekeeperMetadata memory newMetadata = gatekeeper.metadata();
-        assertEq(newMetadata.amountIn, amountIn);
-        assertEq(newMetadata.amountOut, amountOut);
-        assertEq(gatekeeper.ghostedSupply(), ghostedSupply);
-    }
-
-}

test/gatekeeper/GatekeeperWeaver.t.sol

@@ -5,20 +5,37 @@ import {Test} from "forge-std/Test.sol";
 import {Gatekeeper} from "../../src/Gatekeeper.sol";
 import {Hashes} from "../../src/libraries/Hashes.sol";
 import {Checkpoints} from "../../src/libraries/Checkpoints.sol";
+import {IGatekeeper} from "../../src/interfaces/IGatekeeper.sol";
+import {IStorageHistory} from "../../src/interfaces/IStorageHistory.sol";
+
+contract MockStaking {
+    GatekeeperVerification public gatekeeper;
+    address public governor;
+
+    constructor(uint256 existential) {
+        gatekeeper = new GatekeeperVerification(existential, address(0));
+        governor = msg.sender;
+    }
+
+    function ghost(bytes32 receiver, uint256 amount) external returns (uint256) {
+        require(msg.sender == governor);
+        return gatekeeper.ghost(receiver, amount);
+    }
+
+    function createNewGatekeeper(uint256 existential, address previousGatekeeper) external {
+        require(msg.sender == governor);
+        GatekeeperVerification newGatekeeper = new GatekeeperVerification(existential, address(gatekeeper));
+        address storageHistory = IGatekeeper(previousGatekeeper).storageHistory();
+        IStorageHistory(storageHistory).setOwner(address(newGatekeeper));
+        gatekeeper = newGatekeeper;
+    }
+}
 
 contract GatekeeperVerification is Gatekeeper {
     using Checkpoints for Checkpoints.Trace256;
     using Checkpoints for Checkpoints.Trace160;
 
-    constructor(
+    constructor(uint256 existential, address previousWeaver) Gatekeeper(existential, previousWeaver) {}
-        address staking,
-        uint256 existential,
-        address previousWeaver
-    ) Gatekeeper(
-        staking,
-        existential,
-        previousWeaver
-    ) {}
 
     function filledEntries(uint256 session) public view returns (uint256) {
         return _filledEntries[session];
@@ -93,14 +110,17 @@ contract GatekeeperWeaverTest is Test {
     uint256 constant EXISTENTIAL = 1337;
     uint256 constant AMOUNT      = 1 * 1e7;
 
+    MockStaking staking;
     GatekeeperVerification gatekeeper;
 
     function setUp() public {
-        gatekeeper = new GatekeeperVerification(ALICE, EXISTENTIAL, address(0));
+        vm.prank(ALICE);
+        staking = new MockStaking(EXISTENTIAL);
+        gatekeeper = staking.gatekeeper();
     }
 
     function test_insertationWorksAsExpected() public {
-        uint256 currentSession = gatekeeper.currentSession();
+        uint256 currentWeavingSession = gatekeeper.currentWeavingSession();
         uint256 maxCount = gatekeeper.ENTRIES();
         uint256 globalIndex;
 
@@ -108,55 +128,59 @@ contract GatekeeperWeaverTest is Test {
 
         for (uint256 i = 0; i < maxCount; i++) {
             if (i % 5 == 0) { vm.roll(block.number + 1); }
-            globalIndex = _insertWithAssert(currentSession, amounts[i], whos[i]);
+            globalIndex = _insertWithAssert(currentWeavingSession, amounts[i], whos[i]);
-            assertTrue(_verifyProof(globalIndex, currentSession, block.number, amounts[i], whos[i]));
+            assertTrue(_verifyProof(globalIndex, currentWeavingSession, block.number, amounts[i], whos[i]));
         }
 
-        globalIndex = _insertWithAssert(currentSession, amounts[69], whos[69]);
+        globalIndex = _insertWithAssert(currentWeavingSession, amounts[69], whos[69]);
-        uint256 newSession = gatekeeper.currentSession();
+        uint256 newSession = gatekeeper.currentWeavingSession();
 
-        assertEq(currentSession + 1, newSession);
+        assertEq(currentWeavingSession + 1, newSession);
         vm.roll(block.number + 1337);
 
         assertTrue(_verifyProof(globalIndex, newSession, block.number, amounts[69], whos[69]));
-        assertTrue(_verifyProof(0, currentSession, block.number, amounts[0], whos[0]));
+        assertTrue(_verifyProof(0, currentWeavingSession, block.number, amounts[0], whos[0]));
-        assertTrue(_verifyProof(69, currentSession, block.number, amounts[69], whos[69]));
+        assertTrue(_verifyProof(69, currentWeavingSession, block.number, amounts[69], whos[69]));
-        assertTrue(_verifyProof(420, currentSession, block.number, amounts[420], whos[420]));
+        assertTrue(_verifyProof(420, currentWeavingSession, block.number, amounts[420], whos[420]));
-        assertTrue(_verifyProof(1337, currentSession, block.number, amounts[1337], whos[1337]));
+        assertTrue(_verifyProof(1337, currentWeavingSession, block.number, amounts[1337], whos[1337]));
-        assertTrue(_verifyProof(2047, currentSession, block.number, amounts[2047], whos[2047]));
+        assertTrue(_verifyProof(2047, currentWeavingSession, block.number, amounts[2047], whos[2047]));
 
-        assertTrue(_verifyProof(0, currentSession, 100, amounts[0], whos[0]));
+        assertTrue(_verifyProof(0, currentWeavingSession, 100, amounts[0], whos[0]));
-        assertTrue(_verifyProof(69, currentSession, 100, amounts[69], whos[69]));
+        assertTrue(_verifyProof(69, currentWeavingSession, 100, amounts[69], whos[69]));
-        assertTrue(_verifyProof(420, currentSession, 100, amounts[420], whos[420]));
+        assertTrue(_verifyProof(420, currentWeavingSession, 100, amounts[420], whos[420]));
 
         assertFalse(_verifyProof(globalIndex, newSession, 100, amounts[69], whos[69]));
-        assertFalse(_verifyProof(1337, currentSession, 100, amounts[1337], whos[1337]));
+        assertFalse(_verifyProof(1337, currentWeavingSession, 100, amounts[1337], whos[1337]));
-        assertFalse(_verifyProof(2047, currentSession, 100, amounts[2047], whos[2047]));
+        assertFalse(_verifyProof(2047, currentWeavingSession, 100, amounts[2047], whos[2047]));
 
         vm.roll(block.number + 420);
-        gatekeeper = new GatekeeperVerification(ALICE, EXISTENTIAL, address(gatekeeper));
+
-        uint256 finalSession = gatekeeper.currentSession();
+        vm.prank(ALICE);
+        staking.createNewGatekeeper(EXISTENTIAL, address(gatekeeper));
+        gatekeeper = staking.gatekeeper();
+
+        uint256 finalSession = gatekeeper.currentWeavingSession();
 
         for (uint256 i = 0; i < 69; i++) {
             if (i % 2 == 0) { vm.roll(block.number + 1); }
             vm.prank(ALICE);
-            gatekeeper.ghost(whos[i], amounts[i]);
+            staking.ghost(whos[i], amounts[i]);
         }
 
         assertTrue(_verifyProof(globalIndex, newSession, block.number, amounts[69], whos[69]));
-        assertTrue(_verifyProof(0, currentSession, block.number, amounts[0], whos[0]));
+        assertTrue(_verifyProof(0, currentWeavingSession, block.number, amounts[0], whos[0]));
-        assertTrue(_verifyProof(69, currentSession, block.number, amounts[69], whos[69]));
+        assertTrue(_verifyProof(69, currentWeavingSession, block.number, amounts[69], whos[69]));
-        assertTrue(_verifyProof(420, currentSession, block.number, amounts[420], whos[420]));
+        assertTrue(_verifyProof(420, currentWeavingSession, block.number, amounts[420], whos[420]));
-        assertTrue(_verifyProof(1337, currentSession, block.number, amounts[1337], whos[1337]));
+        assertTrue(_verifyProof(1337, currentWeavingSession, block.number, amounts[1337], whos[1337]));
-        assertTrue(_verifyProof(2047, currentSession, block.number, amounts[2047], whos[2047]));
+        assertTrue(_verifyProof(2047, currentWeavingSession, block.number, amounts[2047], whos[2047]));
 
-        assertTrue(_verifyProof(0, currentSession, 100, amounts[0], whos[0]));
+        assertTrue(_verifyProof(0, currentWeavingSession, 100, amounts[0], whos[0]));
-        assertTrue(_verifyProof(69, currentSession, 100, amounts[69], whos[69]));
+        assertTrue(_verifyProof(69, currentWeavingSession, 100, amounts[69], whos[69]));
-        assertTrue(_verifyProof(420, currentSession, 100, amounts[420], whos[420]));
+        assertTrue(_verifyProof(420, currentWeavingSession, 100, amounts[420], whos[420]));
 
         assertFalse(_verifyProof(globalIndex, newSession, 100, amounts[69], whos[69]));
-        assertFalse(_verifyProof(1337, currentSession, 100, amounts[1337], whos[1337]));
+        assertFalse(_verifyProof(1337, currentWeavingSession, 100, amounts[1337], whos[1337]));
-        assertFalse(_verifyProof(2047, currentSession, 100, amounts[2047], whos[2047]));
+        assertFalse(_verifyProof(2047, currentWeavingSession, 100, amounts[2047], whos[2047]));
 
         assertTrue(_verifyProof(0, finalSession, block.number, amounts[0], whos[0]));
         assertTrue(_verifyProof(34, finalSession, block.number, amounts[34], whos[34]));
@@ -191,14 +215,14 @@ contract GatekeeperWeaverTest is Test {
         uint160 prevLength = gatekeeper.slotLengths(session, targetSlot);
 
         vm.prank(ALICE);
-        globalIndex = gatekeeper.ghost(who, amount);
+        globalIndex = staking.ghost(who, amount);
 
-        if (session + 1 == gatekeeper.currentSession()) {
+        if (session + 1 == gatekeeper.currentWeavingSession()) {
             assertEq(prevLength, gatekeeper.DEPTH());
             assertEq(gatekeeper.slotLengths(session + 1, 0), 1);
             assertEq(prevEntries, gatekeeper.ENTRIES());
             assertEq(gatekeeper.filledEntries(session + 1), 1);
-            assertEq(session + 1, gatekeeper.currentSession());
+            assertEq(session + 1, gatekeeper.currentWeavingSession());
 
             session += 1;
             previousHash = bytes32(0);

test/staking/Staking.t.sol

@@ -10,7 +10,6 @@ import {GhostDistributor} from "../../src/StakingDistributor.sol";
 import {GhostTreasury} from "../../src/Treasury.sol";
 import {GhostStaking} from "../../src/Staking.sol";
 import {ERC20Mock} from "../../src/mocks/ERC20Mock.sol";
-import {Gatekeeper} from "../../src/Gatekeeper.sol";
 import {GhostBondingCalculator} from "../../src/StandardBondingCalculator.sol";
 
 import {ITreasury} from "../../src/interfaces/ITreasury.sol";
@@ -61,7 +60,6 @@ contract StakingTest is Test {
     GhostStaking staking;
     GhostTreasury treasury;
     GhostAuthority authority;
-    Gatekeeper gatekeeper;
     GhostBondingCalculator calculator;
 
     uint256 public constant AMOUNT = 69;
@@ -105,12 +103,12 @@ contract StakingTest is Test {
             EPOCH_LENGTH,
             EPOCH_NUMBER,
             EPOCH_END_TIME,
-            address(authority)
+            address(authority),
+            0
         );
         treasury = new GhostTreasury(address(ftso), 69, address(authority));
         stnk.initialize(address(staking), address(treasury), address(ghst));
         ghst.initialize(address(staking));
-        gatekeeper = new Gatekeeper(address(staking), 0, address(0));
         calculator = new GhostBondingCalculator(address(ftso), 1, 1);
         vm.stopPrank();
         vm.roll(block.number + 1);
@@ -588,34 +586,14 @@ contract StakingTest is Test {
         staking.setDistributor(maybeGatekeeper);
     }
 
-    function test_GOVERNORCouldSetGatekeeper(address maybeGatekeeper) public {
+    function test_GOVERNORCouldSetGatekeeper() public {
-        vm.assume(maybeGatekeeper != address(0));
+        address previousGatekeeper = staking.gatekeeper();
-        assertEq(staking.gatekeeper(), address(0));
         vm.prank(GOVERNOR);
-        staking.setGatekeeperAddress(maybeGatekeeper);
+        staking.setGatekeeperAddress(420);
-        assertEq(staking.gatekeeper(), maybeGatekeeper);
+        assert(staking.gatekeeper() != previousGatekeeper);
-    }
-
-    function test_couldNotGhostIfNoGatekeeper() public {
-        assertEq(staking.ghostedSupply(), 0);
-        vm.expectRevert();
-        staking.ghost(bytes32(abi.encodePacked(ALICE)), AMOUNT);
-        assertEq(staking.ghostedSupply(), 0);
-    }
-
-    function test_couldNotMaterializeIfNoGatekeeper() public {
-        assertEq(staking.ghostedSupply(), 0);
-        vm.expectRevert();
-        staking.materialize(ALICE, AMOUNT, 0, 0); // dummy rx and s
-        assertEq(staking.ghostedSupply(), 0);
     }
 
     function test_couldNotGhostTokensIfNoGhst() public {
-        assertEq(staking.gatekeeper(), address(0));
-        vm.prank(GOVERNOR);
-        staking.setGatekeeperAddress(address(gatekeeper));
-        assertEq(staking.gatekeeper(), address(gatekeeper));
-
         assertEq(staking.ghostedSupply(), 0);
         vm.expectRevert();
         vm.prank(ALICE);
@@ -624,11 +602,6 @@ contract StakingTest is Test {
     }
 
     function test_correctlyGhostTokens() public {
-        assertEq(staking.gatekeeper(), address(0));
-        vm.prank(GOVERNOR);
-        staking.setGatekeeperAddress(address(gatekeeper));
-        assertEq(staking.gatekeeper(), address(gatekeeper));
-
         _prepareAndRoll(ALICE, BIG_AMOUNT, true, true);
         uint256 aliceBalance = stnk.balanceOf(ALICE);
 
@@ -650,11 +623,6 @@ contract StakingTest is Test {
     }
 
     function test_ghostTokensEmitsEvent() public {
-        assertEq(staking.gatekeeper(), address(0));
-        vm.prank(GOVERNOR);
-        staking.setGatekeeperAddress(address(gatekeeper));
-        assertEq(staking.gatekeeper(), address(gatekeeper));
-
         _prepareAndRoll(ALICE, BIG_AMOUNT, true, true);
         uint256 aliceBalance = stnk.balanceOf(ALICE);
 
@@ -664,7 +632,7 @@ contract StakingTest is Test {
         vm.stopPrank();
 
         bytes32 receiver = bytes32(abi.encodePacked(ALICE));
-        vm.expectEmit(true, true, true, false, address(gatekeeper));
+        vm.expectEmit(true, true, true, false, staking.gatekeeper());
         emit Ghosted(receiver, ghstBalance);
 
         vm.prank(ALICE);
@@ -672,11 +640,6 @@ contract StakingTest is Test {
     }
 
     function test_breakoutLogicWorks() public {
-        assertEq(staking.gatekeeper(), address(0));
-        vm.prank(GOVERNOR);
-        staking.setGatekeeperAddress(address(gatekeeper));
-        assertEq(staking.gatekeeper(), address(gatekeeper));
-
         uint256 initialIndex = staking.index();
         bytes32 receiver = bytes32(abi.encodePacked(ALICE));
         uint256 rebased = _prepareAndRoll(ALICE, BIG_AMOUNT, false, false);
@@ -697,7 +660,7 @@ contract StakingTest is Test {
             uint256 range = (payout * 3) / 100;
             requestedPayout = (pseudoRandom % range) + 1;
 
-            vm.expectEmit(true, true, true, false, address(gatekeeper));
+            vm.expectEmit(true, true, true, false, staking.gatekeeper());
             emit Ghosted(receiver, requestedPayout);
 
             vm.prank(ALICE);

test/staking/StakingDistributor.t.sol

@@ -61,7 +61,8 @@ contract StakingDistributorTest is Test {
             EPOCH_LENGTH,
             EPOCH_NUMBER,
             EPOCH_END_TIME,
-            address(authority)
+            address(authority),
+            0
         );
         treasury = new GhostTreasury(address(ftso), 69, address(authority));
         calculator = new GhostBondingCalculator(address(ftso), 1, 1);

test/tokens/Ghst.t.sol

@@ -53,7 +53,8 @@ contract GhostTest is
             69,
             1337,
             1337,
-            address(authority)
+            address(authority),
+            0
         );
         stnk.initialize(address(staking), TREASURY, address(ghst));
         ghst.initialize(address(staking));

test/tokens/Stnk.t.sol

@@ -59,7 +59,8 @@ contract StinkyTest is Test, ERC20PermitTest, ERC20AllowanceTest, ERC20TransferT
             69,
             1337,
             1337,
-            address(authority)
+            address(authority),
+            0
         );
         ghst.initialize(address(staking));
         vm.stopPrank();