@arbitrum/nitro-contracts 1.0.0-beta.1

package/src/state/ValueArray.sol

@@ -0,0 +1,47 @@
+// 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 "./Value.sol";
+
+struct ValueArray {
+    Value[] inner;
+}
+
+library ValueArrayLib {
+    function get(ValueArray memory arr, uint256 index) internal pure returns (Value memory) {
+        return arr.inner[index];
+    }
+
+    function set(
+        ValueArray memory arr,
+        uint256 index,
+        Value memory val
+    ) internal pure {
+        arr.inner[index] = val;
+    }
+
+    function length(ValueArray memory arr) internal pure returns (uint256) {
+        return arr.inner.length;
+    }
+
+    function push(ValueArray memory arr, Value memory val) internal pure {
+        Value[] memory newInner = new Value[](arr.inner.length + 1);
+        for (uint256 i = 0; i < arr.inner.length; i++) {
+            newInner[i] = arr.inner[i];
+        }
+        newInner[arr.inner.length] = val;
+        arr.inner = newInner;
+    }
+
+    function pop(ValueArray memory arr) internal pure returns (Value memory popped) {
+        popped = arr.inner[arr.inner.length - 1];
+        Value[] memory newInner = new Value[](arr.inner.length - 1);
+        for (uint256 i = 0; i < newInner.length; i++) {
+            newInner[i] = arr.inner[i];
+        }
+        arr.inner = newInner;
+    }
+}

package/src/state/ValueStack.sol

@@ -0,0 +1,39 @@
+// 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 "./Value.sol";
+import "./ValueArray.sol";
+
+struct ValueStack {
+    ValueArray proved;
+    bytes32 remainingHash;
+}
+
+library ValueStackLib {
+    using ValueLib for Value;
+    using ValueArrayLib for ValueArray;
+
+    function hash(ValueStack 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("Value stack:", stack.proved.get(i).hash(), h));
+        }
+    }
+
+    function peek(ValueStack memory stack) internal pure returns (Value memory) {
+        uint256 len = stack.proved.length();
+        return stack.proved.get(len - 1);
+    }
+
+    function pop(ValueStack memory stack) internal pure returns (Value memory) {
+        return stack.proved.pop();
+    }
+
+    function push(ValueStack memory stack, Value memory val) internal pure {
+        return stack.proved.push(val);
+    }
+}

package/src/test-helpers/CryptographyPrimitivesTester.sol

@@ -0,0 +1,27 @@
+// 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 "../libraries/CryptographyPrimitives.sol";
+
+library CryptographyPrimitivesTester {
+    function keccakF(uint256[25] memory input) public pure returns (uint256[25] memory) {
+        return CryptographyPrimitives.keccakF(input);
+    }
+
+    function sha256Block(bytes32[2] memory inputChunk, bytes32 hashState)
+        public
+        pure
+        returns (bytes32)
+    {
+        return
+            bytes32(
+                CryptographyPrimitives.sha256Block(
+                    [uint256(inputChunk[0]), uint256(inputChunk[1])],
+                    uint256(hashState)
+                )
+            );
+    }
+}

package/src/test-helpers/MessageTester.sol

@@ -0,0 +1,34 @@
+// 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 "../bridge/Messages.sol";
+
+contract MessageTester {
+    function messageHash(
+        uint8 messageType,
+        address sender,
+        uint64 blockNumber,
+        uint64 timestamp,
+        uint256 inboxSeqNum,
+        uint256 gasPriceL1,
+        bytes32 messageDataHash
+    ) public pure returns (bytes32) {
+        return
+            Messages.messageHash(
+                messageType,
+                sender,
+                blockNumber,
+                timestamp,
+                inboxSeqNum,
+                gasPriceL1,
+                messageDataHash
+            );
+    }
+
+    function accumulateInboxMessage(bytes32 inbox, bytes32 message) public pure returns (bytes32) {
+        return Messages.accumulateInboxMessage(inbox, message);
+    }
+}

package/src/test-helpers/ValueArrayTester.sol

@@ -0,0 +1,34 @@
+// 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 "../state/ValueArray.sol";
+
+contract ValueArrayTester {
+    using ValueArrayLib for ValueArray;
+
+    function test() external pure {
+        ValueArray memory arr = ValueArray(new Value[](2));
+        require(arr.length() == 2, "START_LEN");
+        arr.set(0, ValueLib.newI32(1));
+        arr.set(1, ValueLib.newI32(2));
+        arr.push(ValueLib.newI32(3));
+        require(arr.length() == 3, "PUSH_LEN");
+        for (uint256 i = 0; i < arr.length(); i++) {
+            Value memory val = arr.get(i);
+            require(val.valueType == ValueType.I32, "PUSH_VAL_TYPE");
+            require(val.contents == i + 1, "PUSH_VAL_CONTENTS");
+        }
+        Value memory popped = arr.pop();
+        require(popped.valueType == ValueType.I32, "POP_RET_TYPE");
+        require(popped.contents == 3, "POP_RET_CONTENTS");
+        require(arr.length() == 2, "POP_LEN");
+        for (uint256 i = 0; i < arr.length(); i++) {
+            Value memory val = arr.get(i);
+            require(val.valueType == ValueType.I32, "POP_VAL_TYPE");
+            require(val.contents == i + 1, "POP_VAL_CONTENTS");
+        }
+    }
+}