@hyperlane-xyz/core 1.3.4 → 1.3.6

package/contracts/hooks/OptimismMessageHook.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+/*@@@@@@@       @@@@@@@@@
+ @@@@@@@@@       @@@@@@@@@
+  @@@@@@@@@       @@@@@@@@@
+   @@@@@@@@@       @@@@@@@@@
+    @@@@@@@@@@@@@@@@@@@@@@@@@
+     @@@@@  HYPERLANE  @@@@@@@
+    @@@@@@@@@@@@@@@@@@@@@@@@@
+   @@@@@@@@@       @@@@@@@@@
+  @@@@@@@@@       @@@@@@@@@
+ @@@@@@@@@       @@@@@@@@@
+@@@@@@@@@       @@@@@@@@*/
+
+// ============ Internal Imports ============
+import {IMessageHook} from "../interfaces/hooks/IMessageHook.sol";
+import {OptimismISM} from "../isms/native/OptimismISM.sol";
+
+// ============ External Imports ============
+import {ICrossDomainMessenger} from "@eth-optimism/contracts/libraries/bridge/ICrossDomainMessenger.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+
+/**
+ * @title OptimismMessageHook
+ * @notice Message hook to inform the Optimism ISM of messages published through
+ * the native Optimism bridge.
+ */
+contract OptimismMessageHook is IMessageHook {
+    // ============ Constants ============
+
+    // Domain of chain on which the optimism ISM is deployed
+    uint32 public immutable destinationDomain;
+    // Messenger used to send messages from L1 -> L2
+    ICrossDomainMessenger public immutable l1Messenger;
+    // address for Optimism ISM to verify messages
+    address public immutable ism;
+    // Gas limit for sending messages to L2
+    // First 1.92e6 gas is provided by Optimism, see more here:
+    // https://community.optimism.io/docs/developers/bridge/messaging/#for-l1-%E2%87%92-l2-transactions
+    uint32 internal constant GAS_LIMIT = 1_920_000;
+
+    // ============ Constructor ============
+
+    constructor(
+        uint32 _destinationDomain,
+        address _messenger,
+        address _ism
+    ) {
+        require(
+            _destinationDomain != 0,
+            "OptimismHook: invalid destination domain"
+        );
+        require(_ism != address(0), "OptimismHook: invalid ISM");
+        destinationDomain = _destinationDomain;
+
+        require(
+            Address.isContract(_messenger),
+            "OptimismHook: invalid messenger"
+        );
+        l1Messenger = ICrossDomainMessenger(_messenger);
+        ism = _ism;
+    }
+
+    // ============ External Functions ============
+
+    /**
+     * @notice Hook to inform the optimism ISM of messages published through.
+     * @dev anyone can call this function, that's why we need to send msg.sender
+     * @param _destination The destination domain of the message.
+     * @param _messageId The message ID.
+     * @return gasOverhead The gas overhead for the function call on L2.
+     */
+    function postDispatch(uint32 _destination, bytes32 _messageId)
+        public
+        payable
+        override
+        returns (uint256)
+    {
+        require(msg.value == 0, "OptimismHook: no value allowed");
+        require(
+            _destination == destinationDomain,
+            "OptimismHook: invalid destination domain"
+        );
+
+        bytes memory _payload = abi.encodeCall(
+            OptimismISM.verifyMessageId,
+            (msg.sender, _messageId)
+        );
+
+        l1Messenger.sendMessage(ism, _payload, GAS_LIMIT);
+
+        // calling the verifyMessageId function is ~25k gas but we get 1.92m gas from Optimism
+        return 0;
+    }
+}

package/contracts/interfaces/IInterchainSecurityModule.sol

@@ -3,11 +3,13 @@ pragma solidity >=0.6.11;
 
 interface IInterchainSecurityModule {
     enum Types {
-        UNUSED,
+        NULL, // used with relayer carrying no metadata
         ROUTING,
         AGGREGATION,
         LEGACY_MULTISIG,
-        MULTISIG
+        MERKLE_ROOT_MULTISIG,
+        MESSAGE_ID_MULTISIG,
+        OPTIMISM
     }
 
     /**

package/contracts/interfaces/hooks/IMessageHook.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+interface IMessageHook {
+    function postDispatch(uint32 _destination, bytes32 _messageId)
+        external
+        payable
+        returns (uint256);
+}

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/native/AbstractNativeISM.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+
+import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
+import {Message} from "../../libs/Message.sol";
+import {TypeCasts} from "../../libs/TypeCasts.sol";
+
+// ============ External Imports ============
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+
+/**
+ * @title ArbtractNativeISM
+ * @notice Uses the native bridges to verify interchain messages.
+ * @dev In the future, the hook might be moved inside the Mailbox which doesn't require storage mappings for senders.
+ *      for more details see https://github.com/hyperlane-xyz/hyperlane-monorepo/issues/2381
+ */
+abstract contract AbstractNativeISM is
+    IInterchainSecurityModule,
+    Initializable
+{
+    // ============ Public Storage ============
+
+    // mapping to check if the specific messageID from a specific sender has been received
+    // @dev anyone can send an untrusted messageId, so need to check for that while verifying
+    mapping(bytes32 => mapping(address => bool)) public verifiedMessageIds;
+
+    // ============ Events ============
+
+    event ReceivedMessage(address indexed sender, bytes32 indexed messageId);
+
+    // ============ External Functions ============
+
+    /**
+     * @notice Verify a message was received by ISM.
+     * @param _message Message to verify.
+     */
+    function verify(
+        bytes calldata, /*_metadata*/
+        bytes calldata _message
+    ) external view returns (bool) {
+        bytes32 _messageId = Message.id(_message);
+        address _messageSender = Message.senderAddress(_message);
+
+        return verifiedMessageIds[_messageId][_messageSender];
+    }
+}

package/contracts/isms/native/OptimismISM.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+
+import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
+import {OptimismMessageHook} from "../../hooks/OptimismMessageHook.sol";
+import {Message} from "../../libs/Message.sol";
+import {TypeCasts} from "../../libs/TypeCasts.sol";
+import {AbstractNativeISM} from "./AbstractNativeISM.sol";
+
+// ============ External Imports ============
+
+import {ICrossDomainMessenger} from "@eth-optimism/contracts/libraries/bridge/ICrossDomainMessenger.sol";
+import {CrossChainEnabledOptimism} from "@openzeppelin/contracts/crosschain/optimism/CrossChainEnabledOptimism.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+
+/**
+ * @title OptimismISM
+ * @notice Uses the native Optimism bridge to verify interchain messages.
+ */
+contract OptimismISM is CrossChainEnabledOptimism, AbstractNativeISM {
+    // ============ Constants ============
+
+    // solhint-disable-next-line const-name-snakecase
+    uint8 public constant moduleType =
+        uint8(IInterchainSecurityModule.Types.NULL);
+
+    // ============ Public Storage ============
+
+    // Address for Hook on L1 responsible for sending message via the Optimism bridge
+    // @dev check https://github.com/hyperlane-xyz/hyperlane-monorepo/issues/2381 for updates to native
+    address public l1Hook;
+
+    // ============ Modifiers ============
+
+    /**
+     * @notice Check if sender is authorized to message `verifyMessageId`.
+     */
+    modifier isAuthorized() {
+        require(
+            _crossChainSender() == l1Hook,
+            "OptimismISM: sender is not the hook"
+        );
+        _;
+    }
+
+    // ============ Constructor ============
+
+    constructor(address _l2Messenger) CrossChainEnabledOptimism(_l2Messenger) {
+        require(
+            Address.isContract(_l2Messenger),
+            "OptimismISM: invalid L2Messenger"
+        );
+    }
+
+    // ============ Initializer ============
+
+    function setOptimismHook(address _l1Hook) external initializer {
+        require(_l1Hook != address(0), "OptimismISM: invalid l1Hook");
+        l1Hook = _l1Hook;
+    }
+
+    // ============ External Functions ============
+
+    /**
+     * @notice Receive a message from the L2 messenger.
+     * @dev Only callable by the L2 messenger.
+     * @param _sender Address of the sender.
+     * @param _messageId Hyperlane ID for the message.
+     */
+    function verifyMessageId(address _sender, bytes32 _messageId)
+        external
+        isAuthorized
+    {
+        verifiedMessageIds[_messageId][_sender] = true;
+
+        emit ReceivedMessage(_sender, _messageId);
+    }
+}

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
                     )
                 )
             );