@arbitrum/nitro-contracts 1.0.0-beta.5 → 1.0.0-beta.6

package/src/test-helpers/BridgeTester.sol

@@ -0,0 +1,223 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.4;
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
+
+import "../bridge/IBridge.sol";
+import "../bridge/Messages.sol";
+import "../libraries/DelegateCallAware.sol";
+
+/**
+ * @title Staging ground for incoming and outgoing messages
+ * @notice Holds the inbox accumulator for delayed messages, and is the ETH escrow
+ * for value sent with these messages.
+ * Since the escrow is held here, this contract also contains a list of allowed
+ * outboxes that can make calls from here and withdraw this escrow.
+ */
+contract BridgeTester is Initializable, DelegateCallAware, IBridge {
+    using AddressUpgradeable for address;
+
+    struct InOutInfo {
+        uint256 index;
+        bool allowed;
+    }
+
+    mapping(address => InOutInfo) private allowedInboxesMap;
+    mapping(address => InOutInfo) private allowedOutboxesMap;
+
+    address[] public allowedDelayedInboxList;
+    address[] public allowedOutboxList;
+
+    address private _activeOutbox;
+
+    IOwnable public rollup;
+    address public sequencerInbox;
+
+    modifier onlyRollupOrOwner() {
+        if (msg.sender != address(rollup)) {
+            address rollupOwner = rollup.owner();
+            if (msg.sender != rollupOwner) {
+                revert NotRollupOrOwner(msg.sender, address(rollup), rollupOwner);
+            }
+        }
+        _;
+    }
+
+    function setSequencerInbox(address _sequencerInbox) external override onlyRollupOrOwner {
+        sequencerInbox = _sequencerInbox;
+        emit SequencerInboxUpdated(_sequencerInbox);
+    }
+
+    /// @dev Accumulator for delayed inbox messages; tail represents hash of the current state; each element represents the inclusion of a new message.
+    bytes32[] public override delayedInboxAccs;
+
+    bytes32[] public override sequencerInboxAccs;
+
+    address private constant EMPTY_ACTIVEOUTBOX = address(type(uint160).max);
+
+    function initialize(IOwnable rollup_) external initializer {
+        _activeOutbox = EMPTY_ACTIVEOUTBOX;
+        rollup = rollup_;
+    }
+
+    function activeOutbox() public view returns (address) {
+        if (_activeOutbox == EMPTY_ACTIVEOUTBOX) return address(uint160(0));
+        return _activeOutbox;
+    }
+
+    function allowedDelayedInboxes(address inbox) external view override returns (bool) {
+        return allowedInboxesMap[inbox].allowed;
+    }
+
+    function allowedOutboxes(address outbox) external view override returns (bool) {
+        return allowedOutboxesMap[outbox].allowed;
+    }
+
+    function enqueueSequencerMessage(bytes32 dataHash, uint256 afterDelayedMessagesRead)
+        external
+        returns (
+            uint256 seqMessageIndex,
+            bytes32 beforeAcc,
+            bytes32 delayedAcc,
+            bytes32 acc
+        )
+    {
+        // TODO: implement stub logic
+    }
+
+    function submitBatchSpendingReport(address batchPoster, bytes32 dataHash)
+        external
+        returns (uint256)
+    {
+        // TODO: implement stub
+    }
+
+    /**
+     * @dev Enqueue a message in the delayed inbox accumulator.
+     * These messages are later sequenced in the SequencerInbox, either by the sequencer as
+     * part of a normal batch, or by force inclusion.
+     */
+    function enqueueDelayedMessage(
+        uint8 kind,
+        address sender,
+        bytes32 messageDataHash
+    ) external payable override returns (uint256) {
+        if (!allowedInboxesMap[msg.sender].allowed) revert NotDelayedInbox(msg.sender);
+        return
+            addMessageToDelayedAccumulator(
+                kind,
+                sender,
+                uint64(block.number),
+                uint64(block.timestamp), // solhint-disable-line not-rely-on-time
+                block.basefee,
+                messageDataHash
+            );
+    }
+
+    function addMessageToDelayedAccumulator(
+        uint8 kind,
+        address sender,
+        uint64 blockNumber,
+        uint64 blockTimestamp,
+        uint256 baseFeeL1,
+        bytes32 messageDataHash
+    ) internal returns (uint256) {
+        uint256 count = delayedInboxAccs.length;
+        bytes32 messageHash = Messages.messageHash(
+            kind,
+            sender,
+            blockNumber,
+            blockTimestamp,
+            count,
+            baseFeeL1,
+            messageDataHash
+        );
+        bytes32 prevAcc = 0;
+        if (count > 0) {
+            prevAcc = delayedInboxAccs[count - 1];
+        }
+        delayedInboxAccs.push(Messages.accumulateInboxMessage(prevAcc, messageHash));
+        emit MessageDelivered(
+            count,
+            prevAcc,
+            msg.sender,
+            kind,
+            sender,
+            messageDataHash,
+            baseFeeL1,
+            blockTimestamp
+        );
+        return count;
+    }
+
+    function executeCall(
+        address to,
+        uint256 value,
+        bytes calldata data
+    ) external override returns (bool success, bytes memory returnData) {
+        if (!allowedOutboxesMap[msg.sender].allowed) revert NotOutbox(msg.sender);
+        if (data.length > 0 && !to.isContract()) revert NotContract(to);
+        address prevOutbox = _activeOutbox;
+        _activeOutbox = msg.sender;
+        // We set and reset active outbox around external call so activeOutbox remains valid during call
+
+        // We use a low level call here since we want to bubble up whether it succeeded or failed to the caller
+        // rather than reverting on failure as well as allow contract and non-contract calls
+        // solhint-disable-next-line avoid-low-level-calls
+        (success, returnData) = to.call{value: value}(data);
+        _activeOutbox = prevOutbox;
+        emit BridgeCallTriggered(msg.sender, to, value, data);
+    }
+
+    function setDelayedInbox(address inbox, bool enabled) external override onlyRollupOrOwner {
+        InOutInfo storage info = allowedInboxesMap[inbox];
+        bool alreadyEnabled = info.allowed;
+        emit InboxToggle(inbox, enabled);
+        if ((alreadyEnabled && enabled) || (!alreadyEnabled && !enabled)) {
+            return;
+        }
+        if (enabled) {
+            allowedInboxesMap[inbox] = InOutInfo(allowedDelayedInboxList.length, true);
+            allowedDelayedInboxList.push(inbox);
+        } else {
+            allowedDelayedInboxList[info.index] = allowedDelayedInboxList[
+                allowedDelayedInboxList.length - 1
+            ];
+            allowedInboxesMap[allowedDelayedInboxList[info.index]].index = info.index;
+            allowedDelayedInboxList.pop();
+            delete allowedInboxesMap[inbox];
+        }
+    }
+
+    function setOutbox(address outbox, bool enabled) external override onlyRollupOrOwner {
+        InOutInfo storage info = allowedOutboxesMap[outbox];
+        bool alreadyEnabled = info.allowed;
+        emit OutboxToggle(outbox, enabled);
+        if ((alreadyEnabled && enabled) || (!alreadyEnabled && !enabled)) {
+            return;
+        }
+        if (enabled) {
+            allowedOutboxesMap[outbox] = InOutInfo(allowedOutboxList.length, true);
+            allowedOutboxList.push(outbox);
+        } else {
+            allowedOutboxList[info.index] = allowedOutboxList[allowedOutboxList.length - 1];
+            allowedOutboxesMap[allowedOutboxList[info.index]].index = info.index;
+            allowedOutboxList.pop();
+            delete allowedOutboxesMap[outbox];
+        }
+    }
+
+    function delayedMessageCount() external view override returns (uint256) {
+        return delayedInboxAccs.length;
+    }
+
+    function sequencerMessageCount() external view override returns (uint256) {
+        return sequencerInboxAccs.length;
+    }
+
+    receive() external payable {}
+}

package/src/test-helpers/OutboxWithoutOptTester.sol

@@ -0,0 +1,188 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.4;
+
+import "../bridge/IBridge.sol";
+import "../bridge/IOutbox.sol";
+import "../libraries/MerkleLib.sol";
+import "../libraries/DelegateCallAware.sol";
+
+contract OutboxWithoutOptTester is DelegateCallAware, IOutbox {
+    address public rollup; // the rollup contract
+    IBridge public bridge; // the bridge contract
+
+    mapping(uint256 => bool) public spent; // maps leaf number => if spent
+    mapping(bytes32 => bytes32) public roots; // maps root hashes => L2 block hash
+
+    struct L2ToL1Context {
+        uint128 l2Block;
+        uint128 l1Block;
+        uint128 timestamp;
+        bytes32 outputId;
+        address sender;
+    }
+    // Note, these variables are set and then wiped during a single transaction.
+    // Therefore their values don't need to be maintained, and their slots will
+    // be empty outside of transactions
+    L2ToL1Context internal context;
+    uint128 public constant OUTBOX_VERSION = 2;
+
+    function initialize(IBridge _bridge) external {
+        if (address(bridge) != address(0)) revert AlreadyInit();
+        bridge = _bridge;
+        rollup = address(_bridge.rollup());
+    }
+
+    function updateSendRoot(bytes32 root, bytes32 l2BlockHash) external override {
+        //if (msg.sender != rollup) revert NotRollup(msg.sender, rollup);  //test only!!!
+        roots[root] = l2BlockHash;
+        emit SendRootUpdated(root, l2BlockHash);
+    }
+
+    /// @notice When l2ToL1Sender returns a nonzero address, the message was originated by an L2 account
+    /// When the return value is zero, that means this is a system message
+    /// @dev the l2ToL1Sender behaves as the tx.origin, the msg.sender should be validated to protect against reentrancies
+    function l2ToL1Sender() external view override returns (address) {
+        return context.sender;
+    }
+
+    function l2ToL1Block() external view override returns (uint256) {
+        return uint256(context.l2Block);
+    }
+
+    function l2ToL1EthBlock() external view override returns (uint256) {
+        return uint256(context.l1Block);
+    }
+
+    function l2ToL1Timestamp() external view override returns (uint256) {
+        return uint256(context.timestamp);
+    }
+
+    // @deprecated batch number is now always 0
+    function l2ToL1BatchNum() external pure override returns (uint256) {
+        return 0;
+    }
+
+    function l2ToL1OutputId() external view override returns (bytes32) {
+        return context.outputId;
+    }
+
+    /**
+     * @notice Executes a messages in an Outbox entry.
+     * @dev Reverts if dispute period hasn't expired, since the outbox entry
+     * is only created once the rollup confirms the respective assertion.
+     * @param proof Merkle proof of message inclusion in send root
+     * @param index Merkle path to message
+     * @param l2Sender sender if original message (i.e., caller of ArbSys.sendTxToL1)
+     * @param to destination address for L1 contract call
+     * @param l2Block l2 block number at which sendTxToL1 call was made
+     * @param l1Block l1 block number at which sendTxToL1 call was made
+     * @param l2Timestamp l2 Timestamp at which sendTxToL1 call was made
+     * @param value wei in L1 message
+     * @param data abi-encoded L1 message data
+     */
+    function executeTransaction(
+        bytes32[] calldata proof,
+        uint256 index,
+        address l2Sender,
+        address to,
+        uint256 l2Block,
+        uint256 l1Block,
+        uint256 l2Timestamp,
+        uint256 value,
+        bytes calldata data
+    ) external virtual {
+        bytes32 outputId;
+        {
+            bytes32 userTx = calculateItemHash(
+                l2Sender,
+                to,
+                l2Block,
+                l1Block,
+                l2Timestamp,
+                value,
+                data
+            );
+
+            outputId = recordOutputAsSpent(proof, index, userTx);
+            emit OutBoxTransactionExecuted(to, l2Sender, 0, index);
+        }
+
+        // we temporarily store the previous values so the outbox can naturally
+        // unwind itself when there are nested calls to `executeTransaction`
+        L2ToL1Context memory prevContext = context;
+
+        context = L2ToL1Context({
+            sender: l2Sender,
+            l2Block: uint128(l2Block),
+            l1Block: uint128(l1Block),
+            timestamp: uint128(l2Timestamp),
+            outputId: outputId
+        });
+
+        // set and reset vars around execution so they remain valid during call
+        executeBridgeCall(to, value, data);
+
+        context = prevContext;
+    }
+
+    function recordOutputAsSpent(
+        bytes32[] memory proof,
+        uint256 index,
+        bytes32 item
+    ) internal returns (bytes32) {
+        if (proof.length >= 256) revert ProofTooLong(proof.length);
+        if (index >= 2**proof.length) revert PathNotMinimal(index, 2**proof.length);
+
+        // Hash the leaf an extra time to prove it's a leaf
+        bytes32 calcRoot = calculateMerkleRoot(proof, index, item);
+        if (roots[calcRoot] == bytes32(0)) revert UnknownRoot(calcRoot);
+
+        if (spent[index]) revert AlreadySpent(index);
+        spent[index] = true;
+
+        return bytes32(index);
+    }
+
+    function executeBridgeCall(
+        address to,
+        uint256 value,
+        bytes memory data
+    ) internal {
+        (bool success, bytes memory returndata) = bridge.executeCall(to, value, data);
+        if (!success) {
+            if (returndata.length > 0) {
+                // solhint-disable-next-line no-inline-assembly
+                assembly {
+                    let returndata_size := mload(returndata)
+                    revert(add(32, returndata), returndata_size)
+                }
+            } else {
+                revert BridgeCallFailed();
+            }
+        }
+    }
+
+    function calculateItemHash(
+        address l2Sender,
+        address to,
+        uint256 l2Block,
+        uint256 l1Block,
+        uint256 l2Timestamp,
+        uint256 value,
+        bytes calldata data
+    ) public pure returns (bytes32) {
+        return
+            keccak256(abi.encodePacked(l2Sender, to, l2Block, l1Block, l2Timestamp, value, data));
+    }
+
+    function calculateMerkleRoot(
+        bytes32[] memory proof,
+        uint256 path,
+        bytes32 item
+    ) public pure returns (bytes32) {
+        return MerkleLib.calculateRoot(proof, path, keccak256(abi.encodePacked(item)));
+    }
+}

package/src/test-helpers/RollupMock.sol

@@ -0,0 +1,21 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.4;
+
+contract RollupMock {
+    event WithdrawTriggered();
+    event ZombieTriggered();
+
+    function withdrawStakerFunds() external returns (uint256) {
+        emit WithdrawTriggered();
+        return 0;
+    }
+
+    function removeOldZombies(
+        uint256 /* startIndex */
+    ) external {
+        emit ZombieTriggered();
+    }
+}

package/src/state/PcStack.sol

@@ -1,32 +0,0 @@
-// Copyright 2021-2022, Offchain Labs, Inc.
-// For license information, see https://github.com/nitro/blob/master/LICENSE
-// SPDX-License-Identifier: BUSL-1.1
-
-pragma solidity ^0.8.0;
-
-import "./PcArray.sol";
-
-struct PcStack {
-    PcArray proved;
-    bytes32 remainingHash;
-}
-
-library PcStackLib {
-    using PcArrayLib for PcArray;
-
-    function hash(PcStack memory stack) internal pure returns (bytes32 h) {
-        h = stack.remainingHash;
-        uint256 len = stack.proved.length();
-        for (uint256 i = 0; i < len; i++) {
-            h = keccak256(abi.encodePacked("Program counter stack:", stack.proved.get(i), h));
-        }
-    }
-
-    function pop(PcStack memory stack) internal pure returns (uint32) {
-        return stack.proved.pop();
-    }
-
-    function push(PcStack memory stack, uint32 val) internal pure {
-        return stack.proved.push(val);
-    }
-}