@hyperlane-xyz/core 0.5.1 → 0.5.2

package/contracts/AbacusConnectionClient.sol

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.11;
+
+// ============ Internal Imports ============
+import {IInterchainGasPaymaster} from "../interfaces/IInterchainGasPaymaster.sol";
+import {IOutbox} from "../interfaces/IOutbox.sol";
+import {IAbacusConnectionManager} from "../interfaces/IAbacusConnectionManager.sol";
+
+// ============ External Imports ============
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+abstract contract AbacusConnectionClient is OwnableUpgradeable {
+    // ============ Mutable Storage ============
+
+    IAbacusConnectionManager public abacusConnectionManager;
+    // Interchain Gas Paymaster contract. The relayer associated with this contract
+    // must be willing to relay messages dispatched from the current Outbox contract,
+    // otherwise payments made to the paymaster will not result in relayed messages.
+    IInterchainGasPaymaster public interchainGasPaymaster;
+
+    uint256[48] private __GAP; // gap for upgrade safety
+
+    // ============ Events ============
+
+    /**
+     * @notice Emitted when a new abacusConnectionManager is set.
+     * @param abacusConnectionManager The address of the abacusConnectionManager contract
+     */
+    event AbacusConnectionManagerSet(address indexed abacusConnectionManager);
+
+    /**
+     * @notice Emitted when a new Interchain Gas Paymaster is set.
+     * @param interchainGasPaymaster The address of the Interchain Gas Paymaster.
+     */
+    event InterchainGasPaymasterSet(address indexed interchainGasPaymaster);
+
+    // ============ Modifiers ============
+
+    /**
+     * @notice Only accept messages from an Abacus Inbox contract
+     */
+    modifier onlyInbox() {
+        require(_isInbox(msg.sender), "!inbox");
+        _;
+    }
+
+    // ======== Initializer =========
+
+    function __AbacusConnectionClient_initialize(
+        address _abacusConnectionManager
+    ) internal onlyInitializing {
+        _setAbacusConnectionManager(_abacusConnectionManager);
+        __Ownable_init();
+    }
+
+    function __AbacusConnectionClient_initialize(
+        address _abacusConnectionManager,
+        address _interchainGasPaymaster
+    ) internal onlyInitializing {
+        _setInterchainGasPaymaster(_interchainGasPaymaster);
+        __AbacusConnectionClient_initialize(_abacusConnectionManager);
+    }
+
+    // ============ External functions ============
+
+    /**
+     * @notice Sets the address of the application's AbacusConnectionManager.
+     * @param _abacusConnectionManager The address of the AbacusConnectionManager contract.
+     */
+    function setAbacusConnectionManager(address _abacusConnectionManager)
+        external
+        virtual
+        onlyOwner
+    {
+        _setAbacusConnectionManager(_abacusConnectionManager);
+    }
+
+    /**
+     * @notice Sets the address of the application's InterchainGasPaymaster.
+     * @param _interchainGasPaymaster The address of the InterchainGasPaymaster contract.
+     */
+    function setInterchainGasPaymaster(address _interchainGasPaymaster)
+        external
+        virtual
+        onlyOwner
+    {
+        _setInterchainGasPaymaster(_interchainGasPaymaster);
+    }
+
+    // ============ Internal functions ============
+
+    /**
+     * @notice Sets the address of the application's InterchainGasPaymaster.
+     * @param _interchainGasPaymaster The address of the InterchainGasPaymaster contract.
+     */
+    function _setInterchainGasPaymaster(address _interchainGasPaymaster)
+        internal
+    {
+        interchainGasPaymaster = IInterchainGasPaymaster(
+            _interchainGasPaymaster
+        );
+        emit InterchainGasPaymasterSet(_interchainGasPaymaster);
+    }
+
+    /**
+     * @notice Modify the contract the Application uses to validate Inbox contracts
+     * @param _abacusConnectionManager The address of the abacusConnectionManager contract
+     */
+    function _setAbacusConnectionManager(address _abacusConnectionManager)
+        internal
+    {
+        abacusConnectionManager = IAbacusConnectionManager(
+            _abacusConnectionManager
+        );
+        emit AbacusConnectionManagerSet(_abacusConnectionManager);
+    }
+
+    /**
+     * @notice Get the local Outbox contract from the abacusConnectionManager
+     * @return The local Outbox contract
+     */
+    function _outbox() internal view returns (IOutbox) {
+        return abacusConnectionManager.outbox();
+    }
+
+    /**
+     * @notice Determine whether _potentialInbox is an enrolled Inbox from the abacusConnectionManager
+     * @return True if _potentialInbox is an enrolled Inbox
+     */
+    function _isInbox(address _potentialInbox) internal view returns (bool) {
+        return abacusConnectionManager.isInbox(_potentialInbox);
+    }
+
+    /**
+     * @notice Get the local domain from the abacusConnectionManager
+     * @return The local domain
+     */
+    function _localDomain() internal view virtual returns (uint32) {
+        return abacusConnectionManager.localDomain();
+    }
+}

package/contracts/OwnableMulticall.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+// ============ External Imports ============
+
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+struct Call {
+    address to;
+    bytes data;
+}
+
+/*
+ * @title OwnableMulticall
+ * @dev Allows only only address to execute calls to other contracts
+ */
+contract OwnableMulticall is OwnableUpgradeable {
+    constructor() {
+        _transferOwnership(msg.sender);
+    }
+
+    function proxyCalls(Call[] calldata calls) external onlyOwner {
+        for (uint256 i = 0; i < calls.length; i += 1) {
+            (bool success, bytes memory returnData) = calls[i].to.call(
+                calls[i].data
+            );
+            if (!success) {
+                assembly {
+                    revert(add(returnData, 32), returnData)
+                }
+            }
+        }
+    }
+
+    function _call(Call[] memory calls, bytes[] memory callbacks)
+        internal
+        returns (bytes[] memory resolveCalls)
+    {
+        resolveCalls = new bytes[](callbacks.length);
+        for (uint256 i = 0; i < calls.length; i++) {
+            (bool success, bytes memory returnData) = calls[i].to.call(
+                calls[i].data
+            );
+            require(success, "Multicall: call failed");
+            resolveCalls[i] = bytes.concat(callbacks[i], returnData);
+        }
+    }
+
+    // TODO: deduplicate
+    function proxyCallBatch(address to, bytes[] memory calls) internal {
+        for (uint256 i = 0; i < calls.length; i += 1) {
+            (bool success, bytes memory returnData) = to.call(calls[i]);
+            if (!success) {
+                assembly {
+                    revert(add(returnData, 32), returnData)
+                }
+            }
+        }
+    }
+}

package/contracts/Router.sol

@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.11;
+
+// ============ Internal Imports ============
+import {AbacusConnectionClient} from "./AbacusConnectionClient.sol";
+import {IAbacusConnectionManager} from "../interfaces/IAbacusConnectionManager.sol";
+import {IInterchainGasPaymaster} from "../interfaces/IInterchainGasPaymaster.sol";
+import {IMessageRecipient} from "../interfaces/IMessageRecipient.sol";
+import {IOutbox} from "../interfaces/IOutbox.sol";
+
+abstract contract Router is AbacusConnectionClient, IMessageRecipient {
+    string constant NO_ROUTER_ENROLLED_REVERT_MESSAGE =
+        "No router enrolled for domain. Did you specify the right domain ID?";
+
+    // ============ Mutable Storage ============
+
+    mapping(uint32 => bytes32) public routers;
+    uint256[49] private __GAP; // gap for upgrade safety
+
+    // ============ Events ============
+
+    /**
+     * @notice Emitted when a router is set.
+     * @param domain The domain of the new router
+     * @param router The address of the new router
+     */
+    event RemoteRouterEnrolled(uint32 indexed domain, bytes32 indexed router);
+
+    // ============ Modifiers ============
+    /**
+     * @notice Only accept messages from a remote Router contract
+     * @param _origin The domain the message is coming from
+     * @param _router The address the message is coming from
+     */
+    modifier onlyRemoteRouter(uint32 _origin, bytes32 _router) {
+        require(
+            _isRemoteRouter(_origin, _router),
+            NO_ROUTER_ENROLLED_REVERT_MESSAGE
+        );
+        _;
+    }
+
+    // ======== Initializer =========
+    function __Router_initialize(address _abacusConnectionManager)
+        internal
+        onlyInitializing
+    {
+        __AbacusConnectionClient_initialize(_abacusConnectionManager);
+    }
+
+    function __Router_initialize(
+        address _abacusConnectionManager,
+        address _interchainGasPaymaster
+    ) internal onlyInitializing {
+        __AbacusConnectionClient_initialize(
+            _abacusConnectionManager,
+            _interchainGasPaymaster
+        );
+    }
+
+    // ============ External functions ============
+
+    /**
+     * @notice Register the address of a Router contract for the same Application on a remote chain
+     * @param _domain The domain of the remote Application Router
+     * @param _router The address of the remote Application Router
+     */
+    function enrollRemoteRouter(uint32 _domain, bytes32 _router)
+        external
+        virtual
+        onlyOwner
+    {
+        _enrollRemoteRouter(_domain, _router);
+    }
+
+    /**
+     * @notice Handles an incoming message
+     * @param _origin The origin domain
+     * @param _sender The sender address
+     * @param _message The message
+     */
+    function handle(
+        uint32 _origin,
+        bytes32 _sender,
+        bytes calldata _message
+    ) external virtual override onlyInbox onlyRemoteRouter(_origin, _sender) {
+        // TODO: callbacks on success/failure
+        _handle(_origin, _sender, _message);
+    }
+
+    // ============ Virtual functions ============
+    function _handle(
+        uint32 _origin,
+        bytes32 _sender,
+        bytes calldata _message
+    ) internal virtual;
+
+    // ============ Internal functions ============
+
+    /**
+     * @notice Set the router for a given domain
+     * @param _domain The domain
+     * @param _router The new router
+     */
+    function _enrollRemoteRouter(uint32 _domain, bytes32 _router) internal {
+        routers[_domain] = _router;
+        emit RemoteRouterEnrolled(_domain, _router);
+    }
+
+    /**
+     * @notice Return true if the given domain / router is the address of a remote Application Router
+     * @param _domain The domain of the potential remote Application Router
+     * @param _router The address of the potential remote Application Router
+     */
+    function _isRemoteRouter(uint32 _domain, bytes32 _router)
+        internal
+        view
+        returns (bool)
+    {
+        return routers[_domain] == _router;
+    }
+
+    /**
+     * @notice Assert that the given domain has a Application Router registered and return its address
+     * @param _domain The domain of the chain for which to get the Application Router
+     * @return _router The address of the remote Application Router on _domain
+     */
+    function _mustHaveRemoteRouter(uint32 _domain)
+        internal
+        view
+        returns (bytes32 _router)
+    {
+        _router = routers[_domain];
+        require(_router != bytes32(0), NO_ROUTER_ENROLLED_REVERT_MESSAGE);
+    }
+
+    /**
+     * @notice Dispatches a message to an enrolled router via the local router's Outbox.
+     * @notice Does not pay interchain gas.
+     * @dev Reverts if there is no enrolled router for _destinationDomain.
+     * @param _destinationDomain The domain of the chain to which to send the message.
+     * @param _msg The message to dispatch.
+     */
+    function _dispatch(uint32 _destinationDomain, bytes memory _msg)
+        internal
+        returns (uint256)
+    {
+        return _dispatch(_outbox(), _destinationDomain, _msg);
+    }
+
+    /**
+     * @notice Dispatches a message to an enrolled router via the local router's Outbox
+     * and pays for it to be relayed to the destination.
+     * @dev Reverts if there is no enrolled router for _destinationDomain.
+     * @param _destinationDomain The domain of the chain to which to send the message.
+     * @param _msg The message to dispatch.
+     * @param _gasPayment The amount of native tokens to pay for the message to be relayed.
+     */
+    function _dispatchWithGas(
+        uint32 _destinationDomain,
+        bytes memory _msg,
+        uint256 _gasPayment
+    ) internal {
+        IOutbox _outbox = _outbox();
+        uint256 _leafIndex = _dispatch(_outbox, _destinationDomain, _msg);
+        if (_gasPayment > 0) {
+            interchainGasPaymaster.payGasFor{value: _gasPayment}(
+                address(_outbox),
+                _leafIndex,
+                _destinationDomain
+            );
+        }
+    }
+
+    // ============ Private functions ============
+
+    /**
+     * @notice Dispatches a message to an enrolled router via the provided Outbox.
+     * @dev Does not pay interchain gas.
+     * @dev Reverts if there is no enrolled router for _destinationDomain.
+     * @param _outbox The outbox contract to dispatch the message through.
+     * @param _destinationDomain The domain of the chain to which to send the message.
+     * @param _msg The message to dispatch.
+     */
+    function _dispatch(
+        IOutbox _outbox,
+        uint32 _destinationDomain,
+        bytes memory _msg
+    ) private returns (uint256) {
+        // Ensure that destination chain has an enrolled router.
+        bytes32 _router = _mustHaveRemoteRouter(_destinationDomain);
+        return _outbox.dispatch(_destinationDomain, _router, _msg);
+    }
+}

package/contracts/middleware/InterchainAccountRouter.sol

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+import {OwnableMulticall, Call} from "../OwnableMulticall.sol";
+
+// ============ External Imports ============
+import {Router} from "../Router.sol";
+import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+/*
+ * @title The Hello World App
+ * @dev You can use this simple app as a starting point for your own application.
+ */
+contract InterchainAccountRouter is Router {
+    bytes constant bytecode = type(OwnableMulticall).creationCode;
+    bytes32 constant bytecodeHash = bytes32(keccak256(bytecode));
+
+    event InterchainAccountCreated(
+        uint32 indexed origin,
+        address sender,
+        address account
+    );
+
+    function initialize(
+        address _owner,
+        address _abacusConnectionManager,
+        address _interchainGasPaymaster
+    ) public initializer {
+        // Transfer ownership of the contract to deployer
+        _transferOwnership(_owner);
+        // Set the addresses for the ACM and IGP
+        // Alternatively, this could be done later in an initialize method
+        _setAbacusConnectionManager(_abacusConnectionManager);
+        _setInterchainGasPaymaster(_interchainGasPaymaster);
+    }
+
+    function dispatch(uint32 _destinationDomain, Call[] calldata calls)
+        external
+    {
+        _dispatch(_destinationDomain, abi.encode(msg.sender, calls));
+    }
+
+    function getInterchainAccount(uint32 _origin, address _sender)
+        public
+        view
+        returns (address)
+    {
+        return _getInterchainAccount(_salt(_origin, _sender));
+    }
+
+    function getDeployedInterchainAccount(uint32 _origin, address _sender)
+        public
+        returns (OwnableMulticall)
+    {
+        bytes32 salt = _salt(_origin, _sender);
+        address interchainAccount = _getInterchainAccount(salt);
+        if (!Address.isContract(interchainAccount)) {
+            interchainAccount = Create2.deploy(0, salt, bytecode);
+            emit InterchainAccountCreated(_origin, _sender, interchainAccount);
+        }
+        return OwnableMulticall(interchainAccount);
+    }
+
+    function _salt(uint32 _origin, address _sender)
+        internal
+        pure
+        returns (bytes32)
+    {
+        return bytes32(abi.encodePacked(_origin, _sender));
+    }
+
+    function _getInterchainAccount(bytes32 salt)
+        internal
+        view
+        returns (address)
+    {
+        return Create2.computeAddress(salt, bytecodeHash);
+    }
+
+    function _handle(
+        uint32 _origin,
+        bytes32, // router sender
+        bytes calldata _message
+    ) internal override {
+        (address sender, Call[] memory calls) = abi.decode(
+            _message,
+            (address, Call[])
+        );
+        getDeployedInterchainAccount(_origin, sender).proxyCalls(calls);
+    }
+}

package/contracts/middleware/InterchainQueryRouter.sol

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+import {OwnableMulticall, Call} from "../OwnableMulticall.sol";
+
+// ============ External Imports ============
+import {Router} from "../Router.sol";
+import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+contract InterchainQueryRouter is Router, OwnableMulticall {
+    enum Action {
+        DISPATCH,
+        RESOLVE
+    }
+
+    event QueryDispatched(
+        uint32 indexed destinationDomain,
+        address indexed sender
+    );
+    event QueryReturned(uint32 indexed originDomain, address indexed sender);
+    event QueryResolved(
+        uint32 indexed destinationDomain,
+        address indexed sender
+    );
+
+    function initialize(
+        address _owner,
+        address _abacusConnectionManager,
+        address _interchainGasPaymaster
+    ) public initializer {
+        // Transfer ownership of the contract to deployer
+        _transferOwnership(_owner);
+        // Set the addresses for the ACM and IGP
+        // Alternatively, this could be done later in an initialize method
+        _setAbacusConnectionManager(_abacusConnectionManager);
+        _setInterchainGasPaymaster(_interchainGasPaymaster);
+    }
+
+    /**
+     * @param _destinationDomain Domain of destination chain
+     * @param call Call (to and data packed struct) to be made on destination chain.
+     * @param callback Callback function selector on `msg.sender` and optionally abi-encoded prefix arguments.
+     */
+    function query(
+        uint32 _destinationDomain,
+        Call calldata call,
+        bytes calldata callback
+    ) external {
+        // TODO: fix this ugly arrayification
+        Call[] memory calls = new Call[](1);
+        calls[0] = call;
+        bytes[] memory callbacks = new bytes[](1);
+        callbacks[0] = callback;
+        query(_destinationDomain, calls, callbacks);
+    }
+
+    /**
+     * @param _destinationDomain Domain of destination chain
+     * @param calls Array of calls (to and data packed struct) to be made on destination chain in sequence.
+     * @param callbacks Array of callback function selectors on `msg.sender` and optionally abi-encoded prefix arguments.
+     */
+    function query(
+        uint32 _destinationDomain,
+        Call[] memory calls,
+        bytes[] memory callbacks
+    ) public {
+        require(
+            calls.length == callbacks.length,
+            "InterchainQueryRouter: calls and callbacks must be same length"
+        );
+        _dispatch(
+            _destinationDomain,
+            abi.encode(Action.DISPATCH, msg.sender, calls, callbacks)
+        );
+        emit QueryDispatched(_destinationDomain, msg.sender);
+    }
+
+    // TODO: add REJECT behavior ala NodeJS Promise API
+    function _handle(
+        uint32 _origin,
+        bytes32, // router sender
+        bytes calldata _message
+    ) internal override {
+        // TODO: fix double ABI decoding with calldata slices
+        Action action = abi.decode(_message, (Action));
+        if (action == Action.DISPATCH) {
+            (
+                ,
+                address sender,
+                Call[] memory calls,
+                bytes[] memory callbacks
+            ) = abi.decode(_message, (Action, address, Call[], bytes[]));
+            bytes[] memory resolveCallbacks = _call(calls, callbacks);
+            _dispatch(
+                _origin,
+                abi.encode(Action.RESOLVE, sender, resolveCallbacks)
+            );
+            emit QueryReturned(_origin, sender);
+        } else if (action == Action.RESOLVE) {
+            (, address sender, bytes[] memory resolveCallbacks) = abi.decode(
+                _message,
+                (Action, address, bytes[])
+            );
+            proxyCallBatch(sender, resolveCallbacks);
+            emit QueryResolved(_origin, sender);
+        }
+    }
+}

package/contracts/middleware/README.md

@@ -0,0 +1,13 @@
+# Middleware Contracts
+
+## Interchain Accounts
+
+An interchain account is a smart contract that is deployed on a remote chain and is controlled exclusively by the deploying local account.
+Interchain accounts provide developers with a [transparent multicall API](./contracts/OwnableMulticall.sol) to remote smart contracts.
+This avoids the need to deploy application specific smart contracts on remote chains while simultaneously enabling cross-chain composability.
+
+See [IBC Interchain Accounts](https://github.com/cosmos/ibc/blob/main/spec/app/ics-027-interchain-accounts/README.md) for the Cosmos ecosystem equivalent.
+
+## Interchain Query System
+
+TBD

package/contracts/test/TestAbacusConnectionClient.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.11;
+import {IOutbox} from "../../interfaces/IOutbox.sol";
+
+import "../AbacusConnectionClient.sol";
+
+contract TestAbacusConnectionClient is AbacusConnectionClient {
+    function initialize(address _abacusConnectionManager) external initializer {
+        __AbacusConnectionClient_initialize(_abacusConnectionManager);
+    }
+
+    function outbox() external view returns (IOutbox) {
+        return _outbox();
+    }
+
+    function isInbox(address _potentialInbox) external view returns (bool) {
+        return _isInbox(_potentialInbox);
+    }
+
+    function localDomain() external view returns (uint32) {
+        return _localDomain();
+    }
+}

package/contracts/test/TestQuery.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+import {InterchainQueryRouter} from "../middleware/InterchainQueryRouter.sol";
+import {Call} from "../OwnableMulticall.sol";
+import {TypeCasts} from "../libs/TypeCasts.sol";
+
+contract TestQuery {
+    InterchainQueryRouter public router;
+
+    event Owner(uint256, address);
+
+    constructor(address _router) {
+        router = InterchainQueryRouter(_router);
+    }
+
+    /**
+     * @dev Fetches owner of InterchainQueryRouter on provided domain and passes along with provided secret to `this.receiveRouterOwner`
+     */
+    function queryRouterOwner(uint32 domain, uint256 secret) external {
+        Call memory call = Call({
+            to: TypeCasts.bytes32ToAddress(router.routers(domain)),
+            data: abi.encodeWithSignature("owner()")
+        });
+        bytes memory callback = bytes.concat(
+            this.receiveRouterOwer.selector,
+            bytes32(secret)
+        );
+        router.query(domain, call, callback);
+    }
+
+    /**
+     * @dev `msg.sender` must be restricted to `this.router` to prevent any local account from spoofing query data.
+     */
+    function receiveRouterOwer(uint256 secret, address owner) external {
+        require(msg.sender == address(router), "TestQuery: not from router");
+        emit Owner(secret, owner);
+    }
+}