punkkit-sdk 1.0.0

package/contracts/auction/ChainXWrappedETH.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+
+contract ChainXWrappedETH is ReentrancyGuard {
+    enum TokenType { TRANSFER, TRADE }
+    
+    // 记录每个地址两种类型的余额
+    mapping(address => uint256) public transferBalances;
+    mapping(address => uint256) public tradeBalances;
+    
+    // 只允许存入 transfer 类型
+    function deposit() external payable nonReentrant {
+        require(msg.value > 0, "Must deposit ETH");
+        
+        transferBalances[msg.sender] += msg.value;
+        emit Deposited(msg.sender, msg.value);
+    }
+    
+    // 转账指定类型的代币
+    function transfer(
+        address to,
+        uint256 amount,
+        TokenType fromType,
+        TokenType toType
+    ) external nonReentrant returns (bool) {
+        if (fromType == TokenType.TRANSFER) {
+            require(transferBalances[msg.sender] >= amount, "Insufficient transfer balance");
+            transferBalances[msg.sender] -= amount;
+            
+            // 如果目标类型是 TRADE，则转为 trade.ETH
+            if (toType == TokenType.TRADE) {
+                tradeBalances[to] += amount;
+                emit Transfer(msg.sender, to, amount, TokenType.TRANSFER, TokenType.TRADE);
+            } else {
+                transferBalances[to] += amount;
+                emit Transfer(msg.sender, to, amount, TokenType.TRANSFER, TokenType.TRANSFER);
+            }
+        } else {
+            require(tradeBalances[msg.sender] >= amount, "Insufficient trade balance");
+            tradeBalances[msg.sender] -= amount;
+            
+            // trade.ETH 只能转为 trans.ETH
+            transferBalances[to] += amount;
+            emit Transfer(msg.sender, to, amount, TokenType.TRADE, TokenType.TRANSFER);
+        }
+        
+        return true;
+    }
+    
+    // 只允许提取 transfer 类型的 ETH
+    function withdraw(uint256 amount) external nonReentrant {
+        require(transferBalances[msg.sender] >= amount, "Insufficient transfer balance");
+        
+        transferBalances[msg.sender] -= amount;
+        
+        (bool success, ) = msg.sender.call{value: amount}("");
+        require(success, "ETH transfer failed");
+        
+        emit Withdrawn(msg.sender, amount);
+    }
+    
+    // 查询地址的两种代币余额
+    function balanceOf(address account) external view returns (uint256 transferBalance, uint256 tradeBalance) {
+        return (transferBalances[account], tradeBalances[account]);
+    }
+    
+    event Deposited(address indexed user, uint256 amount);
+    event Transfer(
+        address indexed from,
+        address indexed to,
+        uint256 amount,
+        TokenType fromType,
+        TokenType toType
+    );
+    event Withdrawn(address indexed user, uint256 amount);
+    
+    receive() external payable {}
+} 

package/contracts/auction/ChainYLiquidityManager.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "./ChainYShadowETH.sol";
+import "./interfaces/IUniswapV2Router02.sol";
+
+contract ChainYLiquidityManager {
+    ChainYShadowETH public immutable shadowETH;
+    IUniswapV2Router02 public immutable router;
+    IUniswapV2Pair public immutable pair;
+    
+    constructor(address payable _shadowETH, address _router) {
+        shadowETH = ChainYShadowETH(_shadowETH);
+        router = IUniswapV2Router02(_router);
+        
+        // 初始化交易对
+        pair = IUniswapV2Pair(
+            IUniswapV2Factory(router.factory()).getPair(_shadowETH, router.WETH())
+        );
+    }
+    
+    function addLiquidity(
+        uint256 amount,
+        address to
+    ) external payable {
+        shadowETH.transferFrom(msg.sender, address(this), amount);
+        shadowETH.approve(address(router), amount);
+        
+        router.addLiquidityETH{value: msg.value}(
+            address(shadowETH),
+            amount,
+            amount * 99 / 100,
+            msg.value * 99 / 100,
+            to,
+            block.timestamp
+        );
+    }
+    
+    function removeLiquidity(
+        uint256 liquidity,
+        address to
+    ) external {
+        require(pair.transferFrom(msg.sender, address(this), liquidity), "LP transfer failed");
+        require(pair.approve(address(router), liquidity), "LP approve failed");
+        
+        router.removeLiquidityETH(
+            address(shadowETH),
+            liquidity,
+            0,
+            0,
+            to,
+            block.timestamp
+        );
+    }
+    
+    receive() external payable {}
+} 

package/contracts/auction/ChainYShadowETH.sol

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+import "./interfaces/IUniswapV2Router02.sol";
+import "./interfaces/IUniswapV2Pair.sol";
+import "./interfaces/IUniswapV2Factory.sol";
+import "./utils/RLPReader.sol";
+import "./ChainYLiquidityManager.sol";
+
+contract ChainYShadowETH is ERC20, ReentrancyGuard {
+    using RLPReader for bytes;
+    using RLPReader for RLPReader.RLPItem;
+
+    enum TokenType { TRANSFER, TRADE }
+    
+    // 状态变量
+    mapping(bytes32 => bool) public processedReceipts;
+    
+    // Uniswap相关
+    IUniswapV2Router02 public immutable router;
+    IUniswapV2Pair public immutable pair;
+    ChainYLiquidityManager public immutable liquidityManager;
+    
+    constructor(
+        address _router,
+        address payable _liquidityManager
+    ) ERC20("Shadow ETH", "sETH") {
+        router = IUniswapV2Router02(_router);
+        liquidityManager = ChainYLiquidityManager(_liquidityManager);
+        
+        pair = IUniswapV2Pair(
+            IUniswapV2Factory(router.factory()).getPair(address(this), router.WETH())
+        );
+    }
+    
+    // 主要的收据处理函数
+    function handleReceipt(bytes memory receipt) external nonReentrant {
+        require(verifyAndMarkReceipt(receipt), "Invalid proof");
+
+        // 解析以太坊收据
+        RLPReader.RLPItem[] memory items = receipt.toRlpItem().toList();
+        require(items.length >= 4, "Invalid receipt format");
+        
+        // 解析日志数组
+        bytes memory logs = items[3].toBytes();
+        RLPReader.RLPItem[] memory logItems = logs.toRlpItem().toList();
+        require(logItems.length > 0, "No logs found");
+        
+        // 遍历所有日志
+        for(uint i = 0; i < logItems.length; i++) {
+            RLPReader.RLPItem[] memory logParts = logItems[i].toList();
+            require(logParts.length >= 3, "Invalid log format");
+            
+            // 获取事件主题和数据
+            bytes32 eventTopic = bytes32(logParts[1].toUint());
+            bytes memory eventData = logParts[2].toBytes();
+            
+            if (eventTopic == keccak256("Deposited(address,uint256)")) {
+                (address user, uint256 amount) = abi.decode(
+                    eventData,
+                    (address, uint256)
+                );
+                handleDeposit(user, amount);
+                
+            } else if (eventTopic == keccak256("Transfer(address,address,uint256,uint8,uint8)")) {
+                (
+                    address from,
+                    address to,
+                    uint256 amount,
+                    TokenType fromType,
+                    TokenType toType
+                ) = abi.decode(
+                    eventData,
+                    (address, address, uint256, TokenType, TokenType)
+                );
+                handleTransfer(from, to, amount, fromType, toType);
+                
+            } else if (eventTopic == keccak256("Withdrawn(address,uint256)")) {
+                (address user, uint256 amount) = abi.decode(
+                    eventData,
+                    (address, uint256)
+                );
+                handleWithdraw(user, amount);
+            }
+        }
+    }
+    
+    // 处理存款事件
+    function handleDeposit(
+        address user,
+        uint256 amount
+    ) internal {
+        _mint(user, amount);
+        emit ShadowMinted(user, amount);
+    }
+    
+    // 处理转账事件
+    function handleTransfer(
+        address from,
+        address to,
+        uint256 amount,
+        TokenType fromType,
+        TokenType toType
+    ) internal {        
+        if (fromType == TokenType.TRANSFER && toType == TokenType.TRANSFER) {
+            _transfer(from, to, amount);
+        }
+        else if (fromType == TokenType.TRANSFER && toType == TokenType.TRADE) {
+            _approve(from, address(liquidityManager), amount);
+            liquidityManager.addLiquidity{value: amount}(amount, to);
+        }
+        else if (fromType == TokenType.TRADE && toType == TokenType.TRANSFER) {
+            uint256 liquidity = pair.balanceOf(from);
+            require(liquidity >= amount, "Insufficient LP tokens");
+            liquidityManager.removeLiquidity(liquidity, to);
+        }
+    }
+    
+    // 处理提现事件
+    function handleWithdraw(
+        address user,
+        uint256 amount
+    ) internal {
+        _burn(user, amount);
+        emit ShadowBurned(user, amount);
+    }
+    
+    // 验证并标记收据
+    function verifyAndMarkReceipt(bytes memory receipt) internal returns (bool) {
+        bytes32 receiptHash = keccak256(receipt);
+        
+        require(!processedReceipts[receiptHash], "Receipt already processed");
+        
+        // todo
+        
+        processedReceipts[receiptHash] = true;
+        return true;
+    }
+    
+    // 接收ETH
+    receive() external payable {}
+    
+    // 事件
+    event ShadowMinted(address indexed user, uint256 amount);
+    event ShadowBurned(address indexed user, uint256 amount);
+} 

package/contracts/auction/ChainYVault.sol

@@ -0,0 +1,195 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+import "./utils/RLPReader.sol";
+
+contract ChainYVault is ReentrancyGuard {
+    using RLPReader for bytes;
+    using RLPReader for RLPReader.RLPItem;
+
+    struct AuctionLock {
+        address owner;
+        bytes32 hashSecret;
+        uint256 unlockTime;
+        bool isLocked;
+        uint256 amount;
+        bool secretRevealed;
+        uint256 auctionEndTime;
+        address highestBidder;
+        uint256 highestBid;
+    }
+    
+    uint256 public baseAmount;
+    uint256 public auctionDuration;
+    mapping(bytes32 => AuctionLock) public lockedTokens;
+    address public admin;
+    
+    constructor() {
+        admin = msg.sender;
+        baseAmount = 100 * (10 ** 18); // 初始值 100 PUNK
+        auctionDuration = 1 hours;
+    }
+    
+    function setBaseAmount(uint256 newAmount) external {
+        require(msg.sender == admin, "Only admin can set base amount");
+        require(newAmount > 0, "Base amount must be greater than 0");
+        baseAmount = newAmount;
+        emit BaseAmountUpdated(newAmount);
+    }
+
+    function setAuctionDuration(uint256 newDuration) external {
+        require(msg.sender == admin, "Only admin can set auction duration");
+        require(newDuration > 0, "Auction duration must be greater than 0");
+        auctionDuration = newDuration;
+        emit AuctionDurationUpdated(newDuration);
+    }
+    
+    function lockTokens(
+        bytes32 hashSecret, 
+        uint256 revealTimestamp
+    ) external payable nonReentrant returns (bytes32 lockId) {
+        require(msg.value > 0, "Amount must be greater than 0");
+        require(msg.value % baseAmount == 0, "Amount must be multiple of baseAmount");
+        
+        // 生成锁定ID
+        lockId = keccak256(abi.encodePacked(
+            msg.sender,
+            hashSecret,
+            revealTimestamp
+        ));
+        
+        require(!lockedTokens[lockId].isLocked, "Lock ID already exists");
+        
+        // 记录锁定信息
+        lockedTokens[lockId] = AuctionLock({
+            owner: msg.sender,
+            hashSecret: hashSecret,
+            unlockTime: revealTimestamp,
+            auctionEndTime: revealTimestamp + auctionDuration,
+            isLocked: true,
+            amount: msg.value,
+            secretRevealed: false,
+            highestBidder: address(0),
+            highestBid: 0
+        });
+        
+        emit TokensLocked(lockId, msg.sender, msg.value, hashSecret);
+    }
+    
+    function updateHighestBid(bytes32 lockId, uint256 newBid) external {
+        AuctionLock storage lock = lockedTokens[lockId];
+        require(lock.isLocked, "Tokens not locked");
+        require(newBid > lock.highestBid, "New bid must be higher than current highest bid");
+        lock.highestBid = newBid;
+        lock.highestBidder = msg.sender;
+    }
+
+    function unlockTokens(bytes32 lockId, bytes memory receipt) external nonReentrant {
+        AuctionLock storage lock = lockedTokens[lockId];
+        require(lock.isLocked, "Tokens not locked");
+        
+        // 解析以太坊收据
+        RLPReader.RLPItem[] memory items = receipt.toRlpItem().toList();
+        require(items.length >= 4, "Invalid receipt format");
+        
+        // 收据结构: [status, cumulativeGasUsed, logsBloom, logs[]]
+        bytes memory logs = items[3].toBytes();
+        RLPReader.RLPItem[] memory logItems = logs.toRlpItem().toList();
+        require(logItems.length > 0, "No logs found");
+        
+        // 解析日志
+        RLPReader.RLPItem[] memory logParts = logItems[0].toList();
+        require(logParts.length >= 3, "Invalid log format");
+        
+        // 获取事件主题和数据
+        bytes32 eventTopic = bytes32(logParts[1].toUint());
+        bytes memory eventData = logParts[2].toBytes();
+        if (eventTopic == keccak256("AuctionFinalized(bytes32,address,uint256)")) {
+            (bytes32 auctionId, address winner,) = abi.decode(
+                eventData,
+                (bytes32, address, uint256)
+            );
+            require(auctionId == lockId, "Invalid auction ID");
+            
+            lock.isLocked = false;
+            
+            if (winner != address(0)) {
+                // 有效出价，转给竞拍者
+                (bool success, ) = winner.call{value: lock.amount}("");
+                require(success, "Transfer failed");
+                emit TokensUnlocked(lockId, winner, lock.amount);
+            } else {
+                // 竞拍者地址为0，退回给原主人
+                (bool success, ) = lock.owner.call{value: lock.amount}("");
+                require(success, "Transfer failed");
+                emit TokensUnlocked(lockId, lock.owner, lock.amount);
+            }
+            
+        } else if (eventTopic == keccak256("AuctionCancelled(bytes32)")) {
+            (bytes32 auctionId) = abi.decode(eventData, (bytes32));
+            require(auctionId == lockId, "Invalid auction ID");
+            
+            // 永久锁定
+            emit TokensPermanentlyLocked(lockId, lock.amount);
+        } else {
+            revert("Invalid event");
+        }
+    }
+
+    /*
+    function unlockTokens(bytes32 lockId, bytes32 secret) external nonReentrant {
+        AuctionLock storage lock = lockedTokens[lockId];
+        require(lock.isLocked, "Tokens not locked");
+        
+        if (!lock.secretRevealed) {
+            // 第一阶段：必须在 T_1 前公开 secret
+            require(block.timestamp <= lock.unlockTime, "Secret not revealed before T_1, tokens locked forever");
+            require(lock.owner == msg.sender, "Not the owner");
+            require(keccak256(abi.encodePacked(secret)) == lock.hashSecret, "Invalid secret");
+            
+            lock.secretRevealed = true;
+            lock.auctionEndTime = block.timestamp + auctionDuration;
+            emit SecretRevealed(lockId, uint256(secret));
+            return;
+        }
+        
+        // 第二阶段：等待链 X 同步最高出价或超时解锁
+        require(block.timestamp > lock.auctionEndTime, "Auction period not ended");
+        
+        if (lock.highestBid > uint256(secret) && lock.highestBidder != address(0)) {
+            // 有效出价，转给竞拍者
+            lock.isLocked = false;
+            (bool success, ) = lock.highestBidder.call{value: lock.amount}("");
+            require(success, "Transfer failed");
+            emit TokensUnlocked(lockId, lock.highestBidder, lock.amount);
+        } else {
+            // 无有效出价，退还给原主人
+            lock.isLocked = false;
+            (bool success, ) = lock.owner.call{value: lock.amount}("");
+            require(success, "Transfer failed");
+            emit TokensUnlocked(lockId, lock.owner, lock.amount);
+        }
+    }*/
+
+    // 接收原生代币的回退函数
+    receive() external payable {}
+    
+    event TokensLocked(
+        bytes32 indexed lockId,
+        address indexed owner,
+        uint256 amount,
+        bytes32 hashSecret
+    );
+    
+    event TokensUnlocked(
+        bytes32 indexed lockId,
+        address indexed owner,
+        uint256 amount
+    );
+    
+    event BaseAmountUpdated(uint256 newAmount);
+    event SecretRevealed(bytes32 indexed lockId, uint256 secret);
+    event AuctionDurationUpdated(uint256 newDuration);
+    event TokensPermanentlyLocked(bytes32 indexed lockId, uint256 amount);
+}