@hyperlane-xyz/core 3.12.2 → 3.13.0

package/README.md

@@ -28,7 +28,7 @@ yarn test
 
 ### Fixtures
 
-Some forge tests may generate fixtures in the [fixtures](./fixtures/) directory. This allows [SDK](../typescript/sdk) tests to leverage forge fuzzing. These are git ignored and should not be committed.
+Some forge tests may generate fixtures. This allows the [SDK](https://github.com/hyperlane-xyz/hyperlane-monorepo/tree/main/typescript/sdk) tests to leverage forge fuzzing. These are git ignored and should not be committed.
 
 ## License
 

package/contracts/avs/ECDSAStakeRegistry.sol

@@ -44,13 +44,14 @@ contract ECDSAStakeRegistry is
         __ECDSAStakeRegistry_init(_serviceManager, _thresholdWeight, _quorum);
     }
 
-    /// @notice Registers a new operator using a provided signature
+    /// @notice Registers a new operator using a provided signature and signing key
     /// @param _operatorSignature Contains the operator's signature, salt, and expiry
+    /// @param _signingKey The signing key to add to the operator's history
     function registerOperatorWithSignature(
-        address _operator,
-        ISignatureUtils.SignatureWithSaltAndExpiry memory _operatorSignature
+        ISignatureUtils.SignatureWithSaltAndExpiry memory _operatorSignature,
+        address _signingKey
     ) external {
-        _registerOperatorWithSig(_operator, _operatorSignature);
+        _registerOperatorWithSig(msg.sender, _operatorSignature, _signingKey);
     }
 
     /// @notice Deregisters an existing operator
@@ -58,6 +59,18 @@ contract ECDSAStakeRegistry is
         _deregisterOperator(msg.sender);
     }
 
+    /**
+     * @notice Updates the signing key for an operator
+     * @dev Only callable by the operator themselves
+     * @param _newSigningKey The new signing key to set for the operator
+     */
+    function updateOperatorSigningKey(address _newSigningKey) external {
+        if (!_operatorRegistered[msg.sender]) {
+            revert OperatorNotRegistered();
+        }
+        _updateOperatorSigningKey(msg.sender, _newSigningKey);
+    }
+
     /**
      * @notice Updates the StakeRegistry's view of one or more operators' stakes adding a new entry in their history of stake checkpoints,
      * @dev Queries stakes from the Eigenlayer core DelegationManager contract
@@ -107,18 +120,18 @@ contract ECDSAStakeRegistry is
 
     /// @notice Verifies if the provided signature data is valid for the given data hash.
     /// @param _dataHash The hash of the data that was signed.
-    /// @param _signatureData Encoded signature data consisting of an array of signers, an array of signatures, and a reference block number.
+    /// @param _signatureData Encoded signature data consisting of an array of operators, an array of signatures, and a reference block number.
     /// @return The function selector that indicates the signature is valid according to ERC1271 standard.
     function isValidSignature(
         bytes32 _dataHash,
         bytes memory _signatureData
     ) external view returns (bytes4) {
         (
-            address[] memory signers,
+            address[] memory operators,
             bytes[] memory signatures,
             uint32 referenceBlock
         ) = abi.decode(_signatureData, (address[], bytes[], uint32));
-        _checkSignatures(_dataHash, signers, signatures, referenceBlock);
+        _checkSignatures(_dataHash, operators, signatures, referenceBlock);
         return IERC1271Upgradeable.isValidSignature.selector;
     }
 
@@ -128,6 +141,37 @@ contract ECDSAStakeRegistry is
         return _quorum;
     }
 
+    /**
+     * @notice Retrieves the latest signing key for a given operator.
+     * @param _operator The address of the operator.
+     * @return The latest signing key of the operator.
+     */
+    function getLastestOperatorSigningKey(
+        address _operator
+    ) external view returns (address) {
+        return address(uint160(_operatorSigningKeyHistory[_operator].latest()));
+    }
+
+    /**
+     * @notice Retrieves the latest signing key for a given operator at a specific block number.
+     * @param _operator The address of the operator.
+     * @param _blockNumber The block number to get the operator's signing key.
+     * @return The signing key of the operator at the given block.
+     */
+    function getOperatorSigningKeyAtBlock(
+        address _operator,
+        uint256 _blockNumber
+    ) external view returns (address) {
+        return
+            address(
+                uint160(
+                    _operatorSigningKeyHistory[_operator].getAtBlock(
+                        _blockNumber
+                    )
+                )
+            );
+    }
+
     /// @notice Retrieves the last recorded weight for a given operator.
     /// @param _operator The address of the operator.
     /// @return uint256 - The latest weight of the operator.
@@ -313,9 +357,11 @@ contract ECDSAStakeRegistry is
 
     /// @dev registers an operator through a provided signature
     /// @param _operatorSignature Contains the operator's signature, salt, and expiry
+    /// @param _signingKey The signing key to add to the operator's history
     function _registerOperatorWithSig(
         address _operator,
-        ISignatureUtils.SignatureWithSaltAndExpiry memory _operatorSignature
+        ISignatureUtils.SignatureWithSaltAndExpiry memory _operatorSignature,
+        address _signingKey
     ) internal virtual {
         if (_operatorRegistered[_operator]) {
             revert OperatorAlreadyRegistered();
@@ -324,6 +370,7 @@ contract ECDSAStakeRegistry is
         _operatorRegistered[_operator] = true;
         int256 delta = _updateOperatorWeight(_operator);
         _updateTotalWeight(delta);
+        _updateOperatorSigningKey(_operator, _signingKey);
         IServiceManager(_serviceManager).registerOperatorToAVS(
             _operator,
             _operatorSignature
@@ -331,6 +378,28 @@ contract ECDSAStakeRegistry is
         emit OperatorRegistered(_operator, _serviceManager);
     }
 
+    /// @dev Internal function to update an operator's signing key
+    /// @param _operator The address of the operator to update the signing key for
+    /// @param _newSigningKey The new signing key to set for the operator
+    function _updateOperatorSigningKey(
+        address _operator,
+        address _newSigningKey
+    ) internal {
+        address oldSigningKey = address(
+            uint160(_operatorSigningKeyHistory[_operator].latest())
+        );
+        if (_newSigningKey == oldSigningKey) {
+            return;
+        }
+        _operatorSigningKeyHistory[_operator].push(uint160(_newSigningKey));
+        emit SigningKeyUpdate(
+            _operator,
+            block.number,
+            _newSigningKey,
+            oldSigningKey
+        );
+    }
+
     /// @notice Updates the weight of an operator and returns the previous and current weights.
     /// @param _operator The address of the operator to update the weight of.
     function _updateOperatorWeight(
@@ -401,30 +470,33 @@ contract ECDSAStakeRegistry is
     /**
      * @notice Common logic to verify a batch of ECDSA signatures against a hash, using either last stake weight or at a specific block.
      * @param _dataHash The hash of the data the signers endorsed.
-     * @param _signers A collection of addresses that endorsed the data hash.
+     * @param _operators A collection of addresses that endorsed the data hash.
      * @param _signatures A collection of signatures matching the signers.
      * @param _referenceBlock The block number for evaluating stake weight; use max uint32 for latest weight.
      */
     function _checkSignatures(
         bytes32 _dataHash,
-        address[] memory _signers,
+        address[] memory _operators,
         bytes[] memory _signatures,
         uint32 _referenceBlock
     ) internal view {
-        uint256 signersLength = _signers.length;
-        address lastSigner;
+        uint256 signersLength = _operators.length;
+        address currentOperator;
+        address lastOperator;
+        address signer;
         uint256 signedWeight;
 
         _validateSignaturesLength(signersLength, _signatures.length);
         for (uint256 i; i < signersLength; i++) {
-            address currentSigner = _signers[i];
+            currentOperator = _operators[i];
+            signer = _getOperatorSigningKey(currentOperator, _referenceBlock);
 
-            _validateSortedSigners(lastSigner, currentSigner);
-            _validateSignature(currentSigner, _dataHash, _signatures[i]);
+            _validateSortedSigners(lastOperator, currentOperator);
+            _validateSignature(signer, _dataHash, _signatures[i]);
 
-            lastSigner = currentSigner;
+            lastOperator = currentOperator;
             uint256 operatorWeight = _getOperatorWeight(
-                currentSigner,
+                currentOperator,
                 _referenceBlock
             );
             signedWeight += operatorWeight;
@@ -474,6 +546,27 @@ contract ECDSAStakeRegistry is
         }
     }
 
+    /// @notice Retrieves the operator weight for a signer, either at the last checkpoint or a specified block.
+    /// @param _operator The operator to query their signing key history for
+    /// @param _referenceBlock The block number to query the operator's weight at, or the maximum uint32 value for the last checkpoint.
+    /// @return The weight of the operator.
+    function _getOperatorSigningKey(
+        address _operator,
+        uint32 _referenceBlock
+    ) internal view returns (address) {
+        if (_referenceBlock >= block.number) {
+            revert InvalidReferenceBlock();
+        }
+        return
+            address(
+                uint160(
+                    _operatorSigningKeyHistory[_operator].getAtBlock(
+                        _referenceBlock
+                    )
+                )
+            );
+    }
+
     /// @notice Retrieves the operator weight for a signer, either at the last checkpoint or a specified block.
     /// @param _signer The address of the signer whose weight is returned.
     /// @param _referenceBlock The block number to query the operator's weight at, or the maximum uint32 value for the last checkpoint.
@@ -482,11 +575,10 @@ contract ECDSAStakeRegistry is
         address _signer,
         uint32 _referenceBlock
     ) internal view returns (uint256) {
-        if (_referenceBlock == type(uint32).max) {
-            return _operatorWeightHistory[_signer].latest();
-        } else {
-            return _operatorWeightHistory[_signer].getAtBlock(_referenceBlock);
+        if (_referenceBlock >= block.number) {
+            revert InvalidReferenceBlock();
         }
+        return _operatorWeightHistory[_signer].getAtBlock(_referenceBlock);
     }
 
     /// @notice Retrieve the total stake weight at a specific block or the latest if not specified.
@@ -496,11 +588,10 @@ contract ECDSAStakeRegistry is
     function _getTotalWeight(
         uint32 _referenceBlock
     ) internal view returns (uint256) {
-        if (_referenceBlock == type(uint32).max) {
-            return _totalWeightHistory.latest();
-        } else {
-            return _totalWeightHistory.getAtBlock(_referenceBlock);
+        if (_referenceBlock >= block.number) {
+            revert InvalidReferenceBlock();
         }
+        return _totalWeightHistory.getAtBlock(_referenceBlock);
     }
 
     /// @notice Retrieves the threshold stake for a given reference block.
@@ -510,11 +601,10 @@ contract ECDSAStakeRegistry is
     function _getThresholdStake(
         uint32 _referenceBlock
     ) internal view returns (uint256) {
-        if (_referenceBlock == type(uint32).max) {
-            return _thresholdWeightHistory.latest();
-        } else {
-            return _thresholdWeightHistory.getAtBlock(_referenceBlock);
+        if (_referenceBlock >= block.number) {
+            revert InvalidReferenceBlock();
         }
+        return _thresholdWeightHistory.getAtBlock(_referenceBlock);
     }
 
     /// @notice Validates that the cumulative stake of signed messages meets or exceeds the required threshold.

package/contracts/avs/ECDSAStakeRegistryStorage.sol

@@ -30,6 +30,10 @@ abstract contract ECDSAStakeRegistryStorage is
     /// @notice Defines the duration after which the stake's weight expires.
     uint256 internal _stakeExpiry;
 
+    /// @notice Maps an operator to their signing key history using checkpoints
+    mapping(address => CheckpointsUpgradeable.History)
+        internal _operatorSigningKeyHistory;
+
     /// @notice Tracks the total stake history over time using checkpoints
     CheckpointsUpgradeable.History internal _totalWeightHistory;
 
@@ -51,5 +55,5 @@ abstract contract ECDSAStakeRegistryStorage is
     // slither-disable-next-line shadowing-state
     /// @dev Reserves storage slots for future upgrades
     // solhint-disable-next-line
-    uint256[42] private __gap;
+    uint256[40] private __gap;
 }

package/contracts/interfaces/avs/vendored/IECDSAStakeRegistryEventsAndErrors.sol

@@ -12,8 +12,6 @@ struct Quorum {
     StrategyParams[] strategies; // An array of strategy parameters to define the quorum
 }
 
-/// part of mock interfaces for vendoring necessary Eigenlayer contracts for the hyperlane AVS
-/// @author Layr Labs, Inc.
 interface IECDSAStakeRegistryEventsAndErrors {
     /// @notice Emitted when the system registers an operator
     /// @param _operator The address of the registered operator
@@ -61,7 +59,19 @@ interface IECDSAStakeRegistryEventsAndErrors {
     /// @notice Emits when setting a new threshold weight.
     event ThresholdWeightUpdated(uint256 _thresholdWeight);
 
+    /// @notice Emitted when an operator's signing key is updated
+    /// @param operator The address of the operator whose signing key was updated
+    /// @param updateBlock The block number at which the signing key was updated
+    /// @param newSigningKey The operator's signing key after the update
+    /// @param oldSigningKey The operator's signing key before the update
+    event SigningKeyUpdate(
+        address indexed operator,
+        uint256 indexed updateBlock,
+        address indexed newSigningKey,
+        address oldSigningKey
+    );
     /// @notice Indicates when the lengths of the signers array and signatures array do not match.
+
     error LengthMismatch();
 
     /// @notice Indicates encountering an invalid length for the signers or signatures array.
@@ -76,6 +86,9 @@ interface IECDSAStakeRegistryEventsAndErrors {
     /// @notice Thrown when missing operators in an update
     error MustUpdateAllOperators();
 
+    /// @notice Reference blocks must be for blocks that have already been confirmed
+    error InvalidReferenceBlock();
+
     /// @notice Indicates operator weights were out of sync and the signed weight exceed the total
     error InvalidSignedWeight();
 

package/contracts/test/ERC20Test.sol

@@ -65,4 +65,16 @@ contract XERC20Test is ERC20Test, IXERC20 {
     function burn(address account, uint256 amount) public override {
         _burn(account, amount);
     }
+
+    function setLimits(
+        address _bridge,
+        uint256 _mintingLimit,
+        uint256 _burningLimit
+    ) external {
+        require(false);
+    }
+
+    function owner() external returns (address) {
+        return address(0x0);
+    }
 }

package/contracts/token/extensions/{HypFiatTokenCollateral.sol → HypFiatToken.sol}

@@ -5,7 +5,7 @@ import {IFiatToken} from "../interfaces/IFiatToken.sol";
 import {HypERC20Collateral} from "../HypERC20Collateral.sol";
 
 // see https://github.com/circlefin/stablecoin-evm/blob/master/doc/tokendesign.md#issuing-and-destroying-tokens
-contract HypFiatTokenCollateral is HypERC20Collateral {
+contract HypFiatToken is HypERC20Collateral {
     constructor(
         address _fiatToken,
         address _mailbox

package/contracts/token/extensions/{HypXERC20Collateral.sol → HypXERC20.sol}

@@ -4,7 +4,7 @@ pragma solidity >=0.8.0;
 import {IXERC20} from "../interfaces/IXERC20.sol";
 import {HypERC20Collateral} from "../HypERC20Collateral.sol";
 
-contract HypXERC20Collateral is HypERC20Collateral {
+contract HypXERC20 is HypERC20Collateral {
     constructor(
         address _xerc20,
         address _mailbox

package/contracts/token/extensions/HypXERC20Lockbox.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {IXERC20Lockbox} from "../interfaces/IXERC20Lockbox.sol";
+import {IXERC20, IERC20} from "../interfaces/IXERC20.sol";
+import {HypERC20Collateral} from "../HypERC20Collateral.sol";
+
+contract HypXERC20Lockbox is HypERC20Collateral {
+    uint256 constant MAX_INT = 2 ** 256 - 1;
+
+    IXERC20Lockbox public immutable lockbox;
+    IXERC20 public immutable xERC20;
+
+    constructor(
+        address _lockbox,
+        address _mailbox
+    ) HypERC20Collateral(address(IXERC20Lockbox(_lockbox).ERC20()), _mailbox) {
+        lockbox = IXERC20Lockbox(_lockbox);
+        xERC20 = lockbox.XERC20();
+
+        // grant infinite approvals to lockbox
+        require(
+            IERC20(wrappedToken).approve(_lockbox, MAX_INT),
+            "erc20 lockbox approve failed"
+        );
+        require(
+            xERC20.approve(_lockbox, MAX_INT),
+            "xerc20 lockbox approve failed"
+        );
+    }
+
+    function _transferFromSender(
+        uint256 _amount
+    ) internal override returns (bytes memory) {
+        // transfer erc20 from sender
+        super._transferFromSender(_amount);
+        // convert erc20 to xERC20
+        lockbox.deposit(_amount);
+        // burn xERC20
+        xERC20.burn(address(this), _amount);
+        return bytes("");
+    }
+
+    function _transferTo(
+        address _recipient,
+        uint256 _amount,
+        bytes calldata /*metadata*/
+    ) internal override {
+        // mint xERC20
+        xERC20.mint(address(this), _amount);
+        // convert xERC20 to erc20
+        lockbox.withdrawTo(_recipient, _amount);
+    }
+}

package/contracts/token/interfaces/IXERC20.sol

@@ -21,4 +21,19 @@ interface IXERC20 is IERC20 {
      * @param _amount The amount of tokens being burned
      */
     function burn(address _user, uint256 _amount) external;
+
+    /**
+     * @notice Updates the limits of any bridge
+     * @dev Can only be called by the owner
+     * @param _mintingLimit The updated minting limit we are setting to the bridge
+     * @param _burningLimit The updated burning limit we are setting to the bridge
+     * @param _bridge The address of the bridge we are setting the limits too
+     */
+    function setLimits(
+        address _bridge,
+        uint256 _mintingLimit,
+        uint256 _burningLimit
+    ) external;
+
+    function owner() external returns (address);
 }

package/contracts/token/interfaces/IXERC20Lockbox.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.4 <0.9.0;
+
+// adapted from https://github.com/defi-wonderland/xERC20
+
+import {IXERC20} from "./IXERC20.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface IXERC20Lockbox {
+    /**
+     * @notice The XERC20 token of this contract
+     */
+    function XERC20() external returns (IXERC20);
+
+    /**
+     * @notice The ERC20 token of this contract
+     */
+    function ERC20() external returns (IERC20);
+
+    /**
+     * @notice Deposit ERC20 tokens into the lockbox
+     *
+     * @param _amount The amount of tokens to deposit
+     */
+
+    function deposit(uint256 _amount) external;
+
+    /**
+     * @notice Deposit ERC20 tokens into the lockbox, and send the XERC20 to a user
+     *
+     * @param _user The user to send the XERC20 to
+     * @param _amount The amount of tokens to deposit
+     */
+
+    function depositTo(address _user, uint256 _amount) external;
+
+    /**
+     * @notice Deposit the native asset into the lockbox, and send the XERC20 to a user
+     *
+     * @param _user The user to send the XERC20 to
+     */
+
+    function depositNativeTo(address _user) external payable;
+
+    /**
+     * @notice Withdraw ERC20 tokens from the lockbox
+     *
+     * @param _amount The amount of tokens to withdraw
+     */
+
+    function withdraw(uint256 _amount) external;
+
+    /**
+     * @notice Withdraw ERC20 tokens from the lockbox
+     *
+     * @param _user The user to withdraw to
+     * @param _amount The amount of tokens to withdraw
+     */
+
+    function withdrawTo(address _user, uint256 _amount) external;
+}