punkkit-sdk 1.0.0

package/contracts/auction/strategies/MatchResultWithdrawnStrategy.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "../interfaces/IUnlockStrategy.sol";
+
+// 直接迁移到ChianYVault中实现，该合约弃用
+contract MatchResultWithdrawnStrategy is IUnlockStrategy {
+    function processUnlock(
+        bytes32 eventTopic,
+        bytes memory eventData,
+        uint256 lockedAmount
+    ) external pure override returns (address recipient, uint256 unlockAmount) {
+        // 验证事件主题是否为 MatchResultWithdrawn
+        require(
+            eventTopic == keccak256("MatchResultWithdrawn(uint256,bytes32,address,uint256)"),
+            "Invalid event topic"
+        );
+
+        // 解析事件数据
+        (
+            uint256 auctionId,
+            bytes32 lockId,
+            address bidder,
+            uint256 transferAmount
+        ) = abi.decode(eventData, (uint256, bytes32, address, uint256));
+
+        // 返回解锁信息
+        return (
+            bidder,              // 接收者为中标者
+            transferAmount       // 解锁金额为转账金额
+        );
+    }
+} 

package/contracts/auction/utils/BytesLib.sol

@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+library BytesLib {
+
+    function reverseBytes32(bytes32 input) public pure returns (bytes32) {
+        bytes32 output;
+        assembly {
+            let outputPtr := add(output, 0x20)
+            for { let i := 0 } lt(i, 32) { i := add(i, 1) } {
+                mstore8(add(outputPtr, sub(31, i)), byte(i, input))
+            }
+        }
+        return output;
+    }
+
+    // ref: https://ethereum.stackexchange.com/questions/83626/how-to-reverse-byte-order-in-uint256-or-bytes32
+    function reverse(bytes32 input) internal pure returns (bytes32 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);
+    }
+
+    function slice(bytes memory data, uint start, uint len) internal pure returns (bytes memory) {
+        bytes memory result = new bytes(len);
+        assembly {
+            let dataPtr := add(data, 0x20)
+            let resultPtr := add(result, 0x20)
+            for { let i := 0 } lt(i, len) { i := add(i, 0x20) } {
+                mstore(add(resultPtr, i), mload(add(dataPtr, add(start, i))))
+            }
+        }
+        return result;
+    }
+
+    function slice32(bytes memory data, uint start) internal pure returns (bytes32) {
+        require(start + 32 <= data.length, "slice32: out of bounds");
+
+        bytes32 result;
+        assembly {
+            let dataPtr := add(data, 0x20)
+            result := mload(add(dataPtr, start))
+        }
+        return result;
+    }
+
+    function toUint32(bytes memory b) internal pure returns (uint32) {
+        require(b.length == 4, "Invalid input length");
+
+        uint32 value;
+        assembly {
+            value := mload(add(b, 0x04))
+        }
+        return value;
+    }
+
+    function toUint64(bytes memory b) internal pure returns (uint64) {
+        require(b.length == 8, "Invalid input length");
+
+        uint64 value;
+        assembly {
+            value := mload(add(b, 0x08))
+        }
+        return value;
+    }
+
+    function bytesToUint(bytes memory b) internal pure returns (uint256){
+        uint256 number;
+        for(uint i = 0; i < b.length; i++){
+            number = number + uint256(uint8(b[i])) * (2 ** (8 * (b.length - (i + 1))));
+        }
+        return number;
+    }
+    
+    function reverseBytes(bytes memory input) internal pure returns (bytes memory) {
+        bytes memory output = new bytes(input.length);
+        assembly {
+            let len := mload(input)
+            let inputPtr := add(input, 0x20)
+            let outputPtr := add(output, 0x20)
+            for { let i := 0 } lt(i, len) { i := add(i, 0x20) } {
+                mstore(add(outputPtr, sub(sub(len, i), 0x20)), mload(add(inputPtr, i)))
+            }
+        }
+        return output;
+    }
+
+    function toBytes32(bytes memory b) internal pure returns (bytes32) {
+        bytes32 out;
+        assembly {
+            out := mload(add(b, 0x20))
+        }
+        return out;
+    }
+
+    function toBytes(bytes32 _data) internal pure returns (bytes memory) {
+        return abi.encodePacked(_data);
+    }
+
+    function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
+        bool success = true;
+
+        assembly {
+            let length := mload(_preBytes)
+
+        // if lengths don't match the arrays are not equal
+            switch eq(length, mload(_postBytes))
+            case 1 {
+            // cb is a circuit breaker in the for loop since there's
+            //  no said feature for inline assembly loops
+            // cb = 1 - don't breaker
+            // cb = 0 - break
+                let cb := 1
+
+                let mc := add(_preBytes, 0x20)
+                let end := add(mc, length)
+
+                for {
+                    let cc := add(_postBytes, 0x20)
+                // the next line is the loop condition:
+                // while(uint256(mc < end) + cb == 2)
+                } eq(add(lt(mc, end), cb), 2) {
+                    mc := add(mc, 0x20)
+                    cc := add(cc, 0x20)
+                } {
+                // if any of these checks fails then arrays are not equal
+                    if iszero(eq(mload(mc), mload(cc))) {
+                    // unsuccess:
+                        success := 0
+                        cb := 0
+                    }
+                }
+            }
+            default {
+            // unsuccess:
+                success := 0
+            }
+        }
+
+        return success;
+    }
+
+    /*
+    * @notice Converts a little endian (LE) byte array of size 32 to big endian (BE), i.e., flips byte order
+    * @param bytesLE To be flipped LE byte array
+    * @return bytes32 BE representation of parsed bytesLE
+    */
+    function flipBytes(bytes memory bytesLE) internal pure returns (bytes memory) {
+        bytes memory bytesBE = new bytes(bytesLE.length);
+        for (uint i = 0; i < bytesLE.length; i++){
+            bytesBE[bytesLE.length - i - 1] = bytesLE[i];
+        }
+        return bytesBE;
+    }
+
+    function flipBytes32(bytes32 bytesLE) internal pure returns (bytes32) {
+        bytes memory bytesBE = new bytes(bytesLE.length);
+        for (uint i = 0; i < bytesLE.length; i++){
+            bytesBE[bytesLE.length - i - 1] = bytesLE[i];
+        }
+        return toBytes32(bytesBE);
+    }
+}

package/contracts/auction/utils/RLPReader.sol

@@ -0,0 +1,355 @@
+// SPDX-License-Identifier: Apache-2.0
+
+/*
+ * @author Hamdi Allam hamdi.allam97@gmail.com
+ * Please reach out with any questions or concerns
+ */
+pragma solidity >=0.5.10 <0.9.0;
+
+library RLPReader {
+    uint8 constant STRING_SHORT_START = 0x80;
+    uint8 constant STRING_LONG_START = 0xb8;
+    uint8 constant LIST_SHORT_START = 0xc0;
+    uint8 constant LIST_LONG_START = 0xf8;
+    uint8 constant WORD_SIZE = 32;
+
+    struct RLPItem {
+        uint256 len;
+        uint256 memPtr;
+    }
+
+    struct Iterator {
+        RLPItem item; // Item that's being iterated over.
+        uint256 nextPtr; // Position of the next item in the list.
+    }
+
+    /*
+     * @dev Returns the next element in the iteration. Reverts if it has not next element.
+     * @param self The iterator.
+     * @return The next element in the iteration.
+     */
+    function next(Iterator memory self) internal pure returns (RLPItem memory) {
+        require(hasNext(self));
+
+        uint256 ptr = self.nextPtr;
+        uint256 itemLength = _itemLength(ptr);
+        self.nextPtr = ptr + itemLength;
+
+        return RLPItem(itemLength, ptr);
+    }
+
+    /*
+     * @dev Returns true if the iteration has more elements.
+     * @param self The iterator.
+     * @return true if the iteration has more elements.
+     */
+    function hasNext(Iterator memory self) internal pure returns (bool) {
+        RLPItem memory item = self.item;
+        return self.nextPtr < item.memPtr + item.len;
+    }
+
+    /*
+     * @param item RLP encoded bytes
+     */
+    function toRlpItem(bytes memory item) internal pure returns (RLPItem memory) {
+        uint256 memPtr;
+        assembly {
+            // item 偏移 32字节，因为bytes类型前32字节为长度信息，后32字节才是具体数据
+            memPtr := add(item, 0x20)
+        }
+
+        return RLPItem(item.length, memPtr);
+    }
+
+    /*
+     * @dev Create an iterator. Reverts if item is not a list.
+     * @param self The RLP item.
+     * @return An 'Iterator' over the item.
+     */
+    function iterator(RLPItem memory self) internal pure returns (Iterator memory) {
+        require(isList(self));
+
+        uint256 ptr = self.memPtr + _payloadOffset(self.memPtr);
+        return Iterator(self, ptr);
+    }
+
+    /*
+     * @param the RLP item.
+     */
+    function rlpLen(RLPItem memory item) internal pure returns (uint256) {
+        return item.len;
+    }
+
+    /*
+     * @param the RLP item.
+     * @return (memPtr, len) pair: location of the item's payload in memory.
+     */
+    function payloadLocation(RLPItem memory item) internal pure returns (uint256, uint256) {
+        uint256 offset = _payloadOffset(item.memPtr);
+        uint256 memPtr = item.memPtr + offset;
+        uint256 len = item.len - offset; // data length
+        return (memPtr, len);
+    }
+
+    /*
+     * @param the RLP item.
+     */
+    function payloadLen(RLPItem memory item) internal pure returns (uint256) {
+        (, uint256 len) = payloadLocation(item);
+        return len;
+    }
+
+    /*
+     * @param the RLP item containing the encoded list.
+     */
+    function toList(RLPItem memory item) internal pure returns (RLPItem[] memory) {
+        require(isList(item));
+
+        uint256 items = numItems(item);
+        RLPItem[] memory result = new RLPItem[](items);
+
+        uint256 memPtr = item.memPtr + _payloadOffset(item.memPtr);
+        uint256 dataLen;
+        for (uint256 i = 0; i < items; i++) {
+            dataLen = _itemLength(memPtr);
+            result[i] = RLPItem(dataLen, memPtr);
+            memPtr = memPtr + dataLen;
+        }
+
+        return result;
+    }
+
+    // @return indicator whether encoded payload is a list. negate this function call for isData.
+    function isList(RLPItem memory item) internal pure returns (bool) {
+        if (item.len == 0) return false;
+
+        uint8 byte0;
+        uint256 memPtr = item.memPtr;
+        assembly {
+            byte0 := byte(0, mload(memPtr))
+        }
+
+        if (byte0 < LIST_SHORT_START) return false;
+        return true;
+    }
+
+    /*
+     * @dev A cheaper version of keccak256(toRlpBytes(item)) that avoids copying memory.
+     * @return keccak256 hash of RLP encoded bytes.
+     */
+    function rlpBytesKeccak256(RLPItem memory item) internal pure returns (bytes32) {
+        uint256 ptr = item.memPtr;
+        uint256 len = item.len;
+        bytes32 result;
+        assembly {
+            result := keccak256(ptr, len)
+        }
+        return result;
+    }
+
+    /*
+     * @dev A cheaper version of keccak256(toBytes(item)) that avoids copying memory.
+     * @return keccak256 hash of the item payload.
+     */
+    function payloadKeccak256(RLPItem memory item) internal pure returns (bytes32) {
+        (uint256 memPtr, uint256 len) = payloadLocation(item);
+        bytes32 result;
+        assembly {
+            result := keccak256(memPtr, len)
+        }
+        return result;
+    }
+
+    /** RLPItem conversions into data types **/
+
+    // @returns raw rlp encoding in bytes
+    function toRlpBytes(RLPItem memory item) internal pure returns (bytes memory) {
+        bytes memory result = new bytes(item.len);
+        if (result.length == 0) return result;
+
+        uint256 ptr;
+        assembly {
+            ptr := add(0x20, result)
+        }
+
+        copy(item.memPtr, ptr, item.len);
+        return result;
+    }
+
+    // any non-zero byte except "0x80" is considered true
+    function toBoolean(RLPItem memory item) internal pure returns (bool) {
+        require(item.len == 1);
+        uint256 result;
+        uint256 memPtr = item.memPtr;
+        assembly {
+            result := byte(0, mload(memPtr))
+        }
+
+        // SEE Github Issue #5.
+        // Summary: Most commonly used RLP libraries (i.e Geth) will encode
+        // "0" as "0x80" instead of as "0". We handle this edge case explicitly
+        // here.
+        if (result == 0 || result == STRING_SHORT_START) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    function toAddress(RLPItem memory item) internal pure returns (address) {
+        // 1 byte for the length prefix
+        require(item.len == 21);
+
+        return address(uint160(toUint(item)));
+    }
+
+    function toUint(RLPItem memory item) internal pure returns (uint256) {
+        require(item.len > 0 && item.len <= 33);
+
+        (uint256 memPtr, uint256 len) = payloadLocation(item);
+
+        uint256 result;
+        assembly {
+            result := mload(memPtr)
+
+            // shift to the correct location if neccesary
+            if lt(len, 32) {
+                result := div(result, exp(256, sub(32, len)))
+            }
+        }
+
+        return result;
+    }
+
+    // enforces 32 byte length
+    function toUintStrict(RLPItem memory item) internal pure returns (uint256) {
+        // one byte prefix
+        require(item.len == 33);
+
+        uint256 result;
+        uint256 memPtr = item.memPtr + 1;
+        assembly {
+            result := mload(memPtr)
+        }
+
+        return result;
+    }
+
+    function toBytes(RLPItem memory item) internal pure returns (bytes memory) {
+        require(item.len > 0);
+
+        (uint256 memPtr, uint256 len) = payloadLocation(item);
+        bytes memory result = new bytes(len);
+
+        uint256 destPtr;
+        assembly {
+            destPtr := add(0x20, result)
+        }
+
+        copy(memPtr, destPtr, len);
+        return result;
+    }
+
+    /*
+     * Private Helpers
+     */
+
+    // @return number of payload items inside an encoded list.
+    function numItems(RLPItem memory item) private pure returns (uint256) {
+        if (item.len == 0) return 0;
+
+        uint256 count = 0;
+        uint256 currPtr = item.memPtr + _payloadOffset(item.memPtr);
+        uint256 endPtr = item.memPtr + item.len;
+        while (currPtr < endPtr) {
+            currPtr = currPtr + _itemLength(currPtr); // skip over an item
+            count++;
+        }
+
+        return count;
+    }
+
+    // @return entire rlp item byte length
+    function _itemLength(uint256 memPtr) private pure returns (uint256) {
+        uint256 itemLen;
+        uint256 byte0;
+        assembly {
+            byte0 := byte(0, mload(memPtr))
+        }
+
+        if (byte0 < STRING_SHORT_START) {
+            itemLen = 1;
+        } else if (byte0 < STRING_LONG_START) {
+            itemLen = byte0 - STRING_SHORT_START + 1;
+        } else if (byte0 < LIST_SHORT_START) {
+            assembly {
+                let byteLen := sub(byte0, 0xb7) // # of bytes the actual length is
+                memPtr := add(memPtr, 1) // skip over the first byte
+
+                /* 32 byte word size */
+                let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to get the len
+                itemLen := add(dataLen, add(byteLen, 1))
+            }
+        } else if (byte0 < LIST_LONG_START) {
+            itemLen = byte0 - LIST_SHORT_START + 1;
+        } else {
+            assembly {
+                let byteLen := sub(byte0, 0xf7)
+                memPtr := add(memPtr, 1)
+
+                let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to the correct length
+                itemLen := add(dataLen, add(byteLen, 1))
+            }
+        }
+
+        return itemLen;
+    }
+
+    // @return number of bytes until the data
+    function _payloadOffset(uint256 memPtr) private pure returns (uint256) {
+        uint256 byte0;
+        assembly {
+            byte0 := byte(0, mload(memPtr))
+        }
+
+        if (byte0 < STRING_SHORT_START) {
+            return 0;
+        } else if (byte0 < STRING_LONG_START || (byte0 >= LIST_SHORT_START && byte0 < LIST_LONG_START)) {
+            return 1;
+        } else if (byte0 < LIST_SHORT_START) {
+            // being explicit
+            return byte0 - (STRING_LONG_START - 1) + 1;
+        } else {
+            return byte0 - (LIST_LONG_START - 1) + 1;
+        }
+    }
+
+    /*
+     * @param src Pointer to source
+     * @param dest Pointer to destination
+     * @param len Amount of memory to copy from the source
+     */
+    function copy(uint256 src, uint256 dest, uint256 len) private pure {
+        if (len == 0) return;
+
+        // copy as many word sizes as possible
+        for (; len >= WORD_SIZE; len -= WORD_SIZE) {
+            assembly {
+                mstore(dest, mload(src))
+            }
+
+            src += WORD_SIZE;
+            dest += WORD_SIZE;
+        }
+
+        if (len > 0) {
+            // left over bytes. Mask is used to remove unwanted bytes from the word
+            uint256 mask = 256**(WORD_SIZE - len) - 1;
+            assembly {
+                let srcpart := and(mload(src), not(mask)) // zero out src
+                let destpart := and(mload(dest), mask) // retrieve the bytes
+                mstore(dest, or(destpart, srcpart))
+            }
+        }
+    }
+}

package/contracts/uniswap/Create2.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+import "hardhat/console.sol";
+
+// ref: https://docs.alchemy.com/docs/create2-an-alternative-to-deriving-contract-addresses
+contract Create2 {
+    event Deploy(address addr);
+
+
+    function deployCreate2(bytes memory initCode) public payable returns (address newContract) {
+        // Note that the safeguarding function `_guard` is called as part of the overloaded function
+        // `deployCreate2`.
+        newContract = deployCreate2WithSalt({salt: _generateSalt(), initCode: initCode});
+    }
+
+    function deployCreate2WithSalt(bytes memory initCode, bytes32 salt) public payable returns (address newContract) {
+        assembly ("memory-safe") {
+            /**
+             * @param 1: amount of wei to send
+             * @param 2: pointer to start of code (after the length field)
+             * @param 3: size of code (loaded from the length field)
+             * @param 4: salt from function arguments
+             */
+            newContract := create2(callvalue(), add(initCode, 0x20), mload(initCode), salt)
+        }
+        console.log("Create2 deployed to:", newContract);
+        emit Deploy(newContract);
+    }
+
+     function computeCreate2Address(
+        bytes32 salt,
+        bytes32 initCodeHash,
+        address deployer
+    ) public pure returns (address computedAddress) {
+        assembly ("memory-safe") {
+            // |                      | ↓ ptr ...  ↓ ptr + 0x0B (start) ...  ↓ ptr + 0x20 ...  ↓ ptr + 0x40 ...   |
+            // |----------------------|---------------------------------------------------------------------------|
+            // | initCodeHash         |                                                        CCCCCCCCCCCCC...CC |
+            // | salt                 |                                      BBBBBBBBBBBBB...BB                   |
+            // | deployer             | 000000...0000AAAAAAAAAAAAAAAAAAA...AA                                     |
+            // | 0xFF                 |            FF                                                             |
+            // |----------------------|---------------------------------------------------------------------------|
+            // | memory               | 000000...00FFAAAAAAAAAAAAAAAAAAA...AABBBBBBBBBBBBB...BBCCCCCCCCCCCCC...CC |
+            // | keccak256(start, 85) |            ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ |
+            let ptr := mload(0x40)
+            mstore(add(ptr, 0x40), initCodeHash)
+            mstore(add(ptr, 0x20), salt)
+            mstore(ptr, deployer)
+            let start := add(ptr, 0x0b)
+            mstore8(start, 0xff)
+            computedAddress := keccak256(start, 85)
+        }
+    }
+    
+    function _generateSalt() internal view returns (bytes32 salt) {
+        unchecked {
+            salt = keccak256(
+                abi.encode(
+                    // We don't use `block.number - 256` (the maximum value on the EVM) to accommodate
+                    // any chains that may try to reduce the amount of available historical block hashes.
+                    // We also don't subtract 1 to mitigate any risks arising from consecutive block
+                    // producers on a PoS chain. Therefore, we use `block.number - 32` as a reasonable
+                    // compromise, one we expect should work on most chains, which is 1 epoch on Ethereum
+                    // mainnet. Please note that if you use this function between the genesis block and block
+                    // number 31, the block property `blockhash` will return zero, but the returned salt value
+                    // `salt` will still have a non-zero value due to the hashing characteristic and the other
+                    // remaining properties.
+                    blockhash(block.number - 32),
+                    block.coinbase,
+                    block.number,
+                    block.timestamp,
+                    block.prevrandao,
+                    block.chainid,
+                    msg.sender
+                )
+            );
+        }
+    }
+}