Feat: adjust compendium for per-avs deployment

script/AVSContractsDeploy.s.sol

@@ -19,10 +19,8 @@ import "eigenlayer-contracts/src/contracts/pods/EigenPodManager.sol";
 import "eigenlayer-contracts/src/contracts/pods/DelayedWithdrawalRouter.sol";
 
 import "eigenlayer-contracts/src/contracts/permissions/PauserRegistry.sol";
-import "src/BLSPublicKeyCompendium.sol";
 
 import "eigenlayer-contracts/src/test/mocks/EmptyContract.sol";
-import "eigenlayer-contracts/src/test/mocks/ETHDepositMock.sol";
 import "eigenlayer-contracts/src/test/mocks/ERC20Mock.sol";
 
 import "forge-std/Script.sol";

script/DeploySharedContracts.s.sol

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: BUSL-1.1
 pragma solidity =0.8.12;
 
-import "../src/BLSPublicKeyCompendium.sol";
 import "../src/OperatorStateRetriever.sol";
 
 import "forge-std/Script.sol";
@@ -15,26 +14,24 @@ import "forge-std/Test.sol";
 contract DeploySharedContracts is Script, Test {
     Vm cheats = Vm(HEVM_ADDRESS);
 
-    BLSPublicKeyCompendium public blsPublicKeyCompendium;
     OperatorStateRetriever public blsOperatorStateRetriever;
 
     function run() external {
         vm.startBroadcast();
-        blsPublicKeyCompendium = new BLSPublicKeyCompendium();
         blsOperatorStateRetriever = new OperatorStateRetriever();
         vm.stopBroadcast();
 
         string memory deployed_addresses = "addresses";
-        vm.serializeAddress(
+        // vm.serializeAddress(
+        //     deployed_addresses,
+        //     "blsOperatorStateRetriever",
+        //     address(blsOperatorStateRetriever)
+        // );
+        string memory finalJson = vm.serializeAddress(
             deployed_addresses,
             "blsOperatorStateRetriever",
             address(blsOperatorStateRetriever)
         );
-        string memory finalJson = vm.serializeAddress(
-            deployed_addresses,
-            "blsPublicKeyCompendium",
-            address(blsPublicKeyCompendium)
-        );
         vm.writeJson(finalJson, outputFileName());
     }
 

src/BLSApkRegistry.sol

@@ -3,7 +3,6 @@ pragma solidity =0.8.12;
 
 import {BLSApkRegistryStorage} from "src/BLSApkRegistryStorage.sol";
 
-import {IBLSPublicKeyCompendium} from "src/interfaces/IBLSPublicKeyCompendium.sol";
 import {IRegistryCoordinator} from "src/interfaces/IRegistryCoordinator.sol";
 
 import {BN254} from "src/libraries/BN254.sol";
@@ -20,11 +19,10 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
         _;
     }
 
-    /// @notice Sets the (immutable) `registryCoordinator` and `pubkeyCompendium` addresses
+    /// @notice Sets the (immutable) `registryCoordinator` address
     constructor(
-        IRegistryCoordinator _registryCoordinator, 
-        IBLSPublicKeyCompendium _pubkeyCompendium
-    ) BLSApkRegistryStorage(_registryCoordinator, _pubkeyCompendium) {}
+        IRegistryCoordinator _registryCoordinator
+    ) BLSApkRegistryStorage(_registryCoordinator) {}
 
     /*******************************************************************************
                       EXTERNAL FUNCTIONS - REGISTRY COORDINATOR
@@ -46,8 +44,8 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
         address operator,
         bytes memory quorumNumbers
     ) public virtual onlyRegistryCoordinator returns (bytes32) {
-        // Get the operator's pubkey from the compendium. Reverts if they have not registered a key
-        (BN254.G1Point memory pubkey, bytes32 pubkeyHash) = pubkeyCompendium.getRegisteredPubkey(operator);
+        // Get the operator's pubkey. Reverts if they have not registered a key
+        (BN254.G1Point memory pubkey, bytes32 pubkeyHash) = getRegisteredPubkey(operator);
 
         // Update each quorum's aggregate pubkey
         _processQuorumApkUpdate(quorumNumbers, pubkey);
@@ -73,8 +71,8 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
         address operator,
         bytes memory quorumNumbers
     ) public virtual onlyRegistryCoordinator {
-        // Get the operator's pubkey from the compendium. Reverts if they have not registered a key
-        (BN254.G1Point memory pubkey, ) = pubkeyCompendium.getRegisteredPubkey(operator);
+        // Get the operator's pubkey. Reverts if they have not registered a key
+        (BN254.G1Point memory pubkey, ) = getRegisteredPubkey(operator);
 
         // Update each quorum's aggregate pubkey
         _processQuorumApkUpdate(quorumNumbers, pubkey.negate());
@@ -95,6 +93,60 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
         }));
     }
 
+    /**
+     * @notice Called by an operator to register themselves as the owner of a BLS public key and reveal their G1 and G2 public key.
+     * @param signedMessageHash is the registration message hash signed by the private key of the operator
+     * @param pubkeyG1 is the corresponding G1 public key of the operator 
+     * @param pubkeyG2 is the corresponding G2 public key of the operator
+     */
+    function registerBLSPublicKey(
+        BN254.G1Point memory signedMessageHash, 
+        BN254.G1Point memory pubkeyG1, 
+        BN254.G2Point memory pubkeyG2
+    ) external {
+        bytes32 pubkeyHash = BN254.hashG1Point(pubkeyG1);
+        require(
+            pubkeyHash != ZERO_PK_HASH, "BLSApkRegistry.registerBLSPublicKey: cannot register zero pubkey"
+        );
+        require(
+            operatorToPubkeyHash[msg.sender] == bytes32(0),
+            "BLSApkRegistry.registerBLSPublicKey: operator already registered pubkey"
+        );
+        require(
+            pubkeyHashToOperator[pubkeyHash] == address(0),
+            "BLSApkRegistry.registerBLSPublicKey: public key already registered"
+        );
+
+        // H(m) 
+        BN254.G1Point memory messageHash = getMessageHash(msg.sender);
+
+        // gamma = h(sigma, P, P', H(m))
+        uint256 gamma = uint256(keccak256(abi.encodePacked(
+            signedMessageHash.X, 
+            signedMessageHash.Y, 
+            pubkeyG1.X, 
+            pubkeyG1.Y, 
+            pubkeyG2.X, 
+            pubkeyG2.Y, 
+            messageHash.X, 
+            messageHash.Y
+        ))) % BN254.FR_MODULUS;
+
+        // e(sigma + P * gamma, [-1]_2) = e(H(m) + [1]_1 * gamma, P') 
+        require(BN254.pairing(
+            signedMessageHash.plus(pubkeyG1.scalar_mul(gamma)),
+            BN254.negGeneratorG2(),
+            messageHash.plus(BN254.generatorG1().scalar_mul(gamma)),
+            pubkeyG2
+        ), "BLSApkRegistry.registerBLSPublicKey: either the G1 signature is wrong, or G1 and G2 private key do not match");
+
+        operatorToPubkey[msg.sender] = pubkeyG1;
+        operatorToPubkeyHash[msg.sender] = pubkeyHash;
+        pubkeyHashToOperator[pubkeyHash] = msg.sender;
+
+        emit NewPubkeyRegistration(msg.sender, pubkeyG1, pubkeyG2);
+    }
+
     /*******************************************************************************
                             INTERNAL FUNCTIONS
     *******************************************************************************/
@@ -148,6 +200,34 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
     /*******************************************************************************
                             VIEW FUNCTIONS
     *******************************************************************************/
+    /**
+     * @notice Returns the pubkey and pubkey hash of an operator
+     * @dev Reverts if the operator has not registered a valid pubkey
+     */
+    function getRegisteredPubkey(address operator) public view returns (BN254.G1Point memory, bytes32) {
+        BN254.G1Point memory pubkey = operatorToPubkey[operator];
+        bytes32 pubkeyHash = operatorToPubkeyHash[operator];
+
+        require(
+            pubkeyHash != bytes32(0),
+            "BLSApkRegistry.getRegisteredPubkey: operator is not registered"
+        );
+
+        return (pubkey, pubkeyHash);
+    }
+
+    /**
+     * @notice Returns the message hash that an operator must sign to register their BLS public key.
+     * @param operator is the address of the operator registering their BLS public key
+     */
+    function getMessageHash(address operator) public view returns (BN254.G1Point memory) {
+        return BN254.hashToG1(keccak256(abi.encodePacked(
+            operator, 
+            address(this),
+            block.chainid, 
+            "EigenLayer_BN254_Pubkey_Registration"
+        )));
+    }
 
     /**
      * @notice Returns the indices of the quorumApks index at `blockNumber` for the provided `quorumNumbers`
@@ -212,11 +292,10 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
 
     /// @notice Returns the operator address for the given `pubkeyHash`
     function getOperatorFromPubkeyHash(bytes32 pubkeyHash) public view returns (address) {
-        return pubkeyCompendium.pubkeyHashToOperator(pubkeyHash);
+        return pubkeyHashToOperator[pubkeyHash];
     }
 
     function getOperatorId(address operator) public view returns (bytes32) {
-        (, bytes32 pubkeyHash) = pubkeyCompendium.getRegisteredPubkey(operator);
-        return pubkeyHash;
+        return operatorToPubkeyHash[operator];
     }
 }

src/BLSApkRegistryStorage.sol

@@ -3,30 +3,38 @@ pragma solidity =0.8.12;
 
 import {IBLSApkRegistry} from "src/interfaces/IBLSApkRegistry.sol";
 import {IRegistryCoordinator} from "src/interfaces/IRegistryCoordinator.sol";
-import {IBLSPublicKeyCompendium} from "src/interfaces/IBLSPublicKeyCompendium.sol";
 
 import {Initializable} from "@openzeppelin-upgrades/contracts/proxy/utils/Initializable.sol";
 
 import {BN254} from "src/libraries/BN254.sol";
 
 abstract contract BLSApkRegistryStorage is Initializable, IBLSApkRegistry {
+    /// @notice the hash of the zero pubkey aka BN254.G1Point(0,0)
+    bytes32 internal constant ZERO_PK_HASH = hex"ad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5";
+
     /// @notice the registry coordinator contract
     IRegistryCoordinator public immutable registryCoordinator;
-    /// @notice the BLSPublicKeyCompendium contract against which pubkey ownership is checked
-    IBLSPublicKeyCompendium public immutable pubkeyCompendium;
 
+    // storage for individual pubkeys
+    /// @notice maps operator address to pubkey hash
+    mapping(address => bytes32) public operatorToPubkeyHash;
+    /// @notice maps pubkey hash to operator address
+    mapping(bytes32 => address) public pubkeyHashToOperator;
+    /// @notice maps operator address to pubkeyG1
+    mapping(address => BN254.G1Point) public operatorToPubkey;
+
+    // storage for aggregate pubkeys (APKs)
     /// @notice maps quorumNumber => historical aggregate pubkey updates
     mapping(uint8 => ApkUpdate[]) public apkHistory;
     /// @notice maps quorumNumber => current aggregate pubkey of quorum
     mapping(uint8 => BN254.G1Point) public currentApk;
 
-    constructor(IRegistryCoordinator _registryCoordinator, IBLSPublicKeyCompendium _pubkeyCompendium) {
+    constructor(IRegistryCoordinator _registryCoordinator) {
         registryCoordinator = _registryCoordinator;
-        pubkeyCompendium = _pubkeyCompendium;
         // disable initializers so that the implementation contract cannot be initialized
         _disableInitializers();
     }
 
     // storage gap for upgradeability
-    uint256[48] private __GAP;
+    uint256[45] private __GAP;
 }