@hyperlane-xyz/core 1.2.3 → 1.3.0

package/contracts/isms/{MultisigIsm.sol → multisig/LegacyMultisigIsm.sol}

@@ -7,27 +7,30 @@ import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
 // ============ Internal Imports ============
-import {IMultisigIsm} from "../../interfaces/IMultisigIsm.sol";
-import {Message} from "../libs/Message.sol";
-import {MultisigIsmMetadata} from "../libs/MultisigIsmMetadata.sol";
-import {MerkleLib} from "../libs/Merkle.sol";
+import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
+import {Message} from "../../libs/Message.sol";
+import {IMultisigIsm} from "../../interfaces/isms/IMultisigIsm.sol";
+import {LegacyMultisigIsmMetadata} from "../../libs/isms/LegacyMultisigIsmMetadata.sol";
+import {MerkleLib} from "../../libs/Merkle.sol";
+import {CheckpointLib} from "../../libs/CheckpointLib.sol";
 
 /**
  * @title MultisigIsm
  * @notice Manages an ownable set of validators that ECDSA sign checkpoints to
  * reach a quorum.
  */
-contract MultisigIsm is IMultisigIsm, Ownable {
+contract LegacyMultisigIsm is IMultisigIsm, Ownable {
     // ============ Libraries ============
 
     using EnumerableSet for EnumerableSet.AddressSet;
     using Message for bytes;
-    using MultisigIsmMetadata for bytes;
+    using LegacyMultisigIsmMetadata for bytes;
     using MerkleLib for MerkleLib.Tree;
 
     // ============ Constants ============
 
-    uint8 public constant moduleType = 3;
+    uint8 public constant moduleType =
+        uint8(IInterchainSecurityModule.Types.LEGACY_MULTISIG);
 
     // ============ Mutable Storage ============
 
@@ -195,7 +198,7 @@ contract MultisigIsm is IMultisigIsm, Ownable {
      * @notice Verifies that a quorum of the origin domain's validators signed
      * a checkpoint, and verifies the merkle proof of `_message` against that
      * checkpoint.
-     * @param _metadata ABI encoded module metadata (see MultisigIsmMetadata.sol)
+     * @param _metadata ABI encoded module metadata (see LegacyMultisigIsmMetadata.sol)
      * @param _message Formatted Hyperlane message (see Message.sol).
      */
     function verify(bytes calldata _metadata, bytes calldata _message)
@@ -284,7 +287,7 @@ contract MultisigIsm is IMultisigIsm, Ownable {
     /**
      * @notice Verifies the merkle proof of `_message` against the provided
      * checkpoint.
-     * @param _metadata ABI encoded module metadata (see MultisigIsmMetadata.sol)
+     * @param _metadata ABI encoded module metadata (see LegacyMultisigIsmMetadata.sol)
      * @param _message Formatted Hyperlane message (see Message.sol).
      */
     function _verifyMerkleProof(
@@ -303,7 +306,7 @@ contract MultisigIsm is IMultisigIsm, Ownable {
     /**
      * @notice Verifies that a quorum of the origin domain's validators signed
      * the provided checkpoint.
-     * @param _metadata ABI encoded module metadata (see MultisigIsmMetadata.sol)
+     * @param _metadata ABI encoded module metadata (see LegacyMultisigIsmMetadata.sol)
      * @param _message Formatted Hyperlane message (see Message.sol).
      */
     function _verifyValidatorSignatures(
@@ -324,7 +327,12 @@ contract MultisigIsm is IMultisigIsm, Ownable {
             // non-zero computed commitment, and this check will fail
             // as the commitment in storage will be zero.
             require(_commitment == commitment[_origin], "!commitment");
-            _digest = _getCheckpointDigest(_metadata, _origin);
+            _digest = CheckpointLib.digest(
+                _origin,
+                LegacyMultisigIsmMetadata.originMailbox(_metadata),
+                LegacyMultisigIsmMetadata.root(_metadata),
+                LegacyMultisigIsmMetadata.index(_metadata)
+            );
         }
         uint256 _validatorCount = _metadata.validatorCount();
         uint256 _validatorIndex = 0;
@@ -344,53 +352,4 @@ contract MultisigIsm is IMultisigIsm, Ownable {
         }
         return true;
     }
-
-    /**
-     * @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 _getDomainHash(uint32 _origin, bytes32 _originMailbox)
-        internal
-        pure
-        returns (bytes32)
-    {
-        // 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 mailbox.
-        return
-            keccak256(abi.encodePacked(_origin, _originMailbox, "HYPERLANE"));
-    }
-
-    /**
-     * @notice Returns the digest validators are expected to sign when signing checkpoints.
-     * @param _metadata ABI encoded module metadata (see MultisigIsmMetadata.sol)
-     * @param _origin The origin domain of the checkpoint.
-     * @return The digest of the checkpoint.
-     */
-    function _getCheckpointDigest(bytes calldata _metadata, uint32 _origin)
-        internal
-        pure
-        returns (bytes32)
-    {
-        bytes32 _domainHash = _getDomainHash(
-            _origin,
-            _metadata.originMailbox()
-        );
-        return
-            ECDSA.toEthSignedMessageHash(
-                keccak256(
-                    abi.encodePacked(
-                        _domainHash,
-                        _metadata.root(),
-                        _metadata.index()
-                    )
-                )
-            );
-    }
 }

package/contracts/isms/multisig/StaticMultisigIsm.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {AbstractMultisigIsm} from "./AbstractMultisigIsm.sol";
+import {MultisigIsmMetadata} from "../../libs/isms/MultisigIsmMetadata.sol";
+import {MetaProxy} from "../../libs/MetaProxy.sol";
+
+/**
+ * @title StaticMultisigIsm
+ * @notice Manages per-domain m-of-n Validator sets that are used
+ * to verify interchain messages.
+ */
+contract StaticMultisigIsm is AbstractMultisigIsm {
+    // ============ Public Functions ============
+
+    /**
+     * @notice Returns the set of validators responsible for verifying _message
+     * and the number of signatures required
+     * @dev Can change based on the content of _message
+     * @return validators The array of validator addresses
+     * @return threshold The number of validator signatures needed
+     */
+    function validatorsAndThreshold(bytes calldata)
+        public
+        view
+        virtual
+        override
+        returns (address[] memory, uint8)
+    {
+        return abi.decode(MetaProxy.metadata(), (address[], uint8));
+    }
+}

package/contracts/isms/multisig/StaticMultisigIsmFactory.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+// ============ Internal Imports ============
+import {StaticMultisigIsm} from "./StaticMultisigIsm.sol";
+import {StaticMOfNAddressSetFactory} from "../../libs/StaticMOfNAddressSetFactory.sol";
+
+contract StaticMultisigIsmFactory is StaticMOfNAddressSetFactory {
+    function _deployImplementation()
+        internal
+        virtual
+        override
+        returns (address)
+    {
+        return address(new StaticMultisigIsm());
+    }
+}

package/contracts/libs/Call.sol

@@ -13,8 +13,10 @@ library CallLib {
     }
 
     struct Call {
+        // supporting non EVM targets
+        bytes32 to;
         uint256 value;
-        StaticCall _call;
+        bytes data;
     }
 
     struct StaticCallWithCallback {
@@ -22,18 +24,14 @@ library CallLib {
         bytes callback;
     }
 
-    function target(StaticCall memory _call) internal pure returns (address) {
-        return TypeCasts.bytes32ToAddress(_call.to);
-    }
-
     function call(Call memory _call)
         internal
         returns (bytes memory returnData)
     {
         return
             Address.functionCallWithValue(
-                target(_call._call),
-                _call._call.data,
+                TypeCasts.bytes32ToAddress(_call.to),
+                _call.data,
                 _call.value
             );
     }
@@ -43,7 +41,11 @@ library CallLib {
         view
         returns (bytes memory)
     {
-        return Address.functionStaticCall(target(_call), _call.data);
+        return
+            Address.functionStaticCall(
+                TypeCasts.bytes32ToAddress(_call.to),
+                _call.data
+            );
     }
 
     function staticcall(StaticCallWithCallback memory _call)
@@ -114,7 +116,7 @@ library CallLib {
         uint256 value,
         bytes memory data
     ) internal pure returns (Call memory) {
-        return Call(value, build(to, data));
+        return Call(to, value, data);
     }
 
     function build(
@@ -122,7 +124,7 @@ library CallLib {
         uint256 value,
         bytes memory data
     ) internal pure returns (Call memory) {
-        return Call(value, build(to, data));
+        return Call(TypeCasts.addressToBytes32(to), value, data);
     }
 
     function build(

package/contracts/libs/CheckpointLib.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ External Imports ============
+import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+
+library CheckpointLib {
+    /**
+     * @notice Returns the digest validators are expected to sign when signing checkpoints.
+     * @param _origin The origin domain of the checkpoint.
+     * @param _originMailbox The address of the origin mailbox as bytes32.
+     * @return The digest of the 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)
+    {
+        // 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 mailbox.
+        return
+            keccak256(abi.encodePacked(_origin, _originMailbox, "HYPERLANE"));
+    }
+}

package/contracts/libs/MetaProxy.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: CC0-1.0
+pragma solidity >=0.7.6;
+
+/// @dev Adapted from https://eips.ethereum.org/EIPS/eip-3448
+library MetaProxy {
+    bytes32 constant PREFIX =
+        hex"600b380380600b3d393df3363d3d373d3d3d3d60368038038091363936013d73";
+    bytes13 constant SUFFIX = hex"5af43d3d93803e603457fd5bf3";
+
+    function bytecode(address _implementation, bytes memory _metadata)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return
+            abi.encodePacked(
+                PREFIX,
+                bytes20(_implementation),
+                SUFFIX,
+                _metadata,
+                _metadata.length
+            );
+    }
+
+    function metadata() internal pure returns (bytes memory) {
+        bytes memory data;
+        assembly {
+            let posOfMetadataSize := sub(calldatasize(), 32)
+            let size := calldataload(posOfMetadataSize)
+            let dataPtr := sub(posOfMetadataSize, size)
+            data := mload(64)
+            // increment free memory pointer by metadata size + 32 bytes (length)
+            mstore(64, add(data, add(size, 32)))
+            mstore(data, size)
+            let memPtr := add(data, 32)
+            calldatacopy(memPtr, dataPtr, size)
+        }
+        return data;
+    }
+}

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/TypeCasts.sol

@@ -2,26 +2,6 @@
 pragma solidity >=0.6.11;
 
 library TypeCasts {
-    // treat it as a null-terminated string of max 32 bytes
-    function coerceString(bytes32 _buf)
-        internal
-        pure
-        returns (string memory _newStr)
-    {
-        uint8 _slen = 0;
-        while (_slen < 32 && _buf[_slen] != 0) {
-            _slen++;
-        }
-
-        // solhint-disable-next-line no-inline-assembly
-        assembly {
-            _newStr := mload(0x40)
-            mstore(0x40, add(_newStr, 0x40)) // may end up with extra
-            mstore(_newStr, _slen)
-            mstore(add(_newStr, 0x20), _buf)
-        }
-    }
-
     // alignment preserving cast
     function addressToBytes32(address _addr) internal pure returns (bytes32) {
         return bytes32(uint256(uint160(_addr)));

package/contracts/libs/isms/AggregationIsmMetadata.sol

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+/**
+ * Format of metadata:
+ *
+ * [????:????] Metadata start/end uint32 ranges, packed as uint64
+ * [????:????] ISM metadata, packed encoding
+ */
+library AggregationIsmMetadata {
+    uint256 private constant RANGE_SIZE = 4;
+
+    /**
+     * @notice Returns whether or not metadata was provided for the ISM at
+     * `_index`
+     * @dev Callers must ensure _index is less than the number of metadatas
+     * provided
+     * @param _metadata Encoded Aggregation ISM metadata
+     * @param _index The index of the ISM to check for metadata for
+     * @return Whether or not metadata was provided for the ISM at `_index`
+     */
+    function hasMetadata(bytes calldata _metadata, uint8 _index)
+        internal
+        pure
+        returns (bool)
+    {
+        (uint32 _start, ) = _metadataRange(_metadata, _index);
+        return _start > 0;
+    }
+
+    /**
+     * @notice Returns the metadata provided for the ISM at `_index`
+     * @dev Callers must ensure _index is less than the number of metadatas
+     * provided
+     * @dev Callers must ensure `hasMetadata(_metadata, _index)`
+     * @param _metadata Encoded Aggregation ISM metadata
+     * @param _index The index of the ISM to return metadata for
+     * @return The metadata provided for the ISM at `_index`
+     */
+    function metadataAt(bytes calldata _metadata, uint8 _index)
+        internal
+        pure
+        returns (bytes calldata)
+    {
+        (uint32 _start, uint32 _end) = _metadataRange(_metadata, _index);
+        return _metadata[_start:_end];
+    }
+
+    /**
+     * @notice Returns the range of the metadata provided for the ISM at
+     * `_index`, or zeroes if not provided
+     * @dev Callers must ensure _index is less than the number of metadatas
+     * provided
+     * @param _metadata Encoded Aggregation ISM metadata
+     * @param _index The index of the ISM to return metadata range for
+     * @return The range of the metadata provided for the ISM at `_index`, or
+     * zeroes if not provided
+     */
+    function _metadataRange(bytes calldata _metadata, uint8 _index)
+        private
+        pure
+        returns (uint32, uint32)
+    {
+        uint256 _start = (uint32(_index) * RANGE_SIZE * 2);
+        uint256 _mid = _start + RANGE_SIZE;
+        uint256 _end = _mid + RANGE_SIZE;
+        return (
+            uint32(bytes4(_metadata[_start:_mid])),
+            uint32(bytes4(_metadata[_mid:_end]))
+        );
+    }
+}

package/contracts/libs/{MultisigIsmMetadata.sol → isms/LegacyMultisigIsmMetadata.sol}

@@ -11,7 +11,7 @@ pragma solidity >=0.8.0;
  * [1093:????] Validator signatures, 65 bytes each, length == Threshold
  * [????:????] Addresses of the entire validator set, left padded to bytes32
  */
-library MultisigIsmMetadata {
+library LegacyMultisigIsmMetadata {
     uint256 private constant MERKLE_ROOT_OFFSET = 0;
     uint256 private constant MERKLE_INDEX_OFFSET = 32;
     uint256 private constant ORIGIN_MAILBOX_OFFSET = 36;

package/contracts/libs/isms/MultisigIsmMetadata.sol

@@ -0,0 +1,91 @@
+// 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:????] Validator signatures, 65 bytes each, length == Threshold
+ */
+library MultisigIsmMetadata {
+    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 SIGNATURES_OFFSET = 1092;
+    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:SIGNATURES_OFFSET],
+                (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];
+    }
+}