@hyperlane-xyz/core 1.5.6-beta0 → 1.5.8

package/contracts/libs/Call.sol

@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+
+import {TypeCasts} from "./TypeCasts.sol";
+
+library CallLib {
+    struct StaticCall {
+        // supporting non EVM targets
+        bytes32 to;
+        bytes data;
+    }
+
+    struct Call {
+        // supporting non EVM targets
+        bytes32 to;
+        uint256 value;
+        bytes data;
+    }
+
+    struct StaticCallWithCallback {
+        StaticCall _call;
+        bytes callback;
+    }
+
+    function call(Call memory _call)
+        internal
+        returns (bytes memory returnData)
+    {
+        return
+            Address.functionCallWithValue(
+                TypeCasts.bytes32ToAddress(_call.to),
+                _call.data,
+                _call.value
+            );
+    }
+
+    function staticcall(StaticCall memory _call)
+        private
+        view
+        returns (bytes memory)
+    {
+        return
+            Address.functionStaticCall(
+                TypeCasts.bytes32ToAddress(_call.to),
+                _call.data
+            );
+    }
+
+    function staticcall(StaticCallWithCallback memory _call)
+        internal
+        view
+        returns (bytes memory callback)
+    {
+        return bytes.concat(_call.callback, staticcall(_call._call));
+    }
+
+    function multicall(Call[] memory calls) internal {
+        uint256 i = 0;
+        uint256 len = calls.length;
+        while (i < len) {
+            call(calls[i]);
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function multistaticcall(StaticCallWithCallback[] memory _calls)
+        internal
+        view
+        returns (bytes[] memory)
+    {
+        uint256 i = 0;
+        uint256 len = _calls.length;
+        bytes[] memory callbacks = new bytes[](len);
+        while (i < len) {
+            callbacks[i] = staticcall(_calls[i]);
+            unchecked {
+                ++i;
+            }
+        }
+        return callbacks;
+    }
+
+    function multicallto(address to, bytes[] memory calls) internal {
+        uint256 i = 0;
+        uint256 len = calls.length;
+        while (i < len) {
+            Address.functionCall(to, calls[i]);
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function build(bytes32 to, bytes memory data)
+        internal
+        pure
+        returns (StaticCall memory)
+    {
+        return StaticCall(to, data);
+    }
+
+    function build(address to, bytes memory data)
+        internal
+        pure
+        returns (StaticCall memory)
+    {
+        return build(TypeCasts.addressToBytes32(to), data);
+    }
+
+    function build(
+        bytes32 to,
+        uint256 value,
+        bytes memory data
+    ) internal pure returns (Call memory) {
+        return Call(to, value, data);
+    }
+
+    function build(
+        address to,
+        uint256 value,
+        bytes memory data
+    ) internal pure returns (Call memory) {
+        return Call(TypeCasts.addressToBytes32(to), value, data);
+    }
+
+    function build(
+        bytes32 to,
+        bytes memory data,
+        bytes memory callback
+    ) internal pure returns (StaticCallWithCallback memory) {
+        return StaticCallWithCallback(build(to, data), callback);
+    }
+
+    function build(
+        address to,
+        bytes memory data,
+        bytes memory callback
+    ) internal pure returns (StaticCallWithCallback memory) {
+        return StaticCallWithCallback(build(to, data), callback);
+    }
+}

package/contracts/libs/CheckpointLib.sol

@@ -4,11 +4,13 @@ pragma solidity >=0.8.0;
 // ============ External Imports ============
 import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 
+import {LegacyCheckpointLib} from "./LegacyCheckpointLib.sol";
+
 library CheckpointLib {
     /**
      * @notice Returns the digest validators are expected to sign when signing checkpoints.
      * @param _origin The origin domain of the checkpoint.
-     * @param _originmerkleTreeHook The address of the origin merkle tree hook as bytes32.
+     * @param _originMailbox The address of the origin mailbox as bytes32.
      * @param _checkpointRoot The root of the checkpoint.
      * @param _checkpointIndex The index of the checkpoint.
      * @param _messageId The message ID of the checkpoint.
@@ -17,12 +19,12 @@ library CheckpointLib {
      */
     function digest(
         uint32 _origin,
-        bytes32 _originmerkleTreeHook,
+        bytes32 _originMailbox,
         bytes32 _checkpointRoot,
         uint32 _checkpointIndex,
         bytes32 _messageId
     ) internal pure returns (bytes32) {
-        bytes32 _domainHash = domainHash(_origin, _originmerkleTreeHook);
+        bytes32 _domainHash = domainHash(_origin, _originMailbox);
         return
             ECDSA.toEthSignedMessageHash(
                 keccak256(
@@ -40,22 +42,21 @@ library CheckpointLib {
      * @notice Returns the domain hash that validators are expected to use
      * when signing checkpoints.
      * @param _origin The origin domain of the checkpoint.
-     * @param _originmerkleTreeHook The address of the origin merkle tree as bytes32.
+     * @param _originMailbox The address of the origin mailbox as bytes32.
      * @return The domain hash.
      */
-    function domainHash(uint32 _origin, bytes32 _originmerkleTreeHook)
+    function domainHash(uint32 _origin, bytes32 _originMailbox)
         internal
         pure
         returns (bytes32)
     {
-        // Including the origin merkle tree address in the signature allows the slashing
-        // protocol to enroll multiple trees. Otherwise, a valid signature for
-        // tree A would be indistinguishable from a fraudulent signature for tree B.
+        // Including the origin mailbox address in the signature allows the slashing
+        // protocol to enroll multiple mailboxes. Otherwise, a valid signature for
+        // mailbox A would be indistinguishable from a fraudulent signature for mailbox
+        // B.
         // The slashing protocol should slash if validators sign attestations for
-        // anything other than a whitelisted tree.
+        // anything other than a whitelisted mailbox.
         return
-            keccak256(
-                abi.encodePacked(_origin, _originmerkleTreeHook, "HYPERLANE")
-            );
+            keccak256(abi.encodePacked(_origin, _originMailbox, "HYPERLANE"));
     }
 }

package/contracts/libs/LegacyCheckpointLib.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ External Imports ============
+import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+
+// ============ Internal Imports ============
+import {CheckpointLib} from "./CheckpointLib.sol";
+
+library LegacyCheckpointLib {
+    /**
+     * @notice Returns the digest validators are expected to sign when signing legacy checkpoints.
+     * @param _origin The origin domain of the checkpoint.
+     * @param _originMailbox The address of the origin mailbox as bytes32.
+     * @return The digest of the legacy checkpoint.
+     */
+    function digest(
+        uint32 _origin,
+        bytes32 _originMailbox,
+        bytes32 _checkpointRoot,
+        uint32 _checkpointIndex
+    ) internal pure returns (bytes32) {
+        bytes32 _domainHash = domainHash(_origin, _originMailbox);
+        return
+            ECDSA.toEthSignedMessageHash(
+                keccak256(
+                    abi.encodePacked(
+                        _domainHash,
+                        _checkpointRoot,
+                        _checkpointIndex
+                    )
+                )
+            );
+    }
+
+    /**
+     * @notice Returns the domain hash that validators are expected to use
+     * when signing checkpoints.
+     * @param _origin The origin domain of the checkpoint.
+     * @param _originMailbox The address of the origin mailbox as bytes32.
+     * @return The domain hash.
+     */
+    function domainHash(uint32 _origin, bytes32 _originMailbox)
+        internal
+        pure
+        returns (bytes32)
+    {
+        return CheckpointLib.domainHash(_origin, _originMailbox);
+    }
+}

package/contracts/libs/StaticMOfNAddressSetFactory.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+// ============ External Imports ============
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
+
+// ============ Internal Imports ============
+import {MetaProxy} from "./MetaProxy.sol";
+
+abstract contract StaticMOfNAddressSetFactory {
+    // ============ Immutables ============
+    address private immutable _implementation;
+
+    // ============ Constructor ============
+
+    constructor() {
+        _implementation = _deployImplementation();
+    }
+
+    function _deployImplementation() internal virtual returns (address);
+
+    /**
+     * @notice Deploys a StaticMOfNAddressSet contract address for the given
+     * values
+     * @dev Consider sorting addresses to ensure contract reuse
+     * @param _values An array of addresses
+     * @param _threshold The threshold value to use
+     * @return set The contract address representing this StaticMOfNAddressSet
+     */
+    function deploy(address[] calldata _values, uint8 _threshold)
+        external
+        returns (address)
+    {
+        (bytes32 _salt, bytes memory _bytecode) = _saltAndBytecode(
+            _values,
+            _threshold
+        );
+        address _set = _getAddress(_salt, _bytecode);
+        if (!Address.isContract(_set)) {
+            _set = Create2.deploy(0, _salt, _bytecode);
+        }
+        return _set;
+    }
+
+    /**
+     * @notice Returns the StaticMOfNAddressSet contract address for the given
+     * values
+     * @dev Consider sorting addresses to ensure contract reuse
+     * @param _values An array of addresses
+     * @param _threshold The threshold value to use
+     * @return set The contract address representing this StaticMOfNAddressSet
+     */
+    function getAddress(address[] calldata _values, uint8 _threshold)
+        external
+        view
+        returns (address)
+    {
+        (bytes32 _salt, bytes memory _bytecode) = _saltAndBytecode(
+            _values,
+            _threshold
+        );
+        return _getAddress(_salt, _bytecode);
+    }
+
+    /**
+     * @notice Returns the StaticMOfNAddressSet contract address for the given
+     * values
+     * @param _salt The salt used in Create2
+     * @param _bytecode The metaproxy bytecode used in Create2
+     * @return set The contract address representing this StaticMOfNAddressSet
+     */
+    function _getAddress(bytes32 _salt, bytes memory _bytecode)
+        private
+        view
+        returns (address)
+    {
+        bytes32 _bytecodeHash = keccak256(_bytecode);
+        return Create2.computeAddress(_salt, _bytecodeHash);
+    }
+
+    /**
+     * @notice Returns the create2 salt and bytecode for the given values
+     * @param _values An array of addresses
+     * @param _threshold The threshold value to use
+     * @return _salt The salt used in Create2
+     * @return _bytecode The metaproxy bytecode used in Create2
+     */
+    function _saltAndBytecode(address[] calldata _values, uint8 _threshold)
+        private
+        view
+        returns (bytes32, bytes memory)
+    {
+        bytes memory _metadata = abi.encode(_values, _threshold);
+        bytes memory _bytecode = MetaProxy.bytecode(_implementation, _metadata);
+        bytes32 _salt = keccak256(_metadata);
+        return (_salt, _bytecode);
+    }
+}

package/contracts/libs/ValidatorAnnouncements.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+// ============ Internal Imports ============
+import {TypeCasts} from "./TypeCasts.sol";
+// ============ External Imports ============
+import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+
+library ValidatorAnnouncements {
+    using TypeCasts for address;
+
+    /**
+     * @notice Returns the digest validators are expected to sign when signing announcements.
+     * @param _mailbox Address of the mailbox being validated
+     * @param _localDomain Domain of chain on which the contract is deployed
+     * @param _storageLocation Storage location string.
+     * @return The digest of the announcement.
+     */
+    function getAnnouncementDigest(
+        address _mailbox,
+        uint32 _localDomain,
+        string memory _storageLocation
+    ) internal pure returns (bytes32) {
+        bytes32 _domainHash = keccak256(
+            abi.encodePacked(
+                _localDomain,
+                _mailbox.addressToBytes32(),
+                "HYPERLANE_ANNOUNCEMENT"
+            )
+        );
+        return
+            ECDSA.toEthSignedMessageHash(
+                keccak256(abi.encodePacked(_domainHash, _storageLocation))
+            );
+    }
+}

package/contracts/libs/isms/LegacyMultisigIsmMetadata.sol

@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+/**
+ * Format of metadata:
+ * [   0:  32] Merkle root
+ * [  32:  36] Root index
+ * [  36:  68] Origin mailbox address
+ * [  68:1092] Merkle proof
+ * [1092:1093] Threshold
+ * [1093:????] Validator signatures, 65 bytes each, length == Threshold
+ * [????:????] Addresses of the entire validator set, left padded to bytes32
+ */
+library LegacyMultisigIsmMetadata {
+    uint256 private constant MERKLE_ROOT_OFFSET = 0;
+    uint256 private constant MERKLE_INDEX_OFFSET = 32;
+    uint256 private constant ORIGIN_MAILBOX_OFFSET = 36;
+    uint256 private constant MERKLE_PROOF_OFFSET = 68;
+    uint256 private constant THRESHOLD_OFFSET = 1092;
+    uint256 private constant SIGNATURES_OFFSET = 1093;
+    uint256 private constant SIGNATURE_LENGTH = 65;
+
+    /**
+     * @notice Returns the merkle root of the signed checkpoint.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return Merkle root of the signed checkpoint
+     */
+    function root(bytes calldata _metadata) internal pure returns (bytes32) {
+        return bytes32(_metadata[MERKLE_ROOT_OFFSET:MERKLE_INDEX_OFFSET]);
+    }
+
+    /**
+     * @notice Returns the index of the signed checkpoint.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return Index of the signed checkpoint
+     */
+    function index(bytes calldata _metadata) internal pure returns (uint32) {
+        return
+            uint32(
+                bytes4(_metadata[MERKLE_INDEX_OFFSET:ORIGIN_MAILBOX_OFFSET])
+            );
+    }
+
+    /**
+     * @notice Returns the origin mailbox of the signed checkpoint as bytes32.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return Origin mailbox of the signed checkpoint as bytes32
+     */
+    function originMailbox(bytes calldata _metadata)
+        internal
+        pure
+        returns (bytes32)
+    {
+        return bytes32(_metadata[ORIGIN_MAILBOX_OFFSET:MERKLE_PROOF_OFFSET]);
+    }
+
+    /**
+     * @notice Returns the merkle proof branch of the message.
+     * @dev This appears to be more gas efficient than returning a calldata
+     * slice and using that.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return Merkle proof branch of the message.
+     */
+    function proof(bytes calldata _metadata)
+        internal
+        pure
+        returns (bytes32[32] memory)
+    {
+        return
+            abi.decode(
+                _metadata[MERKLE_PROOF_OFFSET:THRESHOLD_OFFSET],
+                (bytes32[32])
+            );
+    }
+
+    /**
+     * @notice Returns the number of required signatures. Verified against
+     * the commitment stored in the module.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return The number of required signatures.
+     */
+    function threshold(bytes calldata _metadata) internal pure returns (uint8) {
+        return uint8(bytes1(_metadata[THRESHOLD_OFFSET:SIGNATURES_OFFSET]));
+    }
+
+    /**
+     * @notice Returns the validator ECDSA signature at `_index`.
+     * @dev Assumes signatures are sorted by validator
+     * @dev Assumes `_metadata` encodes `threshold` signatures.
+     * @dev Assumes `_index` is less than `threshold`
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @param _index The index of the signature to return.
+     * @return The validator ECDSA signature at `_index`.
+     */
+    function signatureAt(bytes calldata _metadata, uint256 _index)
+        internal
+        pure
+        returns (bytes calldata)
+    {
+        uint256 _start = SIGNATURES_OFFSET + (_index * SIGNATURE_LENGTH);
+        uint256 _end = _start + SIGNATURE_LENGTH;
+        return _metadata[_start:_end];
+    }
+
+    /**
+     * @notice Returns the validator address at `_index`.
+     * @dev Assumes `_index` is less than the number of validators
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @param _index The index of the validator to return.
+     * @return The validator address at `_index`.
+     */
+    function validatorAt(bytes calldata _metadata, uint256 _index)
+        internal
+        pure
+        returns (address)
+    {
+        // Validator addresses are left padded to bytes32 in order to match
+        // abi.encodePacked(address[]).
+        uint256 _start = _validatorsOffset(_metadata) + (_index * 32) + 12;
+        uint256 _end = _start + 20;
+        return address(bytes20(_metadata[_start:_end]));
+    }
+
+    /**
+     * @notice Returns the validator set encoded as bytes. Verified against the
+     * commitment stored in the module.
+     * @dev Validator addresses are encoded as tightly packed array of bytes32,
+     * sorted to match the enumerable set stored by the module.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return The validator set encoded as bytes.
+     */
+    function validators(bytes calldata _metadata)
+        internal
+        pure
+        returns (bytes calldata)
+    {
+        return _metadata[_validatorsOffset(_metadata):];
+    }
+
+    /**
+     * @notice Returns the size of the validator set encoded in the metadata
+     * @dev Validator addresses are encoded as tightly packed array of bytes32,
+     * sorted to match the enumerable set stored by the module.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return The size of the validator set encoded in the metadata
+     */
+    function validatorCount(bytes calldata _metadata)
+        internal
+        pure
+        returns (uint256)
+    {
+        return (_metadata.length - _validatorsOffset(_metadata)) / 32;
+    }
+
+    /**
+     * @notice Returns the offset in bytes of the list of validators within
+     * `_metadata`.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return The index at which the list of validators starts
+     */
+    function _validatorsOffset(bytes calldata _metadata)
+        private
+        pure
+        returns (uint256)
+    {
+        return
+            SIGNATURES_OFFSET +
+            (uint256(threshold(_metadata)) * SIGNATURE_LENGTH);
+    }
+}

package/contracts/libs/isms/MerkleRootMultisigIsmMetadata.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+/**
+ * Format of metadata:
+ * [   0:  32] Origin mailbox address
+ * [  32:  36] Signed checkpoint index
+ * [  36:  68] Signed checkpoint message ID
+ * [  68:1092] Merkle proof
+ * [1092:????] Validator signatures (length := threshold * 65)
+ */
+library MerkleRootMultisigIsmMetadata {
+    uint8 private constant ORIGIN_MAILBOX_OFFSET = 0;
+    uint8 private constant CHECKPOINT_INDEX_OFFSET = 32;
+    uint8 private constant CHECKPOINT_MESSAGE_ID_OFFSET = 36;
+    uint8 private constant MERKLE_PROOF_OFFSET = 68;
+    uint16 private constant MERKLE_PROOF_LENGTH = 32 * 32;
+    uint16 private constant SIGNATURES_OFFSET = 1092;
+    uint8 private constant SIGNATURE_LENGTH = 65;
+
+    /**
+     * @notice Returns the origin mailbox of the signed checkpoint as bytes32.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return Origin mailbox of the signed checkpoint as bytes32
+     */
+    function originMailbox(bytes calldata _metadata)
+        internal
+        pure
+        returns (bytes32)
+    {
+        return
+            bytes32(
+                _metadata[ORIGIN_MAILBOX_OFFSET:ORIGIN_MAILBOX_OFFSET + 32]
+            );
+    }
+
+    /**
+     * @notice Returns the index of the signed checkpoint.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return Index of the signed checkpoint
+     */
+    function index(bytes calldata _metadata) internal pure returns (uint32) {
+        return
+            uint32(
+                bytes4(
+                    _metadata[CHECKPOINT_INDEX_OFFSET:CHECKPOINT_INDEX_OFFSET +
+                        4]
+                )
+            );
+    }
+
+    /**
+     * @notice Returns the message ID of the signed checkpoint.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return Message ID of the signed checkpoint
+     */
+    function messageId(bytes calldata _metadata)
+        internal
+        pure
+        returns (bytes32)
+    {
+        return
+            bytes32(
+                _metadata[CHECKPOINT_MESSAGE_ID_OFFSET:CHECKPOINT_MESSAGE_ID_OFFSET +
+                    32]
+            );
+    }
+
+    /**
+     * @notice Returns the merkle proof branch of the message.
+     * @dev This appears to be more gas efficient than returning a calldata
+     * slice and using that.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return Merkle proof branch of the message.
+     */
+    function proof(bytes calldata _metadata)
+        internal
+        pure
+        returns (bytes32[32] memory)
+    {
+        return
+            abi.decode(
+                _metadata[MERKLE_PROOF_OFFSET:MERKLE_PROOF_OFFSET +
+                    MERKLE_PROOF_LENGTH],
+                (bytes32[32])
+            );
+    }
+
+    /**
+     * @notice Returns the validator ECDSA signature at `_index`.
+     * @dev Assumes signatures are sorted by validator
+     * @dev Assumes `_metadata` encodes `threshold` signatures.
+     * @dev Assumes `_index` is less than `threshold`
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @param _index The index of the signature to return.
+     * @return The validator ECDSA signature at `_index`.
+     */
+    function signatureAt(bytes calldata _metadata, uint256 _index)
+        internal
+        pure
+        returns (bytes calldata)
+    {
+        uint256 _start = SIGNATURES_OFFSET + (_index * SIGNATURE_LENGTH);
+        uint256 _end = _start + SIGNATURE_LENGTH;
+        return _metadata[_start:_end];
+    }
+}