punkkit-sdk 1.0.0

package/src/auction/type.ts

@@ -0,0 +1,71 @@
+import { MatchResultWithdrawnEvent } from "./event";
+
+// * chainXAuction 相关参数
+export interface CreateAuctionParams {
+  seller: string;
+  sourceChainId: number;
+  activeAuctionCount: bigint;
+  auctionType: number;
+}
+
+export interface PlaceBidParams {
+  auctionId: string;
+  seller: string;
+  valueEth: string;
+  secretText?: string;
+}
+
+export interface RevealBidParams {
+  auctionId: string;
+  valueEth: string;
+  saltHex?: string;
+}
+
+export interface RevealLockParams {
+  auctionId: string;
+  lockId: string;
+  valueEth: string;
+  saltHex?: string;
+}
+
+export interface SubmitMatchResultsParams {
+  auctionId: string;
+  lockIds: string[];
+  bidders: string[];
+  finalValuesEth: string[];
+}
+
+export interface ChallengeMatchResultParams {
+  auctionId: string;
+  bidder: string;
+}
+
+export interface WithdrawMatchResultParams {
+  auctionId: string;
+  lockId: string;
+}
+
+// * chainYVaultClient 相关参数
+
+export interface CreateAuctionConfigParams {
+  auctionType: number;
+  baseAmountEth: string;
+  extendSeconds: number;
+}
+
+export interface SetUnlockStrategyParams {
+  auctionType: number;
+  strategyAddress: string;
+}
+
+export interface CreateAuctionParams {
+  configId: number;
+  secretText: string;
+  expirationTs: number;
+  amountEth: string;
+}
+
+export interface UnlockTokensParams {
+  lockId: string;
+  rawReceipt: string;
+}

package/src/lib/signer.ts

@@ -0,0 +1,20 @@
+import { Wallet, providers } from "ethers";
+
+export function addressFromPrivateKey(pk: string): string {
+	return new Wallet(pk).address;
+}
+
+export function getSigner(
+	rpcUrl: string,
+	privateKey: string
+): Wallet {
+	if (!privateKey) {
+		throw new Error("PRIVATE_KEY not set");
+	}
+	const provider = new providers.JsonRpcProvider(rpcUrl);
+	return new Wallet(privateKey, provider);
+}
+
+export function getProvider(rpcUrl:string): providers.JsonRpcProvider {
+	return new providers.JsonRpcProvider(rpcUrl);
+}

package/src/lib/unlock.ts

@@ -0,0 +1,14 @@
+import { ethers } from "ethers";
+import fs from "fs";
+
+const keystore = fs.readFileSync("keystore.json", "utf-8");
+const password = "mypassword";
+
+async function loadWallet() {
+  const wallet = await ethers.Wallet.fromEncryptedJson(keystore, password);
+  console.log("Private Key:", wallet.privateKey);
+  console.log("Public Key:", wallet.publicKey);
+  console.log("Address:", wallet.address);
+}
+
+loadWallet();

package/src/uniswap/1-marketprice/addLiquidity.ts

@@ -0,0 +1,80 @@
+import { ethers } from "hardhat";
+import { Wallet, Contract } from "ethers";
+
+import { CONTRACT_ADDRESSES, POOL_KEYS, RPC_URL, PRIVATE_KEY, INITIAL_LIQUIDITY } from "../../../config/uniswap.config";
+import { ModifyPositionParams, PoolKey } from "../lib/types";
+import { getPoolPrice, getPoolSqrtPrice, modifyPosition } from "../lib/pool";
+import { getERC20Balance, isApproved, approveERC20 } from "../lib/ERC20";
+import { calculateLiqDelta, calculateTickFromPriceWithSpacing } from "../lib/liqCalculation";
+import { getContract } from "../lib/contract";
+
+
+
+
+
+
+async function addLiq(wallet: Wallet, priceLower: number, priceUpper: number, amount0: bigint, amount1: bigint, poolKey: PoolKey): Promise<void> {
+    // 合约对象实例化
+    const token0 = await getContract(wallet, "Token0");
+    const token1 = await getContract(wallet, "Token1");
+    const liqPool = await getContract(wallet, "LiquidPool");
+
+    const ticklow = calculateTickFromPriceWithSpacing(priceLower, poolKey.tickSpacing);
+    const tickhigh = calculateTickFromPriceWithSpacing(priceUpper, poolKey.tickSpacing);
+    const sqrtCurrent = await getPoolSqrtPrice(liqPool);
+
+    const [liqDelta, amount0Add, amount1Add] = calculateLiqDelta(ticklow, sqrtCurrent, tickhigh, amount0, amount1);
+
+    let modifyPositionParams: ModifyPositionParams = {
+        tickLower: ticklow,
+        tickUpper: tickhigh,
+        liquidityDelta: liqDelta,
+    };
+    console.log("Modify position params:", modifyPositionParams);
+
+    // Check ERC20 token balances and approve if necessary
+    const liqPoolAddr = liqPool.address;
+    if (!(await isApproved(token0, wallet.address, liqPoolAddr, amount0Add))) {
+        await approveERC20(token0, liqPoolAddr, amount0Add);
+    }
+
+    if (!(await isApproved(token1, wallet.address, liqPoolAddr, amount1Add))) {
+        await approveERC20(token1, liqPoolAddr, amount1Add);
+    }
+
+    await modifyPosition(liqPool, modifyPositionParams, "0x00");
+}
+
+async function main(): Promise<void> {
+    const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+    const wallet = new Wallet(PRIVATE_KEY, provider);
+    const tokenContractName = "MockERC20";
+    const liqPoolAddress = CONTRACT_ADDRESSES.LiquidPool;
+
+    const token0 = await getContract(wallet, "Token0");
+    const token1 = await getContract(wallet, "Token1");
+    const liqPool = await getContract(wallet, "LiquidPool");
+
+    const token0Before = (await getERC20Balance(token0, wallet.address)).valueOf();
+    const token1Before = (await getERC20Balance(token1, wallet.address)).valueOf();
+    let poolPrice = await getPoolPrice(liqPool);
+    console.log(`Current price of pool before adding liquidity is ${poolPrice}`);
+
+    // 如果价格比当前区间最大值还要大，则只会添加token1。比当前价格区间还要小，则只会添加token0
+    const priceLower = 0.5;
+    const priceUpper = 1.5;
+    const amount0 = INITIAL_LIQUIDITY;
+    const amount1 = INITIAL_LIQUIDITY;
+    await addLiq(wallet, priceLower, priceUpper, amount0, amount1, POOL_KEYS.limitOrderPoolKey);
+
+
+    const token0After = (await getERC20Balance(token0, wallet.address)).valueOf();
+    const token1After = (await getERC20Balance(token1, wallet.address)).valueOf();
+    console.log("Token0 change:", token0After - token0Before);
+    console.log("Token1 change:", token1After - token1Before);
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/src/uniswap/1-marketprice/removeLiquidity.ts

@@ -0,0 +1,63 @@
+import { Contract, Wallet,providers } from "ethers";
+import { CONTRACT_ADDRESSES, POOL_KEYS, RPC_URL, PRIVATE_KEY, SALT } from "../../../config/uniswap.config";
+import { getPoolPrice, getPoolSqrtPrice, modifyPosition } from "../lib/pool";
+import { getERC20Balance, isApproved, approveERC20 } from "../lib/ERC20";
+import { calculateLiqDelta, calculateTickFromPriceWithSpacing } from "../lib/liqCalculation";
+import { ModifyPositionParams } from "../lib/types";
+import { getContract } from "../lib/contract";
+
+async function removeLiq(wallet: Wallet, priceLower: number, priceUpper: number, amount0: bigint, amount1: bigint, poolKey: any): Promise<void> {
+    const ticklow = calculateTickFromPriceWithSpacing(priceLower, poolKey.tickSpacing);
+    const tickhigh = calculateTickFromPriceWithSpacing(priceUpper, poolKey.tickSpacing);
+    const liqPool = await getContract(wallet, "LiquidPool");
+
+    const sqrtCurrent = await getPoolSqrtPrice(liqPool);
+    const [liqDelta, amount0Rmv, amount1Rmv] = calculateLiqDelta(ticklow, sqrtCurrent, tickhigh, amount0, amount1);
+    console.log(`Attempting to remove liquidity ${liqDelta} to price range [${priceLower}, ${priceUpper}] with amount0[${amount0Rmv.toString()}], amount1[${amount1Rmv.toString()}]`);
+    const modifyPositionParams: ModifyPositionParams = {
+        tickLower: ticklow,
+        tickUpper: tickhigh,
+        liquidityDelta: liqDelta * BigInt(-1),
+    };
+    await modifyPosition(liqPool, modifyPositionParams, "0x00");
+}
+
+async function main(): Promise<void> {
+    const provider = new providers.JsonRpcProvider(RPC_URL);
+    const wallet = new Wallet(PRIVATE_KEY, provider);
+
+    const liqPoolAddress = CONTRACT_ADDRESSES.LiquidPool;
+
+    const token0 = await getContract(wallet, "Token0");
+    const token1 = await getContract(wallet, "Token1");
+    const liqPool = await getContract(wallet, "LiquidPool");
+
+
+    let poolPrice = await getPoolPrice(liqPool);
+    console.log(`Current price of pool ${liqPool.address} before removing liquidity is ${poolPrice}`);
+
+    const token0Before = await getERC20Balance(token0, wallet.address);
+    const token1Before = await getERC20Balance(token1, wallet.address);
+    console.log("Token0 balance before removing liquidity:", token0Before.toString());
+    console.log("Token1 balance before removing liquidity:", token1Before.toString());
+
+    const priceLower = 0.5;
+    const priceUpper = 1.5;
+    const amount0 = 100n;
+    const amount1 = 100n;
+
+    await removeLiq(wallet, priceLower, priceUpper, amount0, amount1, POOL_KEYS.limitOrderPoolKey);
+
+    poolPrice = await getPoolPrice(liqPool);
+    console.log(`Current price of pool ${liqPool.address} after removing liquidity is ${poolPrice}`);
+
+    const token0After = await getERC20Balance(token0, wallet.address);
+    const token1After = await getERC20Balance(token1, wallet.address);
+    console.log("Token0 change:", token0After - token0Before);
+    console.log("Token1 change:", token1After - token1Before);
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/src/uniswap/1-marketprice/swap.ts

@@ -0,0 +1,100 @@
+import { Wallet,providers,constants, utils } from "ethers";
+import { CONTRACT_ADDRESSES, RPC_URL, PRIVATE_KEY, SALT, SALT_LIMITORDER } from "../../../config/uniswap.config";
+import { SwapParams } from "../lib/types";
+import { getPoolPrice, getCurrentTick } from "../lib/pool";
+import { getERC20Balance, isApproved, approveERC20 } from "../lib/ERC20";
+import { executeSwap } from "../lib/swap";
+import { priceToSqrtPrice, calculateTickFromPriceWithSpacing } from "../lib/liqCalculation";
+import { getContract } from "../lib/contract";
+
+// Swap function that handles token approval and execution
+// amountIn代表投入的代币数量，获取到的数量不定
+export async function swap(wallet: Wallet, amountIn: bigint, zeroForOne: boolean, hookData: string): Promise<void> {
+    const token0 = await getContract(wallet,"MockERC20");
+    const token1 = await getContract(wallet,"MockERC20");
+    const liqPool = await getContract(wallet,"LiquidPool");
+
+    const priceCurrent = await getPoolPrice(liqPool);
+    // slippage at 5%
+    const slippageMultiplier = 105;
+    const base = 100;
+
+    // after zero for one, the price is decreased, the price0 is the maximum slippage
+    const price0 = priceCurrent * base / slippageMultiplier;
+    const price1 = priceCurrent * slippageMultiplier / base;
+    const sqrtPricecur = priceToSqrtPrice(priceCurrent)
+    const sqrtPrice0 = priceToSqrtPrice(price0)
+    const sqrtPrice1 = priceToSqrtPrice(price1)
+    // console.log(`sqrtPricecur: ${sqrtPricecur.toString()}, sqrtPrice0: ${sqrtPrice0.toString()}, sqrtPrice1: ${sqrtPrice1.toString()}`);
+
+    const tick = await getCurrentTick(liqPool);
+    console.log("Current tick at liquild pool:", tick);
+
+    // If zero for one, the price cannot be less than this value after the swap. 
+    // If one for zero, the price cannot be greater than this value after the swap
+    const sqrtPriceLimitX96 = zeroForOne
+        ? sqrtPrice0
+        : sqrtPrice1;
+
+    const swapParams: SwapParams = {
+        zeroForOne: zeroForOne, // Swap direction, if true, swap token0 for token1
+        amountSpecified: amountIn,
+        sqrtPriceLimitX96: sqrtPriceLimitX96 // Price limit after swap to protect against slippage
+    };
+
+    // Check and approve ERC20 tokens if necessary
+    const token = zeroForOne ? token0 : token1;
+    // Calculate an approval amount with a 1% buffer to account for fees
+    if (!(await isApproved(token, wallet.address, liqPool.address, constants.MaxUint256.toBigInt()))) {
+        await approveERC20(token, liqPool.address, constants.MaxUint256.toBigInt());
+    }
+    // Execute the swap
+    await executeSwap(liqPool, swapParams, hookData);
+}
+
+// Main function to execute the swap and display results
+export async function main(): Promise<void> {
+    const provider = new providers.JsonRpcProvider(RPC_URL);
+    const wallet = new Wallet(PRIVATE_KEY, provider);
+
+    const token0 = await getContract(wallet, "Token0");
+    const token1 = await getContract(wallet, "Token1");
+    const liqPool = await getContract(wallet, 'LiquidPool');
+
+    const token0Before = await getERC20Balance(token0, wallet.address);
+    const token1Before = await getERC20Balance(token1, wallet.address);
+    console.log("Token0 balance before swapping:", token0Before.toString());
+    console.log("Token1 balance before swapping:", token1Before.toString());
+
+
+    const swapAmount = utils.parseEther("1000").toBigInt();
+    // False will make price higher, True will make price lower
+    const zeroForOne = false;
+    const x = zeroForOne ? 0 : 1;
+    console.log(`swap ${utils.formatEther(swapAmount)} amount of token${1 - x} from token${x}`);
+
+    // used for LimitOrder.sol afterSwap
+    const hookData = utils.defaultAbiCoder.encode(["bytes32"], [SALT_LIMITORDER]);
+    await swap(wallet, swapAmount, zeroForOne, hookData);
+
+    const token0After: bigint = await getERC20Balance(token0, wallet.address);
+    const token1After: bigint = await getERC20Balance(token1, wallet.address);
+    const token0Diff = token0After - token0Before;
+    const token1Diff = token1After - token1Before;
+    console.log("Token0 change:", utils.formatEther(token0Diff));
+    console.log("Token1 change:", utils.formatEther(token1Diff));
+
+    if (token0Diff === BigInt(0) || token1Diff === BigInt(0)) {
+        console.log("No tokens were swapped. Maybe liquidity is insufficient.");
+        return;
+    } else {
+        const currentTick = await getCurrentTick(liqPool);
+        console.log(`Current Tick After Swap: ${currentTick}`);
+    }
+}
+
+// Run the main function
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/src/uniswap/2-limitorder/kill.ts

@@ -0,0 +1,70 @@
+import { Contract, providers, Wallet } from "ethers";
+import { CONTRACT_ADDRESSES, POOL_KEYS, PRIVATE_KEY, RPC_URL, PRICE_LIMIT } from "../../../config/uniswap.config";
+import { calculateTickFromPriceWithSpacing } from "../lib/liqCalculation";
+import { PoolKey } from "../lib/types";
+import { getERC20Balance } from "../lib/ERC20";
+import { getPoolPrice } from "../lib/pool";
+import { getContract } from "../lib/contract";
+
+async function killLimitOrderFrontend(sender: string, priceLimit: number, poolkey: PoolKey, wallet: Wallet) {
+    const liqPool = await getContract(wallet, "LiquidPool");
+    const limitHook = await getContract(wallet, "LimitOrder");
+
+    const priceCurrent = await getPoolPrice(liqPool);
+    const tickcurr = calculateTickFromPriceWithSpacing(priceCurrent, poolkey.tickSpacing)
+    const ticklow = calculateTickFromPriceWithSpacing(priceLimit, poolkey.tickSpacing)
+    const tickhigh = ticklow + poolkey.tickSpacing;
+    console.log(`tickcurr: ${tickcurr}, ticklower: ${ticklow}, tickhigh: ${tickhigh}`);
+
+    let zeroForOne: boolean;
+    if (tickcurr < ticklow) {
+        zeroForOne = true;
+    } else if (tickcurr > tickhigh) {
+        zeroForOne = false;
+    } else {
+        throw new Error("Price mismatch for limit order");
+    }
+    console.log("Killing limit order, zeroForOne:", zeroForOne);
+
+    let tx = await limitHook.kill(poolkey, ticklow, zeroForOne, wallet.address);
+    await tx.wait();
+
+    await limitHook.once("Kill", (owner, epoch, key, tickLower, zeroForOne, liquidity, event) => {
+        console.log("Kill event emitted:");
+        console.log(`Owner: ${owner}`);
+        console.log(`Epoch: ${epoch.toString()}`);
+        console.log(`Key: ${key}`);
+        console.log(`TickLower: ${tickLower.toString()}`);
+        console.log(`ZeroForOne: ${zeroForOne}`);
+        console.log(`Liquidity: ${liquidity.toString()}`);
+
+        // Handle event here
+    });
+}
+
+async function main(): Promise<void> {
+    const provider = new providers.JsonRpcProvider(RPC_URL);
+    const wallet = new Wallet(PRIVATE_KEY, provider);
+
+    const token0 = await getContract(wallet, "Token0");
+    const token1 = await getContract(wallet, "Token1");
+
+    const token0Before = (await getERC20Balance(token0, wallet.address)).valueOf();
+    const token1Before = (await getERC20Balance(token1, wallet.address)).valueOf();
+    console.log("Token0 balance before adding Limit order:", token0Before.toString());
+    console.log("Token1 balance before adding limit order:", token1Before.toString());
+
+    const price = PRICE_LIMIT;
+    const epo = await killLimitOrderFrontend(wallet.address, price, POOL_KEYS.limitOrderPoolKey, wallet)
+    console.log("epoch:", epo);
+
+    const token0After = (await getERC20Balance(token0, wallet.address)).valueOf();
+    const token1After = (await getERC20Balance(token1, wallet.address)).valueOf();
+    console.log("Token0 change:", token0After - token0Before);
+    console.log("Token1 change:", token1After - token1Before);
+}
+
+main().catch(error => {
+    console.error(error);
+    process.exit(1);
+});

package/src/uniswap/2-limitorder/place.ts

@@ -0,0 +1,93 @@
+import type { Contract, Wallet } from "ethers";
+import { CONTRACT_ADDRESSES, PRIVATE_KEY, RPC_URL, POOL_KEYS, SALT_LIMITORDER, PRICE_LIMIT } from "../../../config/uniswap.config";
+import { getCurrentTick, getPoolPrice } from "../lib/pool";
+import { getERC20Balance, isApproved, approveERC20 } from "../lib/ERC20";
+import { calculateTickFromPriceWithSpacing, calculatePriceFromTick, getSqrtPriceAtTick, liquidity0, liquidity1, amount0 } from "../lib/liqCalculation";
+import { PoolKey } from "../lib/types";
+import { ethers } from "hardhat";
+import { getContract } from "../lib/contract";
+
+async function placeLimitOrder(contract: Contract, poolKey: any, tickLower: number, zeroForOne: boolean, liquidity: BigInt): Promise<any> {
+    const tx = await contract.place(poolKey, tickLower, zeroForOne, liquidity);
+    await tx.wait();
+    console.log("Limit order set successfully:");
+
+    return new Promise((resolve, reject) => {
+        contract.once("Place", (owner, epoch, key, tickLower, zeroForOne, liquidity) => {
+            resolve({
+                owner,
+                epoch: epoch.toString(),
+                key,
+                tickLower: tickLower.toString(),
+                zeroForOne,
+                liquidity: liquidity.toString()
+            });
+        });
+    });
+}
+
+async function placeLimitOrderFrontend(token0: Contract, token1: Contract, amountIn: bigint, priceLimit: number, poolKey: PoolKey, wallet: Wallet): Promise<any> {
+    const ticklow = calculateTickFromPriceWithSpacing(priceLimit, poolKey.tickSpacing);
+    const tickhigh = ticklow + poolKey.tickSpacing;
+
+    const pricelow = calculatePriceFromTick(ticklow);
+    const priceupp = calculatePriceFromTick(tickhigh);
+
+    const sqrt_low = getSqrtPriceAtTick(ticklow);
+    const sqrt_upp = getSqrtPriceAtTick(tickhigh);
+
+    const liqPool = await getContract(wallet, "LiquidPool");
+    const currentTick = await getCurrentTick(liqPool);
+    const priceCurrent = await getPoolPrice(liqPool);
+
+    console.log(`Current pool price: ${priceCurrent}, price low: ${pricelow}, price upp: ${priceupp}`);
+    console.log(`Tick low: ${ticklow}, Tick high: ${tickhigh}, Current Tick: ${currentTick}`);
+
+    let liquidity: bigint;
+    let zeroForOne: boolean;
+    if (ticklow > currentTick) {
+        zeroForOne = true;
+        liquidity = liquidity0(amountIn, sqrt_low, sqrt_upp);
+        if (!(await isApproved(token0, wallet.address, CONTRACT_ADDRESSES.LimitOrder, amountIn))) {
+            await approveERC20(token0, CONTRACT_ADDRESSES.LimitOrder, amountIn);
+        }
+    } else if (tickhigh <= currentTick) {
+        zeroForOne = false;
+        liquidity = liquidity1(amountIn, sqrt_upp, sqrt_low);
+        if (!(await isApproved(token1, wallet.address, CONTRACT_ADDRESSES.LimitOrder, amountIn))) {
+            await approveERC20(token1, CONTRACT_ADDRESSES.LimitOrder, amountIn);
+        }
+    } else {
+        throw new Error("Price mismatch for limit order");
+    }
+
+    const hook = await getContract(wallet, "LimitOrder");
+    const epoch = await placeLimitOrder(hook, poolKey, ticklow, zeroForOne, liquidity);
+    return epoch;
+}
+
+async function main() {
+    const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+    const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+
+    const token0 = await getContract(wallet, "Token0");
+    const token1 = await getContract(wallet, "Token1");
+
+    const token0Before = (await getERC20Balance(token0, wallet.address)).valueOf();
+    const token1Before = (await getERC20Balance(token1, wallet.address)).valueOf();
+
+    const limitPrice = PRICE_LIMIT;
+    const amountIn = ethers.utils.parseEther("1000").toBigInt();
+    const epo = await placeLimitOrderFrontend(token0, token1, amountIn, limitPrice, POOL_KEYS.limitOrderPoolKey, wallet)
+    console.log("epoch:", epo);
+
+    const token0After = (await getERC20Balance(token0, wallet.address)).valueOf();
+    const token1After = (await getERC20Balance(token1, wallet.address)).valueOf();
+    console.log("Token0 change:", token0After - token0Before);
+    console.log("Token1 change:", token1After - token1Before);
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/src/uniswap/2-limitorder/withdraw.ts

@@ -0,0 +1,78 @@
+import { Contract, providers, Wallet } from "ethers";
+import { CONTRACT_ADDRESSES, PRIVATE_KEY, RPC_URL } from "../../../config/uniswap.config";
+import { getERC20Balance } from "../lib/ERC20";
+import { getContract } from "../lib/contract";
+
+async function withdrawLimitOrder(contract: Contract, epoch: number, to: string): Promise<{ owner: string; epoch: string; liquidity: string; }> {
+    try {
+        // Initiate the withdraw transaction
+        const tx = await contract.withdraw(epoch, to);
+        await tx.wait();
+        console.log("Withdraw executed successfully.");
+
+        // Return a promise that resolves when the "Kill" event is emitted
+        // 监听链上事件，如果事件成功则返回结果。
+        return new Promise((resolve, reject) => {
+            contract.once("Withdraw", (owner, eventEpoch, liquidity) => {
+                resolve({
+                    owner,
+                    epoch: eventEpoch.toString(),
+                    liquidity: liquidity.toString(),
+                });
+            });
+        });
+
+    } catch (error: any) {
+        handleContractError(error);
+        throw error;
+    }
+}
+
+function handleContractError(error: any): void {
+    if (error.code === 'CALL_EXCEPTION') {
+        console.error('Transaction failed with CALL_EXCEPTION');
+        switch (error.data) {
+            case '0x10074548':
+                console.error('Encountered custom error ZeroLiquidity()');
+                break;
+            case '0x6cb6fbf0':
+                console.error('Encountered custom error NotFilled()');
+                break;
+            default:
+                console.error('Unknown error data:', error.data);
+        }
+        console.log('Transaction Details:', error.transaction);
+    } else {
+        console.error('An unexpected error occurred:', error);
+    }
+}
+
+
+async function main() {
+    const provider = new providers.JsonRpcProvider(RPC_URL);
+    const wallet = new Wallet(PRIVATE_KEY, provider);
+
+    const token0 = await getContract(wallet, "Token0");
+    const token1 = await getContract(wallet, "Token1");
+    const LimitOrder = await getContract(wallet, "LimitOrder");
+
+    const token0Before = await getERC20Balance(token0, wallet.address);
+    const token1Before = await getERC20Balance(token1, wallet.address);
+    console.log("Token0 balance before adding Limit order:", token0Before.toString());
+    console.log("Token1 balance before adding limit order:", token1Before.toString());
+
+
+    const epoch = 1;
+    const epo = await withdrawLimitOrder(LimitOrder, epoch, wallet.address);
+    console.log("epoch:", epo);
+
+    const token0After = await getERC20Balance(token0, wallet.address);
+    const token1After = await getERC20Balance(token1, wallet.address);
+    console.log("Token0 change:", token0After - token0Before);
+    console.log("Token1 change:", token1After - token1Before);
+}
+
+main().catch(error => {
+    console.error(error);
+    process.exit(1);
+});