punkkit-sdk 1.0.0

package/contracts/auction/coinbase-and-stake/coinbase.sol

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Coinbase {
+    // 白名单mapping
+    mapping(address => bool) public whitelist;
+    
+    // 硬编码的mapping地址
+    address public constant STAKING_ADDRESS = 0x63BC05BC6FCAb99AF9A4c215B2e92a9C6f45D41F;
+    
+    // 构造函数中初始化硬编码地址到白名单
+    constructor() {
+        whitelist[STAKING_ADDRESS] = true;
+    }
+    
+    // 事件定义
+    event CoinbaseAdded(
+        string indexed source,  // 来源区 string类型 
+        string indexed rewardType,      // 奖励类型(如：挖矿、质押、投票等)
+        uint256 indexed timestamp,
+        address[] selectedAddresses, // 奖励地址
+        uint256[] rewards       // 奖励金额
+    );
+    
+    // 检查白名单的modifier
+    modifier onlyWhitelisted() {
+        require(whitelist[msg.sender], "Caller is not whitelisted");
+        _;
+    }
+    
+    // 添加白名单地址
+    function addToWhitelist(address _address) public {
+        require(_address != address(0), "Invalid address");
+        whitelist[_address] = true;
+    }
+    
+    // 选择随机地址的内部函数 ： "Fisher-Yates洗牌算法"的变体
+    function _selectRandomAddresses(address[] memory addresses, uint256 numToSelect) 
+        internal view returns (address[] memory) {
+        require(numToSelect <= addresses.length, "Cannot select more addresses than provided");
+        
+        address[] memory selectedAddresses = new address[](numToSelect);
+        address[] memory tempAddresses = new address[](addresses.length);
+        
+        // 复制地址数组
+        for(uint i = 0; i < addresses.length; i++) {
+            tempAddresses[i] = addresses[i];
+        }
+        
+        // 随机选择地址
+        for(uint i = 0; i < numToSelect; i++) {
+            // 1. 生成随机索引：范围是从0到未处理的地址数量
+            // block.prevrandao 经过修改后可获取共识传来的随机数
+            uint256 randomIndex = block.prevrandao % (tempAddresses.length - i);
+            
+            // 2. 将随机选中的地址保存到结果数组
+            selectedAddresses[i] = tempAddresses[randomIndex];
+            
+            // 3. 将已选中的地址与数组末尾未选择的地址交换
+            tempAddresses[randomIndex] = tempAddresses[tempAddresses.length - 1 - i];
+        }
+        
+        return selectedAddresses;
+    }
+    
+    // 添加coinbase奖励（带抽签）
+    function addCoinbase(
+        string calldata source,  // 新增 source 参数，类型为 string
+        address[] calldata rewardAddresses,
+        string calldata rewardType,
+        uint256 totalAmount,
+        uint256 numWinners  // 抽签人数
+    ) external onlyWhitelisted {
+        require(rewardAddresses.length > 0, "No addresses provided");
+        require(numWinners > 0 && numWinners <= rewardAddresses.length, "Invalid number of winners");
+        
+        // 随机选择获奖地址
+        address[] memory selectedAddresses = _selectRandomAddresses(rewardAddresses, numWinners);
+        
+        // 计算奖励比例
+        uint256[] memory rewards = new uint256[](numWinners);
+        uint256 remainingAmount = totalAmount;
+        
+        // 按抽签顺序分配不同比例的奖励
+        // 第一名获得剩余金额的50%
+        // 第二名获得剩余金额的30%
+        // 其余平分剩下的金额
+        if(numWinners >= 1) {
+            rewards[0] = remainingAmount * 50 / 100; // 第一名50%
+            remainingAmount -= rewards[0];
+        }
+        
+        if(numWinners >= 2) {
+            rewards[1] = remainingAmount * 30 / 100; // 第二名30%
+            remainingAmount -= rewards[1];
+        }
+        
+        if(numWinners > 2) {
+            uint256 rewardPerRemaining = remainingAmount / (numWinners - 2);
+            for(uint i = 2; i < numWinners; i++) {
+                rewards[i] = rewardPerRemaining;
+                remainingAmount -= rewardPerRemaining;
+            }
+        }
+        
+        // 如果有余数，将余数加到第一名的奖励中
+        if(remainingAmount > 0) {
+            rewards[0] += remainingAmount;
+        }
+        
+        // 触发事件
+        emit CoinbaseAdded(
+            source,  // 使用传入的 source
+            rewardType,
+            block.timestamp,
+            selectedAddresses,
+            rewards
+        );
+    }
+    
+    // 添加coinbase奖励（不需要抽签）
+    function addCoinbaseDirectly(
+        string calldata source,  // 新增 source 参数，类型为 string
+        address[] calldata rewardAddresses,
+        uint256[] calldata rewardAmounts,
+        string calldata rewardType
+    ) external onlyWhitelisted {
+        require(rewardAddresses.length > 0, "No addresses provided");
+        require(rewardAddresses.length == rewardAmounts.length, "Arrays length mismatch");
+        
+        emit CoinbaseAdded(
+            source,  // 使用传入的 source
+            rewardType,
+            block.timestamp,
+            rewardAddresses,
+            rewardAmounts
+        );
+    }
+}
+
+
+

package/contracts/auction/coinbase-and-stake/invokeCoinbase.sol

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface ICoinbase {
+    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;
+}
+
+contract CoinbaseOperator {
+    // Coinbase合约地址
+    address public immutable COINBASE_ADDRESS = 0xF02F87F086a53cb793E7e920bea648bb52A7d75D;
+    
+    // 操作者mapping
+    mapping(address => bool) public operators;
+    
+    // 奖励类型枚举
+    enum RewardType {
+        STAKE,
+        MINE,
+        VOTE,
+        CUSTOM
+    }
+    
+    // 自定义奖励类型结构体
+    struct CustomRewardType {
+        string name;
+        string description;
+        bool isValid;
+    }
+    
+    // 存储自定义奖励类型
+    mapping(uint256 => CustomRewardType) public customRewardTypes;
+    uint256 public nextCustomRewardTypeId = uint256(RewardType.CUSTOM);
+    
+    // 事件
+    event OperatorAdded(address indexed operator);
+    event OperatorRemoved(address indexed operator);
+    event CustomRewardTypeAdded(uint256 indexed typeId, string name);
+    event RewardDistributed(
+        string source,
+        string rewardType,
+        uint256 totalAmount,
+        uint256 recipientCount
+    );
+    
+    // 构造函数
+    constructor() {
+        operators[msg.sender] = true;
+    }
+    
+    // 修饰符
+    modifier onlyOperator() {
+        require(operators[msg.sender], "Caller is not an operator");
+        _;
+    }
+    
+    // 管理操作者
+    function addOperator(address operator) external onlyOperator {
+        require(operator != address(0), "Invalid operator address");
+        operators[operator] = true;
+        emit OperatorAdded(operator);
+    }
+    
+    function removeOperator(address operator) external onlyOperator {
+        operators[operator] = false;
+        emit OperatorRemoved(operator);
+    }
+    
+    // 增加白名单
+    function addToWhitelist(address _address) external onlyOperator {
+        ICoinbase(COINBASE_ADDRESS).addToWhitelist(_address);
+    }
+
+    // 添加自定义奖励类型
+    function addCustomRewardType(
+        string calldata name,
+        string calldata description
+    ) external onlyOperator returns (uint256) {
+        uint256 newTypeId = nextCustomRewardTypeId++;
+        
+        customRewardTypes[newTypeId] = CustomRewardType({
+            name: name,
+            description: description,
+            isValid: true
+        });
+        
+        emit CustomRewardTypeAdded(newTypeId, name);
+        return newTypeId;
+    }
+    
+    // 获取奖励类型字符串
+    function getRewardTypeString(uint256 rewardTypeId) public view returns (string memory) {
+        if (rewardTypeId == uint256(RewardType.STAKE)) return "stake";
+        if (rewardTypeId == uint256(RewardType.MINE)) return "mine";
+        if (rewardTypeId == uint256(RewardType.VOTE)) return "vote";
+        
+        require(customRewardTypes[rewardTypeId].isValid, "Invalid reward type");
+        return customRewardTypes[rewardTypeId].name;
+    }
+    
+    // 随机抽奖分发奖励
+    function distributeRewardWithLottery(
+        string calldata source,
+        uint256 rewardTypeId,
+        address[] calldata candidates,
+        uint256 totalAmount,
+        uint256 numWinners
+    ) external onlyOperator {
+        string memory rewardType = getRewardTypeString(rewardTypeId);
+        
+        ICoinbase(COINBASE_ADDRESS).addCoinbase(
+            source,
+            candidates,
+            rewardType,
+            totalAmount,
+            numWinners
+        );
+        
+        emit RewardDistributed(source, rewardType, totalAmount, numWinners);
+    }
+    
+    // 直接分发奖励
+    function distributeRewardDirectly(
+        string calldata source,
+        uint256 rewardTypeId,
+        address[] calldata recipients,
+        uint256[] calldata amounts
+    ) external onlyOperator {
+        string memory rewardType = getRewardTypeString(rewardTypeId);
+        
+        ICoinbase(COINBASE_ADDRESS).addCoinbaseDirectly(
+            source,
+            recipients,
+            amounts,
+            rewardType
+        );
+        
+        uint256 totalAmount = 0;
+        for(uint i = 0; i < amounts.length; i++) {
+            totalAmount += amounts[i];
+        }
+        
+        emit RewardDistributed(source, rewardType, totalAmount, recipients.length);
+    }
+}

package/contracts/auction/coinbase-and-stake/invokeStake.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IStake {
+    function withdraw(
+        string calldata source,
+        address account,
+        uint256 amount
+    ) external;
+    
+    function withdrawMultiple(
+        string calldata source,
+        address[] calldata accounts,
+        uint256[] calldata amounts
+    ) external;
+    
+    function addToWhitelist(address _address) external;
+}
+
+contract InvokeStake {
+    // Stake合约地址
+    address public immutable STAKE_ADDRESS = 0x63BC05BC6FCAb99AF9A4c215B2e92a9C6f45D41F;
+    
+    // 操作者地址
+    address public owner;
+    
+    // 事件
+    event SingleWithdraw(string source, address account, uint256 amount);
+    event MultipleWithdraw(string source, address[] accounts, uint256[] amounts);
+    
+    constructor() {
+        owner = msg.sender;
+    }
+    
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Only owner can call this function");
+        _;
+    }
+    
+    // 初始化：将本合约添加到stake合约的白名单中
+    function initialize() external onlyOwner {
+        IStake(STAKE_ADDRESS).addToWhitelist(address(this));
+    }
+    
+    // 增加白名单
+    function addToWhitelist(address _address) public onlyOwner {
+        IStake(STAKE_ADDRESS).addToWhitelist(_address);
+    }
+
+    // 单地址提现示例
+    function singleWithdrawExample(
+        string calldata source,
+        address account,
+        uint256 amount
+    ) external onlyOwner {
+        // 调用stake合约的withdraw方法
+        IStake(STAKE_ADDRESS).withdraw(
+            source,
+            account,
+            amount
+        );
+        
+        emit SingleWithdraw(source, account, amount);
+    }
+    
+    // 多地址提现示例
+    function multipleWithdrawExample(
+        string calldata source,
+        address[] calldata accounts,
+        uint256[] calldata amounts
+    ) external onlyOwner {
+        // 调用stake合约的withdrawMultiple方法
+        IStake(STAKE_ADDRESS).withdrawMultiple(
+            source,
+            accounts,
+            amounts
+        );
+        
+        emit MultipleWithdraw(source, accounts, amounts);
+    }
+    
+}

package/contracts/auction/coinbase-and-stake/stake.sol

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+// 修改 Coinbase 合约的接口
+interface ICoinbase {
+    function addCoinbaseDirectly(
+        string calldata source,
+        address[] calldata rewardAddresses,
+        uint256[] calldata rewardAmounts,
+        string calldata rewardType
+    ) external;
+    
+    function addCoinbase(
+        string calldata source,
+        address[] calldata rewardAddresses,
+        string calldata rewardType,
+        uint256 totalAmount,
+        uint256 numWinners
+    ) external;
+}
+
+contract Stake {
+    // Coinbase合约地址
+    address public constant COINBASE_ADDRESS = 0xF02F87F086a53cb793E7e920bea648bb52A7d75D;
+    string public constant REWARDTYPE = "STAKE";
+    
+    
+    // 白名单mapping
+    mapping(address => bool) public whitelist;
+    
+    // 检查白名单的modifier
+    modifier onlyWhitelisted() {
+        require(whitelist[msg.sender], "Caller is not whitelisted");
+        _;
+    }
+    
+    // 添加白名单地址
+    function addToWhitelist(address _address) public {
+        require(_address != address(0), "Invalid address");
+        whitelist[_address] = true;
+    }
+    
+    // 单地址提现函数
+    function withdraw(
+        string calldata source,
+        address account,
+        uint256 amount
+    ) external onlyWhitelisted {
+        require(account != address(0), "Invalid address");
+        require(amount > 0, "Amount must be greater than 0");
+        
+        // 准备参数
+        address[] memory accounts = new address[](1);
+        accounts[0] = account;
+        
+        uint256[] memory amounts = new uint256[](1);
+        amounts[0] = amount;
+        
+        // 调用Coinbase合约的addCoinbaseDirectly方法
+        ICoinbase(COINBASE_ADDRESS).addCoinbaseDirectly(
+            source,
+            accounts,
+            amounts,
+            REWARDTYPE
+        );
+    }
+    
+    // 多地址提现函数
+    function withdrawMultiple(
+        string calldata source,
+        address[] calldata accounts,
+        uint256[] calldata amounts
+    ) external onlyWhitelisted {
+        require(accounts.length > 0, "No addresses provided");
+        require(accounts.length == amounts.length, "Arrays length mismatch");
+        
+        // 计算总金额
+        uint256 totalAmount = 0;
+        for(uint i = 0; i < amounts.length; i++) {
+            totalAmount += amounts[i];
+        }
+        
+        // 调用Coinbase合约的addCoinbase方法
+        ICoinbase(COINBASE_ADDRESS).addCoinbase(
+            source,
+            accounts,
+            REWARDTYPE,
+            totalAmount,
+            accounts.length
+        );
+    }
+}

package/contracts/auction/interfaces/IUniswapV2Factory.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IUniswapV2Factory {
+    event PairCreated(address indexed token0, address indexed token1, address pair, uint);
+
+    function feeTo() external view returns (address);
+    function feeToSetter() external view returns (address);
+    function getPair(address tokenA, address tokenB) external view returns (address pair);
+    function allPairs(uint) external view returns (address pair);
+    function allPairsLength() external view returns (uint);
+    function createPair(address tokenA, address tokenB) external returns (address pair);
+    function setFeeTo(address) external;
+    function setFeeToSetter(address) external;
+} 

package/contracts/auction/interfaces/IUniswapV2Pair.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IUniswapV2Pair {
+    event Approval(address indexed owner, address indexed spender, uint value);
+    event Transfer(address indexed from, address indexed to, uint value);
+
+    function name() external pure returns (string memory);
+    function symbol() external pure returns (string memory);
+    function decimals() external pure returns (uint8);
+    function totalSupply() external view returns (uint);
+    function balanceOf(address owner) external view returns (uint);
+    function allowance(address owner, address spender) external view returns (uint);
+
+    function approve(address spender, uint value) external returns (bool);
+    function transfer(address to, uint value) external returns (bool);
+    function transferFrom(address from, address to, uint value) external returns (bool);
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function PERMIT_TYPEHASH() external pure returns (bytes32);
+    function nonces(address owner) external view returns (uint);
+
+    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
+
+    event Mint(address indexed sender, uint amount0, uint amount1);
+    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
+    event Swap(
+        address indexed sender,
+        uint amount0In,
+        uint amount1In,
+        uint amount0Out,
+        uint amount1Out,
+        address indexed to
+    );
+    event Sync(uint112 reserve0, uint112 reserve1);
+
+    function MINIMUM_LIQUIDITY() external pure returns (uint);
+    function factory() external view returns (address);
+    function token0() external view returns (address);
+    function token1() external view returns (address);
+    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
+    function price0CumulativeLast() external view returns (uint);
+    function price1CumulativeLast() external view returns (uint);
+    function kLast() external view returns (uint);
+
+    function mint(address to) external returns (uint liquidity);
+    function burn(address to) external returns (uint amount0, uint amount1);
+    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
+    function skim(address to) external;
+    function sync() external;
+
+    function initialize(address, address) external;
+} 

package/contracts/auction/interfaces/IUniswapV2Router02.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+interface IUniswapV2Router02 {
+    function WETH() external pure returns (address);
+    function factory() external pure returns (address);
+    
+    function addLiquidityETH(
+        address token,
+        uint amountTokenDesired,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
+    
+    function removeLiquidityETH(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) external returns (uint amountToken, uint amountETH);
+}

package/contracts/auction/interfaces/IUnlockStrategy.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IUnlockStrategy {
+    /**
+     * @dev 处理解锁逻辑
+     * @param eventTopic 事件的主题哈希
+     * @param eventData 事件数据
+     * @param lockedAmount 已锁定的金额
+     * @return recipient 解锁的接收者
+     * @return unlockAmount 解锁的金额
+     */
+    function processUnlock(
+        bytes32 eventTopic,
+        bytes memory eventData,
+        uint256 lockedAmount
+    ) external returns (address recipient, uint256 unlockAmount);
+}

package/contracts/auction/libraries/EventParser.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+library EventParser {
+    // AuctionCreated 事件解析
+    function parseAuctionCreatedEvent(bytes memory eventData) internal view returns (
+        uint256 auctionId,
+        uint32 auctionType,
+        uint256 nonce,
+        uint256 revealTime
+    ) {
+        // 验证数据长度
+        require(eventData.length == 100, "Invalid event data length"); // 3 * 32 + 4 bytes
+
+        // ! 直接使用assemly获取存在问题，改用abi.decode
+        assembly {
+            // 跳过前32字节的长度数据
+            auctionId := mload(add(eventData, 32))    // 读取 auctionId
+            auctionType := mload(add(eventData, 36))  // 读取 auctionType
+            nonce := mload(add(eventData, 68))        // 读取 nonce
+            revealTime := mload(add(eventData, 100))  // 读取 revealTime
+        }
+
+        // 验证参数有效性
+        require(auctionId != 0, "Invalid auction ID");
+        // require(nonce != 0, "Invalid nonce");
+        require(revealTime > block.timestamp, "Invalid reveal time");
+    }
+
+    // 其他事件解析函数可以在这里添加... d
+
+} 

package/contracts/auction/libraries/TransactionParser.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "../utils/RLPReader.sol";
+import "hardhat/console.sol";
+
+library TransactionParser {
+    using RLPReader for bytes;
+    using RLPReader for RLPReader.RLPItem;
+    
+    struct RawTransaction {
+        uint256 nonce;
+        uint256 gasPrice;
+        uint256 gasLimit;
+        address to;
+        uint256 value;
+        bytes data;
+        uint256 v; // use full width to keep chainId info
+        bytes32 r;
+        bytes32 s;
+    }
+
+    struct RecptLog {
+        bytes32 eventTopic;   // topic0: keccak256(event signature)
+        bytes32[] topics;     // full topics array (topic0 + indexed fields)
+        bytes eventData;      // abi-encoded non-indexed event data
+    }
+
+    // RLP 交易解析
+    function parseRawTransaction(bytes memory rawTx) internal pure returns (RawTransaction memory) {
+        RLPReader.RLPItem[] memory items = rawTx.toRlpItem().toList();
+        require(items.length == 9, "Invalid transaction format");
+        
+        return RawTransaction({
+            nonce: items[0].toUint(),
+            gasPrice: items[1].toUint(),
+            gasLimit: items[2].toUint(),
+            to: address(uint160(items[3].toUint())),
+            value: items[4].toUint(),
+            data: items[5].toBytes(),
+            v: items[6].toUint(),
+            r: bytes32(items[7].toUint()),
+            s: bytes32(items[8].toUint())
+        });
+    }
+
+    function parseRecptLog(bytes memory receipt) internal pure returns (RecptLog memory) {
+        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 logTopics = logItems[1].toList();
+
+        bytes32[] memory topics = new bytes32[](logTopics.length);
+        for (uint256 i = 0; i < logTopics.length; i++) {
+            topics[i] = bytes32(logTopics[i].toBytes());
+        }
+
+
+        return RecptLog({
+            eventTopic: topics[0],
+            topics: topics,
+            eventData: logItems[2].toBytes()
+        });
+    }
+
+}