punkkit-sdk 1.0.0

package/src/uniswap/3-dynamicfee/dynamicfee.ts

@@ -0,0 +1,321 @@
+import { ethers } from "hardhat";
+import type { Contract } from "ethers";
+import { PoolKey, SwapParams, ModifyPositionParams } from "../lib/types";
+
+let provider = new ethers.providers.JsonRpcProvider('http://localhost:8545');
+let wallet = new ethers.Wallet("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", provider)
+
+
+
+function calculateTickFromPrice(price: number, tickSpacing = 60): number {
+    let unroundedTick = Math.floor(Math.log(price) / Math.log(1.0001));
+    return Math.round(unroundedTick / tickSpacing) * tickSpacing;
+}
+
+async function checkAllowance(contract: Contract, ownerAddress: string, spenderAddress: string) {
+    // Check the amount of tokens that an owner allowed to a spender
+    let allowance = await contract.allowance(ownerAddress, spenderAddress);
+    console.log(`Allowance: ${allowance.toString()}`);
+}
+
+async function isdepolyed(address: string) {
+    let code = await provider.getCode(address);
+    if (code !== "0x") {
+        console.log(`The contract ${address} has been deployed.`);
+    } else {
+        console.log(`The contract ${address} has not been deployed. `);
+    }
+}
+
+async function donate(contract: Contract, poolKey: PoolKey, amount0: bigint, amount1: bigint) {
+    // Donate
+    console.log("begin donate")
+    let to0params = {
+        tickLower: 840000, // lower price 0.5
+        tickUpper: 876600, // upper price 1.5
+        liquidityDelta: 0
+    }
+    let tx1 = await contract.setPositionParameters(poolKey, to0params);
+    await tx1.wait();
+    let swapParams = {
+        zeroForOne: false,
+        amountSpecified: 0,
+        sqrtPriceLimitX96: 0
+    }
+    let tx2 = await contract.setSwapParameters(poolKey, swapParams);
+    await tx2.wait();
+
+    let tx3 = await contract.setDonateParameters(poolKey, amount0, amount1);
+    await tx3.wait();
+
+    let tx4 = await contract.donate();
+    await tx4.wait();
+
+    console.log("donate successfully");
+}
+
+async function modifyPosition(contract: Contract, poolKey: PoolKey, modifyPositionParams: ModifyPositionParams) {
+    // Set position parameters
+    let tx = await contract.setPositionParameters(poolKey, modifyPositionParams);
+    await tx.wait();
+    console.log("Position parameters set successfully");
+    // Add liquidity
+    tx = await contract.addLiquidity();
+    await tx.wait();
+}
+//function kill(IPoolManager.PoolKey calldata key, int24 tickLower, bool zeroForOne, address to)
+async function killLimitOrder(contract: Contract, poolKey: PoolKey, tickLower: number, zeroForOne: boolean, to: string) {
+    let tx = await contract.kill(poolKey, tickLower, zeroForOne, to);
+    await tx.wait();
+    console.log("kill successfully");
+    //emit Kill(msg.sender, epoch, key, tickLower, zeroForOne, liquidity);
+    await contract.on("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 placeLimitOrder(contract: Contract, poolKey: PoolKey, tickLower: number, zeroForOne: boolean, liquidity: number) {
+    let tx = await contract.place(poolKey, tickLower, zeroForOne, liquidity);
+    await tx.wait();
+    console.log("limit order set successfully");
+
+    await contract.on("Place", (owner, epoch, key, tickLower, zeroForOne, liquidity, event) => {
+        console.log("Place 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 withdrawLimitOrder(contract: Contract, epoch: number, to: string) {
+    let tx = await contract.withdraw(epoch, to);
+    await tx.wait();
+    console.log("limit order withdraw successfully");
+    await contract.on("Withdraw", (owner, epoch, liquidity, event) => {
+        console.log("Withdraw event emitted:");
+        console.log("Owner: ", owner);
+        console.log("Epoch: ", epoch.toString());
+        console.log("Liquidity: ", liquidity.toString());
+    });
+}
+
+async function initialize(contract: Contract, key: PoolKey, sqrtPriceX96: bigint) {
+    let tick = await contract.initialize(key, sqrtPriceX96);
+    console.log(`Returned tick: ${JSON.stringify(tick)}`);
+}
+
+async function approveERC20(contract: Contract, toAddress: string, amount: bigint) {
+    let tx = await contract.approve(toAddress, amount);
+    let receipt = await tx.wait();
+    console.log(`Transaction hash: ${receipt.transactionHash}`);
+}
+
+function getPoolId(poolKey: PoolKey): string {
+    return ethers.utils.solidityKeccak256(
+        ["bytes"],
+        [ethers.utils.defaultAbiCoder.encode(
+            ["address", "address", "uint24", "int24", "address"],
+            [poolKey.currency0, poolKey.currency1, poolKey.fee, poolKey.tickSpacing, poolKey.hooks]
+        )]
+    );
+}
+
+async function getSlot0(contract: Contract, poolKey: PoolKey) {
+    let poolId = getPoolId(poolKey);
+    console.log(`PoolId: ${poolId}`);
+    let slot0 = await contract.getSlot0(poolId);
+    console.log(`Returned slot0: ${JSON.stringify(slot0)}`);
+}
+
+async function getLiquidity(contract: Contract, poolKey: PoolKey) {
+    let poolId = getPoolId(poolKey);
+    console.log(`PoolId: ${poolId}`);
+    //let liq0 = await contract.getLiquidity(poolId);
+    let liq0 = await contract.functions['getLiquidity(bytes32)'](poolId);
+
+    console.log(`Returned liquidity: ${liq0}`);
+}
+
+async function getERC20Balance(contract: Contract, address: string) {
+    // 查询ERC20余额
+    let balance = await contract.balanceOf(address);
+    console.log(`ERC20 Balance: ${balance.toString()}`);
+    return balance;
+}
+
+async function executeSwap(contract: Contract, poolKey: PoolKey, swapParams: SwapParams) {
+
+    // Set position parameters
+    console.log("begin swap")
+    let to0params = {
+        tickLower: 840000, // lower price 0.5
+        tickUpper: 876600, // upper price 1.5
+        liquidityDelta: 0
+    }
+    let tx1 = await contract.setPositionParameters(poolKey, to0params);
+    await tx1.wait();
+    let tx2 = await contract.setSwapParameters(poolKey, swapParams);
+    console.log("begin swap1")
+    await tx2.wait();
+    console.log("Position parameters set successfully");
+    // swap
+    let tx3 = await contract.executeSwap();
+    await tx3.wait();
+}
+
+async function depolyContract(contractName: string, params?: any): Promise<Contract> {
+    const Factory = await ethers.getContractFactory(contractName);
+    let contract;
+    if (params === undefined) {
+        contract = await Factory.deploy();
+    } else {
+        console.log(`params: ${JSON.stringify(params)}`);
+        contract = await Factory.deploy(params);
+        //depolyContract("depoly1");
+    }
+    await contract.deployed();
+    console.log(`${contractName} deployed to ${contract.address}`);
+    return contract;
+}
+
+async function delay(milliseconds: any) {
+    // 这个新的 Promise 将在指定的毫秒数后 resolve
+    return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+
+describe("PoolManager", function () {
+    it("Should return the new greeting once it's changed", async function () {
+        const token0 = await depolyContract("Token0");
+        const token1 = await depolyContract("Token1");
+        // await isdepolyed(token0.address);
+        // await isdepolyed(token1.address);
+        const totalSupply0 = await token0.totalSupply();
+        console.log(`Token0 deployed to ${token0.address} with an initial supply ${totalSupply0}`);
+        const totalSupply1 = await token1.totalSupply();
+        console.log(`Token1 deployed to ${token1.address} with an initial supply ${totalSupply1}`);
+        getERC20Balance(token0, wallet.address);
+        getERC20Balance(token1, wallet.address);
+        const token0Address = token0.address < token1.address ? token0.address : token1.address;
+        const token1Address = token0.address > token1.address ? token0.address : token1.address;
+        //await isdepolyed(token0Address);
+        //await isdepolyed(token1Address);
+
+        //depoly poolManager
+        const poolManager = await depolyContract("PoolManager", 88888888888);
+        // const Factory = await ethers.getContractFactory("PoolManager");
+        // const controllerGasLimit = 88888888888;
+        // const contractpm = await Factory.deploy(controllerGasLimit);
+        // await contractpm.deployed();
+        const poolManagerAddress = poolManager.address;
+        //console.log("PoolManager Contract deployed to:", poolManagerAddress);
+        await isdepolyed(poolManagerAddress);
+
+        //depoly hook
+        // 部署 LimitOrder 合约
+        const dynamicFee = await depolyContract("DynamicFee", poolManagerAddress);
+        console.log("LimitOrder Contract deployed to:", dynamicFee.address);
+        // await isdepolyed(limitOrder.address);
+
+        //initial poolManager
+        let sqrtPriceX96 = BigInt("792281625142643375935439503360")// price = 100 token1/token0
+        const DYNAMIC_FEE_FLAG = 0x800000;
+        let poolKey: PoolKey = {
+            currency0: token0Address,
+            currency1: token1Address,
+            fee: DYNAMIC_FEE_FLAG,
+            tickSpacing: 60,
+            hooks: dynamicFee.address,
+        };
+        //await getSlot0(poolManager, poolKey);
+        await initialize(poolManager, poolKey, sqrtPriceX96);
+        //await getSlot0(poolManager, poolKey);
+
+        //approve ERC20 token to limitOrder
+        //await approveERC20(token0,poolManager.address,ethers.utils.parseUnits("21000000", 18))
+        //await approveERC20(token1,poolManager.address,ethers.utils.parseUnits("21000000", 18))
+
+        const MyLiquidityProvider = await depolyContract("MyLiquidityProvider", poolManagerAddress);
+        //approve ERC20 token to MyLiquidityProvider
+        const wei = ethers.utils.parseUnits("21000000", 18).toBigInt();
+        await approveERC20(token0, MyLiquidityProvider.address, wei);
+        await approveERC20(token1, MyLiquidityProvider.address, wei);
+
+        //add liquidity
+        let modifyPositionParams: ModifyPositionParams = {
+            tickLower: 45000, // lower price 90
+            tickUpper: 46980, // upper price 110
+            //liquidityDelta: 194868329805051412324060
+            liquidityDelta: BigInt('10000000000000000000000')// 10000token0 10000token1
+        };
+
+        //console.log(`modifyPositionParams: ${JSON.stringify(modifyPositionParams)}`);
+        //console.log(`Poolkey: ${JSON.stringify(poolKey)}`);
+        await getERC20Balance(token0, wallet.address);
+        await getERC20Balance(token1, wallet.address);
+
+        await modifyPosition(MyLiquidityProvider, poolKey, modifyPositionParams);
+        console.log("Liquidity added successfully");
+
+        await getERC20Balance(token0, wallet.address);
+        await getERC20Balance(token1, wallet.address);
+        //swap
+        let sqrtpricelimit = ethers.BigNumber.from('7922816251426433759354395033600').toBigInt();
+        let amountswap = ethers.BigNumber.from('1083456789101112134000').toBigInt();
+        console.log("amountswap:", amountswap.toString())
+
+        let swapParams: SwapParams = {
+            zeroForOne: false,
+            amountSpecified: amountswap,
+            sqrtPriceLimitX96: sqrtpricelimit
+        }
+        //console.log("sprtprice to price",sqrtPricetoPrice(pricetoSqrtPrice(110)))
+
+        let token0beforswap = await getERC20Balance(token0, wallet.address);
+        let token1beforswap = await getERC20Balance(token1, wallet.address);
+
+        //await getSlot0(poolManager, poolKey);
+        await executeSwap(MyLiquidityProvider, poolKey, swapParams);
+        //await getSlot0(poolManager, poolKey);
+
+
+        console.log("swap successfully");
+        let token0afterswap = await getERC20Balance(token0, wallet.address);
+        let token1afterswap = await getERC20Balance(token1, wallet.address);
+
+        console.log("token0 change:", token0afterswap.sub(token0beforswap).toString())
+        console.log("token1 change:", token1afterswap.sub(token1beforswap).toString())
+        //price=token0 change/token1 change
+        console.log("price:", token1afterswap.sub(token1beforswap).toString() / token0afterswap.sub(token0beforswap).toString())
+
+        token0beforswap = await getERC20Balance(token0, wallet.address);
+        token1beforswap = await getERC20Balance(token1, wallet.address);
+
+        //await getSlot0(poolManager, poolKey);
+        await executeSwap(MyLiquidityProvider, poolKey, swapParams);
+        //await getSlot0(poolManager, poolKey);
+
+
+        console.log("swap successfully");
+        token0afterswap = await getERC20Balance(token0, wallet.address);
+        token1afterswap = await getERC20Balance(token1, wallet.address);
+
+        console.log("token0 change:", token0afterswap.sub(token0beforswap).toString())
+        console.log("token1 change:", token1afterswap.sub(token1beforswap).toString())
+        //price=token0 change/token1 change
+        console.log("price:", token1afterswap.sub(token1beforswap).toString() / token0afterswap.sub(token0beforswap).toString())
+
+    })
+});

package/src/uniswap/lib/ERC20.ts

@@ -0,0 +1,49 @@
+import { Contract } from "ethers";
+// Check if the spender is approved to spend at least 'amount' tokens from ownerAddress
+export async function isApproved(contract: Contract, ownerAddress: string, spenderAddress: string, amount: bigint) {
+    let allowance = await contract.allowance(ownerAddress, spenderAddress);
+    if (allowance >= amount) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
+export async function approveERC20(contract: Contract, spenderAddress: string, amount: bigint) {
+    let tx = await contract.approve(spenderAddress, amount);
+    await tx.wait();
+}
+
+export async function getAllowance(contract: Contract, ownerAddress: string, spenderAddress: string): Promise<bigint> {
+    const allowance = await contract.allowance(ownerAddress, spenderAddress);
+    return allowance;
+}
+
+export async function checkAndApproveERC20(contract: Contract, ownerAddress: string, spenderAddress: string, amount: bigint) {
+    const allowance = await getAllowance(contract, ownerAddress, spenderAddress);
+
+    if (allowance >= amount) {
+        return;
+    }
+
+    const tx = await contract.approve(spenderAddress, amount);
+    const receipt = await tx.wait();
+}
+
+export async function getERC20Balance(contract: Contract, address: string): Promise<bigint> {
+    const balance: bigint = BigInt(await contract.balanceOf(address));
+    // console.log(`ERC20 Balance: ${balance.toString()}`);
+    return balance;
+}
+
+export async function transferERC20(contract: Contract, toAddress: string, amount: bigint) {
+    const tx = await contract.transfer(toAddress, amount);
+    const receipt = await tx.wait();
+}
+
+
+export async function mintERC20(contract: Contract, toAddress: string, amount: bigint) {
+    const tx = await contract.mint(toAddress, amount);
+    await tx.wait();
+}

package/src/uniswap/lib/contract.ts

@@ -0,0 +1,18 @@
+import {Wallet , Contract} from "ethers";
+import { CONTRACT_ADDRESSES , CONTRACTS_ABI} from "../../../config/uniswap.config";
+import { ethers } from "hardhat";
+
+export async function getContract(wallet:Wallet, name:string): Promise<Contract> {
+    switch(name){
+        case "Token0":
+            return new ethers.Contract(CONTRACT_ADDRESSES.Token0,CONTRACTS_ABI.MockERC20,wallet);
+        case "Token1":
+            return new ethers.Contract(CONTRACT_ADDRESSES.Token1,CONTRACTS_ABI.MockERC20,wallet);
+        case "LiquidPool":
+            return new ethers.Contract(CONTRACT_ADDRESSES.LiquidPool,CONTRACTS_ABI.LiquidPool,wallet);
+        case "LimitOrder":
+            return new ethers.Contract(CONTRACT_ADDRESSES.LimitOrder,CONTRACTS_ABI.LimitOrder,wallet);
+        default:
+            throw new Error(`Contract(${name}) initial method not defined`);
+    }
+}

package/src/uniswap/lib/limitOrder.ts

@@ -0,0 +1,40 @@
+import { Contract, providers, Wallet } from "ethers";
+import { PoolKey } from "./types";
+import { getPoolId } from "./pool";
+import { RPC_URL, PRIVATE_KEY, POOL_KEYS } from "../../../config/uniswap.config";
+import {ethers} from "hardhat";
+import { getContract } from "./contract";
+
+export async function getTickLowerLast(contract:Contract, poolKey: PoolKey): Promise<bigint> {
+    const poolId = getPoolId(poolKey);
+    return contract.getTickLowerLast(poolId);
+}
+
+// epoach is uint232 in solidity
+export async function getEpoch(contract:Contract, poolKey: PoolKey, tickLower: bigint, zeroForOne: boolean): Promise<bigint> {
+    const poolId = getPoolId(poolKey);
+    return contract.getEpoch(poolId, tickLower, zeroForOne);
+}
+
+// uint256
+export async function getEpochLiquidity(contract:Contract, epoch: bigint, ownerAddress:string): Promise<bigint> {
+    return contract.getEpochLiquidity(epoch, ownerAddress);
+}
+
+export async function getTick(contract:Contract, poolKey: PoolKey): Promise<bigint> {
+    const poolId = getPoolId(poolKey);
+    return contract.getTick(poolId);
+}
+
+async function test(){
+    const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+    const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+    let contract= await getContract(wallet,"LiquidPool");
+
+    let zeroForOne=true;
+    let tickLower=BigInt(-60);
+    let epoch=getEpoch(contract, POOL_KEYS.limitOrderPoolKey,tickLower,zeroForOne);
+
+}
+
+test();

package/src/uniswap/lib/liqCalculation.ts

@@ -0,0 +1,152 @@
+// Constants
+const MAX_TICK = BigInt('887272');
+const q32 = BigInt(2) ** BigInt(32);
+const q96 = BigInt(2) ** BigInt(96);
+const q128 = BigInt(2) ** BigInt(128);
+const q256 = BigInt(2) ** BigInt(256);
+
+// Function to calculate tick from price with optional spacing
+export function calculateTickFromPriceWithSpacing(price: number, tickSpacing = 60): number {
+    const unroundedTick = calculateTickFromPrice(price);
+    return Math.floor(unroundedTick / tickSpacing) * tickSpacing;
+}
+
+// Function to calculate tick from price without spacing
+export function calculateTickFromPrice(price: number): number {
+    return Math.floor(Math.log(price) / Math.log(1.0001));
+}
+
+function getAbsTick(tick: bigint): bigint {
+    // Ensure tick is within the int24 range
+    const int24Max: bigint = BigInt(2) ** BigInt(23) - BigInt(1);
+    const int24Min: bigint = BigInt(-2) ** BigInt(23);
+    if (tick > int24Max || tick < int24Min) {
+        throw new Error('tick is out of int24 range');
+    }
+
+    // Determine the mask: 0 if tick >= 0, -1 if tick < 0
+    const mask: bigint = tick < BigInt(0) ? BigInt(-1) : BigInt(0);
+
+    // Calculate absTick
+    const absTick: bigint = (mask ^ (tick + mask));
+
+    return absTick;
+}
+
+export function getSqrtPriceAtTick(tick: number): bigint {
+    const absTick: bigint = getAbsTick(BigInt(tick));
+
+    if (absTick > MAX_TICK) {
+        throw new Error("Invalid tick");
+    }
+
+    let price = (absTick & BigInt(1)) === BigInt(0)
+        ? q128
+        : BigInt("0xfffcb933bd6fad37aa2d162d1a594001");
+
+    if (absTick & BigInt(2)) price = (price * BigInt("0xfff97272373d413259a46990580e213a")) >> BigInt(128);
+    if (absTick & BigInt(4)) price = (price * BigInt("0xfff2e50f5f656932ef12357cf3c7fdcc")) >> BigInt(128);
+    if (absTick & BigInt(8)) price = (price * BigInt("0xffe5caca7e10e4e61c3624eaa0941cd0")) >> BigInt(128);
+    if (absTick & BigInt(16)) price = (price * BigInt("0xffcb9843d60f6159c9db58835c926644")) >> BigInt(128);
+    if (absTick & BigInt(32)) price = (price * BigInt("0xff973b41fa98c081472e6896dfb254c0")) >> BigInt(128);
+    if (absTick & BigInt(64)) price = (price * BigInt("0xff2ea16466c96a3843ec78b326b52861")) >> BigInt(128);
+    if (absTick & BigInt(128)) price = (price * BigInt("0xfe5dee046a99a2a811c461f1969c3053")) >> BigInt(128);
+    if (absTick & BigInt(256)) price = (price * BigInt("0xfcbe86c7900a88aedcffc83b479aa3a4")) >> BigInt(128);
+    if (absTick & BigInt(512)) price = (price * BigInt("0xf987a7253ac413176f2b074cf7815e54")) >> BigInt(128);
+    if (absTick & BigInt(1024)) price = (price * BigInt("0xf3392b0822b70005940c7a398e4b70f3")) >> BigInt(128);
+    if (absTick & BigInt(2048)) price = (price * BigInt("0xe7159475a2c29b7443b29c7fa6e889d9")) >> BigInt(128);
+    if (absTick & BigInt(4096)) price = (price * BigInt("0xd097f3bdfd2022b8845ad8f792aa5825")) >> BigInt(128);
+    if (absTick & BigInt(8192)) price = (price * BigInt("0xa9f746462d870fdf8a65dc1f90e061e5")) >> BigInt(128);
+    if (absTick & BigInt(16384)) price = (price * BigInt("0x70d869a156d2a1b890bb3df62baf32f7")) >> BigInt(128);
+    if (absTick & BigInt(32768)) price = (price * BigInt("0x31be135f97d08fd981231505542fcfa6")) >> BigInt(128);
+    if (absTick & BigInt(65536)) price = (price * BigInt("0x9aa508b5b7a84e1c677de54f3e99bc9")) >> BigInt(128);
+    if (absTick & BigInt(131072)) price = (price * BigInt("0x5d6af8dedb81196699c329225ee604")) >> BigInt(128);
+    if (absTick & BigInt(262144)) price = (price * BigInt("0x2216e584f5fa1ea926041bedfe98")) >> BigInt(128);
+    if (absTick & BigInt(524288)) price = (price * BigInt("0x48a170391f7dc42444e8fa2")) >> BigInt(128);
+
+    if (tick > 0) {
+        price = (q256 - BigInt(1)) / price;
+    }
+
+    return (price + q32 - BigInt(1)) >> BigInt(32); // Convert from Q128.128 to Q128.96 and round up
+}
+
+// Function to calculate price from tick
+export function calculatePriceFromTick(tick: number): number {
+    return Math.exp(tick * Math.log(1.0001));
+}
+
+// Function to convert price to sqrtPriceX96
+export function priceToSqrtPrice(price: number): bigint {
+    return BigInt(Math.floor(Math.sqrt(price) * Number(q96)));
+}
+
+// Function to convert sqrtPriceX96 to price
+function sqrtPricetoPrice(sqrtprice: bigint): number {
+    return (Number(sqrtprice) ** 2) / Number(q96 ** BigInt(2));
+}
+
+// Liquidity calculations for amount0 and amount1
+export function liquidity0(amount: bigint, pa: bigint, pb: bigint): bigint {
+    if (pa > pb) {
+        [pa, pb] = [pb, pa];
+    }
+
+    return (amount * pa * pb) / (q96 * (pb - pa));
+}
+
+export function liquidity1(amount: bigint, pa: bigint, pb: bigint): bigint {
+    if (pa > pb) {
+        [pa, pb] = [pb, pa];
+    }
+    return (amount * q96) / (pb - pa);
+}
+
+function divRoundingUp(a: bigint, b: bigint): bigint {
+    const remainder = a % b;
+    const quotient = a / b;
+    return remainder === BigInt(0) ? quotient : quotient + BigInt(1);
+}
+
+// Amount calculations for liquidity0 and liquidity1
+export function amount0(liquidity0: bigint, pa: bigint, pb: bigint): bigint {
+    if (pa > pb) {
+        [pa, pb] = [pb, pa];
+    }
+    const diff = pb - pa;
+    return divRoundingUp((liquidity0 * q96 * diff), pa * pb);
+}
+
+export function amount1(liquidity1: bigint, pa: bigint, pb: bigint): bigint {
+    if (pa > pb) {
+        [pa, pb] = [pb, pa];
+    }
+    const diff = pb - pa;
+    return divRoundingUp(liquidity1 * diff, q96);
+}
+
+// Simplified version to calculate liquidity delta
+/// @liquidity delta, @amount0 used, @amount1 used
+export function calculateLiqDelta(ticklow: number, sqrt_cur: bigint, tickupp: number, amt0: bigint, amt1: bigint): [bigint, bigint, bigint] {
+    const sqrt_low = getSqrtPriceAtTick(ticklow);
+    const sqrt_upp = getSqrtPriceAtTick(tickupp);
+    // console.log(`sqrt_low: ${sqrt_low}, sqrt_upp: ${sqrt_upp}, sqrt_cur: ${sqrt_cur}`);
+
+ 
+    if (sqrt_low > sqrt_cur) {
+        // 当前价格比最低价格还要小，流动性按照token0数量计算
+        const liq0 = liquidity0(amt0, sqrt_low, sqrt_upp);
+        return [liq0, amount0(liq0, sqrt_low, sqrt_upp), BigInt(0)];
+    } else if (sqrt_cur > sqrt_upp) {
+        // 当前价格比最高价格还要高，流动性按照token1数量计算
+        const liq1 = liquidity1(amt1, sqrt_upp, sqrt_low);
+        return [liq1, BigInt(0), amount1(liq1, sqrt_low, sqrt_upp)];
+    } else {
+        // 按照流动性最高的来计算
+        const liq0 = liquidity0(amt0, sqrt_cur, sqrt_upp);
+        const liq1 = liquidity1(amt1, sqrt_cur, sqrt_low);
+
+        const liq = liq0 < liq1 ? liq1 : liq0;
+        return [liq, amount0(liq, sqrt_cur, sqrt_upp), amount1(liq, sqrt_low, sqrt_cur)];
+    }
+}

package/src/uniswap/lib/listen.ts

@@ -0,0 +1,57 @@
+import { Contract } from "ethers";
+
+export async function listenAllEvents(hook: Contract): Promise<void> {
+    hook.on('*', (event) => {
+        console.log(`${event.event} event emitted:`);
+        for (const key in event.args) {
+            if (event.args.hasOwnProperty(key)) {
+                console.log(`${key}: ${event.args[key].toString()}`);
+            }
+        }
+    });
+}
+
+export async function listenPlaceEvent(contract: Contract): Promise<void> {
+    contract.once("Place", (owner, epoch, key, tickLower, zeroForOne, liquidity) => {
+        console.log("Place 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());
+    });
+}
+
+export async function listenKillEvent(contract: Contract): Promise<void> {
+    contract.once("Kill", (owner, epoch, key, tickLower, zeroForOne, liquidity) => {
+        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());
+    });
+}
+
+export async function listenWithdrawEvent(contract: Contract): Promise<void> {
+    contract.once("Withdraw", (owner, epoch, liquidity) => {
+        console.log("Withdraw event emitted:");
+        console.log("Owner: ", owner);
+        console.log("Epoch: ", epoch.toString());
+        console.log("Liquidity: ", liquidity.toString());
+    });
+}
+
+export async function listenFillEvent(contract: Contract): Promise<void> {
+    contract.once("Fill", (owner, epoch, key, tickLower, zeroForOne, liquidity) => {
+        console.log("Fill 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());
+    });
+}