punkkit-sdk 1.0.0

package/contracts/auction/ChainYVaultCoinbase.sol

@@ -0,0 +1,276 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "./utils/RLPReader.sol";
+import "./interfaces/IUnlockStrategy.sol";
+import "./coinbase-and-stake/invokeCoinbase.sol";
+
+contract ChainYVaultV2CB is CoinbaseOperator, ReentrancyGuard, Ownable {
+    using RLPReader for bytes;
+    using RLPReader for RLPReader.RLPItem;
+
+    struct AuctionConfig {
+        uint32 auctionType;            // 4字节竞标类型: 0000 || 00 || 00 竞价方式||单次||公开竞标
+        uint256 baseAmount;            // 基础金额
+        bool isSystemExpiration;       // 是否系统时间
+        bool isActive;                 // 是否激活
+    }
+
+    struct Auction {
+        uint32 auctionType;           // 应该和config保持一致
+        uint256 baseAmount;           // 基础金额
+        uint256 revealTime;           // 揭示时间
+    }
+
+    struct AuctionLock {
+        address owner;
+        bytes32 hashSecret;
+        uint256 amount;
+        uint32 auctionType;           // 4字节竞标类型
+        bool isLocked;
+        bool secretRevealed;
+        uint256 revealTime;           // 揭示时间
+        uint256 auctionId;            // 竞标ID
+    }
+
+    uint256 public activeAuctionsCount;
+    uint256 public activeConfigsCount;
+    uint256 public onlyOneAuction;
+
+    mapping(bytes32 => AuctionLock) public lockedTokens;
+    mapping(uint256 => AuctionConfig) public auctionConfigs;
+    mapping(uint32 => address) public unlockStrategies;
+    mapping(uint256 => Auction) public auctions;
+
+    event AuctionConfigCreated(
+        uint256 indexed configId,
+        uint32 auctionType,
+        uint256 baseAmount,
+        uint256 extension
+    );
+    
+    event AuctionCreated(
+        uint256 indexed auctionId,
+        uint32 auctionType,
+        uint256 nounce,
+        uint256 revealTime
+    );
+    
+    event TokensLocked(
+        bytes32 indexed lockId,
+        address indexed owner,
+        uint256 amount,
+        uint32 auctionType,
+        uint256 auctionId
+    );
+
+    event TokensUnlocked(
+        bytes32 indexed lockId,
+        address indexed recipient,
+        uint256 amount
+    );
+
+    event UnlockStrategyUpdated(uint32 indexed auctionType, address strategy);
+
+    constructor() ReentrancyGuard() Ownable(msg.sender) {}
+
+    function isSingleAuction(uint32 auctionType) internal pure returns (bool) {
+        return (auctionType & 0x0000FF00) == 0;
+    }
+
+    function setUnlockStrategy(uint32 auctionType, address strategy) external onlyOwner {
+        require(strategy != address(0), "Invalid strategy address");
+        unlockStrategies[auctionType] = strategy;
+        emit UnlockStrategyUpdated(auctionType, strategy);
+    }
+
+    function createAuctionConfig(
+        uint32 auctionType,
+        uint256 baseAmount,
+        uint256 extension
+    ) external onlyOwner {
+        uint256 configId = activeConfigsCount;
+        auctionConfigs[configId] = AuctionConfig({
+            auctionType: auctionType,
+            baseAmount: baseAmount,
+            isSystemExpiration: false,
+            isActive: true
+        });
+        activeConfigsCount++;
+        emit AuctionConfigCreated(configId, auctionType, baseAmount, extension);
+    }
+
+    function getTodayEndTimestamp() public view returns (uint256) {
+        // 获取当前时间戳
+        uint256 timestamp = block.timestamp;
+        
+        // 计算当天结束时间 (UTC 23:59:59)
+        // 1 天 = 86400 秒
+        // 将时间戳除以86400得到天数，加1后乘以86400得到下一天的开始
+        // 然后减去1秒得到当天的结束时间
+        return ((timestamp / 86400) * 86400) + 86400 - 1;
+    }
+
+    function createAuction(
+        uint256 configId,
+        bytes32 hashSecret,
+        uint256 expiration
+    ) external payable nonReentrant returns (bytes32 lockId) { 
+        AuctionConfig memory config = auctionConfigs[configId];
+        require(config.isActive, "Auction not active");   
+
+        Auction memory auction = auctions[onlyOneAuction];
+        if (!isSingleAuction(auction.auctionType)) {
+            require(auction.revealTime < block.timestamp, "Only one auction is allowed");
+        }
+        
+        // 生成唯一的 auctionId
+        uint256 auctionId = uint256(keccak256(abi.encodePacked(
+            msg.sender,
+            block.chainid,
+            address(this),
+            activeAuctionsCount
+        )));
+
+        uint32 auctionType = config.auctionType;
+        uint256 revealTime = isSingleAuction(auctionType) && !config.isSystemExpiration ? 
+                            expiration : getTodayEndTimestamp();
+
+        onlyOneAuction = isSingleAuction(config.auctionType) ? onlyOneAuction : auctionId;
+
+        auctions[auctionId] = Auction({
+            auctionType: auctionType,
+            baseAmount: config.baseAmount,
+            revealTime: revealTime
+        });
+
+        lockId = lockTokens(hashSecret, auctionId);
+        activeAuctionsCount++;
+
+        emit AuctionCreated(auctionId, auctionType, activeAuctionsCount-1, revealTime);
+    }
+
+    function lockTokens(
+        bytes32 hashSecret,
+        uint256 auctionId
+    ) public payable nonReentrant returns (bytes32 lockId) {
+        Auction storage auction = auctions[auctionId];
+        uint32 auctionType = auction.auctionType;
+        require(auctionType != 0, "Auction not exist");
+        require(msg.value > 0, "Amount must be greater than 0");
+        require(msg.value % auction.baseAmount == 0, "Amount must be multiple of baseAmount");
+
+        lockId = keccak256(abi.encodePacked(
+            block.chainid,
+            address(this),
+            auctionId,
+            msg.sender,
+            hashSecret,
+            auctionType
+        ));
+
+        require(!lockedTokens[lockId].isLocked, "Lock ID exists");
+
+        lockedTokens[lockId] = AuctionLock({
+            owner: msg.sender,
+            hashSecret: hashSecret,
+            amount: msg.value,
+            auctionType: auctionType,
+            isLocked: true,
+            secretRevealed: false,
+            revealTime: auction.revealTime,
+            auctionId: auctionId
+        });
+
+        emit TokensLocked(lockId, msg.sender, msg.value, auctionType, auctionId);
+    }
+
+    function unlockTokens(bytes32 lockId, bytes memory receipt) external nonReentrant {
+        AuctionLock storage lock = lockedTokens[lockId];
+        require(lock.isLocked, "Tokens not locked");
+        
+        address strategy = unlockStrategies[lock.auctionType];
+        require(strategy != address(0), "No unlock strategy");
+
+        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");
+        
+        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();
+
+        (address recipient, uint256 unlockAmount) = IUnlockStrategy(strategy).processUnlock(
+            eventTopic,
+            eventData,
+            lock.amount
+        );
+
+        require(unlockAmount <= lock.amount, "Invalid unlock amount"); 
+        lock.isLocked = false;
+        
+        uint256 rewardAmount = 0;
+        if (recipient == address(0)) {
+            // 竞拍者地址为0，退回给原主人
+            recipient = lock.owner;
+            rewardAmount = lock.amount;
+        } else if (recipient != address(this)) {
+            rewardAmount = unlockAmount;
+        }
+
+        /*
+        distributeRewardDirectly(
+            "ChainYVaultV2",
+            0,
+            new address[](1, lock.owner),
+            new uint256[](1, rewardAmount)
+        );*/
+
+        emit TokensUnlocked(lockId, recipient, unlockAmount);
+    }
+
+    function getAuctionInfo(uint256 auctionId) 
+        external 
+        view 
+        returns (
+            uint32 auctionType,
+            uint256 baseAmount,
+            uint256 revealTime
+        ) 
+    {
+        Auction storage auction = auctions[auctionId];
+        return (
+            auction.auctionType,
+            auction.baseAmount,
+            auction.revealTime
+        );
+    }
+
+    function getAuctionLockInfo(bytes32 lockId)
+        external
+        view
+        returns (
+            address owner,
+            uint256 amount,
+            bool isLocked,
+            uint256 revealTime
+        )
+    {
+        AuctionLock storage lock = lockedTokens[lockId];
+        return (
+            lock.owner,
+            lock.amount,
+            lock.isLocked,
+            lock.revealTime
+        );
+    }
+
+    receive() external payable {}
+} 

package/contracts/auction/ChainYVaultV2.sol

@@ -0,0 +1,318 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "./utils/RLPReader.sol";
+import "./interfaces/IUnlockStrategy.sol";
+import "./libraries/TransactionParser.sol";
+import "./coinbase-and-stake/invokeCoinbase.sol";
+
+// CoinBaseOperator继承属性，支持Coinbase激励发放
+contract ChainYVaultV2 is ReentrancyGuard, Ownable,CoinbaseOperator {
+    using RLPReader for bytes;
+    using RLPReader for RLPReader.RLPItem;
+
+    struct AuctionConfig {
+        uint32 auctionType;            // 4字节竞标类型: 00 || 00 || 单次/多次 || 公开竞标
+        uint256 baseAmount;            // 拍卖的最小单位金额
+        bool isSystemExpiration;       // 是否系统时间
+        bool isActive;                 // 是否激活
+    }
+
+    struct Auction {
+        uint32 auctionType;           // 应该和config保持一致
+        uint256 baseAmount;           
+        uint256 revealTime;           // 揭示时间
+    }
+
+    struct AuctionLock {
+        address owner;
+        bytes32 hashSecret;
+        uint256 amount;
+        uint32 auctionType;           // 4字节竞标类型
+        bool isLocked;
+        bool secretRevealed;
+        uint256 revealTime;           // 揭示时间
+        uint256 auctionId;            // 竞标ID
+    }
+
+    uint256 public activeAuctionsCount;
+    uint256 public activeConfigsCount;
+    uint256 public onlyOneAuction;
+    CoinbaseOperator public coinbase; 
+
+    mapping(bytes32 => AuctionLock) public lockedTokens;
+    mapping(uint256 => AuctionConfig) public auctionConfigs;
+    mapping(uint32 => address) public unlockStrategies;
+    mapping(uint256 => Auction) public auctions;
+
+    event AuctionConfigCreated(
+        uint256 indexed configId,
+        uint32 auctionType,
+        uint256 baseAmount,
+        uint256 extension
+    );
+    
+    event AuctionCreated(
+        uint256 indexed auctionId,
+        uint32 auctionType,
+        uint256 activeAuctionCount,
+        uint256 revealTime
+    );
+    
+    event TokensLocked(
+        bytes32 indexed lockId,
+        address indexed owner,
+        uint256 amount,
+        uint32 auctionType,
+        uint256 auctionId
+    );
+
+    event TokensUnlocked(
+        bytes32 indexed lockId,
+        address indexed recipient,
+        uint256 amount
+    );
+
+
+    constructor(address coinBaseAddress) ReentrancyGuard() Ownable(msg.sender) {
+        coinbase = CoinbaseOperator(coinBaseAddress);
+    }
+
+    function isSingleAuction(uint32 auctionType) internal pure returns (bool) {
+        return (auctionType & 0x0000FF00) == 0;
+    }
+
+    // 创建Config，创建config，createAuction创建必须指定ID
+    function createAuctionConfig(
+        uint32 auctionType,
+        uint256 baseAmount,
+        uint256 extension
+    ) external onlyOwner {
+        uint256 configId = activeConfigsCount;
+        auctionConfigs[configId] = AuctionConfig({
+            auctionType: auctionType,
+            baseAmount: baseAmount,
+            isSystemExpiration: false,
+            isActive: true
+        });
+        activeConfigsCount++;
+        emit AuctionConfigCreated(configId, auctionType, baseAmount, extension);
+    }
+
+    function getTodayEndTimestamp() public view returns (uint256) {
+        // 获取当前时间戳
+        uint256 timestamp = block.timestamp;
+        
+        // 计算当天结束时间 (UTC 23:59:59)
+        // 1 天 = 86400 秒
+        // 将时间戳除以86400得到天数，加1后乘以86400得到下一天的开始
+        // 然后减去1秒得到当天的结束时间
+        return ((timestamp / 86400) * 86400) + 86400 - 1;
+    }
+
+    function createAuction(
+        uint256 configId,
+        bytes32 hashSecret,  // 哈希时间锁.
+        uint256 expiration
+    ) external payable returns (bytes32 lockId) { // nonReentrant
+        AuctionConfig memory config = auctionConfigs[configId];
+        require(config.isActive, "Auction not active");   
+
+        Auction memory auction = auctions[onlyOneAuction];
+        if (auction.baseAmount != 0 && !isSingleAuction(auction.auctionType)) {
+            require(auction.revealTime < block.timestamp, "Only one auction is allowed");
+        }
+        
+        // 生成唯一的 auctionId
+        uint256 auctionId = uint256(keccak256(abi.encodePacked(
+            msg.sender,
+            block.chainid,
+            address(this),
+            activeAuctionsCount
+        )));
+        uint256 currentCount=activeAuctionsCount;
+        activeAuctionsCount++;
+
+
+        uint32 auctionType = config.auctionType;
+        uint256 revealTime = isSingleAuction(auctionType) && !config.isSystemExpiration ?  expiration : getTodayEndTimestamp();
+
+        onlyOneAuction = isSingleAuction(config.auctionType) ? onlyOneAuction : auctionId;
+
+        auctions[auctionId] = Auction({
+            auctionType: auctionType,
+            baseAmount: config.baseAmount,
+            revealTime: revealTime
+        });
+
+        lockId = lockTokens(hashSecret, auctionId);
+        emit AuctionCreated(auctionId, auctionType, currentCount, revealTime);
+        
+    }
+
+    function lockTokens(
+        bytes32 hashSecret,
+        uint256 auctionId
+    ) public payable nonReentrant returns (bytes32 lockId) {
+        Auction storage auction = auctions[auctionId];
+        uint32 auctionType = auction.auctionType;
+        require(auctionType != 0, "Auction not exist");
+        require(msg.value > 0, "Amount must be greater than 0");
+        require(msg.value % auction.baseAmount == 0, "Amount must be multiple of baseAmount");
+
+        lockId = keccak256(abi.encodePacked(
+            block.chainid,
+            address(this),
+            auctionId,
+            msg.sender,
+            hashSecret,
+            auctionType
+        ));
+
+        require(!lockedTokens[lockId].isLocked, "Lock ID exists");
+
+        lockedTokens[lockId] = AuctionLock({
+            owner: msg.sender,
+            hashSecret: hashSecret,
+            amount: msg.value,
+            auctionType: auctionType,
+            isLocked: true,
+            secretRevealed: false,
+            revealTime: auction.revealTime,
+            auctionId: auctionId
+        });
+
+        emit TokensLocked(lockId, msg.sender, msg.value, auctionType, auctionId);
+    }
+
+    // 接受 auction链的receipt事件才可以解锁。
+    // 例如： MatchResultWithdrawn(uint256,bytes32,address,uint256)
+    function unlockTokens(bytes32 lockId, bytes memory receipt) external nonReentrant {
+        AuctionLock storage lock = lockedTokens[lockId];
+        require(lock.isLocked, "Tokens not locked");
+        
+        TransactionParser.RecptLog memory log = TransactionParser.parseRecptLog(receipt);
+        // 从log中解析出：中标成功者，和解锁金额
+        (address recipient, uint256 unlockAmount) = processUnlock(
+            log.eventTopic,
+            log.eventData,
+            lock.amount
+        );
+
+        require(unlockAmount <= lock.amount, "Invalid unlock amount"); 
+        lock.isLocked = false;
+        
+        // CoinBase逻辑,通过CoinBase发送奖励
+        uint256 rewardAmount = 0;
+        if (recipient == address(0)) {
+            // 竞拍者地址为0，退回给原主人
+            recipient = lock.owner;
+            rewardAmount = lock.amount;
+        } else if (recipient != address(this)) {
+            rewardAmount = unlockAmount;
+        }
+
+        if (address(coinbase) == address(0)){
+            // 方法1 :直接发起转账
+            if (recipient == address(0)) {
+                // 竞拍者地址为0，退回给原主人
+                (bool success, ) = lock.owner.call{value: lock.amount}("");
+                require(success, "Transfer failed");
+            } else if (recipient != address(this)) {
+                // 直接转账
+                (bool success, ) = recipient.call{value: unlockAmount}("");
+                require(success, "Transfer failed");
+            }
+        }else{
+            // 方法2: CoinBase合约发放
+            address[] memory recipients = new address[](1);
+            recipients[0] = recipient;      // 或 lock.owner，看你的业务
+            uint256[] memory amounts = new uint256[](1);
+            amounts[0] = rewardAmount;
+
+            // 调用CoinBase分发奖励接口
+            coinbase.distributeRewardDirectly(
+                "ChainYVaultV2",
+                0,               // rewardTypeId，确保 0 对应你定义的类型
+                recipients,
+                amounts
+            );
+        }
+        emit TokensUnlocked(lockId, recipient, unlockAmount);
+    }
+
+    function processUnlock(
+        bytes32 eventTopic,
+        bytes memory eventData,
+        uint256 lockedAmount
+    ) internal 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       // 解锁金额为转账金额
+        );
+    }
+
+
+    function getAuctionInfo(uint256 auctionId) 
+        external 
+        view 
+        returns (
+            uint32 auctionType,
+            uint256 baseAmount,
+            uint256 revealTime
+        ) 
+    {
+        Auction storage auction = auctions[auctionId];
+        return (
+            auction.auctionType,
+            auction.baseAmount,
+            auction.revealTime
+        );
+    }
+
+    function getAuctionLockInfo(bytes32 lockId)
+        external
+        view
+        returns (
+            address owner,
+            uint256 amount,
+            bool isLocked,
+            uint256 revealTime
+        )
+    {
+        AuctionLock storage lock = lockedTokens[lockId];
+        return (
+            lock.owner,
+            lock.amount,
+            lock.isLocked,
+            lock.revealTime
+        );
+    }
+
+    function getActiveAuctionsCount() external view returns (uint256){
+        return activeAuctionsCount;
+    }
+
+    function getActiveConfigsCount() external view returns (uint256){
+        return activeConfigsCount;
+    }
+
+    receive() external payable {}
+} 

package/contracts/auction/coinbase-and-stake/README.md

@@ -0,0 +1,55 @@
+##### 两个合约的地址
+
+```
+coinbase 合约地址："F02F87F086a53cb793E7e920bea648bb52A7d75D"
+
+stake 合约地址："63BC05BC6FCAb99AF9A4c215B2e92a9C6f45D41F"
+```
+
+##### 合约接口说明
+
+```solidity
+interface ICoinbase {
+    // 设置Coinbase合约的白名单（目前是没有限制该方法的调用者，任何人都可以设置）
+    function addToWhitelist(address _address) external;
+
+    // 带抽签的激励记录
+    function addCoinbase(
+        string calldata source,            // 激励来源区
+        address[] calldata rewardAddresses,// 激励地址 
+        string calldata rewardType,        // 激励类型，质押、投票等
+        uint256 totalAmount,              // 激励总额
+        uint256 numWinners                // 最终可获得激励的人数
+    ) external;
+    
+    // 不带抽签的激励记录
+    function addCoinbaseDirectly(
+        string calldata source,            // 来源区
+        address[] calldata rewardAddresses,// 激励地址
+        uint256[] calldata rewardAmounts,  // 每个地址对应的金额
+        string calldata rewardType         // 激励类型
+    ) external;
+}
+```
+
+```solidity
+// Stake合约仅作记录，Deposit 和 Withdraw 具体方法自定义
+interface IStake {
+    // 单地址的提现：用于大额提现，不会经过抽签
+    function withdraw(
+        string calldata source,    // 来源区
+        address account,           // 提现地址
+        uint256 amount            // 提现金额
+    ) external;
+    
+    // 多地址的提现：用于小额提现，会经过抽签
+    function withdrawMultiple(
+        string calldata source,            // 来源区
+        address[] calldata accounts,       // 提现地址
+        uint256[] calldata amounts        // 每个提现地址对应的金额
+    ) external;
+    
+    // 设置Stake合约的白名单（目前是没有限制该方法的调用者，任何人都可以设置）
+    function addToWhitelist(address _address) external;
+}
+```