@across-protocol/contracts 0.1.0

package/contracts/external/polygon/test/FxRootMock.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IStateSender {
+    function syncState(address receiver, bytes calldata data) external;
+}
+
+interface IFxStateSender {
+    function sendMessageToChild(address _receiver, bytes calldata _data) external;
+}
+
+/**
+ * @title FxRoot root contract for fx-portal
+ */
+contract FxRootMock is IFxStateSender {
+    IStateSender public stateSender;
+    address public fxChild;
+
+    constructor(address _stateSender) {
+        stateSender = IStateSender(_stateSender);
+    }
+
+    function setFxChild(address _fxChild) public {
+        require(fxChild == address(0x0));
+        fxChild = _fxChild;
+    }
+
+    function sendMessageToChild(address _receiver, bytes calldata _data) public override {
+        bytes memory data = abi.encode(msg.sender, _receiver, _data);
+        stateSender.syncState(fxChild, data);
+    }
+}

package/contracts/external/polygon/test/StateSyncMock.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/**
+ * @notice Dummy State Sender contract to simulate plasma state sender while testing
+ */
+contract StateSyncMock {
+    /**
+     * @notice Event emitted when when syncState is called
+     * @dev Heimdall bridge listens to this event and sends the data to receiver contract on child chain
+     * @param id Id of the sync, increamented for each event in case of actual state sender contract
+     * @param contractAddress the contract receiving data on child chain
+     * @param data bytes data to be sent
+     */
+    event StateSynced(uint256 indexed id, address indexed contractAddress, bytes data);
+
+    /**
+     * @notice called to send data to child chain
+     * @dev sender and receiver contracts need to be registered in case of actual state sender contract
+     * @param receiver the contract receiving data on child chain
+     * @param data bytes data to be sent
+     */
+    function syncState(address receiver, bytes calldata data) external {
+        emit StateSynced(1, receiver, data);
+    }
+}

package/contracts/external/polygon/tunnel/FxBaseChildTunnel.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: MIT
+// Copied with no modifications from Polygon demo FxTunnel repo: https://github.com/jdkanani/fx-portal
+// except bumping version from 0.7.3 --> 0.8
+pragma solidity ^0.8.0;
+
+// IFxMessageProcessor represents interface to process message
+interface IFxMessageProcessor {
+    function processMessageFromRoot(
+        uint256 stateId,
+        address rootMessageSender,
+        bytes calldata data
+    ) external;
+}
+
+/**
+ * @notice Mock child tunnel contract to receive and send message from L2
+ */
+abstract contract FxBaseChildTunnel is IFxMessageProcessor {
+    // MessageTunnel on L1 will get data from this event
+    event MessageSent(bytes message);
+
+    // fx child
+    address public fxChild;
+
+    // fx root tunnel
+    address public fxRootTunnel;
+
+    constructor(address _fxChild) {
+        fxChild = _fxChild;
+    }
+
+    // Sender must be fxRootTunnel.
+    modifier validateSender(address sender) {
+        require(sender == fxRootTunnel, "FxBaseChildTunnel: INVALID_SENDER_FROM_ROOT");
+        _;
+    }
+
+    // Set fxRootTunnel if not set already.
+    function setFxRootTunnel(address _fxRootTunnel) public {
+        require(fxRootTunnel == address(0x0), "FxBaseChildTunnel: ROOT_TUNNEL_ALREADY_SET");
+        fxRootTunnel = _fxRootTunnel;
+    }
+
+    function processMessageFromRoot(
+        uint256 stateId,
+        address rootMessageSender,
+        bytes calldata data
+    ) public override {
+        require(msg.sender == fxChild, "FxBaseChildTunnel: INVALID_SENDER");
+        _processMessageFromRoot(stateId, rootMessageSender, data);
+    }
+
+    /**
+     * @notice Emit message that can be received on Root Tunnel
+     * @dev Call the internal function when need to emit message
+     * @param message bytes message that will be sent to Root Tunnel
+     * some message examples -
+     *   abi.encode(tokenId);
+     *   abi.encode(tokenId, tokenMetadata);
+     *   abi.encode(messageType, messageData);
+     */
+    function _sendMessageToRoot(bytes memory message) internal {
+        emit MessageSent(message);
+    }
+
+    /**
+     * @notice Process message received from Root Tunnel
+     * @dev function needs to be implemented to handle message as per requirement
+     * This is called by onStateReceive function.
+     * Since it is called via a system call, any event will not be emitted during its execution.
+     * @param stateId unique state id
+     * @param sender root message sender
+     * @param message bytes message that was sent from Root Tunnel
+     */
+    function _processMessageFromRoot(
+        uint256 stateId,
+        address sender,
+        bytes memory message
+    ) internal virtual;
+}

package/contracts/external/polygon/tunnel/FxBaseRootTunnel.sol

@@ -0,0 +1,185 @@
+// SPDX-License-Identifier: MIT
+// Copied with no modifications from Polygon demo FxTunnel repo: https://github.com/jdkanani/fx-portal
+// except bumping version from 0.7.3 --> 0.8
+pragma solidity ^0.8.0;
+
+import "../lib/RLPReader.sol";
+import "../lib/MerklePatriciaProof.sol";
+import "../lib/Merkle.sol";
+
+interface IFxStateSender {
+    function sendMessageToChild(address _receiver, bytes calldata _data) external;
+}
+
+contract ICheckpointManager {
+    struct HeaderBlock {
+        bytes32 root;
+        uint256 start;
+        uint256 end;
+        uint256 createdAt;
+        address proposer;
+    }
+
+    /**
+     * @notice mapping of checkpoint header numbers to block details
+     * @dev These checkpoints are submited by plasma contracts
+     */
+    mapping(uint256 => HeaderBlock) public headerBlocks;
+}
+
+abstract contract FxBaseRootTunnel {
+    using RLPReader for bytes;
+    using RLPReader for RLPReader.RLPItem;
+    using Merkle for bytes32;
+
+    // keccak256(MessageSent(bytes))
+    bytes32 public constant SEND_MESSAGE_EVENT_SIG = 0x8c5261668696ce22758910d05bab8f186d6eb247ceac2af2e82c7dc17669b036;
+
+    // state sender contract
+    IFxStateSender public fxRoot;
+    // root chain manager
+    ICheckpointManager public checkpointManager;
+    // child tunnel contract which receives and sends messages
+    address public fxChildTunnel;
+
+    // storage to avoid duplicate exits
+    mapping(bytes32 => bool) public processedExits;
+
+    constructor(address _checkpointManager, address _fxRoot) {
+        checkpointManager = ICheckpointManager(_checkpointManager);
+        fxRoot = IFxStateSender(_fxRoot);
+    }
+
+    // set fxChildTunnel if not set already
+    function setFxChildTunnel(address _fxChildTunnel) public {
+        require(fxChildTunnel == address(0x0), "FxBaseRootTunnel: CHILD_TUNNEL_ALREADY_SET");
+        fxChildTunnel = _fxChildTunnel;
+    }
+
+    /**
+     * @notice Send bytes message to Child Tunnel
+     * @param message bytes message that will be sent to Child Tunnel
+     * some message examples -
+     *   abi.encode(tokenId);
+     *   abi.encode(tokenId, tokenMetadata);
+     *   abi.encode(messageType, messageData);
+     */
+    function _sendMessageToChild(bytes memory message) internal {
+        fxRoot.sendMessageToChild(fxChildTunnel, message);
+    }
+
+    function _validateAndExtractMessage(bytes memory inputData) internal returns (bytes memory) {
+        RLPReader.RLPItem[] memory inputDataRLPList = inputData.toRlpItem().toList();
+
+        // checking if exit has already been processed
+        // unique exit is identified using hash of (blockNumber, branchMask, receiptLogIndex)
+        bytes32 exitHash =
+            keccak256(
+                abi.encodePacked(
+                    inputDataRLPList[2].toUint(), // blockNumber
+                    // first 2 nibbles are dropped while generating nibble array
+                    // this allows branch masks that are valid but bypass exitHash check (changing first 2 nibbles only)
+                    // so converting to nibble array and then hashing it
+                    MerklePatriciaProof._getNibbleArray(inputDataRLPList[8].toBytes()), // branchMask
+                    inputDataRLPList[9].toUint() // receiptLogIndex
+                )
+            );
+        require(processedExits[exitHash] == false, "FxRootTunnel: EXIT_ALREADY_PROCESSED");
+        processedExits[exitHash] = true;
+
+        RLPReader.RLPItem[] memory receiptRLPList = inputDataRLPList[6].toBytes().toRlpItem().toList();
+        RLPReader.RLPItem memory logRLP =
+            receiptRLPList[3].toList()[
+                inputDataRLPList[9].toUint() // receiptLogIndex
+            ];
+
+        RLPReader.RLPItem[] memory logRLPList = logRLP.toList();
+
+        // check child tunnel
+        require(fxChildTunnel == RLPReader.toAddress(logRLPList[0]), "FxRootTunnel: INVALID_FX_CHILD_TUNNEL");
+
+        // verify receipt inclusion
+        require(
+            MerklePatriciaProof.verify(
+                inputDataRLPList[6].toBytes(), // receipt
+                inputDataRLPList[8].toBytes(), // branchMask
+                inputDataRLPList[7].toBytes(), // receiptProof
+                bytes32(inputDataRLPList[5].toUint()) // receiptRoot
+            ),
+            "FxRootTunnel: INVALID_RECEIPT_PROOF"
+        );
+
+        // verify checkpoint inclusion
+        _checkBlockMembershipInCheckpoint(
+            inputDataRLPList[2].toUint(), // blockNumber
+            inputDataRLPList[3].toUint(), // blockTime
+            bytes32(inputDataRLPList[4].toUint()), // txRoot
+            bytes32(inputDataRLPList[5].toUint()), // receiptRoot
+            inputDataRLPList[0].toUint(), // headerNumber
+            inputDataRLPList[1].toBytes() // blockProof
+        );
+
+        RLPReader.RLPItem[] memory logTopicRLPList = logRLPList[1].toList(); // topics
+
+        require(
+            bytes32(logTopicRLPList[0].toUint()) == SEND_MESSAGE_EVENT_SIG, // topic0 is event sig
+            "FxRootTunnel: INVALID_SIGNATURE"
+        );
+
+        // received message data
+        bytes memory receivedData = logRLPList[2].toBytes();
+        bytes memory message = abi.decode(receivedData, (bytes)); // event decodes params again, so decoding bytes to get message
+        return message;
+    }
+
+    function _checkBlockMembershipInCheckpoint(
+        uint256 blockNumber,
+        uint256 blockTime,
+        bytes32 txRoot,
+        bytes32 receiptRoot,
+        uint256 headerNumber,
+        bytes memory blockProof
+    ) private view returns (uint256) {
+        (bytes32 headerRoot, uint256 startBlock, , uint256 createdAt, ) = checkpointManager.headerBlocks(headerNumber);
+
+        require(
+            keccak256(abi.encodePacked(blockNumber, blockTime, txRoot, receiptRoot)).checkMembership(
+                blockNumber - startBlock,
+                headerRoot,
+                blockProof
+            ),
+            "FxRootTunnel: INVALID_HEADER"
+        );
+        return createdAt;
+    }
+
+    /**
+     * @notice receive message from  L2 to L1, validated by proof
+     * @dev This function verifies if the transaction actually happened on child chain
+     *
+     * @param inputData RLP encoded data of the reference tx containing following list of fields
+     *  0 - headerNumber - Checkpoint header block number containing the reference tx
+     *  1 - blockProof - Proof that the block header (in the child chain) is a leaf in the submitted merkle root
+     *  2 - blockNumber - Block number containing the reference tx on child chain
+     *  3 - blockTime - Reference tx block time
+     *  4 - txRoot - Transactions root of block
+     *  5 - receiptRoot - Receipts root of block
+     *  6 - receipt - Receipt of the reference transaction
+     *  7 - receiptProof - Merkle proof of the reference receipt
+     *  8 - branchMask - 32 bits denoting the path of receipt in merkle tree
+     *  9 - receiptLogIndex - Log Index to read from the receipt
+     */
+    function receiveMessage(bytes memory inputData) public virtual {
+        bytes memory message = _validateAndExtractMessage(inputData);
+        _processMessageFromChild(message);
+    }
+
+    /**
+     * @notice Process message received from Child Tunnel
+     * @dev function needs to be implemented to handle message as per requirement
+     * This is called by onStateReceive function.
+     * Since it is called via a system call, any event will not be emitted during its execution.
+     * @param message bytes message that was sent from Child Tunnel
+     */
+    function _processMessageFromChild(bytes memory message) internal virtual;
+}