@hyperlane-xyz/core 1.3.4 → 1.3.5

package/contracts/interfaces/IInterchainSecurityModule.sol

@@ -7,7 +7,8 @@ interface IInterchainSecurityModule {
         ROUTING,
         AGGREGATION,
         LEGACY_MULTISIG,
-        MULTISIG
+        MERKLE_ROOT_MULTISIG,
+        MESSAGE_ID_MULTISIG
     }
 
     /**

package/contracts/isms/multisig/AbstractMerkleRootMultisigIsm.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
+import {AbstractMultisigIsm} from "./AbstractMultisigIsm.sol";
+import {MerkleRootMultisigIsmMetadata} from "../../libs/isms/MerkleRootMultisigIsmMetadata.sol";
+import {Message} from "../../libs/Message.sol";
+import {MerkleLib} from "../../libs/Merkle.sol";
+import {CheckpointLib} from "../../libs/CheckpointLib.sol";
+
+/**
+ * @title MerkleRootMultisigIsm
+ * @notice Provides abstract logic for verifying signatures on a merkle root
+ * and a merkle proof of message inclusion in that root.
+ * @dev Implement and use if you want strong censorship resistance guarantees.
+ * @dev May be adapted in future to support batch message verification against a single root.
+ */
+abstract contract AbstractMerkleRootMultisigIsm is AbstractMultisigIsm {
+    // ============ Constants ============
+
+    // solhint-disable-next-line const-name-snakecase
+    uint8 public constant moduleType =
+        uint8(IInterchainSecurityModule.Types.MERKLE_ROOT_MULTISIG);
+
+    /**
+     * @inheritdoc AbstractMultisigIsm
+     */
+    function digest(bytes calldata _metadata, bytes calldata _message)
+        internal
+        pure
+        override
+        returns (bytes32)
+    {
+        // We verify a merkle proof of (messageId, index) I to compute root J
+        bytes32 _root = MerkleLib.branchRoot(
+            Message.id(_message),
+            MerkleRootMultisigIsmMetadata.proof(_metadata),
+            Message.nonce(_message)
+        );
+        // We provide (messageId, index) J in metadata for digest derivation
+        return
+            CheckpointLib.digest(
+                Message.origin(_message),
+                MerkleRootMultisigIsmMetadata.originMailbox(_metadata),
+                _root,
+                MerkleRootMultisigIsmMetadata.index(_metadata),
+                MerkleRootMultisigIsmMetadata.messageId(_metadata)
+            );
+    }
+
+    /**
+     * @inheritdoc AbstractMultisigIsm
+     */
+    function signatureAt(bytes calldata _metadata, uint256 _index)
+        internal
+        pure
+        virtual
+        override
+        returns (bytes memory signature)
+    {
+        return MerkleRootMultisigIsmMetadata.signatureAt(_metadata, _index);
+    }
+}

package/contracts/isms/multisig/AbstractMessageIdMultisigIsm.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
+import {AbstractMultisigIsm} from "./AbstractMultisigIsm.sol";
+import {MessageIdMultisigIsmMetadata} from "../../libs/isms/MessageIdMultisigIsmMetadata.sol";
+import {Message} from "../../libs/Message.sol";
+import {CheckpointLib} from "../../libs/CheckpointLib.sol";
+
+/**
+ * @title AbstractMessageIdMultisigIsm
+ * @notice Provides abstract logic for verifying signatures on a message ID.
+ * @dev Implement and use if you want fastest and cheapest security.
+ */
+abstract contract AbstractMessageIdMultisigIsm is AbstractMultisigIsm {
+    // ============ Constants ============
+
+    // solhint-disable-next-line const-name-snakecase
+    uint8 public constant moduleType =
+        uint8(IInterchainSecurityModule.Types.MESSAGE_ID_MULTISIG);
+
+    /**
+     * @inheritdoc AbstractMultisigIsm
+     */
+    function digest(bytes calldata _metadata, bytes calldata _message)
+        internal
+        pure
+        override
+        returns (bytes32)
+    {
+        return
+            CheckpointLib.digest(
+                Message.origin(_message),
+                MessageIdMultisigIsmMetadata.originMailbox(_metadata),
+                MessageIdMultisigIsmMetadata.root(_metadata),
+                Message.nonce(_message),
+                Message.id(_message)
+            );
+    }
+
+    /**
+     * @inheritdoc AbstractMultisigIsm
+     */
+    function signatureAt(bytes calldata _metadata, uint256 _index)
+        internal
+        pure
+        virtual
+        override
+        returns (bytes memory)
+    {
+        return MessageIdMultisigIsmMetadata.signatureAt(_metadata, _index);
+    }
+}

package/contracts/isms/multisig/AbstractMultisigIsm.sol

@@ -8,22 +8,17 @@ import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
 import {IMultisigIsm} from "../../interfaces/isms/IMultisigIsm.sol";
 import {Message} from "../../libs/Message.sol";
-import {MultisigIsmMetadata} from "../../libs/isms/MultisigIsmMetadata.sol";
-import {CheckpointLib} from "../../libs/CheckpointLib.sol";
 import {MerkleLib} from "../../libs/Merkle.sol";
 
 /**
  * @title MultisigIsm
  * @notice Manages per-domain m-of-n Validator sets that are used to verify
  * interchain messages.
+ * @dev See ./AbstractMerkleRootMultisigIsm.sol and ./AbstractMessageIdMultisigIsm.sol
+ * for concrete implementations of `digest` and `signatureAt`.
+ * @dev See ./StaticMultisigIsm.sol for concrete implementations.
  */
 abstract contract AbstractMultisigIsm is IMultisigIsm {
-    // ============ Constants ============
-
-    // solhint-disable-next-line const-name-snakecase
-    uint8 public constant moduleType =
-        uint8(IInterchainSecurityModule.Types.MULTISIG);
-
     // ============ Virtual Functions ============
     // ======= OVERRIDE THESE TO IMPLEMENT =======
 
@@ -41,74 +36,55 @@ abstract contract AbstractMultisigIsm is IMultisigIsm {
         virtual
         returns (address[] memory, uint8);
 
-    // ============ Public Functions ============
-
     /**
-     * @notice Requires that m-of-n validators verify a merkle root,
-     * and verifies a merkle proof of `_message` against that root.
-     * @param _metadata ABI encoded module metadata (see MultisigIsmMetadata.sol)
+     * @notice Returns the digest to be used for signature verification.
+     * @param _metadata ABI encoded module metadata
      * @param _message Formatted Hyperlane message (see Message.sol).
+     * @return digest The digest to be signed by validators
      */
-    function verify(bytes calldata _metadata, bytes calldata _message)
-        public
+    function digest(bytes calldata _metadata, bytes calldata _message)
+        internal
         view
-        returns (bool)
-    {
-        require(_verifyMerkleProof(_metadata, _message), "!merkle");
-        require(_verifyValidatorSignatures(_metadata, _message), "!sigs");
-        return true;
-    }
-
-    // ============ Internal Functions ============
+        virtual
+        returns (bytes32);
 
     /**
-     * @notice Verifies the merkle proof of `_message` against the provided
-     * checkpoint.
-     * @param _metadata ABI encoded module metadata (see MultisigIsmMetadata.sol)
-     * @param _message Formatted Hyperlane message (see Message.sol).
+     * @notice Returns the signature at a given index from the metadata.
+     * @param _metadata ABI encoded module metadata
+     * @param _index The index of the signature to return
+     * @return signature Packed encoding of signature (65 bytes)
      */
-    function _verifyMerkleProof(
-        bytes calldata _metadata,
-        bytes calldata _message
-    ) internal pure returns (bool) {
-        // calculate the expected root based on the proof
-        bytes32 _calculatedRoot = MerkleLib.branchRoot(
-            Message.id(_message),
-            MultisigIsmMetadata.proof(_metadata),
-            Message.nonce(_message)
-        );
-        return _calculatedRoot == MultisigIsmMetadata.root(_metadata);
-    }
+    function signatureAt(bytes calldata _metadata, uint256 _index)
+        internal
+        pure
+        virtual
+        returns (bytes memory);
+
+    // ============ Public Functions ============
 
     /**
-     * @notice Verifies that a quorum of the origin domain's validators signed
-     * the provided checkpoint.
-     * @param _metadata ABI encoded module metadata (see MultisigIsmMetadata.sol)
+     * @notice Requires that m-of-n validators verify a merkle root,
+     * and verifies a me∑rkle proof of `_message` against that root.
+     * @param _metadata ABI encoded module metadata
      * @param _message Formatted Hyperlane message (see Message.sol).
      */
-    function _verifyValidatorSignatures(
-        bytes calldata _metadata,
-        bytes calldata _message
-    ) internal view returns (bool) {
+    function verify(bytes calldata _metadata, bytes calldata _message)
+        public
+        view
+        returns (bool)
+    {
+        bytes32 _digest = digest(_metadata, _message);
         (
             address[] memory _validators,
             uint8 _threshold
         ) = validatorsAndThreshold(_message);
         require(_threshold > 0, "No MultisigISM threshold present for message");
-        bytes32 _digest = CheckpointLib.digest(
-            Message.origin(_message),
-            MultisigIsmMetadata.originMailbox(_metadata),
-            MultisigIsmMetadata.root(_metadata),
-            MultisigIsmMetadata.index(_metadata)
-        );
+
         uint256 _validatorCount = _validators.length;
         uint256 _validatorIndex = 0;
         // Assumes that signatures are ordered by validator
         for (uint256 i = 0; i < _threshold; ++i) {
-            address _signer = ECDSA.recover(
-                _digest,
-                MultisigIsmMetadata.signatureAt(_metadata, i)
-            );
+            address _signer = ECDSA.recover(_digest, signatureAt(_metadata, i));
             // Loop through remaining validators until we find a match
             while (
                 _validatorIndex < _validatorCount &&

package/contracts/isms/multisig/LegacyMultisigIsm.sol

@@ -12,7 +12,7 @@ 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";
+import {LegacyCheckpointLib} from "../../libs/LegacyCheckpointLib.sol";
 
 /**
  * @title MultisigIsm
@@ -331,7 +331,7 @@ contract LegacyMultisigIsm 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 = CheckpointLib.digest(
+            _digest = LegacyCheckpointLib.digest(
                 _origin,
                 LegacyMultisigIsmMetadata.originMailbox(_metadata),
                 LegacyMultisigIsmMetadata.root(_metadata),

package/contracts/isms/multisig/StaticMultisigIsm.sol

@@ -1,33 +1,68 @@
 // 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 {AbstractMerkleRootMultisigIsm} from "./AbstractMerkleRootMultisigIsm.sol";
+import {AbstractMessageIdMultisigIsm} from "./AbstractMessageIdMultisigIsm.sol";
 import {MetaProxy} from "../../libs/MetaProxy.sol";
+import {StaticMOfNAddressSetFactory} from "../../libs/StaticMOfNAddressSetFactory.sol";
 
 /**
- * @title StaticMultisigIsm
- * @notice Manages per-domain m-of-n Validator sets that are used
+ * @title AbstractMetaProxyMultisigIsm
+ * @notice Manages per-domain m-of-n Validator set that is used
  * to verify interchain messages.
  */
-contract StaticMultisigIsm is AbstractMultisigIsm {
-    // ============ Public Functions ============
-
+abstract contract AbstractMetaProxyMultisigIsm is AbstractMultisigIsm {
     /**
-     * @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
+     * @inheritdoc AbstractMultisigIsm
      */
     function validatorsAndThreshold(bytes calldata)
         public
-        view
-        virtual
+        pure
         override
         returns (address[] memory, uint8)
     {
         return abi.decode(MetaProxy.metadata(), (address[], uint8));
     }
 }
+
+// solhint-disable no-empty-blocks
+
+/**
+ * @title StaticMerkleRootMultisigIsm
+ * @notice Manages per-domain m-of-n validator set that is used
+ * to verify interchain messages using a merkle root signature quorum
+ * and merkle proof of inclusion.
+ */
+contract StaticMerkleRootMultisigIsm is
+    AbstractMerkleRootMultisigIsm,
+    AbstractMetaProxyMultisigIsm
+{
+
+}
+
+/**
+ * @title StaticMessageIdMultisigIsm
+ * @notice Manages per-domain m-of-n validator set that is used
+ * to verify interchain messages using a message ID signature quorum.
+ */
+contract StaticMessageIdMultisigIsm is
+    AbstractMessageIdMultisigIsm,
+    AbstractMetaProxyMultisigIsm
+{
+
+}
+
+// solhint-enable no-empty-blocks
+
+contract StaticMerkleRootMultisigIsmFactory is StaticMOfNAddressSetFactory {
+    function _deployImplementation() internal override returns (address) {
+        return address(new StaticMerkleRootMultisigIsm());
+    }
+}
+
+contract StaticMessageIdMultisigIsmFactory is StaticMOfNAddressSetFactory {
+    function _deployImplementation() internal override returns (address) {
+        return address(new StaticMessageIdMultisigIsm());
+    }
+}

package/contracts/isms/routing/AbstractRoutingIsm.sol

@@ -11,6 +11,7 @@ import {IRoutingIsm} from "../../interfaces/isms/IRoutingIsm.sol";
 abstract contract AbstractRoutingIsm is IRoutingIsm {
     // ============ Constants ============
 
+    // solhint-disable-next-line const-name-snakecase
     uint8 public constant moduleType =
         uint8(IInterchainSecurityModule.Types.ROUTING);
 

package/contracts/libs/CheckpointLib.sol

@@ -4,18 +4,25 @@ 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 _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.
+     * @dev Message ID must match leaf content of checkpoint root at index.
      * @return The digest of the checkpoint.
      */
     function digest(
         uint32 _origin,
         bytes32 _originMailbox,
         bytes32 _checkpointRoot,
-        uint32 _checkpointIndex
+        uint32 _checkpointIndex,
+        bytes32 _messageId
     ) internal pure returns (bytes32) {
         bytes32 _domainHash = domainHash(_origin, _originMailbox);
         return
@@ -24,7 +31,8 @@ library CheckpointLib {
                     abi.encodePacked(
                         _domainHash,
                         _checkpointRoot,
-                        _checkpointIndex
+                        _checkpointIndex,
+                        _messageId
                     )
                 )
             );

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

@@ -124,13 +124,14 @@ library MerkleLib {
      **/
     function branchRoot(
         bytes32 _item,
-        bytes32[TREE_DEPTH] memory _branch,
+        bytes32[TREE_DEPTH] memory _branch, // cheaper than calldata indexing
         uint256 _index
     ) internal pure returns (bytes32 _current) {
         _current = _item;
 
         for (uint256 i = 0; i < TREE_DEPTH; i++) {
             uint256 _ithBit = (_index >> i) & 0x01;
+            // cheaper than calldata indexing _branch[i*32:(i+1)*32];
             bytes32 _next = _branch[i];
             if (_ithBit == 1) {
                 _current = keccak256(abi.encodePacked(_next, _current));

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

@@ -3,27 +3,35 @@ pragma solidity >=0.8.0;
 
 /**
  * Format of metadata:
- * [   0:  32] Merkle root
- * [  32:  36] Root index
- * [  36:  68] Origin mailbox address
+ * [   0:  32] Origin mailbox address
+ * [  32:  36] Signed checkpoint index
+ * [  36:  68] Signed checkpoint message ID
  * [  68:1092] Merkle proof
- * [1092:????] Validator signatures, 65 bytes each, length == Threshold
+ * [1092:????] Validator signatures (length := threshold * 65)
  */
-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;
+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 merkle root of the signed checkpoint.
+     * @notice Returns the origin mailbox of the signed checkpoint as bytes32.
      * @param _metadata ABI encoded Multisig ISM metadata.
-     * @return Merkle root of the signed checkpoint
+     * @return Origin mailbox of the signed checkpoint as bytes32
      */
-    function root(bytes calldata _metadata) internal pure returns (bytes32) {
-        return bytes32(_metadata[MERKLE_ROOT_OFFSET:MERKLE_INDEX_OFFSET]);
+    function originMailbox(bytes calldata _metadata)
+        internal
+        pure
+        returns (bytes32)
+    {
+        return
+            bytes32(
+                _metadata[ORIGIN_MAILBOX_OFFSET:ORIGIN_MAILBOX_OFFSET + 32]
+            );
     }
 
     /**
@@ -34,21 +42,28 @@ library MultisigIsmMetadata {
     function index(bytes calldata _metadata) internal pure returns (uint32) {
         return
             uint32(
-                bytes4(_metadata[MERKLE_INDEX_OFFSET:ORIGIN_MAILBOX_OFFSET])
+                bytes4(
+                    _metadata[CHECKPOINT_INDEX_OFFSET:CHECKPOINT_INDEX_OFFSET +
+                        4]
+                )
             );
     }
 
     /**
-     * @notice Returns the origin mailbox of the signed checkpoint as bytes32.
+     * @notice Returns the message ID of the signed checkpoint.
      * @param _metadata ABI encoded Multisig ISM metadata.
-     * @return Origin mailbox of the signed checkpoint as bytes32
+     * @return Message ID of the signed checkpoint
      */
-    function originMailbox(bytes calldata _metadata)
+    function messageId(bytes calldata _metadata)
         internal
         pure
         returns (bytes32)
     {
-        return bytes32(_metadata[ORIGIN_MAILBOX_OFFSET:MERKLE_PROOF_OFFSET]);
+        return
+            bytes32(
+                _metadata[CHECKPOINT_MESSAGE_ID_OFFSET:CHECKPOINT_MESSAGE_ID_OFFSET +
+                    32]
+            );
     }
 
     /**
@@ -65,7 +80,8 @@ library MultisigIsmMetadata {
     {
         return
             abi.decode(
-                _metadata[MERKLE_PROOF_OFFSET:SIGNATURES_OFFSET],
+                _metadata[MERKLE_PROOF_OFFSET:MERKLE_PROOF_OFFSET +
+                    MERKLE_PROOF_LENGTH],
                 (bytes32[32])
             );
     }

package/contracts/libs/isms/MessageIdMultisigIsmMetadata.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+/**
+ * Format of metadata:
+ * [   0:  32] Origin mailbox address
+ * [  32:  64] Signed checkpoint root
+ * [  64:????] Validator signatures (length := threshold * 65)
+ */
+library MessageIdMultisigIsmMetadata {
+    uint8 private constant ORIGIN_MAILBOX_OFFSET = 0;
+    uint8 private constant MERKLE_ROOT_OFFSET = 32;
+    uint8 private constant SIGNATURES_OFFSET = 64;
+    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 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_ROOT_OFFSET + 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];
+    }
+}

package/contracts/test/TestLegacyMultisigIsm.sol

@@ -3,7 +3,7 @@ pragma solidity >=0.8.0;
 
 // ============ Internal Imports ============
 import {LegacyMultisigIsm} from "../isms/multisig/LegacyMultisigIsm.sol";
-import {CheckpointLib} from "../libs/CheckpointLib.sol";
+import {LegacyCheckpointLib} from "../libs/LegacyCheckpointLib.sol";
 
 contract TestLegacyMultisigIsm is LegacyMultisigIsm {
     function getDomainHash(uint32 _origin, bytes32 _originMailbox)
@@ -11,6 +11,6 @@ contract TestLegacyMultisigIsm is LegacyMultisigIsm {
         pure
         returns (bytes32)
     {
-        return CheckpointLib.domainHash(_origin, _originMailbox);
+        return LegacyCheckpointLib.domainHash(_origin, _originMailbox);
     }
 }

package/contracts/test/TestMultisigIsm.sol

@@ -7,7 +7,7 @@ import {IMultisigIsm} from "../interfaces/isms/IMultisigIsm.sol";
 contract TestMultisigIsm is IMultisigIsm {
     // solhint-disable-next-line const-name-snakecase
     uint8 public constant moduleType =
-        uint8(IInterchainSecurityModule.Types.MULTISIG);
+        uint8(IInterchainSecurityModule.Types.MERKLE_ROOT_MULTISIG);
 
     bool public accept;