punkkit-sdk 1.0.0

package/scripts/uniswap/deploy/help.ts

@@ -0,0 +1,96 @@
+import { ethers } from "hardhat";
+import type { Contract } from "ethers";
+import { CONTRACTS } from "../../../config/uniswap.config";
+import { bigintToBytes32, bytecodeWithArgs } from "../../../src/uniswap/lib/utils";
+
+// Constants that correspond to the ones in Solidity
+const FLAG_MASK = BigInt(0x3FFF);
+const MAX_LOOP = 100_000;
+
+// create2Deploy deploys a contract using CREATE2 via the Create2 factory contract
+export async function create2Deploy(create2: Contract, contractName: string, types: string[], params: any[], salt: bigint): Promise<string> {
+
+    // Load the contract artifact using TypeScript
+    const scArtifact = CONTRACTS[contractName];
+    if (scArtifact == null) {
+        throw new Error(`Contract artifact for ${contractName} not found`);
+    }
+    let bytecode = scArtifact.bytecode;
+
+    if (bytecode == undefined || bytecode.length == 0) {
+        console.log("bytecode length is zero");
+        throw new Error(`Bytecode for contract ${contractName} is undefined or empty`);
+    }
+
+    const initCode = bytecodeWithArgs(bytecode, types, params);
+    const create2Addr = getCreate2Address(await create2.address, salt, initCode);
+    // console.log(`precomputed ${contractName} address: ${create2Addr}`);
+
+    const saltHex = bigintToBytes32(salt);
+
+    console.log("create2 address",create2.address);
+
+    const tx = await create2.deployCreate2WithSalt(initCode, saltHex, { gasLimit: 30_000_000 });
+    await tx.wait();
+
+    console.log(`deterministic deployed ${contractName} by transaction(${tx.hash})`);
+    return create2Addr;
+}
+
+// Simulate the HookMiner.find function in TypeScript
+export async function findHookAddress(
+    deployer: string,
+    contractName: string,
+    types: string[],
+    params: any[],
+    flags: bigint
+): Promise<{ hookAddress: string, salt: bigint }> {
+    // Load the contract artifact using TypeScript
+    const bytecode = CONTRACTS[contractName].bytecode;
+    if (bytecode == undefined || bytecode.length == 0) {
+        throw new Error(`Bytecode for contract ${contractName} is undefined or empty`);
+    }
+
+    const creationCodeWithArgs = bytecodeWithArgs(bytecode, types, params);
+
+    let salt = BigInt(0);
+    for (let i = 0; i < MAX_LOOP; i++) {
+        const hookAddress = getCreate2Address(deployer, salt, creationCodeWithArgs);
+        if (hookAddress && (BigInt(hookAddress) & FLAG_MASK) === flags) {
+            // Check if the address is not deployed
+            const code = await ethers.provider.getCode(hookAddress);
+            if (code === "0x") {
+                return { hookAddress, salt };
+            }
+        }
+        salt = salt + BigInt(1);
+    }
+    throw new Error("HookMiner: could not find salt");
+}
+
+export function getCreate2Address(factoryAddress: string, salt: bigint, initCode: string): string {
+    const saltHex = bigintToBytes32(salt);
+    const create2Addr = ethers.utils.getCreate2Address(factoryAddress, saltHex, ethers.utils.keccak256(initCode));
+    return create2Addr;
+}
+
+
+export async function deployHookWithFlags(factory: Contract, factoryAddr: string, contractName: string, constructorTypes: string[], constructorValues: any[], flags: bigint) {
+    // 1. compute hook address
+    const { hookAddress, salt } = await findHookAddress(
+        factoryAddr,
+        contractName,
+        constructorTypes,
+        constructorValues,
+        flags
+    );
+
+    console.log(`\n=== Deploying ${contractName} Hook ===`);
+    console.log("Hook Address:", hookAddress);
+    console.log("Salt Used:", salt.toString());
+    console.log("Salt Keccak256:", ethers.utils.id(salt.toString()));
+
+    // 2. use CREATE2 deploy
+    await create2Deploy(factory,contractName,constructorTypes,constructorValues,salt);
+    return hookAddress;
+}

package/scripts/uniswap/deploy/init.ts

@@ -0,0 +1,70 @@
+import { ethers } from "hardhat";
+import { CONTRACT_ADDRESSES, CONTRACTS, POOL_KEYS, RPC_URL, PRIVATE_KEY, PRICE_INIT, INITIAL_SUPPLY } from "../../../config/uniswap.config";
+import { priceToSqrtPrice } from "../../../src/uniswap/lib/liqCalculation";
+import { getERC20Balance, mintERC20 } from "../../../src/uniswap/lib/ERC20";
+import { getContract } from "../../../src/uniswap/lib/contract";
+import { Wallet,Contract } from "ethers";
+import { get } from "http";
+
+async function isPoolInitialized( poolManager: Contract,  poolKey: any,sqrtPriceX96:bigint): Promise<boolean> {
+    try {
+        // callStatic 用于模拟调用，不会产生交易。如果报错说明已经初始化
+        await poolManager.callStatic.initialize(poolKey, sqrtPriceX96);
+        return false;
+    } catch {
+        return true;
+    }
+}
+
+
+// InitPoolManager must be called only token is deployed.
+export async function initPoolManager(contractAddress: string) {
+    const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+    const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+    const constract = new ethers.Contract(contractAddress, CONTRACTS["PoolManager"].abi, wallet);
+    const price = PRICE_INIT
+    const sqrtPriceX96 = priceToSqrtPrice(price);
+    // console.log(`sqrtPriceX96: ${sqrtPriceX96}`);
+    if (await isPoolInitialized(constract, POOL_KEYS.limitOrderPoolKey, sqrtPriceX96)) {
+        console.log("Limit Order Pool is already initialized.");
+    }else{
+        await constract.initialize(POOL_KEYS.limitOrderPoolKey, sqrtPriceX96);
+    }
+    if (await isPoolInitialized(constract, POOL_KEYS.dynamicFeePoolKey, sqrtPriceX96)) {
+        console.log("Dynamic Fee Pool is already initialized.");
+    }else{
+        await constract.initialize(POOL_KEYS.dynamicFeePoolKey, sqrtPriceX96);
+    }
+}
+
+export async function ERC20Initial(wallet: Wallet, contractName: string, account:string, supply: bigint) {
+    const token = await getContract(wallet, contractName);
+    // 判断是否已经初始化
+    if (await getERC20Balance(token,account) !== BigInt(0)) {
+        console.log(`${contractName} already initialized for account ${account}`);
+        return 
+    }
+    await mintERC20(token, account, supply);
+    // 检查是否初始化成功
+    const balance = await getERC20Balance(token,account)
+    if (balance !== supply) {
+        throw new Error(`${contractName} mint failed. Acount ${account} balance is ${balance}, expected ${supply}`);
+    }
+}
+
+async function main() {
+    // 1. PoolManager initial
+    const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+    const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+    const walletAddress = await wallet.getAddress();
+    await initPoolManager(CONTRACT_ADDRESSES["PoolManager"]);
+
+    // 2. ERC20 initial
+    const supply = INITIAL_SUPPLY;
+    await ERC20Initial(wallet,"Token0", walletAddress, supply);
+    await ERC20Initial(wallet,"Token1", walletAddress, supply);
+}
+
+if (require.main === module) {
+    main();
+}

package/src/auction/chainXAuction.ts

@@ -0,0 +1,209 @@
+
+import { RPC_URL, PRIVATE_KEY, AUCTION_ADDR, AUCTION_ABI } from "../../config/auction.config";
+import { getAuctionID, buildAuctionCreatedReceipt, buildAuctionCreatedTx } from "./serialize"; // 路径按需调整
+import { Contract, Signer, utils } from "ethers";
+import { getSigner } from "../lib/signer"
+import {
+    CreateAuctionParams,
+    PlaceBidParams,
+    RevealBidParams,
+    RevealLockParams,
+    SubmitMatchResultsParams,
+    WithdrawMatchResultParams,
+} from "./type";
+
+
+export function getAuctionContract(
+    signer: Signer
+): Contract {
+    if (!AUCTION_ADDR.chainXAuction) {
+        throw new Error("chainXAuctionV2Addr not set");
+    }
+    return new Contract(
+        AUCTION_ADDR.chainXAuction,
+        AUCTION_ABI.chainXAuction.abi,
+        signer
+    );
+}
+
+export async function createAuction(
+    params: CreateAuctionParams
+): Promise<{ auctionId: string; revealStartTime: bigint }> {
+    const { seller, sourceChainId, activeAuctionCount, auctionType } = params;
+
+    const signer = getSigner(RPC_URL, PRIVATE_KEY);
+    const provider = signer.provider!;
+    const nonce= await provider.getTransactionCount(signer.address);
+
+    const chainId =
+        sourceChainId ?? (await provider.getNetwork()).chainId;
+
+    const auctionId = getAuctionID(
+        seller,
+        chainId,
+        AUCTION_ADDR.chainYVault,
+        activeAuctionCount
+    );
+
+    const rawTx  = await buildAuctionCreatedTx({
+        nonce: nonce,
+        gasPrice: utils.parseUnits("1", "gwei").toBigInt(),
+        gasLimit: BigInt(52_200),
+        to: AUCTION_ADDR.chainYVault,
+        value: BigInt(0),
+        chainId:chainId,
+        data: "0x",
+    });
+    const signedTx = await signer.signTransaction(rawTx);
+    const revealStartTime = BigInt(Math.floor(Date.now() / 1000) + 60);
+
+    const rawRecpt = buildAuctionCreatedReceipt({
+        auctionId,
+        auctionType,
+        activeAuctionCount: activeAuctionCount,
+        revealTime: revealStartTime,
+    });
+
+    const crossChainMessage =
+        utils.defaultAbiCoder.encode(
+            ["tuple(uint256, bytes, bytes)"],
+            [[chainId, signedTx, rawRecpt]]
+        );
+
+    const contract = getAuctionContract(signer);
+    const tx = await contract.createAuction(crossChainMessage);
+    await tx.wait();
+
+    return { auctionId, revealStartTime };
+}
+
+
+export async function placeBid(
+    params: PlaceBidParams
+): Promise<{ bidValue: string; secretHash: string }> {
+    const { auctionId, seller, valueEth, secretText = "secret" } = params;
+
+    const signer = getSigner(RPC_URL, PRIVATE_KEY);
+    const contract = getAuctionContract(signer);
+
+    const value = utils.parseEther(valueEth);
+    const bidValue = utils.hexZeroPad(
+        value.toHexString(),
+        32
+    );
+    const secretHash = utils.keccak256(
+        utils.toUtf8Bytes(secretText)
+    );
+
+    const depositAmount = value.mul(15).div(10);
+
+    const tx = await contract.placeBid(
+        auctionId,
+        seller,
+        secretHash,
+        bidValue,
+        { value: depositAmount }
+    );
+    await tx.wait();
+
+    return { bidValue, secretHash };
+}
+
+export async function revealBid(
+    params: RevealBidParams
+): Promise<void> {
+    const signer = getSigner(RPC_URL, PRIVATE_KEY);
+    const contract = getAuctionContract(signer);
+
+    const value = utils.parseEther(params.valueEth);
+    const salt =
+        params.saltHex ?? utils.randomBytes(32);
+
+    const tx = await contract.revealBid(
+        params.auctionId,
+        value,
+        salt
+    );
+    await tx.wait();
+}
+
+export async function revealLock(
+    params: RevealLockParams
+): Promise<void> {
+    const signer = getSigner(RPC_URL, PRIVATE_KEY);
+    const contract = getAuctionContract(signer);
+
+    const value = utils.parseEther(params.valueEth);
+    const salt = params.saltHex ?? utils.randomBytes(32);
+
+    const tx = await contract.revealLock(
+        params.auctionId,
+        params.lockId,
+        value,
+        salt
+    );
+    await tx.wait();
+}
+
+export async function submitMatchResults(
+    params: SubmitMatchResultsParams
+): Promise<void> {
+    const signer = getSigner(RPC_URL, PRIVATE_KEY);
+    const contract = getAuctionContract(signer);
+
+    const finalValues = params.finalValuesEth.map((v) =>
+        utils.parseEther(v)
+    );
+
+    const tx = await contract.submitMatchResults(
+        params.auctionId,
+        params.lockIds,
+        params.bidders,
+        finalValues
+    );
+    await tx.wait();
+}
+
+export async function withdrawMatchResult(
+    params: WithdrawMatchResultParams
+): Promise<void> {
+    const signer = getSigner(RPC_URL, PRIVATE_KEY);
+    const contract = getAuctionContract(signer);
+
+    const tx = await contract.withdrawMatchResult(
+        params.auctionId,
+        params.lockId
+    );
+    await tx.wait();
+}
+
+export async function getLockInfo(
+    auctionId: string,
+    lockId: string
+): Promise<{ exists: boolean; revealTime: bigint; secret: string }> {
+    const signer = getSigner(RPC_URL, PRIVATE_KEY);
+    const contract = getAuctionContract(signer);
+
+    const result = await contract.getLockInfo(auctionId, lockId);
+    return {
+        exists: result[0],
+        revealTime: result[1].toBigInt(),
+        secret: result[2],
+    };
+}
+
+export async function getMatchResult(
+    auctionId: string,
+    bidder: string
+): Promise<{ lockId: string; isChallenged: boolean; isWithdrawn: boolean }> {
+    const signer = getSigner(RPC_URL, PRIVATE_KEY);
+    const contract = getAuctionContract(signer);
+
+    const result = await contract.getMatchResult(auctionId, bidder);
+    return {
+        lockId: result[0],
+        isChallenged: result[1],
+        isWithdrawn: result[2],
+    };
+}
+

package/src/auction/chainYVault.ts

@@ -0,0 +1,153 @@
+
+import  { getAuctionID } from "./serialize";
+import {
+  CreateAuctionConfigParams,
+  SetUnlockStrategyParams,
+  CreateAuctionParams,
+  UnlockTokensParams,
+} from "./type";
+import {getSigner} from "../lib/signer";
+import {RPC_URL, PRIVATE_KEY,AUCTION_ADDR,AUCTION_ABI} from "../../config/auction.config";
+import {Wallet,Contract,providers,Signer, utils} from "ethers";
+import { MatchResultWithdrawnEvent } from "./event";
+
+async function getChainYContract(signer:Wallet) {
+    const abi= AUCTION_ABI.chainYVault.abi;
+    return new Contract(AUCTION_ADDR.chainYVault, abi, signer);
+}
+
+
+export function getProvider(): providers.JsonRpcProvider {
+    return new providers.JsonRpcProvider(RPC_URL);
+}
+
+export function toWei(valueEth: string): bigint {
+    return utils.parseEther(valueEth).toBigInt();
+}
+
+
+// 创建 Auction 配置
+export async function createAuctionConfig({
+    auctionType,
+    baseAmountEth,
+    extendSeconds,
+}: CreateAuctionConfigParams): Promise<string> {
+    const signer = getSigner(RPC_URL,PRIVATE_KEY);
+    const vault = await getChainYContract(signer);
+
+    const tx = await vault.createAuctionConfig(
+        auctionType,
+        toWei(baseAmountEth),
+        extendSeconds
+    );
+
+    await tx.wait();
+    return tx.hash;
+}
+
+// 创建Auction
+export async function createAuction({
+    configId,
+    secretText,
+    expirationTs,
+    amountEth,
+}: CreateAuctionParams): Promise<{
+    txHash: string;
+    auctionId?: string;
+    lockId?: string;
+}> {
+    const signer = getSigner(RPC_URL,PRIVATE_KEY);
+    const vault = await getChainYContract(signer);
+    const hashSecret = utils.keccak256(
+        utils.toUtf8Bytes(secretText)
+    );
+
+    const tx = await vault.createAuction(
+        configId,
+        hashSecret,
+        expirationTs,
+        { value: toWei(amountEth) }
+    );
+
+    const receipt = await tx.wait();
+    const evt = receipt.events?.find(
+        (e:any) => e.event === "TokensLocked"
+    );
+
+    return {
+        txHash: tx.hash,
+        auctionId: evt?.args?.auctionId,
+        lockId: evt?.args?.lockId,
+    };
+}
+
+// 解锁Token
+export async function unlockTokens({
+    lockId,
+    rawReceipt,
+}: UnlockTokensParams): Promise<{
+    txHash: string;
+    recipient?: string;
+    amount?: bigint;
+}> {
+    const signer = getSigner(RPC_URL,PRIVATE_KEY);
+    const vault = await getChainYContract(signer);
+
+    const tx = await vault.unlockTokens(lockId, rawReceipt);
+    const receipt = await tx.wait();
+
+    const evt = receipt.events?.find(
+        (e:any) => e.event === "TokensUnlocked"
+    );
+
+    return {
+        txHash: tx.hash,
+        recipient: evt?.args?.recipient,
+        amount: evt?.args?.amount,
+    };
+}
+
+// 查询拍卖信息
+export async function getAuctionInfo(auctionId: string | number): Promise<{
+    auctionType: number;
+    baseAmount: bigint;
+    revealTime: bigint;
+}> {
+    const signer = getSigner(RPC_URL, PRIVATE_KEY);
+    const vault = await getChainYContract(signer);
+
+    const result = await vault.getAuctionInfo(auctionId);
+    return {
+        auctionType: result[0],
+        baseAmount: result[1].toBigInt(),
+        revealTime: result[2].toBigInt(),
+    };
+}
+
+// 查询锁仓信息
+export async function getAuctionLockInfo(lockId: string): Promise<{
+    owner: string;
+    amount: bigint;
+    isLocked: boolean;
+    revealTime: bigint;
+}> {
+    const signer = getSigner(RPC_URL, PRIVATE_KEY);
+    const vault = await getChainYContract(signer);
+
+    const result = await vault.getAuctionLockInfo(lockId);
+    return {
+        owner: result[0],
+        amount: result[1].toBigInt(),
+        isLocked: result[2],
+        revealTime: result[3].toBigInt(),
+    };
+}
+
+// 获取当前激活拍卖数量
+export async function getActiveAuctionsCount(): Promise<bigint> {
+    const signer = getSigner(RPC_URL, PRIVATE_KEY);
+    const vault = await getChainYContract(signer);
+    const count = await vault.getActiveAuctionsCount();
+    return count.toBigInt();
+}
+

package/src/auction/event.ts

@@ -0,0 +1,19 @@
+
+// * ChainXAuction 相关事件
+
+export interface MatchResultWithdrawnEvent{
+    auctionId: bigint;
+    lockId: string;
+    recipient: string;
+    amount: bigint;
+}
+
+
+// * ChainYVault 相关事件
+// event AuctionCreated(uint256 indexed auctionId, uint32 auctionType, uint256 activeAuctionCount, uint256 revealTime
+export interface auctionCreatedEvent {
+    auctionId: string; // 使用string存储，auctionId是Keccak256计算的hash值，在调用合约时候会自动转化为uiny256
+    auctionType: number;
+    activeAuctionCount: bigint;
+    revealTime: bigint;
+}

package/src/auction/serialize.ts

@@ -0,0 +1,162 @@
+import { ethers } from "hardhat";
+import { Wallet } from "ethers";
+import { MatchResultWithdrawnEvent,auctionCreatedEvent} from "./event";
+import { utils } from "ethers";
+import { AUCTION_ADDR } from "../../config/auction.config";
+
+
+export function buildAuctionCreatedReceipt(
+    event: auctionCreatedEvent,
+    status: number = 0x01,
+    gasUsed: bigint = BigInt(0),
+    gasPrice: bigint = BigInt(0),
+) {
+    // * 随意填写的数据
+    const statusHex = ethers.utils.hexlify(status);
+    const gasUsedHex = ethers.utils.hexlify(gasUsed);
+    const gasPriceHex = ethers.utils.hexlify(gasPrice);
+
+    // 构造Event，实际上只需要Event字段是合法的就可以，并且确保在数组的index=3.
+    const topic0 = ethers.utils.id("AuctionCreated(uint256,uint32,uint256,uint256)");
+    const topic1 = event.auctionId;
+    const eventData = ethers.utils.defaultAbiCoder.encode(
+        ["uint32", "uint256", "uint256"],
+        [event.auctionType, event.activeAuctionCount, event.revealTime]
+    );
+    const log = [
+        AUCTION_ADDR.chainYVault,
+        [topic0, topic1],
+        ethers.utils.arrayify(eventData),
+    ];
+    const logBlob = ethers.utils.RLP.encode(log);
+
+    // recipt每个元素必须都是 Hex-string
+    const receipt = [statusHex, gasUsedHex, gasPriceHex, logBlob];
+    return ethers.utils.RLP.encode(receipt);
+}
+
+// 根据 Auciton 所在合约的信息构造AuctionID
+export function getAuctionID(seller: string, sourceChainId: number, vaultAddress: string, activeAuctionCount: bigint): string {
+    return ethers.utils.keccak256(
+        ethers.utils.solidityPack(
+            ["address", "uint256", "address", "uint256"],
+            [seller, sourceChainId, vaultAddress, activeAuctionCount]
+        )
+    );
+}
+
+// 构造 rawTx: legacy 格式 [nonce, gasPrice, gasLimit, to, value, data, v, r, s]
+export function buildXTx(
+    nonce: number,
+    gasPrice: bigint,
+    gasLimit: bigint,
+    to: string,
+    value: bigint,
+    data: string,
+    v: bigint,
+    r: string,
+    s: string,
+) {
+    return ethers.utils.RLP.encode([
+        nonce,
+        gasPrice,
+        gasLimit,
+        to,
+        value,
+        ethers.utils.arrayify(data),
+        v,
+        ethers.utils.zeroPad(ethers.utils.arrayify(r), 32),
+        ethers.utils.zeroPad(ethers.utils.arrayify(s), 32),
+    ]);
+}
+
+
+interface BuildAuctionCreatedTxParams {
+    nonce?: number;
+    gasPrice?: bigint;
+    gasLimit?: bigint;
+    to?: string;
+    value?: bigint;
+    data?: string;
+    chainId?: number;
+}
+
+export async function buildAuctionCreatedTx({
+    nonce = 0,
+    gasPrice = BigInt(0),
+    gasLimit = BigInt(0),
+    to = "0x",
+    value = BigInt(0),
+    data = "0x",
+    chainId=31337,
+}: BuildAuctionCreatedTxParams
+){
+    const tx = {
+        nonce,
+        gasPrice,
+        gasLimit,
+        to,
+        value,
+        data,
+        chainId,
+        type: 0, // Legacy tx
+    };
+    return tx
+}
+
+
+/**
+ * 构造 Unlock Receipt（RLP）
+ */
+export function buildChainXUnlockReceipt({
+    auctionId,
+    lockId,
+    recipient,
+    amount,
+}: MatchResultWithdrawnEvent): string {
+    const status = "0x01";
+    const cumulativeGasUsed = "0x00";
+    const logsBloom = "0x" + "00".repeat(256);
+    const logAddress = AUCTION_ADDR.chainXAuction;
+
+    const topic0 = utils.id(
+        "MatchResultWithdrawn(uint256,bytes32,address,uint256)"
+    );
+
+    const eventData = utils.defaultAbiCoder.encode(
+        ["uint256", "bytes32", "address", "uint256"],
+        [auctionId, lockId, recipient, amount]
+    );
+
+    const log = [
+        logAddress,
+        [topic0],
+        utils.arrayify(eventData),
+    ];
+
+    const logBlob = utils.RLP.encode(log);
+    return utils.RLP.encode([
+        status,
+        cumulativeGasUsed,
+        logsBloom,
+        logBlob,
+    ]);
+}
+
+// 仅在直接运行本文件时演示生成 rawReceipt，避免被 require 时产生副作用
+if (require.main === module) {
+    const stauts = 0x01;
+    const gasUsed = BigInt(21000);
+    const gasPrice = BigInt(21000);
+    const sourceChainId = 11223344;
+
+    const auctionType = 0x00000001;
+    const seller = "0x5F40D0aA63957D41ec56500c5dc61c28Ae866a5e";
+    const activeAuctionCount = BigInt(0);
+    const auctionId = getAuctionID(seller, sourceChainId, seller, activeAuctionCount);
+    const revealTime = BigInt(Math.floor(Date.now() / 1000) + 3600);
+    const logAddress = "0x307833383843383138434138423932353162333933313331433038613733364136376363423139323937";
+
+    const rowReceipt = buildAuctionCreatedReceipt({ auctionId, auctionType, activeAuctionCount, revealTime })
+    console.log("rawReceipt:", rowReceipt);
+}