@hyperlane-xyz/core 0.5.0-beta0

package/contracts/test/TestInbox.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import "../Inbox.sol";
+
+contract TestInbox is Inbox {
+    using Message for bytes32;
+    using TypeCasts for bytes32;
+
+    constructor(uint32 _localDomain) Inbox(_localDomain) {} // solhint-disable-line no-empty-blocks
+
+    function testBranchRoot(
+        bytes32 leaf,
+        bytes32[32] calldata proof,
+        uint256 index
+    ) external pure returns (bytes32) {
+        return MerkleLib.branchRoot(leaf, proof, index);
+    }
+
+    function testProcess(bytes calldata _message, uint256 leafIndex) external {
+        bytes32 _messageHash = keccak256(abi.encodePacked(_message, leafIndex));
+        _process(_message, _messageHash);
+    }
+
+    function testHandle(
+        uint32 origin,
+        bytes32 sender,
+        bytes32 recipient,
+        bytes calldata body
+    ) external {
+        IMessageRecipient(recipient.bytes32ToAddress()).handle(
+            origin,
+            sender,
+            body
+        );
+    }
+
+    function setMessageStatus(bytes32 _leaf, MessageStatus status) external {
+        messages[_leaf] = status;
+    }
+
+    function getRevertMsg(bytes calldata _res)
+        internal
+        pure
+        returns (string memory)
+    {
+        // If the _res length is less than 68, then the transaction failed
+        // silently (without a revert message)
+        if (_res.length < 68) return "Transaction reverted silently";
+
+        // Remove the selector (first 4 bytes) and decode revert string
+        return abi.decode(_res[4:], (string));
+    }
+}

package/contracts/test/TestMailbox.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import "../Mailbox.sol";
+
+contract TestMailbox is Mailbox {
+    constructor(uint32 _localDomain) Mailbox(_localDomain) {}
+
+    function initialize(address _validatorManager) external initializer {
+        __Mailbox_initialize(_validatorManager);
+    }
+}

package/contracts/test/TestMerkle.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import "../MerkleTreeManager.sol";
+
+contract TestMerkle is MerkleTreeManager {
+    using MerkleLib for MerkleLib.Tree;
+
+    // solhint-disable-next-line no-empty-blocks
+    constructor() MerkleTreeManager() {}
+
+    function insert(bytes32 _node) external {
+        tree.insert(_node);
+    }
+
+    function branchRoot(
+        bytes32 _leaf,
+        bytes32[32] calldata _proof,
+        uint256 _index
+    ) external pure returns (bytes32 _node) {
+        return MerkleLib.branchRoot(_leaf, _proof, _index);
+    }
+
+    /**
+     * @notice Returns the number of inserted leaves in the tree
+     */
+    function count() public view returns (uint256) {
+        return tree.count;
+    }
+}

package/contracts/test/TestMessage.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.11;
+
+import {Message} from "../libs/Message.sol";
+
+contract TestMessage {
+    using Message for bytes;
+
+    function body(bytes calldata _message)
+        external
+        pure
+        returns (bytes calldata _body)
+    {
+        (, , , , _body) = _message.destructure();
+    }
+
+    function origin(bytes calldata _message)
+        external
+        pure
+        returns (uint32 _origin)
+    {
+        (_origin, , , , ) = _message.destructure();
+    }
+
+    function sender(bytes calldata _message)
+        external
+        pure
+        returns (bytes32 _sender)
+    {
+        (, _sender, , , ) = _message.destructure();
+    }
+
+    function destination(bytes calldata _message)
+        external
+        pure
+        returns (uint32 _destination)
+    {
+        (, , _destination, , ) = _message.destructure();
+    }
+
+    function recipient(bytes calldata _message)
+        external
+        pure
+        returns (bytes32 _recipient)
+    {
+        (, , , _recipient, ) = _message.destructure();
+    }
+
+    function recipientAddress(bytes calldata _message)
+        external
+        pure
+        returns (address _recipient)
+    {
+        (, , , _recipient, ) = _message.destructureAddresses();
+    }
+
+    function leaf(bytes calldata _message, uint256 _leafIndex)
+        external
+        pure
+        returns (bytes32)
+    {
+        return _message.leaf(_leafIndex);
+    }
+}

package/contracts/test/TestMultisigValidatorManager.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {MultisigValidatorManager} from "../validator-manager/MultisigValidatorManager.sol";
+
+/**
+ * This contract exists to test MultisigValidatorManager.sol, which is abstract
+ * and cannot be deployed directly.
+ */
+contract TestMultisigValidatorManager is MultisigValidatorManager {
+    // solhint-disable-next-line no-empty-blocks
+    constructor(
+        uint32 _domain,
+        address[] memory _validators,
+        uint256 _threshold
+    ) MultisigValidatorManager(_domain, _validators, _threshold) {}
+
+    /**
+     * @notice Hash of domain concatenated with "ABACUS".
+     * @dev This is a public getter of _domainHash to test with.
+     * @param _domain The domain to hash.
+     */
+    function getDomainHash(uint32 _domain) external pure returns (bytes32) {
+        return _domainHash(_domain);
+    }
+}

package/contracts/test/TestOutbox.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import "../Outbox.sol";
+import {MerkleLib} from "../libs/Merkle.sol";
+
+contract TestOutbox is Outbox {
+    constructor(uint32 _localDomain) Outbox(_localDomain) {} // solhint-disable-line no-empty-blocks
+
+    /**
+     * @notice Set the validator manager
+     * @param _validatorManager Address of the validator manager
+     */
+    function testSetValidatorManager(address _validatorManager) external {
+        validatorManager = _validatorManager;
+    }
+
+    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 branch() external view returns (bytes32[32] memory) {
+        return tree.branch;
+    }
+
+    function branchRoot(
+        bytes32 _item,
+        bytes32[32] memory _branch,
+        uint256 _index
+    ) external pure returns (bytes32) {
+        return MerkleLib.branchRoot(_item, _branch, _index);
+    }
+}

package/contracts/test/TestRecipient.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {IMessageRecipient} from "../../interfaces/IMessageRecipient.sol";
+
+contract TestRecipient is IMessageRecipient {
+    bytes32 public lastSender;
+    bytes public lastData;
+
+    function handle(
+        uint32,
+        bytes32 _sender,
+        bytes calldata _data
+    ) external override {
+        lastSender = _sender;
+        lastData = _data;
+    }
+}

package/contracts/test/TestSendReceiver.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {TypeCasts} from "../libs/TypeCasts.sol";
+
+import {IInterchainGasPaymaster} from "../../interfaces/IInterchainGasPaymaster.sol";
+import {IMessageRecipient} from "../../interfaces/IMessageRecipient.sol";
+import {IOutbox} from "../../interfaces/IOutbox.sol";
+
+contract TestSendReceiver is IMessageRecipient {
+    using TypeCasts for address;
+
+    event Handled(bytes32 blockHash);
+
+    function dispatchToSelf(
+        IOutbox _outbox,
+        IInterchainGasPaymaster _paymaster,
+        uint32 _destinationDomain,
+        bytes calldata _messageBody
+    ) external payable {
+        uint256 _leafIndex = _outbox.dispatch(
+            _destinationDomain,
+            address(this).addressToBytes32(),
+            _messageBody
+        );
+        uint256 _blockHashNum = uint256(previousBlockHash());
+        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
+            );
+            _paymaster.payGasFor{value: _value - _half}(
+                address(_outbox),
+                _leafIndex,
+                _destinationDomain
+            );
+        } else {
+            // Pay the entire msg.value in one call
+            _paymaster.payGasFor{value: _value}(
+                address(_outbox),
+                _leafIndex,
+                _destinationDomain
+            );
+        }
+    }
+
+    function handle(
+        uint32,
+        bytes32,
+        bytes calldata
+    ) external override {
+        bytes32 blockHash = previousBlockHash();
+        bool isBlockHashEven = uint256(blockHash) % 2 == 0;
+        require(isBlockHashEven, "block hash is odd");
+        emit Handled(blockHash);
+    }
+
+    function previousBlockHash() internal view returns (bytes32) {
+        return blockhash(block.number - 1);
+    }
+}

package/contracts/test/TestValidatorManager.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {IInbox} from "../../interfaces/IInbox.sol";
+
+/**
+ * Intended for testing Inbox.sol, which requires its validator manager
+ * to be a contract.
+ */
+contract TestValidatorManager {
+    function process(
+        IInbox _inbox,
+        bytes32 _root,
+        uint256 _index,
+        bytes calldata _message,
+        bytes32[32] calldata _proof,
+        uint256 _leafIndex
+    ) external {
+        _inbox.process(_root, _index, _message, _proof, _leafIndex);
+    }
+}

package/contracts/test/bad-recipient/BadRecipient1.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {IMessageRecipient} from "../../../interfaces/IMessageRecipient.sol";
+
+contract BadRecipient1 is IMessageRecipient {
+    function handle(
+        uint32,
+        bytes32,
+        bytes calldata
+    ) external pure override {
+        assembly {
+            revert(0, 0)
+        }
+    }
+}

package/contracts/test/bad-recipient/BadRecipient2.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+contract BadRecipient2 {
+    function handle(uint32, bytes32) external pure {} // solhint-disable-line no-empty-blocks
+}

package/contracts/test/bad-recipient/BadRecipient3.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {IMessageRecipient} from "../../../interfaces/IMessageRecipient.sol";
+
+contract BadRecipient3 is IMessageRecipient {
+    function handle(
+        uint32,
+        bytes32,
+        bytes calldata
+    ) external pure override {
+        assembly {
+            mstore(0, 0xabcdef)
+            revert(0, 32)
+        }
+    }
+}

package/contracts/test/bad-recipient/BadRecipient5.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {IMessageRecipient} from "../../../interfaces/IMessageRecipient.sol";
+
+contract BadRecipient5 is IMessageRecipient {
+    function handle(
+        uint32,
+        bytes32,
+        bytes calldata
+    ) external pure override {
+        require(false, "no can do");
+    }
+}

package/contracts/test/bad-recipient/BadRecipient6.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {IMessageRecipient} from "../../../interfaces/IMessageRecipient.sol";
+
+contract BadRecipient6 is IMessageRecipient {
+    function handle(
+        uint32,
+        bytes32,
+        bytes calldata
+    ) external pure override {
+        require(false); // solhint-disable-line reason-string
+    }
+}

package/contracts/upgrade/UpgradeBeacon.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+// ============ External Imports ============
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+
+/**
+ * @title UpgradeBeacon
+ * @notice Stores the address of an implementation contract
+ * and allows a controller to upgrade the implementation address
+ * @dev This implementation combines the gas savings of having no function selectors
+ * found in 0age's implementation:
+ * https://github.com/dharma-eng/dharma-smart-wallet/blob/master/contracts/proxies/smart-wallet/UpgradeBeaconProxyV1.sol
+ * With the added niceties of a safety check that each implementation is a contract
+ * and an Upgrade event emitted each time the implementation is changed
+ * found in OpenZeppelin's implementation:
+ * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/proxy/beacon/BeaconProxy.sol
+ */
+contract UpgradeBeacon {
+    // ============ Immutables ============
+
+    // The controller is capable of modifying the implementation address
+    address private immutable controller;
+
+    // ============ Private Storage Variables ============
+
+    // The implementation address is held in storage slot zero.
+    address private implementation;
+
+    // ============ Events ============
+
+    // Upgrade event is emitted each time the implementation address is set
+    // (including deployment)
+    event Upgrade(address indexed implementation);
+
+    // ============ Constructor ============
+
+    /**
+     * @notice Validate the initial implementation and store it.
+     * Store the controller immutably.
+     * @param _initialImplementation Address of the initial implementation contract
+     * @param _controller Address of the controller who can upgrade the implementation
+     */
+    constructor(address _initialImplementation, address _controller) payable {
+        _setImplementation(_initialImplementation);
+        controller = _controller;
+    }
+
+    // ============ External Functions ============
+
+    /**
+     * @notice For all callers except the controller, return the current implementation address.
+     * If called by the Controller, update the implementation address
+     * to the address passed in the calldata.
+     * Note: this requires inline assembly because Solidity fallback functions
+     * do not natively take arguments or return values.
+     */
+    fallback() external payable {
+        if (msg.sender != controller) {
+            // if not called by the controller,
+            // load implementation address from storage slot zero
+            // and return it.
+            assembly {
+                mstore(0, sload(0))
+                return(0, 32)
+            }
+        } else {
+            // if called by the controller,
+            // load new implementation address from the first word of the calldata
+            address _newImplementation;
+            assembly {
+                _newImplementation := calldataload(0)
+            }
+            // set the new implementation
+            _setImplementation(_newImplementation);
+        }
+    }
+
+    // ============ Private Functions ============
+
+    /**
+     * @notice Perform checks on the new implementation address
+     * then upgrade the stored implementation.
+     * @param _newImplementation Address of the new implementation contract which will replace the old one
+     */
+    function _setImplementation(address _newImplementation) private {
+        // Require that the new implementation is different from the current one
+        require(implementation != _newImplementation, "!upgrade");
+        // Require that the new implementation is a contract
+        require(
+            Address.isContract(_newImplementation),
+            "implementation !contract"
+        );
+        // set the new implementation
+        implementation = _newImplementation;
+        emit Upgrade(_newImplementation);
+    }
+}

package/contracts/upgrade/UpgradeBeaconController.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {UpgradeBeacon} from "./UpgradeBeacon.sol";
+// ============ External Imports ============
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+
+/**
+ * @title UpgradeBeaconController
+ * @notice Set as the controller of UpgradeBeacon contract(s),
+ * capable of changing their stored implementation address.
+ * @dev This implementation is a minimal version inspired by 0age's implementation:
+ * https://github.com/dharma-eng/dharma-smart-wallet/blob/master/contracts/upgradeability/DharmaUpgradeBeaconController.sol
+ */
+contract UpgradeBeaconController is Ownable {
+    // ============ Events ============
+
+    event BeaconUpgraded(address indexed beacon, address implementation);
+
+    // ============ External Functions ============
+
+    /**
+     * @notice Modify the implementation stored in the UpgradeBeacon,
+     * which will upgrade the implementation used by all
+     * Proxy contracts using that UpgradeBeacon
+     * @param _beacon Address of the UpgradeBeacon which will be updated
+     * @param _implementation Address of the Implementation contract to upgrade the Beacon to
+     */
+    function upgrade(address _beacon, address _implementation)
+        external
+        onlyOwner
+    {
+        // Require that the beacon is a contract
+        require(Address.isContract(_beacon), "beacon !contract");
+        // Call into beacon and supply address of new implementation to update it.
+        (bool _success, ) = _beacon.call(abi.encode(_implementation));
+        // Revert with message on failure (i.e. if the beacon is somehow incorrect).
+        if (!_success) {
+            assembly {
+                returndatacopy(0, 0, returndatasize())
+                revert(0, returndatasize())
+            }
+        }
+        emit BeaconUpgraded(_beacon, _implementation);
+    }
+}