@hyperlane-xyz/core 0.5.0-beta0

package/contracts/Outbox.sol

@@ -0,0 +1,191 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {Versioned} from "./upgrade/Versioned.sol";
+import {Mailbox} from "./Mailbox.sol";
+import {MerkleLib} from "./libs/Merkle.sol";
+import {Message} from "./libs/Message.sol";
+import {TypeCasts} from "./libs/TypeCasts.sol";
+import {MerkleTreeManager} from "./MerkleTreeManager.sol";
+import {IOutbox} from "../interfaces/IOutbox.sol";
+
+/**
+ * @title Outbox
+ * @author Celo Labs Inc.
+ * @notice Accepts messages to be dispatched to remote chains,
+ * constructs a Merkle tree of the messages,
+ * and accepts signatures from a bonded Validator
+ * which notarize the Merkle tree roots.
+ * Accepts submissions of fraudulent signatures
+ * by the Validator and slashes the Validator in this case.
+ */
+contract Outbox is IOutbox, Versioned, MerkleTreeManager, Mailbox {
+    // ============ Libraries ============
+
+    using MerkleLib for MerkleLib.Tree;
+    using TypeCasts for address;
+
+    // ============ Constants ============
+
+    // Maximum bytes per message = 2 KiB
+    // (somewhat arbitrarily set to begin)
+    uint256 public constant MAX_MESSAGE_BODY_BYTES = 2 * 2**10;
+
+    // ============ Enums ============
+
+    // States:
+    //   0 - UnInitialized - before initialize function is called
+    //   note: the contract is initialized at deploy time, so it should never be in this state
+    //   1 - Active - as long as the contract has not become fraudulent
+    //   2 - Failed - after a valid fraud proof has been submitted;
+    //   contract will no longer accept updates or new messages
+    enum States {
+        UnInitialized,
+        Active,
+        Failed
+    }
+
+    // ============ Public Storage Variables ============
+
+    // Cached checkpoints, mapping root => leaf index.
+    // Cached checkpoints must have index > 0 as the presence of such
+    // a checkpoint cannot be distinguished from its absence.
+    mapping(bytes32 => uint256) public cachedCheckpoints;
+    // The latest cached root
+    bytes32 public latestCachedRoot;
+    // Current state of contract
+    States public state;
+
+    // ============ Upgrade Gap ============
+
+    // gap for upgrade safety
+    uint256[47] private __GAP;
+
+    // ============ Events ============
+
+    /**
+     * @notice Emitted when a checkpoint is cached.
+     * @param root Merkle root
+     * @param index Leaf index
+     */
+    event CheckpointCached(bytes32 indexed root, uint256 indexed index);
+
+    /**
+     * @notice Emitted when a new message is dispatched via Abacus
+     * @param leafIndex Index of message's leaf in merkle tree
+     * @param message Raw bytes of message
+     */
+    event Dispatch(uint256 indexed leafIndex, bytes message);
+
+    event Fail();
+
+    // ============ Constructor ============
+
+    constructor(uint32 _localDomain) Mailbox(_localDomain) {} // solhint-disable-line no-empty-blocks
+
+    // ============ Initializer ============
+
+    function initialize(address _validatorManager) external initializer {
+        __Mailbox_initialize(_validatorManager);
+        state = States.Active;
+    }
+
+    // ============ Modifiers ============
+
+    /**
+     * @notice Ensures that contract state != FAILED when the function is called
+     */
+    modifier notFailed() {
+        require(state != States.Failed, "failed state");
+        _;
+    }
+
+    // ============ External Functions  ============
+
+    /**
+     * @notice Dispatch the message it to the destination domain & recipient
+     * @dev Format the message, insert its hash into Merkle tree,
+     * and emit `Dispatch` event with message information.
+     * @param _destinationDomain Domain of destination chain
+     * @param _recipientAddress Address of recipient on destination chain as bytes32
+     * @param _messageBody Raw bytes content of message
+     * @return The leaf index of the dispatched message's hash in the Merkle tree.
+     */
+    function dispatch(
+        uint32 _destinationDomain,
+        bytes32 _recipientAddress,
+        bytes calldata _messageBody
+    ) external override notFailed returns (uint256) {
+        require(_messageBody.length <= MAX_MESSAGE_BODY_BYTES, "msg too long");
+        // The leaf has not been inserted yet at this point
+        uint256 _leafIndex = count();
+        // format the message into packed bytes
+        bytes memory _message = Message.formatMessage(
+            localDomain,
+            msg.sender.addressToBytes32(),
+            _destinationDomain,
+            _recipientAddress,
+            _messageBody
+        );
+        // insert the hashed message into the Merkle tree
+        bytes32 _messageHash = keccak256(
+            abi.encodePacked(_message, _leafIndex)
+        );
+        tree.insert(_messageHash);
+        emit Dispatch(_leafIndex, _message);
+        return _leafIndex;
+    }
+
+    /**
+     * @notice Caches the current merkle root and index.
+     * @dev emits CheckpointCached event
+     */
+    function cacheCheckpoint() external override notFailed {
+        (bytes32 _root, uint256 _index) = latestCheckpoint();
+        require(_index > 0, "!index");
+        cachedCheckpoints[_root] = _index;
+        latestCachedRoot = _root;
+        emit CheckpointCached(_root, _index);
+    }
+
+    /**
+     * @notice Set contract state to FAILED.
+     * @dev Called by the validator manager when fraud is proven.
+     */
+    function fail() external override onlyValidatorManager {
+        // set contract to FAILED
+        state = States.Failed;
+        emit Fail();
+    }
+
+    /**
+     * @notice Returns the latest entry in the checkpoint cache.
+     * @return root Latest cached root
+     * @return index Latest cached index
+     */
+    function latestCachedCheckpoint()
+        external
+        view
+        returns (bytes32 root, uint256 index)
+    {
+        root = latestCachedRoot;
+        index = cachedCheckpoints[root];
+    }
+
+    /**
+     * @notice Returns the number of inserted leaves in the tree
+     */
+    function count() public view returns (uint256) {
+        return tree.count;
+    }
+
+    /**
+     * @notice Returns a checkpoint representing the current merkle tree.
+     * @return root The root of the Outbox's merkle tree.
+     * @return index The index of the last element in the tree.
+     */
+    function latestCheckpoint() public view returns (bytes32, uint256) {
+        return (root(), count() - 1);
+    }
+}

package/contracts/libs/Merkle.sol

@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.11;
+
+// work based on eth2 deposit contract, which is used under CC0-1.0
+
+/**
+ * @title MerkleLib
+ * @author Celo Labs Inc.
+ * @notice An incremental merkle tree modeled on the eth2 deposit contract.
+ **/
+library MerkleLib {
+    uint256 internal constant TREE_DEPTH = 32;
+    uint256 internal constant MAX_LEAVES = 2**TREE_DEPTH - 1;
+
+    /**
+     * @notice Struct representing incremental merkle tree. Contains current
+     * branch and the number of inserted leaves in the tree.
+     **/
+    struct Tree {
+        bytes32[TREE_DEPTH] branch;
+        uint256 count;
+    }
+
+    /**
+     * @notice Inserts `_node` into merkle tree
+     * @dev Reverts if tree is full
+     * @param _node Element to insert into tree
+     **/
+    function insert(Tree storage _tree, bytes32 _node) internal {
+        require(_tree.count < MAX_LEAVES, "merkle tree full");
+
+        _tree.count += 1;
+        uint256 size = _tree.count;
+        for (uint256 i = 0; i < TREE_DEPTH; i++) {
+            if ((size & 1) == 1) {
+                _tree.branch[i] = _node;
+                return;
+            }
+            _node = keccak256(abi.encodePacked(_tree.branch[i], _node));
+            size /= 2;
+        }
+        // As the loop should always end prematurely with the `return` statement,
+        // this code should be unreachable. We assert `false` just to be safe.
+        assert(false);
+    }
+
+    /**
+     * @notice Calculates and returns`_tree`'s current root given array of zero
+     * hashes
+     * @param _zeroes Array of zero hashes
+     * @return _current Calculated root of `_tree`
+     **/
+    function rootWithCtx(Tree storage _tree, bytes32[TREE_DEPTH] memory _zeroes)
+        internal
+        view
+        returns (bytes32 _current)
+    {
+        uint256 _index = _tree.count;
+
+        for (uint256 i = 0; i < TREE_DEPTH; i++) {
+            uint256 _ithBit = (_index >> i) & 0x01;
+            bytes32 _next = _tree.branch[i];
+            if (_ithBit == 1) {
+                _current = keccak256(abi.encodePacked(_next, _current));
+            } else {
+                _current = keccak256(abi.encodePacked(_current, _zeroes[i]));
+            }
+        }
+    }
+
+    /// @notice Calculates and returns`_tree`'s current root
+    function root(Tree storage _tree) internal view returns (bytes32) {
+        return rootWithCtx(_tree, zeroHashes());
+    }
+
+    /// @notice Returns array of TREE_DEPTH zero hashes
+    /// @return _zeroes Array of TREE_DEPTH zero hashes
+    function zeroHashes()
+        internal
+        pure
+        returns (bytes32[TREE_DEPTH] memory _zeroes)
+    {
+        _zeroes[0] = Z_0;
+        _zeroes[1] = Z_1;
+        _zeroes[2] = Z_2;
+        _zeroes[3] = Z_3;
+        _zeroes[4] = Z_4;
+        _zeroes[5] = Z_5;
+        _zeroes[6] = Z_6;
+        _zeroes[7] = Z_7;
+        _zeroes[8] = Z_8;
+        _zeroes[9] = Z_9;
+        _zeroes[10] = Z_10;
+        _zeroes[11] = Z_11;
+        _zeroes[12] = Z_12;
+        _zeroes[13] = Z_13;
+        _zeroes[14] = Z_14;
+        _zeroes[15] = Z_15;
+        _zeroes[16] = Z_16;
+        _zeroes[17] = Z_17;
+        _zeroes[18] = Z_18;
+        _zeroes[19] = Z_19;
+        _zeroes[20] = Z_20;
+        _zeroes[21] = Z_21;
+        _zeroes[22] = Z_22;
+        _zeroes[23] = Z_23;
+        _zeroes[24] = Z_24;
+        _zeroes[25] = Z_25;
+        _zeroes[26] = Z_26;
+        _zeroes[27] = Z_27;
+        _zeroes[28] = Z_28;
+        _zeroes[29] = Z_29;
+        _zeroes[30] = Z_30;
+        _zeroes[31] = Z_31;
+    }
+
+    /**
+     * @notice Calculates and returns the merkle root for the given leaf
+     * `_item`, a merkle branch, and the index of `_item` in the tree.
+     * @param _item Merkle leaf
+     * @param _branch Merkle proof
+     * @param _index Index of `_item` in tree
+     * @return _current Calculated merkle root
+     **/
+    function branchRoot(
+        bytes32 _item,
+        bytes32[TREE_DEPTH] memory _branch,
+        uint256 _index
+    ) internal pure returns (bytes32 _current) {
+        _current = _item;
+
+        for (uint256 i = 0; i < TREE_DEPTH; i++) {
+            uint256 _ithBit = (_index >> i) & 0x01;
+            bytes32 _next = _branch[i];
+            if (_ithBit == 1) {
+                _current = keccak256(abi.encodePacked(_next, _current));
+            } else {
+                _current = keccak256(abi.encodePacked(_current, _next));
+            }
+        }
+    }
+
+    // keccak256 zero hashes
+    bytes32 internal constant Z_0 =
+        hex"0000000000000000000000000000000000000000000000000000000000000000";
+    bytes32 internal constant Z_1 =
+        hex"ad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5";
+    bytes32 internal constant Z_2 =
+        hex"b4c11951957c6f8f642c4af61cd6b24640fec6dc7fc607ee8206a99e92410d30";
+    bytes32 internal constant Z_3 =
+        hex"21ddb9a356815c3fac1026b6dec5df3124afbadb485c9ba5a3e3398a04b7ba85";
+    bytes32 internal constant Z_4 =
+        hex"e58769b32a1beaf1ea27375a44095a0d1fb664ce2dd358e7fcbfb78c26a19344";
+    bytes32 internal constant Z_5 =
+        hex"0eb01ebfc9ed27500cd4dfc979272d1f0913cc9f66540d7e8005811109e1cf2d";
+    bytes32 internal constant Z_6 =
+        hex"887c22bd8750d34016ac3c66b5ff102dacdd73f6b014e710b51e8022af9a1968";
+    bytes32 internal constant Z_7 =
+        hex"ffd70157e48063fc33c97a050f7f640233bf646cc98d9524c6b92bcf3ab56f83";
+    bytes32 internal constant Z_8 =
+        hex"9867cc5f7f196b93bae1e27e6320742445d290f2263827498b54fec539f756af";
+    bytes32 internal constant Z_9 =
+        hex"cefad4e508c098b9a7e1d8feb19955fb02ba9675585078710969d3440f5054e0";
+    bytes32 internal constant Z_10 =
+        hex"f9dc3e7fe016e050eff260334f18a5d4fe391d82092319f5964f2e2eb7c1c3a5";
+    bytes32 internal constant Z_11 =
+        hex"f8b13a49e282f609c317a833fb8d976d11517c571d1221a265d25af778ecf892";
+    bytes32 internal constant Z_12 =
+        hex"3490c6ceeb450aecdc82e28293031d10c7d73bf85e57bf041a97360aa2c5d99c";
+    bytes32 internal constant Z_13 =
+        hex"c1df82d9c4b87413eae2ef048f94b4d3554cea73d92b0f7af96e0271c691e2bb";
+    bytes32 internal constant Z_14 =
+        hex"5c67add7c6caf302256adedf7ab114da0acfe870d449a3a489f781d659e8becc";
+    bytes32 internal constant Z_15 =
+        hex"da7bce9f4e8618b6bd2f4132ce798cdc7a60e7e1460a7299e3c6342a579626d2";
+    bytes32 internal constant Z_16 =
+        hex"2733e50f526ec2fa19a22b31e8ed50f23cd1fdf94c9154ed3a7609a2f1ff981f";
+    bytes32 internal constant Z_17 =
+        hex"e1d3b5c807b281e4683cc6d6315cf95b9ade8641defcb32372f1c126e398ef7a";
+    bytes32 internal constant Z_18 =
+        hex"5a2dce0a8a7f68bb74560f8f71837c2c2ebbcbf7fffb42ae1896f13f7c7479a0";
+    bytes32 internal constant Z_19 =
+        hex"b46a28b6f55540f89444f63de0378e3d121be09e06cc9ded1c20e65876d36aa0";
+    bytes32 internal constant Z_20 =
+        hex"c65e9645644786b620e2dd2ad648ddfcbf4a7e5b1a3a4ecfe7f64667a3f0b7e2";
+    bytes32 internal constant Z_21 =
+        hex"f4418588ed35a2458cffeb39b93d26f18d2ab13bdce6aee58e7b99359ec2dfd9";
+    bytes32 internal constant Z_22 =
+        hex"5a9c16dc00d6ef18b7933a6f8dc65ccb55667138776f7dea101070dc8796e377";
+    bytes32 internal constant Z_23 =
+        hex"4df84f40ae0c8229d0d6069e5c8f39a7c299677a09d367fc7b05e3bc380ee652";
+    bytes32 internal constant Z_24 =
+        hex"cdc72595f74c7b1043d0e1ffbab734648c838dfb0527d971b602bc216c9619ef";
+    bytes32 internal constant Z_25 =
+        hex"0abf5ac974a1ed57f4050aa510dd9c74f508277b39d7973bb2dfccc5eeb0618d";
+    bytes32 internal constant Z_26 =
+        hex"b8cd74046ff337f0a7bf2c8e03e10f642c1886798d71806ab1e888d9e5ee87d0";
+    bytes32 internal constant Z_27 =
+        hex"838c5655cb21c6cb83313b5a631175dff4963772cce9108188b34ac87c81c41e";
+    bytes32 internal constant Z_28 =
+        hex"662ee4dd2dd7b2bc707961b1e646c4047669dcb6584f0d8d770daf5d7e7deb2e";
+    bytes32 internal constant Z_29 =
+        hex"388ab20e2573d171a88108e79d820e98f26c0b84aa8b2f4aa4968dbb818ea322";
+    bytes32 internal constant Z_30 =
+        hex"93237c50ba75ee485f4c22adf2f741400bdf8d6a9cc7df7ecae576221665d735";
+    bytes32 internal constant Z_31 =
+        hex"8448818bb4ae4562849e949e17ac16e0be16688e156b5cf15e098c627c0056a9";
+}

package/contracts/libs/Message.sol

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {TypeCasts} from "./TypeCasts.sol";
+
+/**
+ * @title Message Library
+ * @author Celo Labs Inc.
+ * @notice Library for formatted messages used by Outbox and Replica.
+ **/
+library Message {
+    using TypeCasts for bytes32;
+
+    /**
+     * @notice Returns formatted (packed) message with provided fields
+     * @dev This function should only be used in memory message construction.
+     * @param _originDomain Domain of home chain
+     * @param _sender Address of sender as bytes32
+     * @param _destinationDomain Domain of destination chain
+     * @param _recipient Address of recipient on destination chain as bytes32
+     * @param _messageBody Raw bytes of message body
+     * @return Formatted message
+     **/
+    function formatMessage(
+        uint32 _originDomain,
+        bytes32 _sender,
+        uint32 _destinationDomain,
+        bytes32 _recipient,
+        bytes calldata _messageBody
+    ) internal pure returns (bytes memory) {
+        return
+            abi.encodePacked(
+                _originDomain,
+                _sender,
+                _destinationDomain,
+                _recipient,
+                _messageBody
+            );
+    }
+
+    /**
+     * @notice Returns leaf of formatted message with provided fields.
+     * @dev hash of abi packed message and leaf index.
+     * @param _message Raw bytes of message contents.
+     * @param _leafIndex Index of the message in the tree
+     * @return Leaf (hash) of formatted message
+     */
+    function leaf(bytes calldata _message, uint256 _leafIndex)
+        internal
+        pure
+        returns (bytes32)
+    {
+        return keccak256(abi.encodePacked(_message, _leafIndex));
+    }
+
+    /**
+     * @notice Decode raw message bytes into structured message fields.
+     * @dev Efficiently slices calldata into structured message fields.
+     * @param _message Raw bytes of message contents.
+     * @return origin Domain of home chain
+     * @return sender Address of sender as bytes32
+     * @return destination Domain of destination chain
+     * @return recipient Address of recipient on destination chain as bytes32
+     * @return body Raw bytes of message body
+     */
+    function destructure(bytes calldata _message)
+        internal
+        pure
+        returns (
+            uint32 origin,
+            bytes32 sender,
+            uint32 destination,
+            bytes32 recipient,
+            bytes calldata body
+        )
+    {
+        return (
+            uint32(bytes4(_message[0:4])),
+            bytes32(_message[4:36]),
+            uint32(bytes4(_message[36:40])),
+            bytes32(_message[40:72]),
+            bytes(_message[72:])
+        );
+    }
+
+    /**
+     * @notice Decode raw message bytes into structured message fields.
+     * @dev Efficiently slices calldata into structured message fields.
+     * @param _message Raw bytes of message contents.
+     * @return origin Domain of home chain
+     * @return sender Address of sender as address (bytes20)
+     * @return destination Domain of destination chain
+     * @return recipient Address of recipient on destination chain as address (bytes20)
+     * @return body Raw bytes of message body
+     */
+    function destructureAddresses(bytes calldata _message)
+        internal
+        pure
+        returns (
+            uint32,
+            address,
+            uint32,
+            address,
+            bytes calldata
+        )
+    {
+        (
+            uint32 _origin,
+            bytes32 _sender,
+            uint32 destination,
+            bytes32 _recipient,
+            bytes calldata body
+        ) = destructure(_message);
+        return (
+            _origin,
+            _sender.bytes32ToAddress(),
+            destination,
+            _recipient.bytes32ToAddress(),
+            body
+        );
+    }
+}

package/contracts/libs/TypeCasts.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.11;
+
+library TypeCasts {
+    // treat it as a null-terminated string of max 32 bytes
+    function coerceString(bytes32 _buf)
+        internal
+        pure
+        returns (string memory _newStr)
+    {
+        uint8 _slen = 0;
+        while (_slen < 32 && _buf[_slen] != 0) {
+            _slen++;
+        }
+
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            _newStr := mload(0x40)
+            mstore(0x40, add(_newStr, 0x40)) // may end up with extra
+            mstore(_newStr, _slen)
+            mstore(add(_newStr, 0x20), _buf)
+        }
+    }
+
+    // alignment preserving cast
+    function addressToBytes32(address _addr) internal pure returns (bytes32) {
+        return bytes32(uint256(uint160(_addr)));
+    }
+
+    // alignment preserving cast
+    function bytes32ToAddress(bytes32 _buf) internal pure returns (address) {
+        return address(uint160(uint256(_buf)));
+    }
+}

package/contracts/mock/MockInbox.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {TypeCasts} from "../libs/TypeCasts.sol";
+import {IMessageRecipient} from "../../interfaces/IMessageRecipient.sol";
+
+contract MockInbox {
+    using TypeCasts for bytes32;
+
+    struct PendingMessage {
+        bytes32 sender;
+        bytes32 recipient;
+        bytes messageBody;
+    }
+
+    mapping(uint256 => PendingMessage) pendingMessages;
+    uint256 totalMessages = 0;
+    uint256 messageProcessed = 0;
+
+    function addPendingMessage(
+        bytes32 _sender,
+        bytes32 _recipient,
+        bytes memory _messageBody
+    ) external {
+        pendingMessages[totalMessages] = PendingMessage(
+            _sender,
+            _recipient,
+            _messageBody
+        );
+        totalMessages += 1;
+    }
+
+    function processNextPendingMessage() public {
+        PendingMessage memory pendingMessage = pendingMessages[
+            messageProcessed
+        ];
+
+        address recipient = pendingMessage.recipient.bytes32ToAddress();
+
+        IMessageRecipient(recipient).handle(
+            // This is completely arbitrary and consumers should not rely
+            // on domain handling in the mock mailbox contracts.
+            1,
+            pendingMessage.sender,
+            pendingMessage.messageBody
+        );
+        messageProcessed += 1;
+    }
+}

package/contracts/mock/MockOutbox.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {MockInbox} from "./MockInbox.sol";
+import {TypeCasts} from "../libs/TypeCasts.sol";
+
+contract MockOutbox {
+    MockInbox inbox;
+    using TypeCasts for address;
+
+    constructor(address _inbox) {
+        inbox = MockInbox(_inbox);
+    }
+
+    function dispatch(
+        uint32,
+        bytes32 _recipientAddress,
+        bytes calldata _messageBody
+    ) external {
+        inbox.addPendingMessage(
+            msg.sender.addressToBytes32(),
+            _recipientAddress,
+            _messageBody
+        );
+    }
+}

package/contracts/test/MysteryMath.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+abstract contract MysteryMath {
+    uint256 public stateVar;
+
+    function setState(uint256 _var) external {
+        stateVar = _var;
+    }
+
+    function getState() external view returns (uint256) {
+        return stateVar;
+    }
+
+    function doMath(uint256 a, uint256 b)
+        external
+        pure
+        virtual
+        returns (uint256 _result);
+}

package/contracts/test/MysteryMathV1.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import "./MysteryMath.sol";
+
+contract MysteryMathV1 is MysteryMath {
+    uint32 public immutable version;
+
+    constructor() {
+        version = 1;
+    }
+
+    function doMath(uint256 a, uint256 b)
+        external
+        pure
+        override
+        returns (uint256 _result)
+    {
+        _result = a + b;
+    }
+}

package/contracts/test/MysteryMathV2.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import "./MysteryMath.sol";
+
+contract MysteryMathV2 is MysteryMath {
+    uint32 public immutable version;
+
+    constructor() {
+        version = 2;
+    }
+
+    function doMath(uint256 a, uint256 b)
+        external
+        pure
+        override
+        returns (uint256 _result)
+    {
+        _result = a * b;
+    }
+}