chore: forge fmt

Author: pakim249CAL

src/BLSApkRegistry.sol

@@ -21,9 +21,11 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
         IRegistryCoordinator _registryCoordinator
     ) BLSApkRegistryStorage(_registryCoordinator) {}
 
-    /*******************************************************************************
-                      EXTERNAL FUNCTIONS - REGISTRY COORDINATOR
-    *******************************************************************************/
+    /**
+     *
+     *                   EXTERNAL FUNCTIONS - REGISTRY COORDINATOR
+     *
+     */
 
     /**
      * @notice Registers the `operator`'s pubkey for the specified `quorumNumbers`.
@@ -41,7 +43,7 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
         bytes memory quorumNumbers
     ) public virtual onlyRegistryCoordinator {
         // Get the operator's pubkey. Reverts if they have not registered a key
-        (BN254.G1Point memory pubkey, ) = getRegisteredPubkey(operator);
+        (BN254.G1Point memory pubkey,) = getRegisteredPubkey(operator);
 
         // Update each quorum's aggregate pubkey
         _processQuorumApkUpdate(quorumNumbers, pubkey);
@@ -67,7 +69,7 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
         bytes memory quorumNumbers
     ) public virtual onlyRegistryCoordinator {
         // Get the operator's pubkey. Reverts if they have not registered a key
-        (BN254.G1Point memory pubkey, ) = getRegisteredPubkey(operator);
+        (BN254.G1Point memory pubkey,) = getRegisteredPubkey(operator);
 
         // Update each quorum's aggregate pubkey
         _processQuorumApkUpdate(quorumNumbers, pubkey.negate());
@@ -78,14 +80,21 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
      * @notice Initializes a new quorum by pushing its first apk update
      * @param quorumNumber The number of the new quorum
      */
-    function initializeQuorum(uint8 quorumNumber) public virtual onlyRegistryCoordinator {
-        require(apkHistory[quorumNumber].length == 0, "BLSApkRegistry.initializeQuorum: quorum already exists");
-
-        apkHistory[quorumNumber].push(ApkUpdate({
-            apkHash: bytes24(0),
-            updateBlockNumber: uint32(block.number),
-            nextUpdateBlockNumber: 0
-        }));
+    function initializeQuorum(
+        uint8 quorumNumber
+    ) public virtual onlyRegistryCoordinator {
+        require(
+            apkHistory[quorumNumber].length == 0,
+            "BLSApkRegistry.initializeQuorum: quorum already exists"
+        );
+
+        apkHistory[quorumNumber].push(
+            ApkUpdate({
+                apkHash: bytes24(0),
+                updateBlockNumber: uint32(block.number),
+                nextUpdateBlockNumber: 0
+            })
+        );
     }
 
     /**
@@ -101,7 +110,8 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
     ) external onlyRegistryCoordinator returns (bytes32 operatorId) {
         bytes32 pubkeyHash = BN254.hashG1Point(params.pubkeyG1);
         require(
-            pubkeyHash != ZERO_PK_HASH, "BLSApkRegistry.registerBLSPublicKey: cannot register zero pubkey"
+            pubkeyHash != ZERO_PK_HASH,
+            "BLSApkRegistry.registerBLSPublicKey: cannot register zero pubkey"
         );
         require(
             operatorToPubkeyHash[operator] == bytes32(0),
@@ -113,24 +123,31 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
         );
 
         // gamma = h(sigma, P, P', H(m))
-        uint256 gamma = uint256(keccak256(abi.encodePacked(
-            params.pubkeyRegistrationSignature.X, 
-            params.pubkeyRegistrationSignature.Y, 
-            params.pubkeyG1.X, 
-            params.pubkeyG1.Y, 
-            params.pubkeyG2.X, 
-            params.pubkeyG2.Y, 
-            pubkeyRegistrationMessageHash.X, 
-            pubkeyRegistrationMessageHash.Y
-        ))) % BN254.FR_MODULUS;
-        
-        // e(sigma + P * gamma, [-1]_2) = e(H(m) + [1]_1 * gamma, P') 
-        require(BN254.pairing(
-            params.pubkeyRegistrationSignature.plus(params.pubkeyG1.scalar_mul(gamma)),
-            BN254.negGeneratorG2(),
-            pubkeyRegistrationMessageHash.plus(BN254.generatorG1().scalar_mul(gamma)),
-            params.pubkeyG2
-        ), "BLSApkRegistry.registerBLSPublicKey: either the G1 signature is wrong, or G1 and G2 private key do not match");
+        uint256 gamma = uint256(
+            keccak256(
+                abi.encodePacked(
+                    params.pubkeyRegistrationSignature.X,
+                    params.pubkeyRegistrationSignature.Y,
+                    params.pubkeyG1.X,
+                    params.pubkeyG1.Y,
+                    params.pubkeyG2.X,
+                    params.pubkeyG2.Y,
+                    pubkeyRegistrationMessageHash.X,
+                    pubkeyRegistrationMessageHash.Y
+                )
+            )
+        ) % BN254.FR_MODULUS;
+
+        // e(sigma + P * gamma, [-1]_2) = e(H(m) + [1]_1 * gamma, P')
+        require(
+            BN254.pairing(
+                params.pubkeyRegistrationSignature.plus(params.pubkeyG1.scalar_mul(gamma)),
+                BN254.negGeneratorG2(),
+                pubkeyRegistrationMessageHash.plus(BN254.generatorG1().scalar_mul(gamma)),
+                params.pubkeyG2
+            ),
+            "BLSApkRegistry.registerBLSPublicKey: either the G1 signature is wrong, or G1 and G2 private key do not match"
+        );
 
         operatorToPubkey[operator] = params.pubkeyG1;
         operatorToPubkeyHash[operator] = pubkeyHash;
@@ -140,18 +157,24 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
         return pubkeyHash;
     }
 
-    /*******************************************************************************
-                            INTERNAL FUNCTIONS
-    *******************************************************************************/
-
-    function _processQuorumApkUpdate(bytes memory quorumNumbers, BN254.G1Point memory point) internal {
+    /**
+     *
+     *                         INTERNAL FUNCTIONS
+     *
+     */
+    function _processQuorumApkUpdate(
+        bytes memory quorumNumbers,
+        BN254.G1Point memory point
+    ) internal {
         BN254.G1Point memory newApk;
 
         for (uint256 i = 0; i < quorumNumbers.length; i++) {
             // Validate quorum exists and get history length
             uint8 quorumNumber = uint8(quorumNumbers[i]);
             uint256 historyLength = apkHistory[quorumNumber].length;
-            require(historyLength != 0, "BLSApkRegistry._processQuorumApkUpdate: quorum does not exist");
+            require(
+                historyLength != 0, "BLSApkRegistry._processQuorumApkUpdate: quorum does not exist"
+            );
 
             // Update aggregate public key for this quorum
             newApk = currentApk[quorumNumber].plus(point);
@@ -165,31 +188,37 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
                 lastUpdate.apkHash = newApkHash;
             } else {
                 lastUpdate.nextUpdateBlockNumber = uint32(block.number);
-                apkHistory[quorumNumber].push(ApkUpdate({
-                    apkHash: newApkHash,
-                    updateBlockNumber: uint32(block.number),
-                    nextUpdateBlockNumber: 0
-                }));
+                apkHistory[quorumNumber].push(
+                    ApkUpdate({
+                        apkHash: newApkHash,
+                        updateBlockNumber: uint32(block.number),
+                        nextUpdateBlockNumber: 0
+                    })
+                );
             }
         }
     }
 
-    /*******************************************************************************
-                            VIEW FUNCTIONS
-    *******************************************************************************/
+    /**
+     *
+     *                         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) {
+    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);
     }
 
@@ -202,13 +231,18 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
         uint256 blockNumber
     ) external view returns (uint32[] memory) {
         uint32[] memory indices = new uint32[](quorumNumbers.length);
-        
+
         for (uint256 i = 0; i < quorumNumbers.length; i++) {
             uint8 quorumNumber = uint8(quorumNumbers[i]);
-            
+
             uint256 quorumApkUpdatesLength = apkHistory[quorumNumber].length;
-            if (quorumApkUpdatesLength == 0 || blockNumber < apkHistory[quorumNumber][0].updateBlockNumber) {
-                revert("BLSApkRegistry.getApkIndicesAtBlockNumber: blockNumber is before the first update");
+            if (
+                quorumApkUpdatesLength == 0
+                    || blockNumber < apkHistory[quorumNumber][0].updateBlockNumber
+            ) {
+                revert(
+                    "BLSApkRegistry.getApkIndicesAtBlockNumber: blockNumber is before the first update"
+                );
             }
 
             // Loop backward through apkHistory until we find an entry that preceeds `blockNumber`
@@ -223,12 +257,17 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
     }
 
     /// @notice Returns the current APK for the provided `quorumNumber `
-    function getApk(uint8 quorumNumber) external view returns (BN254.G1Point memory) {
+    function getApk(
+        uint8 quorumNumber
+    ) external view returns (BN254.G1Point memory) {
         return currentApk[quorumNumber];
     }
 
     /// @notice Returns the `ApkUpdate` struct at `index` in the list of APK updates for the `quorumNumber`
-    function getApkUpdateAtIndex(uint8 quorumNumber, uint256 index) external view returns (ApkUpdate memory) {
+    function getApkUpdateAtIndex(
+        uint8 quorumNumber,
+        uint256 index
+    ) external view returns (ApkUpdate memory) {
         return apkHistory[quorumNumber][index];
     }
 
@@ -256,26 +295,33 @@ contract BLSApkRegistry is BLSApkRegistryStorage {
             "BLSApkRegistry._validateApkHashAtBlockNumber: index too recent"
         );
         require(
-            quorumApkUpdate.nextUpdateBlockNumber == 0 || blockNumber < quorumApkUpdate.nextUpdateBlockNumber,
+            quorumApkUpdate.nextUpdateBlockNumber == 0
+                || blockNumber < quorumApkUpdate.nextUpdateBlockNumber,
             "BLSApkRegistry._validateApkHashAtBlockNumber: not latest apk update"
         );
 
         return quorumApkUpdate.apkHash;
     }
 
     /// @notice Returns the length of ApkUpdates for the provided `quorumNumber`
-    function getApkHistoryLength(uint8 quorumNumber) external view returns (uint32) {
+    function getApkHistoryLength(
+        uint8 quorumNumber
+    ) external view returns (uint32) {
         return uint32(apkHistory[quorumNumber].length);
     }
 
     /// @notice Returns the operator address for the given `pubkeyHash`
-    function getOperatorFromPubkeyHash(bytes32 pubkeyHash) public view returns (address) {
+    function getOperatorFromPubkeyHash(
+        bytes32 pubkeyHash
+    ) public view returns (address) {
         return pubkeyHashToOperator[pubkeyHash];
     }
 
     /// @notice returns the ID used to identify the `operator` within this AVS
     /// @dev Returns zero in the event that the `operator` has never registered for the AVS
-    function getOperatorId(address operator) public view returns (bytes32) {
+    function getOperatorId(
+        address operator
+    ) public view returns (bytes32) {
         return operatorToPubkeyHash[operator];
     }
 

src/BLSApkRegistryStorage.sol

@@ -10,7 +10,8 @@ import {BN254} from "./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";
+    bytes32 internal constant ZERO_PK_HASH =
+        hex"ad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5";
 
     /// @notice the registry coordinator contract
     address public immutable registryCoordinator;
@@ -29,7 +30,9 @@ abstract contract BLSApkRegistryStorage is Initializable, IBLSApkRegistry {
     /// @notice maps quorumNumber => current aggregate pubkey of quorum
     mapping(uint8 => BN254.G1Point) public currentApk;
 
-    constructor(IRegistryCoordinator _registryCoordinator) {
+    constructor(
+        IRegistryCoordinator _registryCoordinator
+    ) {
         registryCoordinator = address(_registryCoordinator);
         // disable initializers so that the implementation contract cannot be initialized
         _disableInitializers();