code for priority op queue, include unit-tests

Ho · Ho · commit 772c3c2b1578 · 2021-12-28T13:03:44.000+08:00
diff --git a/contracts/Bytes.sol b/contracts/Bytes.sol
@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+pragma solidity ^0.8.0;
+
+library Bytes {
+
+    function shiftAndReverseBits8(uint8 val, uint8 offset) internal pure returns (uint256 ret) {
+        uint16 effectLen = offset < 248 ? 8 : 256 - offset;
+        for(uint16 i = 0; i < effectLen; i++){
+            if (val & 1 == 1){
+                ret += (1 << (255-i-offset));
+            }
+            val >>=1;
+        }
+    }
+
+    function shiftAndReverseBits16(uint16 val, uint8 offset) internal pure returns (uint256 ret) {
+        uint16 effectLen = offset < 240 ? 16 : 256 - offset;
+        for(uint16 i = 0; i < effectLen; i++){
+            if (val & 1 == 1){
+                ret += (1 << (255-i-offset));
+            }
+            val >>=1;
+        }
+    }
+
+    function shiftAndReverseBits32(uint32 val, uint8 offset) internal pure returns (uint256 ret) {
+        uint16 effectLen = offset < 224 ? 32 : 256 - offset;
+        for(uint16 i = 0; i < effectLen; i++){
+            if (val & 1 == 1){
+                ret += (1 << (255-i-offset));
+            }
+            val >>=1;
+        }
+    }
+
+    function shiftAndReverseBits64(uint64 val, uint8 offset) internal pure returns (uint256 ret) {
+        uint16 effectLen = offset < 192 ? 64 : 256 - offset;
+        for(uint16 i = 0; i < effectLen; i++){
+            if (val & 1 == 1){
+                ret += (1 << (255-i-offset));
+            }
+            val >>=1;
+        }
+    }
+
+    function shiftAndReverseBits128(uint128 val, uint8 offset) internal pure returns (uint256 ret) {
+        uint16 effectLen = offset < 128 ? 128 : 256 - offset;
+        for(uint16 i = 0; i < effectLen; i++){
+            if (val & 1 == 1){
+                ret += (1 << (255-i-offset));
+            }
+            val >>=1;
+        }
+    }
+
+    function shiftAndReverseBits(uint256 val, uint8 offset) internal pure returns (uint256 ret) {
+        for(uint16 i = 0; i < 256 - offset; i++){
+            if (val & 1 == 1){
+                ret += (1 << (255-i-offset));
+            }
+            val >>=1;
+        }
+    }
+
+    //see https://ethereum.stackexchange.com/questions/83626/how-to-reverse-byte-order-in-uint256-or-bytes32
+    function swapBytes(uint256 input) internal pure returns (uint256 v) {
+        v = input;
+
+        // swap bytes
+        v = ((v & 0xFF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00) >> 8) |
+            ((v & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) << 8);
+
+        // swap 2-byte long pairs
+        v = ((v & 0xFFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000) >> 16) |
+            ((v & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) << 16);
+
+        // swap 4-byte long pairs
+        v = ((v & 0xFFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000) >> 32) |
+            ((v & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) << 32);
+
+        // swap 8-byte long pairs
+        v = ((v & 0xFFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF0000000000000000) >> 64) |
+            ((v & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) << 64);
+
+        // swap 16-byte long pairs
+        v = (v >> 128) | (v << 128);
+    }
+
+    // See comment at the top of this file for explanation of how this function works.
+    // NOTE: theoretically possible overflow of (_start + 0x2)
+    function bytesToUInt16(bytes memory _bytes, uint256 _start) internal pure returns (uint16 r) {
+        uint256 offset = _start + 0x2;
+        require(_bytes.length >= offset, "T");
+        assembly {
+            r := mload(add(_bytes, offset))
+        }
+    }
+
+    // NOTE: theoretically possible overflow of (_offset + 2)
+    function readUInt16(bytes memory _data, uint256 _offset) internal pure returns (uint256 newOffset, uint16 r) {
+        newOffset = _offset + 2;
+        r = bytesToUInt16(_data, _offset);
+    }
+}
diff --git a/contracts/Operations.sol b/contracts/Operations.sol
@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+pragma solidity ^0.8.0;
+pragma experimental ABIEncoderV2;
+
+import "./Bytes.sol";
+import "./Utils.sol";
+import "hardhat/console.sol"; //for debugging
+
+/// @title Fluidex operations tools
+library Operations {
+
+    /// @notice Config parameters, generated from circuit parameters
+    uint8 constant BALANCE_BITS = 3;
+    uint8 constant ACCOUNT_BITS = 4;
+    uint8 constant ORDER_BITS = 4;
+    uint constant TX_PUBDATA_BYTES = 33;
+
+    /// @dev Expected average period of block creation
+    uint256 internal constant BLOCK_PERIOD = 15 seconds;
+
+    /// @dev Expiration delta for priority request to be satisfied (in seconds)
+    /// @dev NOTE: Priority expiration should be > (EXPECT_VERIFICATION_IN * BLOCK_PERIOD)
+    /// @dev otherwise incorrect block with priority op could not be reverted.
+    uint256 internal constant PRIORITY_EXPIRATION_PERIOD = 7 days;
+
+    /// @dev Expiration delta for priority request to be satisfied (in ETH blocks)
+    uint256 internal constant PRIORITY_EXPIRATION = PRIORITY_EXPIRATION_PERIOD / BLOCK_PERIOD;
+
+    /// @notice Fluidex circuit operation type
+    enum OpType {
+        Deposit,
+        Registry
+    }
+
+    function hashPubData(bytes calldata _public_data, uint pos) internal pure returns (bytes20){
+        return Utils.hashBytesToBytes20(_public_data[pos:pos+TX_PUBDATA_BYTES]);
+    }
+
+    // Registry L2key pubdata
+    struct Registry {
+        uint32 accountId;
+        bytes32 l2key;
+    }
+
+    // Deposit pubdata
+    struct Deposit {
+        uint32 accountId;
+        uint16 tokenId;
+        uint128 amount;
+    }
+
+    function scaleTokenValueToAmount(uint value, uint8 scale) internal pure returns (uint128) {
+        require(scale > 0, "Known token must has a scaling");
+        return uint128(value / (10 ** scale));
+    }
+
+    function hashOpDataFromBuf(bytes memory buf) internal pure returns (bytes20){
+        bytes memory truncatedBuf = new bytes(TX_PUBDATA_BYTES);
+        for(uint i = 0; i < TX_PUBDATA_BYTES; i++){
+            truncatedBuf[i] = buf[i];
+        }
+
+        return Utils.hashBytesToBytes20(truncatedBuf);
+    }
+
+    /// Serialize registry pubdata
+    function writeRegistryPubdataForPriorityQueue(Registry memory op) internal pure returns (bytes20) {
+
+        uint256 encoded_1 = 0;
+        uint8 offset = 0;
+        encoded_1 += Bytes.shiftAndReverseBits8(uint8(1), offset); //100 in bits
+        offset += 3;
+        encoded_1 += Bytes.shiftAndReverseBits32(op.accountId, offset);
+        offset += ACCOUNT_BITS;
+        uint8 sign = op.l2key[31] & 0x80 != 0 ? 1 : 0;
+        encoded_1 += Bytes.shiftAndReverseBits8(sign, offset);
+        offset += 1;
+        uint256 ay = uint256(op.l2key);
+        ay -= (uint8(op.l2key[31]) - uint8(op.l2key[31] & 0x7f));
+        //notice babyjub consider the read bytes as LITTLE-endian integer
+        ay = Bytes.swapBytes(ay);
+        encoded_1 += Bytes.shiftAndReverseBits(ay, offset);
+        //calc the resident of bits in ay
+        ay >>= (256 - offset);
+        uint256 encoded_2 = Bytes.shiftAndReverseBits(ay, 0);
+
+        return hashOpDataFromBuf(abi.encodePacked(encoded_1, encoded_2));
+    }
+
+    /// Serialize deposit pubdata
+    function writeDepositPubdataForPriorityQueue(Deposit memory op) internal pure returns (bytes20) {
+        uint256 encoded_1 = 0;
+        uint8 offset = 0;
+        encoded_1 += Bytes.shiftAndReverseBits8(uint8(0), offset); //000 in bits
+        offset += 3;
+        encoded_1 += Bytes.shiftAndReverseBits32(op.accountId, offset);
+        offset += ACCOUNT_BITS;
+        //according to the encoding scheme we need to encode account id twice
+        encoded_1 += Bytes.shiftAndReverseBits32(op.accountId, offset);
+        offset += ACCOUNT_BITS;
+        encoded_1 += Bytes.shiftAndReverseBits16(op.tokenId, offset);
+        offset += BALANCE_BITS;
+        assert(offset <= 128);
+
+        encoded_1 += Bytes.shiftAndReverseBits128(op.amount, offset);
+
+        return hashOpDataFromBuf(abi.encodePacked(encoded_1, uint256(0)));
+    }
+}
diff --git a/contracts/Storage.sol b/contracts/Storage.sol
@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+pragma solidity ^0.8.0;
+
+import "./Operations.sol";
+
+/// @title Fluidex storage contract
+contract Storage {
+
+    /// @notice First open priority request id
+    uint64 public firstPriorityRequestId;
+
+    /// @notice Total number of requests
+    uint64 public totalOpenPriorityRequests;
+
+    /// @notice Priority Operation container
+    /// @member hashedPubData Hashed priority operation public data
+    /// @member expirationBlock Expiration block number (ETH block) for this request (must be satisfied before)
+    /// @member opType Priority operation type
+    struct PriorityOperation {
+        bytes20 hashedPubData;
+        uint64 expirationBlock;
+        Operations.OpType opType;
+    }
+
+    /// @dev Priority Requests mapping (request id - operation)
+    /// @dev Contains op type, pubdata and expiration block of unsatisfied requests.
+    /// @dev Numbers are in order of requests receiving
+    mapping(uint64 => PriorityOperation) internal priorityRequests;
+
+    /// @notice Verify priorityOp inside the calling public data match the priority queue
+    /// @dev Calculates expiration block for request, store this request and emit NewPriorityRequest event
+    /// @param _public_data Calling public_data
+    /// @param _op_indexs indexs specify which op should be checked
+    function verifyPriorityOp(bytes calldata _public_data, bytes calldata _op_indexs) internal view returns (bool _ret, uint64 _priorityRequestId){
+        //_op_indexs is uint16 being encode packed
+        assert(_op_indexs.length % 2 == 0);
+
+        _priorityRequestId = firstPriorityRequestId;
+
+        for(uint i = 0; i < _op_indexs.length; i+= 2){
+            //TODO: with compiler later than 0.8.10 we can use slice
+            //uint pos = uint16(bytes2(_op_indexs[i:i+2]));
+            uint pos = uint(uint8(_op_indexs[i])) * 256 + uint(uint8(_op_indexs[i+1]));
+            assert(pos < _public_data.length);
+            bytes20 hashedPubdata = priorityRequests[_priorityRequestId].hashedPubData;
+            if (Operations.hashPubData(_public_data, pos) != hashedPubdata){
+                return (false, _priorityRequestId);
+            }
+            _priorityRequestId++;
+        }
+
+        _ret = true;
+    }
+
+    /// @notice Saves priority request in storage
+    /// @dev Calculates expiration block for request, store this request and emit NewPriorityRequest event
+    /// @param _opType Rollup operation type
+    /// @param _hashedPubData Hashed Operation pubdata
+    function addPriorityRequest(Operations.OpType _opType, bytes20 _hashedPubData) internal {
+        // Expiration block is: current block number + priority expiration delta
+        uint64 expirationBlock = uint64(block.number + Operations.PRIORITY_EXPIRATION);
+
+        uint64 nextPriorityRequestId = firstPriorityRequestId + totalOpenPriorityRequests;
+
+        priorityRequests[nextPriorityRequestId] = PriorityOperation({
+            hashedPubData: _hashedPubData,
+            expirationBlock: expirationBlock,
+            opType: _opType
+        });
+
+        totalOpenPriorityRequests++;
+    }    
+}
diff --git a/contracts/TestLibs.sol b/contracts/TestLibs.sol
@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+pragma solidity ^0.8.0;
+
+import "./Operations.sol";
+
+/// @title Unittest contract for libraries
+contract TestLibs {
+
+    function testBitsOp8(uint8 val, uint8 offset) public pure returns (uint256){
+        return Bytes.shiftAndReverseBits8(val, offset);
+    }
+
+    function testBitsOp32(uint32 val, uint8 offset) public pure returns (uint256){
+        return Bytes.shiftAndReverseBits32(val, offset);
+    }
+
+    function testBitsOp256(uint256 val, uint8 offset) public pure returns (uint256){
+        return Bytes.shiftAndReverseBits(val, offset);
+    }
+
+    function testWriteRegistryPubdata(uint32 accId, bytes32 l2key) public pure returns (bytes20){
+
+        Operations.Registry memory op = Operations.Registry({
+            accountId: accId,
+            l2key: l2key
+        });
+
+        return Operations.writeRegistryPubdataForPriorityQueue(op);
+    }
+
+    function testWriteDepositPubdata(uint32 accId, uint16 tokenId, uint128 amount) public pure returns (bytes20){
+
+        Operations.Deposit memory op = Operations.Deposit({
+            accountId: accId,
+            tokenId: tokenId,
+            amount: amount
+        });
+
+        return Operations.writeDepositPubdataForPriorityQueue(op);
+    }    
+}
diff --git a/contracts/Utils.sol b/contracts/Utils.sol
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+pragma solidity ^0.8.0;
+
+library Utils {
+    function hashBytesToBytes20(bytes memory _bytes) internal pure returns (bytes20) {
+        return bytes20(uint160(uint256(keccak256(_bytes))));
+    }
+}
diff --git a/package.json b/package.json
@@ -13,6 +13,7 @@
     "ethers": "^5.0.24",
     "fluidex.js": "git+https://github.com/fluidex/fluidex.js.git#b9224719013c224445fe8ec06f6a05e800b4469e",
     "hardhat": "^2.0.6",
+    "mocha": "^9.1.3",
     "prettier": "^2.2.1",
     "prettier-plugin-solidity": "^1.0.0-beta.2",
     "ts-node": "^10.2.1",
diff --git a/test/operations-test.js b/test/operations-test.js
