@hyperlane-xyz/core 0.5.5 → 1.0.0-beta0

package/contracts/mock/MockHyperlaneEnvironment.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
-import "./MockOutbox.sol";
-import "./MockInbox.sol";
-import "../AbacusConnectionManager.sol";
+import "./MockMailbox.sol";
 import "../middleware/InterchainQueryRouter.sol";
+import "../InterchainGasPaymaster.sol";
+import "../test/TestIsm.sol";
 
 import {TypeCasts} from "../libs/TypeCasts.sol";
 
@@ -12,58 +12,42 @@ contract MockHyperlaneEnvironment {
     uint32 originDomain;
     uint32 destinationDomain;
 
-    mapping(uint32 => MockOutbox) public outboxes;
-    mapping(uint32 => MockInbox) public inboxes;
-    mapping(uint32 => AbacusConnectionManager) public connectionManagers;
+    mapping(uint32 => MockMailbox) public mailboxes;
+    mapping(uint32 => InterchainGasPaymaster) public igps;
+    mapping(uint32 => IInterchainSecurityModule) public isms;
     mapping(uint32 => InterchainQueryRouter) public queryRouters;
 
     constructor(uint32 _originDomain, uint32 _destinationDomain) {
         originDomain = _originDomain;
         destinationDomain = _destinationDomain;
 
-        MockInbox originInbox = new MockInbox();
-        MockOutbox originOutbox = new MockOutbox(
-            _originDomain,
-            address(originInbox)
-        );
+        MockMailbox originMailbox = new MockMailbox(_originDomain);
+        MockMailbox destinationMailbox = new MockMailbox(_destinationDomain);
 
-        MockInbox destinationInbox = new MockInbox();
-        MockOutbox destinationOutbox = new MockOutbox(
-            _destinationDomain,
-            address(destinationInbox)
-        );
+        originMailbox.addRemoteMailbox(_destinationDomain, destinationMailbox);
+        destinationMailbox.addRemoteMailbox(_originDomain, originMailbox);
 
-        outboxes[_originDomain] = originOutbox;
-        outboxes[_destinationDomain] = destinationOutbox;
-        inboxes[_originDomain] = destinationInbox;
-        inboxes[_destinationDomain] = originInbox;
+        igps[originDomain] = new InterchainGasPaymaster();
+        igps[destinationDomain] = new InterchainGasPaymaster();
 
-        AbacusConnectionManager originManager = new AbacusConnectionManager();
-        AbacusConnectionManager destinationManager = new AbacusConnectionManager();
+        isms[originDomain] = new TestIsm();
+        isms[destinationDomain] = new TestIsm();
 
-        originManager.setOutbox(address(originOutbox));
-        destinationManager.enrollInbox(
-            _destinationDomain,
-            address(originInbox)
-        );
-        destinationManager.setOutbox(address(destinationOutbox));
-        originManager.enrollInbox(_originDomain, address(destinationInbox));
-
-        connectionManagers[_originDomain] = originManager;
-        connectionManagers[_destinationDomain] = destinationManager;
+        mailboxes[_originDomain] = originMailbox;
+        mailboxes[_destinationDomain] = destinationMailbox;
 
         InterchainQueryRouter originQueryRouter = new InterchainQueryRouter();
         InterchainQueryRouter destinationQueryRouter = new InterchainQueryRouter();
 
         originQueryRouter.initialize(
-            address(this),
-            address(originManager),
-            address(0)
+            address(originMailbox),
+            address(igps[originDomain]),
+            address(isms[originDomain])
         );
         destinationQueryRouter.initialize(
-            address(this),
-            address(destinationManager),
-            address(0)
+            address(destinationMailbox),
+            address(igps[destinationDomain]),
+            address(isms[destinationDomain])
         );
 
         originQueryRouter.enrollRemoteRouter(
@@ -79,19 +63,11 @@ contract MockHyperlaneEnvironment {
         queryRouters[_destinationDomain] = destinationQueryRouter;
     }
 
-    function connectionManager(uint32 _domain)
-        public
-        view
-        returns (AbacusConnectionManager)
-    {
-        return connectionManagers[_domain];
-    }
-
     function processNextPendingMessage() public {
-        inboxes[destinationDomain].processNextPendingMessage();
+        mailboxes[destinationDomain].processNextInboundMessage();
     }
 
     function processNextPendingMessageFromDestination() public {
-        inboxes[originDomain].processNextPendingMessage();
+        mailboxes[originDomain].processNextInboundMessage();
     }
 }

package/contracts/mock/MockInterchainAccountRouter.sol

@@ -40,7 +40,7 @@ contract MockInterchainAccountRouter is IInterchainAccountRouter {
 
     function dispatch(uint32 _destinationDomain, Call[] calldata calls)
         public
-        returns (uint256)
+        returns (bytes32)
     {
         return _dispatch(_destinationDomain, calls);
     }
@@ -49,20 +49,20 @@ contract MockInterchainAccountRouter is IInterchainAccountRouter {
         uint32 _destinationDomain,
         address target,
         bytes calldata data
-    ) external returns (uint256) {
+    ) external returns (bytes32) {
         Call[] memory calls = new Call[](1);
         calls[0] = Call({to: target, data: data});
         return _dispatch(_destinationDomain, calls);
     }
 
-    function _dispatch(uint32, Call[] memory calls) internal returns (uint256) {
+    function _dispatch(uint32, Call[] memory calls) internal returns (bytes32) {
         pendingCalls[totalCalls] = PendingCall(
             originDomain,
             msg.sender,
             abi.encode(calls)
         );
         totalCalls += 1;
-        return totalCalls;
+        return keccak256(abi.encodePacked(totalCalls));
     }
 
     function getInterchainAccount(uint32 _origin, address _sender)

package/contracts/mock/MockMailbox.sol

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {TypeCasts} from "../libs/TypeCasts.sol";
+import {IMessageRecipient} from "../../interfaces/IMessageRecipient.sol";
+
+contract MockMailbox {
+    using TypeCasts for address;
+    using TypeCasts for bytes32;
+    // Domain of chain on which the contract is deployed
+    uint32 public immutable domain;
+    uint32 public immutable version = 0;
+
+    uint256 public outboundNonce = 0;
+    uint256 public inboundUnprocessedNonce = 0;
+    uint256 public inboundProcessedNonce = 0;
+    mapping(uint32 => MockMailbox) public remoteMailboxes;
+    mapping(uint256 => Message) public inboundMessages;
+
+    struct Message {
+        uint32 origin;
+        address sender;
+        address recipient;
+        bytes body;
+    }
+
+    constructor(uint32 _domain) {
+        domain = _domain;
+    }
+
+    function addRemoteMailbox(uint32 _domain, MockMailbox _mailbox) external {
+        remoteMailboxes[_domain] = _mailbox;
+    }
+
+    function dispatch(
+        uint32 _destinationDomain,
+        bytes32 _recipientAddress,
+        bytes calldata _messageBody
+    ) external returns (bytes32) {
+        MockMailbox _destinationMailbox = remoteMailboxes[_destinationDomain];
+        require(
+            address(_destinationMailbox) != address(0),
+            "Missing remote mailbox"
+        );
+        _destinationMailbox.addInboundMessage(
+            domain,
+            msg.sender,
+            _recipientAddress.bytes32ToAddress(),
+            _messageBody
+        );
+        outboundNonce++;
+        return bytes32(0);
+    }
+
+    function addInboundMessage(
+        uint32 _origin,
+        address _sender,
+        address _recipient,
+        bytes calldata _body
+    ) external {
+        inboundMessages[inboundUnprocessedNonce] = Message(
+            _origin,
+            _sender,
+            _recipient,
+            _body
+        );
+        inboundUnprocessedNonce++;
+    }
+
+    function processNextInboundMessage() public {
+        Message memory _message = inboundMessages[inboundProcessedNonce];
+        IMessageRecipient(_message.recipient).handle(
+            _message.origin,
+            _message.sender.addressToBytes32(),
+            _message.body
+        );
+        inboundProcessedNonce++;
+    }
+}

package/contracts/test/TestHyperlaneConnectionClient.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.11;
+import {HyperlaneConnectionClient} from "../HyperlaneConnectionClient.sol";
+import {IMailbox} from "../../interfaces/IMailbox.sol";
+
+contract TestHyperlaneConnectionClient is HyperlaneConnectionClient {
+    function initialize(address _mailbox) external initializer {
+        __HyperlaneConnectionClient_initialize(_mailbox);
+    }
+
+    function localDomain() external view returns (uint32) {
+        return mailbox.localDomain();
+    }
+}

package/contracts/test/TestIsm.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
+
+contract TestIsm is IInterchainSecurityModule {
+    bool public accept;
+
+    function setAccept(bool _val) external {
+        accept = _val;
+    }
+
+    function verify(bytes calldata, bytes calldata)
+        external
+        view
+        returns (bool)
+    {
+        return accept;
+    }
+}

package/contracts/test/TestLiquidityLayerMessageRecipient.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
-import {ILiquidityLayerMessageRecipient} from "../middleware/liquidity-layer/interfaces/ILiquidityLayerMessageRecipient.sol";
+import {ILiquidityLayerMessageRecipient} from "../../interfaces/ILiquidityLayerMessageRecipient.sol";
 
 contract TestLiquidityLayerMessageRecipient is ILiquidityLayerMessageRecipient {
     event HandledWithTokens(

package/contracts/test/TestMailbox.sol

@@ -1,12 +1,42 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity >=0.8.0;
 
-import "../Mailbox.sol";
+import {Mailbox} from "../Mailbox.sol";
+import {TypeCasts} from "../libs/TypeCasts.sol";
+import {MerkleLib} from "../libs/Merkle.sol";
+import {IMessageRecipient} from "../../interfaces/IMessageRecipient.sol";
 
 contract TestMailbox is Mailbox {
-    constructor(uint32 _localDomain) Mailbox(_localDomain) {}
+    using TypeCasts for bytes32;
 
-    function initialize(address _validatorManager) external initializer {
-        __Mailbox_initialize(_validatorManager);
+    constructor(uint32 _localDomain) Mailbox(_localDomain) {} // solhint-disable-line no-empty-blocks
+
+    function proof() external view returns (bytes32[32] memory) {
+        bytes32[32] memory _zeroes = MerkleLib.zeroHashes();
+        uint256 _index = tree.count - 1;
+        bytes32[32] memory _proof;
+
+        for (uint256 i = 0; i < 32; i++) {
+            uint256 _ithBit = (_index >> i) & 0x01;
+            if (_ithBit == 1) {
+                _proof[i] = tree.branch[i];
+            } else {
+                _proof[i] = _zeroes[i];
+            }
+        }
+        return _proof;
+    }
+
+    function testHandle(
+        uint32 _origin,
+        bytes32 _sender,
+        bytes32 _recipient,
+        bytes calldata _body
+    ) external {
+        IMessageRecipient(_recipient.bytes32ToAddress()).handle(
+            _origin,
+            _sender,
+            _body
+        );
     }
 }

package/contracts/test/TestMerkle.sol

@@ -1,13 +1,14 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity >=0.8.0;
+import {MerkleLib} from "../libs/Merkle.sol";
 
-import "../MerkleTreeManager.sol";
-
-contract TestMerkle is MerkleTreeManager {
+contract TestMerkle {
     using MerkleLib for MerkleLib.Tree;
 
+    MerkleLib.Tree public tree;
+
     // solhint-disable-next-line no-empty-blocks
-    constructor() MerkleTreeManager() {}
+    constructor() {}
 
     function insert(bytes32 _node) external {
         tree.insert(_node);
@@ -27,4 +28,8 @@ contract TestMerkle is MerkleTreeManager {
     function count() public view returns (uint256) {
         return tree.count;
     }
+
+    function root() public view returns (bytes32) {
+        return tree.root();
+    }
 }

package/contracts/test/TestMessage.sol

@@ -6,12 +6,28 @@ import {Message} from "../libs/Message.sol";
 contract TestMessage {
     using Message for bytes;
 
+    function version(bytes calldata _message)
+        external
+        pure
+        returns (uint32 _version)
+    {
+        return _message.version();
+    }
+
+    function nonce(bytes calldata _message)
+        external
+        pure
+        returns (uint256 _nonce)
+    {
+        return _message.nonce();
+    }
+
     function body(bytes calldata _message)
         external
         pure
         returns (bytes calldata _body)
     {
-        (, , , , _body) = _message.destructure();
+        return _message.body();
     }
 
     function origin(bytes calldata _message)
@@ -19,7 +35,7 @@ contract TestMessage {
         pure
         returns (uint32 _origin)
     {
-        (_origin, , , , ) = _message.destructure();
+        return _message.origin();
     }
 
     function sender(bytes calldata _message)
@@ -27,7 +43,7 @@ contract TestMessage {
         pure
         returns (bytes32 _sender)
     {
-        (, _sender, , , ) = _message.destructure();
+        return _message.sender();
     }
 
     function destination(bytes calldata _message)
@@ -35,7 +51,7 @@ contract TestMessage {
         pure
         returns (uint32 _destination)
     {
-        (, , _destination, , ) = _message.destructure();
+        return _message.destination();
     }
 
     function recipient(bytes calldata _message)
@@ -43,7 +59,7 @@ contract TestMessage {
         pure
         returns (bytes32 _recipient)
     {
-        (, , , _recipient, ) = _message.destructure();
+        return _message.recipient();
     }
 
     function recipientAddress(bytes calldata _message)
@@ -51,14 +67,10 @@ contract TestMessage {
         pure
         returns (address _recipient)
     {
-        (, , , _recipient, ) = _message.destructureAddresses();
+        return _message.recipientAddress();
     }
 
-    function leaf(bytes calldata _message, uint256 _leafIndex)
-        external
-        pure
-        returns (bytes32)
-    {
-        return _message.leaf(_leafIndex);
+    function id(bytes calldata _message) external pure returns (bytes32) {
+        return _message.id();
     }
 }

package/contracts/test/TestMultisigIsm.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {MultisigIsm} from "../isms/MultisigIsm.sol";
+
+contract TestMultisigIsm is MultisigIsm {
+    function getDomainHash(uint32 _origin, bytes32 _originMailbox)
+        external
+        pure
+        returns (bytes32)
+    {
+        return _getDomainHash(_origin, _originMailbox);
+    }
+
+    function getCheckpointDigest(bytes calldata _metadata, uint32 _origin)
+        external
+        pure
+        returns (bytes32)
+    {
+        return _getCheckpointDigest(_metadata, _origin);
+    }
+}

package/contracts/test/TestRouter.sol

@@ -6,8 +6,8 @@ import "../Router.sol";
 contract TestRouter is Router {
     event InitializeOverload();
 
-    function initialize(address _abacusConnectionManager) external initializer {
-        __Router_initialize(_abacusConnectionManager);
+    function initialize(address _mailbox) external initializer {
+        __Router_initialize(_mailbox);
         emit InitializeOverload();
     }
 
@@ -38,10 +38,18 @@ contract TestRouter is Router {
     }
 
     function dispatchWithGas(
-        uint32 _destination,
-        bytes memory _msg,
-        uint256 _gasPayment
+        uint32 _destinationDomain,
+        bytes memory _messageBody,
+        uint256 _gasAmount,
+        uint256 _gasPayment,
+        address _gasPaymentRefundAddress
     ) external payable {
-        _dispatchWithGas(_destination, _msg, _gasPayment);
+        _dispatchWithGas(
+            _destinationDomain,
+            _messageBody,
+            _gasAmount,
+            _gasPayment,
+            _gasPaymentRefundAddress
+        );
     }
 }

package/contracts/test/TestSendReceiver.sol

@@ -5,20 +5,22 @@ import {TypeCasts} from "../libs/TypeCasts.sol";
 
 import {IInterchainGasPaymaster} from "../../interfaces/IInterchainGasPaymaster.sol";
 import {IMessageRecipient} from "../../interfaces/IMessageRecipient.sol";
-import {IOutbox} from "../../interfaces/IOutbox.sol";
+import {IMailbox} from "../../interfaces/IMailbox.sol";
 
 contract TestSendReceiver is IMessageRecipient {
     using TypeCasts for address;
 
+    uint256 public constant HANDLE_GAS_AMOUNT = 50_000;
+
     event Handled(bytes32 blockHash);
 
     function dispatchToSelf(
-        IOutbox _outbox,
+        IMailbox _mailbox,
         IInterchainGasPaymaster _paymaster,
         uint32 _destinationDomain,
         bytes calldata _messageBody
     ) external payable {
-        uint256 _leafIndex = _outbox.dispatch(
+        bytes32 _messageId = _mailbox.dispatch(
             _destinationDomain,
             address(this).addressToBytes32(),
             _messageBody
@@ -27,23 +29,27 @@ contract TestSendReceiver is IMessageRecipient {
         uint256 _value = msg.value;
         if (_blockHashNum % 5 == 0) {
             // Pay in two separate calls, resulting in 2 distinct events
-            uint256 _half = _value / 2;
-            _paymaster.payGasFor{value: _half}(
-                address(_outbox),
-                _leafIndex,
-                _destinationDomain
+            uint256 _halfPayment = _value / 2;
+            uint256 _halfGasAmount = HANDLE_GAS_AMOUNT / 2;
+            _paymaster.payForGas{value: _halfPayment}(
+                _messageId,
+                _destinationDomain,
+                _halfGasAmount,
+                msg.sender
             );
-            _paymaster.payGasFor{value: _value - _half}(
-                address(_outbox),
-                _leafIndex,
-                _destinationDomain
+            _paymaster.payForGas{value: _value - _halfPayment}(
+                _messageId,
+                _destinationDomain,
+                HANDLE_GAS_AMOUNT - _halfGasAmount,
+                msg.sender
             );
         } else {
             // Pay the entire msg.value in one call
-            _paymaster.payGasFor{value: _value}(
-                address(_outbox),
-                _leafIndex,
-                _destinationDomain
+            _paymaster.payForGas{value: _value}(
+                _messageId,
+                _destinationDomain,
+                HANDLE_GAS_AMOUNT,
+                msg.sender
             );
         }
     }

package/contracts/test/TestTokenRecipient.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity >=0.8.0;
 
-import {ILiquidityLayerMessageRecipient} from "../middleware/liquidity-layer/interfaces/ILiquidityLayerMessageRecipient.sol";
+import {ILiquidityLayerMessageRecipient} from "../../interfaces/ILiquidityLayerMessageRecipient.sol";
 
 contract TestTokenRecipient is ILiquidityLayerMessageRecipient {
     bytes32 public lastSender;

package/contracts/upgrade/ProxyAdmin.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.1 (proxy/transparent/ProxyAdmin.sol)
+
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";

package/contracts/upgrade/TransparentUpgradeableProxy.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.7.0) (proxy/transparent/TransparentUpgradeableProxy.sol)
+
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";

package/interfaces/IInterchainAccountRouter.sol

@@ -6,13 +6,13 @@ import {Call} from "../contracts/Call.sol";
 interface IInterchainAccountRouter {
     function dispatch(uint32 _destinationDomain, Call[] calldata calls)
         external
-        returns (uint256);
+        returns (bytes32);
 
     function dispatch(
         uint32 _destinationDomain,
         address target,
         bytes calldata data
-    ) external returns (uint256);
+    ) external returns (bytes32);
 
     function getInterchainAccount(uint32 _originDomain, address _sender)
         external

package/interfaces/IInterchainGasPaymaster.sol

@@ -7,9 +7,10 @@ pragma solidity >=0.6.11;
  * messages to destination chains.
  */
 interface IInterchainGasPaymaster {
-    function payGasFor(
-        address _outbox,
-        uint256 _leafIndex,
-        uint32 _destinationDomain
+    function payForGas(
+        bytes32 _messageId,
+        uint32 _destinationDomain,
+        uint256 _gas,
+        address _refundAddress
     ) external payable;
 }

package/interfaces/IInterchainQueryRouter.sol

@@ -9,17 +9,17 @@ interface IInterchainQueryRouter {
         address target,
         bytes calldata queryData,
         bytes calldata callback
-    ) external returns (uint256);
+    ) external returns (bytes32);
 
     function query(
         uint32 _destinationDomain,
         Call calldata call,
         bytes calldata callback
-    ) external returns (uint256);
+    ) external returns (bytes32);
 
     function query(
         uint32 _destinationDomain,
         Call[] calldata calls,
         bytes[] calldata callbacks
-    ) external returns (uint256);
+    ) external returns (bytes32);
 }

package/interfaces/IInterchainSecurityModule.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.11;
+
+interface IInterchainSecurityModule {
+    // Called by the Mailbox to determine whether or not the message should be accepted.
+    function verify(bytes calldata _metadata, bytes calldata _message)
+        external
+        returns (bool);
+}
+
+interface ISpecifiesInterchainSecurityModule {
+    function interchainSecurityModule()
+        external
+        view
+        returns (IInterchainSecurityModule);
+}

package/interfaces/ILiquidityLayerRouter.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.11;
+
+import {Call} from "../contracts/Call.sol";
+
+interface ILiquidityLayerRouter {
+    function dispatchWithTokens(
+        uint32 _destinationDomain,
+        bytes32 _recipientAddress,
+        bytes calldata _messageBody,
+        address _token,
+        uint256 _amount,
+        string calldata _bridge
+    ) external payable returns (bytes32);
+}