Impl registry coordinator

src/contracts/interfaces/IBLSPubkeyRegistry.sol

@@ -20,7 +20,13 @@ interface IBLSPubkeyRegistry is IRegistry {
     event PubkeyRemoved(
         address operator,
         BN254.G1Point pubkey
-    );  
+    );
+
+    // Emitted when an operator pubkey is removed from a set of quorums
+    event PubkeyRemoveFromQuorums(
+        address operator, 
+        bytes quorumNumbers
+    );
 
 
     /// @notice Data structure used to track the history of the Aggregate Public Key of all operators
@@ -34,36 +40,36 @@ interface IBLSPubkeyRegistry is IRegistry {
     }
 
     /**
-
      * @notice Registers the `operator`'s pubkey for the specified `quorumNumbers`.
      * @param operator The address of the operator to register.
      * @param quorumNumbers The quorum numbers the operator is registering for, where each byte is an 8 bit integer quorumNumber.
      * @param pubkey The operator's BLS public key.
      * @dev access restricted to the RegistryCoordinator
-     * @dev Preconditions:
+     * @dev Preconditions (these are assumed, not validated in this contract):
      *         1) `quorumNumbers` has no duplicates
      *         2) `quorumNumbers.length` != 0
      *         3) `quorumNumbers` is ordered in ascending order
      *         4) the operator is not already registered
      */
-    function registerOperator(address operator, bytes memory quorumNumbers, BN254.G1Point memory pubkey) external returns(bytes32);
+    function registerOperator(address operator, bytes calldata quorumNumbers, BN254.G1Point memory pubkey) external returns(bytes32);
 
     /**
      * @notice Deregisters the `operator`'s pubkey for the specified `quorumNumbers`.
      * @param operator The address of the operator to deregister.
-     * @param quorumNumbers The quourm numbers the operator is deregistering from, where each byte is an 8 bit integer quorumNumber.
+     * @param completeDeregistration Whether the operator is deregistering from all quorums or just some.
+     * @param quorumNumbers The quorum numbers the operator is deregistering from, where each byte is an 8 bit integer quorumNumber.
      * @param pubkey The public key of the operator.
      * @dev access restricted to the RegistryCoordinator
-     * @dev Preconditions:
+     * @dev Preconditions (these are assumed, not validated in this contract):
      *         1) `quorumNumbers` has no duplicates
      *         2) `quorumNumbers.length` != 0
      *         3) `quorumNumbers` is ordered in ascending order
      *         4) the operator is not already deregistered
      *         5) `quorumNumbers` is the same as the parameter use when registering
      *         6) `pubkey` is the same as the parameter used when registering
      */ 
-    function deregisterOperator(address operator, bytes memory quorumNumbers, BN254.G1Point memory pubkey) external returns(bytes32);
-
+    function deregisterOperator(address operator, bool completeDeregistration, bytes calldata quorumNumbers, BN254.G1Point memory pubkey) external returns(bytes32);
+    
     /// @notice Returns the current APK for the provided `quorumNumber `
     function getApkForQuorum(uint8 quorumNumber) external view returns (BN254.G1Point memory);
 

src/contracts/interfaces/IBLSRegistryCoordinatorWithIndices.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity =0.8.12;
+
+import "./IRegistryCoordinator.sol";
+import "./IStakeRegistry.sol";
+import "./IBLSPubkeyRegistry.sol";
+import "./IIndexRegistry.sol";
+
+/**
+ * @title Minimal interface for the `IBLSStakeRegistryCoordinator` contract.
+ * @author Layr Labs, Inc.
+ */
+interface IBLSRegistryCoordinatorWithIndices is IRegistryCoordinator {
+    // STRUCT
+
+    /**
+     * @notice Data structure for storing operator set params for a given quorum. Specifically the 
+     * `maxOperatorCount` is the maximum number of operators that can be registered for the quorum,
+     * `kickBIPsOfOperatorStake` is the basis points of a new operator needs to have of an operator they are trying to kick from the quorum,
+     * `kickBIPsOfAverageStake` is the basis points of the average stake of the quorum that an operator needs to be below to be kicked,
+     * and `kickBIPsOfTotalStake` is the basis points of the total stake of the quorum that an operator needs to be below to be kicked.
+     */ 
+    struct OperatorSetParam {
+        uint32 maxOperatorCount;
+        uint8 kickBIPsOfOperatorStake;
+        uint8 kickBIPsOfAverageStake;
+        uint8 kickBIPsOfTotalStake;
+    }
+
+    /**
+     * @notice Data structure for the parameters needed to kick an operator from a quorum, used during registration churn.
+     * Specifically the `operator` is the address of the operator to kick, `pubkey` is the BLS public key of the operator,
+     * `operatorIdsToSwap` is the list of operatorIds to swap with the operator being kicked in the indexRegistry,
+     * and `globalOperatorListIndex` is the index of the operator in the global operator list in the indexRegistry.
+     */
+    struct OperatorKickParam {
+        address operator;
+        BN254.G1Point pubkey; 
+        bytes32[] operatorIdsToSwap; // should be a single length array when kicking
+        uint32 globalOperatorListIndex;
+    }
+
+    // EVENTS
+
+    event OperatorSetParamsUpdated(uint8 indexed quorumNumber, OperatorSetParam operatorSetParams);
+
+    /// @notice Returns the operator set params for the given `quorumNumber`
+    function getOperatorSetParams(uint8 quorumNumber) external view returns (OperatorSetParam memory);
+    /// @notice the stake registry for this corrdinator is the contract itself
+    function stakeRegistry() external view returns (IStakeRegistry);
+    /// @notice the BLS Pubkey Registry contract that will keep track of operators' BLS public keys
+    function blsPubkeyRegistry() external view returns (IBLSPubkeyRegistry);
+    /// @notice the Index Registry contract that will keep track of operators' indexes
+    function indexRegistry() external view returns (IIndexRegistry);
+}

src/contracts/interfaces/IIndexRegistry.sol

@@ -4,14 +4,21 @@ pragma solidity =0.8.12;
 import "./IRegistry.sol";
 
 /**
- * @title Interface for a `Registry`-type contract that keeps track of an ordered list of operators for up to 256 quroums.
+ * @title Interface for a `Registry`-type contract that keeps track of an ordered list of operators for up to 256 quorums.
  * @author Layr Labs, Inc.
  */
 interface IIndexRegistry is IRegistry {
+    // EVENTS
+    // emitted when an operator's index in the orderd operator list for the quorum with number `quorumNumber` is updated
+    event QuorumIndexUpdate(bytes32 indexed operatorId, uint8 quorumNumber, uint32 newIndex);
+    // emitted when an operator's index in the global operator list is updated
+    event GlobalIndexUpdate(bytes32 indexed operatorId, uint32 newIndex);
+
     // DATA STRUCTURES
 
-    // struct used to give definitive ordering to operators at each blockNumber
-    struct OperatorIndex {
+    // struct used to give definitive ordering to operators at each blockNumber. 
+    // NOTE: this struct is slightly abused for also storing the total number of operators for each quorum over time
+    struct OperatorIndexUpdate {
         // blockNumber number at which operator index changed
         // note that the operator's index is different *for this block number*, i.e. the *new* index is *inclusive* of this value
         uint32 toBlockNumber;
@@ -20,28 +27,41 @@ interface IIndexRegistry is IRegistry {
     }
 
     /**
-     * @notice Registers the operator with the specified `operatorId` for the quorums specified by `quorumBitmap`.
+     * @notice Registers the operator with the specified `operatorId` for the quorums specified by `quorumNumbers`.
      * @param operatorId is the id of the operator that is being registered
      * @param quorumNumbers is the quorum numbers the operator is registered for
      * @dev access restricted to the RegistryCoordinator
+     * @dev Preconditions (these are assumed, not validated in this contract):
+     *         1) `quorumNumbers` has no duplicates
+     *         2) `quorumNumbers.length` != 0
+     *         3) `quorumNumbers` is ordered in ascending order
+     *         4) the operator is not already registered
      */
-    function registerOperator(bytes32 operatorId, uint8[] memory quorumNumbers) external;
+    function registerOperator(bytes32 operatorId, bytes calldata quorumNumbers) external;
 
     /**
-     * @notice Deregisters the operator with the specified `operatorId` for the quorums specified by `quorumBitmap`.
+     * @notice Deregisters the operator with the specified `operatorId` for the quorums specified by `quorumNumbers`.
      * @param operatorId is the id of the operator that is being deregistered
+     * @param completeDeregistration Whether the operator is deregistering from all quorums or just some.
      * @param quorumNumbers is the quorum numbers the operator is deregistered for
-     * @param quorumToOperatorListIndexes is an array of indexes for each quorum being removed from the quorumToOperatorList mapping
-     * @param globalOperatorListIndex is the index of the operator in the global operator list to be removed
-     * @dev Permissioned by RegistryCoordinator
+     * @param operatorIdsToSwap is the list of operatorIds that have the largest indexes in each of the `quorumNumbers`
+     * they will be swapped with the operator's current index when the operator is removed from the list
+     * @param globalOperatorListIndex is the index of the operator that is to be removed from the list
+     * @dev access restricted to the RegistryCoordinator
+     * @dev Preconditions (these are assumed, not validated in this contract):
+     *         1) `quorumNumbers` has no duplicates
+     *         2) `quorumNumbers.length` != 0
+     *         3) `quorumNumbers` is ordered in ascending order
+     *         4) the operator is not already deregistered
+     *         5) `quorumNumbers` is the same as the parameter use when registering
      */
-    function deregisterOperator(bytes32 operatorId, uint8[] memory quorumNumbers, uint32[] memory quorumToOperatorListIndexes, uint32 globalOperatorListIndex) external;
+    function deregisterOperator(bytes32 operatorId, bool completeDeregistration, bytes calldata quorumNumbers, bytes32[] memory operatorIdsToSwap, uint32 globalOperatorListIndex) external;
 
-    /**
-     * @notice Returns the operator id at the index in the list of all operators for all quorums
-     * @param index is the index of the operator in the array of operators
-     */
-    function totalOperatorList(uint256 index) external view returns (bytes32);
+    /// @notice Returns the _operatorIdToIndexHistory entry for the specified `operatorId` and `quorumNumber` at the specified `index`
+    function getOperatorIndexUpdateOfOperatorIdForQuorumAtIndex(bytes32 operatorId, uint8 quorumNumber, uint32 index) external view returns (OperatorIndexUpdate memory);
+
+    /// @notice Returns the _totalOperatorsHistory entry for the specified `quorumNumber` at the specified `index`
+    function getTotalOperatorsUpdateForQuorumAtIndex(uint8 quorumNumber, uint32 index) external view returns (OperatorIndexUpdate memory);
 
     /**
      * @notice Looks up the `operator`'s index for `quorumNumber` at the specified `blockNumber` using the `index`.

src/contracts/interfaces/IQuorumRegistry.sol

@@ -51,7 +51,7 @@ interface IQuorumRegistry {
         uint96 stake;
     }
 
-    function pubkeyHashToQuorumBitmap(bytes32 pubkeyHash) external view returns (uint256);
+    function pubkeyHashToQuorumBitmap(bytes32 pubkeyHash) external view returns (uint192);
 
     function getLengthOfTotalStakeHistoryForQuorum(uint8 quorumNumber) external view returns (uint256);
 

src/contracts/interfaces/IRegistryCoordinator.sol

@@ -6,14 +6,24 @@ pragma solidity =0.8.12;
  * @author Layr Labs, Inc.
  */
 interface IRegistryCoordinator {
+    // EVENTS
+    /// Emits when an operator is registered
+    event OperatorRegistered(address indexed operator, bytes32 indexed operatorId);
+
+    /// Emits when an operator is deregistered
+    event OperatorDeregistered(address indexed operator, bytes32 indexed operatorId);
+
     // DATA STRUCTURES
-    enum Status
+    enum OperatorStatus
     {
-        // default is inactive
-        INACTIVE,
-        ACTIVE
+        // default is NEVER_REGISTERED
+        NEVER_REGISTERED,
+        REGISTERED,
+        DEREGISTERED
     }
 
+    // STRUCTS
+
     /**
      * @notice Data structure for storing info on operators
      */
@@ -23,15 +33,35 @@ interface IRegistryCoordinator {
         // start taskNumber from which the  operator has been registered
         uint32 fromTaskNumber;
         // indicates whether the operator is actively registered for serving the middleware or not
-        Status status;
+        OperatorStatus status;
     }
 
-    /// @notice Returns the bitmap of the quroums the operator is registered for.
-    function operatorIdToQuorumBitmap(bytes32 pubkeyHash) external view returns (uint256);
+    /**
+     * @notice Data structure for storing info on quorum bitmap updates where the `quorumBitmap` is the bitmap of the 
+     * quorums the operator is registered for starting at (inclusive)`updateBlockNumber` and ending at (exclusive) `nextUpdateBlockNumber`
+     * @dev nextUpdateBlockNumber is initialized to 0 for the latest update
+     */
+    struct QuorumBitmapUpdate {
+        uint32 updateBlockNumber;
+        uint32 nextUpdateBlockNumber;
+        uint192 quorumBitmap;
+    }
+
+    /// @notice Returns the operator struct for the given `operator`
+    function getOperator(address operator) external view returns (Operator memory);
 
-    /// @notice Returns the stored id for the specified `operator`.
+    /// @notice Returns the operatorId for the given `operator`
     function getOperatorId(address operator) external view returns (bytes32);
 
+    /**
+     * @notice Returns the quorum bitmap for the given `operatorId` at the given `blockNumber` via the `index`
+     * @dev reverts if `index` is incorrect 
+     */ 
+    function getQuorumBitmapByOperatorIdAtBlockNumberByIndex(bytes32 operatorId, uint32 blockNumber, uint256 index) external view returns (uint192);
+
+    /// @notice Returns the current quorum bitmap for the given `operatorId`
+    function getCurrentQuorumBitmapByOperatorId(bytes32 operatorId) external view returns (uint192);
+
     /// @notice Returns task number from when `operator` has been registered.
     function getFromTaskNumberForOperator(address operator) external view returns (uint32);
 
@@ -41,9 +71,17 @@ interface IRegistryCoordinator {
     /// @notice Returns the number of registries
     function numRegistries() external view returns (uint256);
 
-    /// @notice registers the sender as an operator for the `quorumNumbers` with additional bytes for registry interaction data
-    function registerOperator(uint8[] memory quorumNumbers, bytes calldata) external returns (bytes32);
+    /**
+     * @notice Registers msg.sender as an operator with the middleware
+     * @param quorumNumbers are the bytes representing the quorum numbers that the operator is registering for
+     * @param registrationData is the data that is decoded to get the operator's registration information
+     */
+    function registerOperatorWithCoordinator(bytes memory quorumNumbers, bytes calldata registrationData) external;
 
-    /// @notice deregisters the sender with additional bytes for registry interaction data
-    function deregisterOperator(bytes calldata) external returns (bytes32);
-}
+    /**
+     * @notice Deregisters the msg.sender as an operator from the middleware
+     * @param quorumNumbers are the bytes representing the quorum numbers that the operator is registered for
+     * @param deregistrationData is the the data that is decoded to get the operator's deregistration information
+     */
+    function deregisterOperatorWithCoordinator(bytes calldata quorumNumbers, bytes calldata deregistrationData) external;
+}