punkkit-sdk 1.0.0

package/contracts/uniswap/LiquidPool.sol

@@ -0,0 +1,179 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {IPoolManager} from '@uniswap/v4-core/src/interfaces/IPoolManager.sol';
+import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";
+import {BalanceDelta} from '@uniswap/v4-core/src/PoolManager.sol';
+import {IUnlockCallback} from '@uniswap/v4-core/src/interfaces/callback/IUnlockCallback.sol';
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {CurrencyDelta, Currency} from '@uniswap/v4-core/src/libraries/CurrencyDelta.sol';
+import {TickMath} from '@uniswap/v4-core/src/libraries/TickMath.sol';
+import {ModifyLiquidityParams, SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
+
+
+contract LiquidPool is IUnlockCallback {
+    using SafeERC20 for IERC20;
+    using CurrencyDelta for Currency;
+    using StateLibrary for IPoolManager;
+    using PoolIdLibrary for PoolKey;
+
+    bytes4 constant FUNCSIG_LIQUIDITY = 0x00000001;
+    bytes4 constant FUNCSIG_SWAP = 0x00000002;
+    bytes4 constant FUNCSIG_DONATE = 0x00000003;
+
+    struct LiquidityParams {
+        int24 tickLower;
+        int24 tickUpper;
+        int256 liquidityDelta;
+    }
+
+    IPoolManager public immutable poolManager;
+    PoolKey key;
+
+    mapping(address => BalanceDelta) rewards;
+
+    error InvalidFuncSig();
+
+    constructor(IPoolManager _poolManager, PoolKey memory _key) {
+        poolManager = _poolManager;
+        key = _key;
+    }
+
+    function getSlot0()
+        public
+        view
+        returns (uint160 sqrtPriceX96, int24 tick, uint24 protocolFee, uint24 lpFee)
+    {
+        return poolManager.getSlot0(key.toId());
+    }
+
+    function addLiquidity(
+        LiquidityParams calldata params, 
+        bytes calldata hookData
+    ) external {
+        ModifyLiquidityParams memory positionParams = ModifyLiquidityParams({
+            tickLower: params.tickLower,
+            tickUpper: params.tickUpper,
+            liquidityDelta: params.liquidityDelta,
+            salt: bytes32(uint256(uint160(msg.sender)))
+        });
+
+        _unlock(FUNCSIG_LIQUIDITY, abi.encode(positionParams, hookData));
+        /*
+        poolManager.unlock(
+            abi.encodeCall(this.addLiquidity, (positionParams, hookData))
+        );*/
+    }
+
+    function executeSwap(
+        SwapParams memory params, 
+        bytes calldata hookData
+    ) external {
+        _unlock(FUNCSIG_SWAP, abi.encode(params, hookData));
+        /*
+        poolManager.unlock(
+            abi.encodeCall(this.executeSwap, (params, hookData))
+        );*/
+    }
+
+    function donate(
+        uint256 amount0,
+        uint256 amount1,
+        bytes calldata hookData
+    ) external {
+        _unlock(FUNCSIG_DONATE, abi.encode(amount0, amount1, hookData));
+        /*
+        poolManager.unlock(
+            abi.encodeCall(this.donate, (amount0, amount1, hookData))
+        );*/
+    }
+
+    function _unlock(
+        bytes4 funcSig, 
+        bytes memory args
+    ) private {
+        poolManager.unlock(abi.encode(funcSig, msg.sender, args));
+    }
+
+    function unlockCallback(bytes calldata data) external override returns (bytes memory) {
+        (bytes4 funcSig, address recipient, bytes memory args) = abi.decode(data, (bytes4, address, bytes));
+
+        if (funcSig == FUNCSIG_LIQUIDITY) {
+            _handleLiquidity(args, recipient);
+        } else if (funcSig == FUNCSIG_SWAP) {
+            _handleSwap(args, recipient);
+        } else if (funcSig == FUNCSIG_DONATE) {
+            _handleDonate(args, recipient);
+        } else{
+            revert InvalidFuncSig();
+        }
+
+        return bytes("");
+    }
+
+    function _handleLiquidity(bytes memory args, address recipient) private {
+        (ModifyLiquidityParams memory positionParams, bytes memory hookData) = 
+            abi.decode(args, (ModifyLiquidityParams, bytes));
+
+        (BalanceDelta delta, BalanceDelta fees) = poolManager.modifyLiquidity(key, positionParams, hookData);
+        
+        rewards[recipient] = rewards[recipient] + fees;
+
+        _settleCurrencyBalance(key.currency0, recipient, delta.amount0());
+        _settleCurrencyBalance(key.currency1, recipient, delta.amount1());
+    }
+    
+    function _handleSwap(bytes memory args, address recipient) private {
+        (SwapParams memory swapParams, bytes memory hookData) = abi.decode(args, (SwapParams, bytes));
+        
+        BalanceDelta delta = poolManager.swap(key, swapParams, hookData);
+        
+        _settleCurrencyBalance(key.currency0, recipient, delta.amount0());
+        _settleCurrencyBalance(key.currency1, recipient, delta.amount1());
+    }
+
+    function _handleDonate(bytes memory args, address recipient) private {
+        (uint256 address0, uint256 address1, bytes memory hookData) = abi.decode(args, (uint256, uint256, bytes));
+        
+        BalanceDelta delta = poolManager.donate(key, address0, address1, hookData);
+        
+        _settleCurrencyBalance(key.currency0, recipient, delta.amount0());
+        _settleCurrencyBalance(key.currency1, recipient, delta.amount1());
+    }
+
+    // [Mark] ref: https://learnblockchain.cn/article/6984
+    /*
+    * 根据 poolManager 返回的余额变动 deltaAmount，把资金在池（poolManager）和调用者/接收者（recipient）之间结算清算
+    */
+    function _settleCurrencyBalance(
+        Currency currency,
+        address recipient,
+        int128 deltaAmount
+    ) private {
+        if (deltaAmount > 0) {
+            // send deltaAmount of token to recipient
+            poolManager.take(currency, recipient, uint128(deltaAmount));
+        } else if (deltaAmount < 0) {
+            uint128 amount = uint128(-deltaAmount);
+            // isAdressZero() checks if the currency is the native Ethereum token (ETH)
+            if (currency.isAddressZero()) {
+                // ETH don't need call ERC20 interface to transfer.
+                currency.transfer(address(poolManager), amount);
+                // todo: is {value: uint128(deltaAmount)} correct? 
+                poolManager.settle{value: uint128(deltaAmount)}();
+            } else {
+                IERC20(Currency.unwrap(currency)).safeTransferFrom(
+                    recipient,
+                    address(this),
+                    amount
+                );
+                poolManager.sync(currency);
+                currency.transfer(address(poolManager), amount);
+                poolManager.settle();
+            }
+        }
+    }
+}

package/contracts/uniswap/MockERC20.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract MockERC20 is ERC20 {
+    constructor(
+        string memory name_,
+        string memory symbol_,
+        uint256 initialSupply
+    ) ERC20(name_, symbol_) {
+        _mint(msg.sender, initialSupply);
+    }
+
+    function mint(address to , uint256 amount) external {
+        _mint(to, amount);
+    }
+
+    
+}

package/hardhat.config.ts

@@ -0,0 +1,35 @@
+import type { HardhatUserConfig } from "hardhat/config";
+import "@nomiclabs/hardhat-ethers" // ethers v5, conflict with  
+import "@nomicfoundation/hardhat-chai-matchers"; // Test chai matchers
+import * as dotenv from "dotenv";
+
+// 加载环境变量
+dotenv.config();
+
+const config: HardhatUserConfig = {
+  networks: {
+    punk: {
+      url: process.env.RPC_URL || "http://127.0.0.1:8545",
+      accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [],
+    }
+  },
+  solidity: {
+    version: "0.8.26",
+    settings: {
+      evmVersion: "cancun",
+      optimizer: {
+        enabled: true,
+        runs: 200
+      },
+      viaIR: true
+    }
+  },
+  paths: {
+    sources: "./contracts",
+    tests: "./test",
+    cache: "./cache",
+    artifacts: "./artifacts"
+  },
+};
+
+export default config;

package/ignition/modules/LimitOrder.ts

@@ -0,0 +1,33 @@
+import { ethers } from "hardhat";
+import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
+import { CONTRACT_ADDRESSES, CONTRACTS } from "../../config/uniswap.config";
+
+function encoder(types: string[], values: any[]): string {
+    const abiCoder = ethers.AbiCoder.defaultAbiCoder();
+    const encodedParams = abiCoder.encode(types, values);
+    return encodedParams.slice(2);
+}
+
+// ref: https://hardhat.org/ignition/docs/guides/create2
+// use "@nomicfoundation/hardhat-ignition-ethers" in config
+// npx hardhat ignition deploy ignition/modules/LimitOrder.ts --strategy create2
+export default buildModule("LimitOrder", (m) => {
+    // Load the contract artifact
+    const contractArtifact = CONTRACTS["LimitOrder"];
+    const types = ["address"];
+    const params = [CONTRACT_ADDRESSES.PoolManager];
+    const artifact = {
+        _format: "hh-sol-artifact-1",
+        contractName: "LimitOrder",
+        sourceName: "contracts/LimitOrder.sol",
+        abi: contractArtifact.abi, // Populate with ABI array
+        bytecode: contractArtifact.bytecode.object,
+        deployedBytecode: contractArtifact.bytecode.object,
+        linkReferences: {},
+        deployedLinkReferences: {},
+    };
+
+    // Deploy the contract
+    const limitOrder = m.contract("LimitOrder", artifact, params);
+    return { limitOrder };
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "punkkit-sdk",
+  "version": "1.0.0",
+  "devDependencies": {
+    "@nomicfoundation/hardhat-chai-matchers": "1.0.2",
+    "@nomicfoundation/hardhat-network-helpers": "^1.1.2",
+    "@nomiclabs/hardhat-ethers": "^2.2.3",
+    "@openzeppelin/contracts": "5.4.0",
+    "@types/chai": "^4.2.0",
+    "@types/mocha": "^10.0.10",
+    "@uniswap/v4-core": "1.0.2",
+    "chai": "^4.2.0",
+    "ethers": "5.7.2",
+    "hardhat": "2.26.3",
+    "solmate": "^6.8.0",
+    "ts-node": "^10.9.2"
+  },
+  "dependencies": {
+    "dotenv": "^16.4.5",
+    "solc": "^0.8.25"
+  },
+  "description": "In [Uniswap V4 core](https://github.com/Uniswap/v4-core) repo:",
+  "main": "index.js",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "author": "",
+  "license": "ISC"
+}

package/scripts/auction/deploy.ts

@@ -0,0 +1,23 @@
+import{ ethers } from "hardhat";
+import { RPC_URL, PRIVATE_KEY} from "../../config/auction.config";
+import { deployCoinbase } from "./deployCoinbase";
+import { deployXAuction } from "./deployXAuction";
+import { deployYVault } from "./deployYVault";
+
+async function main(){
+    const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+    const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+
+
+    const coinbaseAddr = await deployCoinbase(wallet);
+    const yVaultAddr = await deployYVault(wallet, coinbaseAddr);
+    const xAuctionAddr = await deployXAuction(wallet, yVaultAddr);
+    console.log("Deployment Summary:");
+    console.log(`Coinbase Address: ${coinbaseAddr}`);
+    console.log(`ChainYVaultV2 Address: ${yVaultAddr}`);
+    console.log(`ChainXAuctionV2 Address: ${xAuctionAddr}`);
+};
+
+if (require.main === module) {
+    main();
+}

package/scripts/auction/deployCoinbase.ts

@@ -0,0 +1,21 @@
+import{ ethers } from "hardhat";
+import { RPC_URL, PRIVATE_KEY} from "../../config/auction.config";
+import { Wallet } from "ethers";
+
+export async function deployCoinbase(wallet:Wallet): Promise<string> {
+  const CoinBaseFactory=await ethers.getContractFactory("Coinbase", wallet);
+  const coinbase=await CoinBaseFactory.deploy();
+  await coinbase.deployed();
+  return coinbase.address;
+}
+
+async function main(){
+  const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+  const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+  const coinbaseAddr = await deployCoinbase(wallet);
+  console.log(`Coinbase deployed at: ${coinbaseAddr} by ${wallet.address}`);
+};
+
+if (require.main === module) {
+    main();
+}

package/scripts/auction/deployXAuction.ts

@@ -0,0 +1,23 @@
+import{ ethers } from "hardhat";
+import { RPC_URL, PRIVATE_KEY, AUCTION_ADDR} from "../../config/auction.config";
+import { Wallet } from "ethers";
+
+export async function deployXAuction(wallet:Wallet,chainYVaultV2Addr:string) : Promise<string> {
+  const ChainXAuctionFactory=await ethers.getContractFactory("ChainXAuctionV2", wallet);
+  const chainXAuction=await ChainXAuctionFactory.deploy(chainYVaultV2Addr);
+  await chainXAuction.deployed();
+
+  return chainXAuction.address;
+}
+
+
+async function main(){
+  const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+  const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+  const xAuctionAddr = await deployXAuction(wallet,AUCTION_ADDR.chainYVault);
+  console.log(`ChainXAuctionV2 deployed at: ${xAuctionAddr} by ${wallet.address}`);
+};
+
+if (require.main === module) {
+    main();
+}

package/scripts/auction/deployYVault.ts

@@ -0,0 +1,22 @@
+import{ ethers } from "hardhat";
+import { RPC_URL, PRIVATE_KEY, AUCTION_ADDR } from "../../config/auction.config";
+import { Wallet } from "ethers";
+
+export async function deployYVault(wallet: Wallet, coinbaseAddr: string) {
+    const ChainYVaultV2Factory = await ethers.getContractFactory("ChainYVaultV2", wallet);
+    const contract = await ChainYVaultV2Factory.deploy(coinbaseAddr);
+    await contract.deployed();
+    return contract.address;
+}
+
+
+async function main(){
+    const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+    const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+    const yVaultAddr = await deployYVault(wallet, AUCTION_ADDR.coinbase);
+    console.log("ChainYVaultV2 deployed to:", yVaultAddr);
+};
+
+if (require.main === module) {
+    main();
+}

package/scripts/deploy_voucher.ts

@@ -0,0 +1,20 @@
+import { ethers } from "hardhat";
+import { RPC_URL, PRIVATE_KEY } from "../config/env.config";
+
+// 事实上在punk链上不需要部署Voucher，其是创世块部署的.
+async function main() {
+    const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+    const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+    const walletAddress = await wallet.getAddress();
+
+    // Normal deploy
+    const MutiVoucherFactory = await ethers.getContractFactory("MutiVoucher", wallet);
+    const Voucher = await MutiVoucherFactory.deploy();
+    await Voucher.deployed();
+    console.log(`MutiVoucher contract is deployed at: ${Voucher.address} by account(${walletAddress})`);
+};
+
+main().catch(error => {
+    console.error(error);
+    process.exit(1);
+});

package/scripts/uniswap/deploy/deploy.ts

@@ -0,0 +1,65 @@
+import { ethers } from "hardhat";
+import type { Contract } from "ethers";
+import {  POOL_KEYS, RPC_URL, PRIVATE_KEY, CONTRACT_ADDRESSES, INITIAL_SUPPLY } from "../../../config/uniswap.config";
+import { isDeployed, bigintToBytes32, abiEncode } from "../../../src/uniswap/lib/utils";
+import { mintERC20 } from "../../../src/uniswap/lib/ERC20";
+import { create2Deploy, deployHookWithFlags } from "./help";
+import { deployMockERC20 } from "./deploy_mockERC20";
+import { deployDynamic, deployLimitOrder } from "./deploy_hooks";
+import { deployCreate2 } from "./deploy_create2";
+
+async function main() {
+    const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+    const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+    const walletAddress = await wallet.getAddress();
+
+    // 1. Deploy Create2 factory 
+    const create2Address = await deployCreate2(wallet);
+    if (!await isDeployed(provider, create2Address)) throw new Error("Factory is not deployed");
+    const factory = await ethers.getContractAt("Create2", create2Address, wallet);
+    // console.log("Factory address:", await factory.getAddress());
+
+    const salt: bigint = BigInt(0);
+    const initialSupply = INITIAL_SUPPLY;
+
+    // 1. Deploy ERC20 tokens
+    let token0Addr = await deployMockERC20("bitcoin", "btc", initialSupply);
+    let token1Addr = await deployMockERC20("ethereum", "eth", initialSupply);
+
+    // ensure token0Addr < token1Addr, for poolmanager poolkey check
+    if (token0Addr > token1Addr) {
+        const temp = token0Addr;
+        token0Addr = token1Addr;
+        token1Addr = temp;
+    }
+
+    // 2. Deploy poolManager.sol
+    const poolManagerAddr = await create2Deploy(factory, "PoolManager", ["address"], [walletAddress], salt);
+    // 3. Deploy DynamicFee Hook and limit order hook.
+    let dynamicAddress = await deployDynamic(wallet,create2Address, poolManagerAddr);
+    let limitOrderAddress = await deployLimitOrder(wallet,create2Address, poolManagerAddr);
+
+    // 4. Deploy liquidity
+    let key = POOL_KEYS.limitOrderPoolKey; // old poolkey, need to update.
+    key.currency0 = token0Addr;
+    key.currency1 = token1Addr;
+    key.hooks = limitOrderAddress;
+
+    const liquidityPoolAddr = await create2Deploy(factory, "LiquidPool", ["address", "(address,address,uint24,int24,address)"], [poolManagerAddr, Object.values(key)], salt);
+
+    // 5. Output deployed addresses
+    console.log("---- Deployed Addresses ----");
+    console.log("create2Factory = ", create2Address);
+    console.log("token0 = ", token0Addr);
+    console.log("token1 = ", token1Addr);
+    console.log("poolManager = ", poolManagerAddr);
+    console.log("liquidityPool = ", liquidityPoolAddr);
+    console.log("limitOrder Hook = ", limitOrderAddress);
+    console.log("dynamicFee Hook = ", dynamicAddress);
+    console.log("\nPlease update the CONTRACT_ADDRESSES in .env!\n");
+}
+
+main().catch(error => {
+    console.error(error);
+    process.exit(1);
+});

package/scripts/uniswap/deploy/deploy_create2.ts

@@ -0,0 +1,11 @@
+import { ethers } from "hardhat"; // Import ethers from 
+import type { Wallet } from "ethers";
+import { ContractFactory, Contract } from "ethers";
+
+export async function deployCreate2(wallet : Wallet): Promise<string> {  
+  const Create2Factory : ContractFactory = await ethers.getContractFactory("Create2", wallet);
+  const create2 : Contract = await Create2Factory.deploy();
+  await create2.deployed();
+  console.log("Factory deployed to:", create2.address);
+  return create2.address;
+}

package/scripts/uniswap/deploy/deploy_example.ts

@@ -0,0 +1,35 @@
+import{ethers} from "hardhat";
+import { RPC_URL, PRIVATE_KEY,CONTRACT_ADDRESSES } from "../../../config/uniswap.config";
+import { isDeployed } from "../../../src/uniswap/lib/utils";
+import { create2Deploy } from "./help";
+import { getContract } from "../../../src/uniswap/lib/contract";
+
+async function main(){
+    const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+    const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+    const walletAddress = await wallet.getAddress();
+    
+
+    // Normal deploy
+    const ExampleFactory = await ethers.getContractFactory("Example", wallet);
+    const example = await ExampleFactory.deploy(0);
+    await example.deployed();
+    console.log(`normally deployed at: ${example.address} by ${walletAddress}`);
+
+
+    // Create2 deploy
+    const factoryAddr = CONTRACT_ADDRESSES["Create2"]
+    if (!await isDeployed(provider, factoryAddr)) throw new Error("Factory is not deployed");
+    const create2Contract = await getContract(wallet,"Create2");
+    const salt: bigint = BigInt(111);
+    let exampleAddr = await create2Deploy(create2Contract, "Example", ["uint256"], [0], salt);
+    console.log(`create2 deployed at: ${exampleAddr} by ${walletAddress}`);
+};
+
+
+main()
+    .then(() => process.exit(0))
+    .catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });

package/scripts/uniswap/deploy/deploy_hooks.ts

@@ -0,0 +1,74 @@
+import { ethers } from "hardhat";
+import { deployHookWithFlags } from "./help";
+import { CONTRACT_ADDRESSES, RPC_URL, PRIVATE_KEY } from "../../../config/uniswap.config";
+import { Wallet } from "ethers";
+
+// Define the extended flags
+const ALL_HOOK_MASK = BigInt((1 << 14) - 1);
+const BEFORE_INITIALIZE_FLAG = BigInt(1 << 13);
+const AFTER_INITIALIZE_FLAG = BigInt(1 << 12);
+const BEFORE_ADD_LIQUIDITY_FLAG = BigInt(1 << 11);
+const AFTER_ADD_LIQUIDITY_FLAG = BigInt(1 << 10);
+const BEFORE_REMOVE_LIQUIDITY_FLAG = BigInt(1 << 9);
+const AFTER_REMOVE_LIQUIDITY_FLAG = BigInt(1 << 8);
+const BEFORE_SWAP_FLAG = BigInt(1 << 7);
+const AFTER_SWAP_FLAG = BigInt(1 << 6);
+const BEFORE_DONATE_FLAG = BigInt(1 << 5);
+const AFTER_DONATE_FLAG = BigInt(1 << 4);
+const BEFORE_SWAP_RETURNS_DELTA_FLAG = BigInt(1 << 3);
+const AFTER_SWAP_RETURNS_DELTA_FLAG = BigInt(1 << 2);
+const AFTER_ADD_LIQUIDITY_RETURNS_DELTA_FLAG = BigInt(1 << 1);
+const AFTER_REMOVE_LIQUIDITY_RETURNS_DELTA_FLAG = BigInt(1 << 0);
+
+// Deploy DynamicFee hooks to pool manager
+export async function deployDynamic(wallet:Wallet,Create2Addr: string, poolManagerAddr:string) : Promise<string>{
+    const factory=await ethers.getContractAt("Create2", Create2Addr,wallet);
+    const factoryAddr=factory.address;
+
+    const flagFee: bigint = AFTER_SWAP_FLAG | AFTER_INITIALIZE_FLAG;
+    const dynamicFeeHook = await deployHookWithFlags(
+        factory,
+        factoryAddr,
+        "DynamicFee",
+        ["address"],
+        [poolManagerAddr],
+        flagFee
+    );
+    return dynamicFeeHook;
+}
+
+export async function deployLimitOrder(wallet:Wallet, Create2Addr: string, poolManagerAddr:string) : Promise<string>{
+    const factory=await ethers.getContractAt("Create2", Create2Addr,wallet);
+    const factoryAddr=factory.address;
+
+    // Deploy LimitOrder Hook
+    const flagLimit: bigint = AFTER_INITIALIZE_FLAG | AFTER_SWAP_FLAG; // | AFTER_SWAP_RETURNS_DELTA_FLAG;
+    const limitOrderHook = await deployHookWithFlags(
+        factory,
+        factoryAddr,
+        "LimitOrder",
+        ["address"],
+        [poolManagerAddr],
+        flagLimit
+    );
+    return limitOrderHook;
+}
+
+async function deployDemo(){
+    const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+    const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+
+    const dynamicAddress=await deployDynamic(wallet,CONTRACT_ADDRESSES.Create2, CONTRACT_ADDRESSES.PoolManager);
+    const limitOrderAddress=await deployLimitOrder(wallet,CONTRACT_ADDRESSES.Create2, CONTRACT_ADDRESSES.PoolManager);
+
+    if (await provider.getCode(dynamicAddress) === "0x") {
+        console.error("DynamicFee hook deployment failed");
+    }
+    if (await provider.getCode(limitOrderAddress) === "0x") {
+        console.error("LimitOrder hook deployment failed");
+    }
+}
+
+if (require.main === module) {
+    deployDemo();
+}

package/scripts/uniswap/deploy/deploy_mockERC20.ts

@@ -0,0 +1,42 @@
+import { ethers } from "hardhat";
+
+import { CONTRACT_ADDRESSES, RPC_URL, PRIVATE_KEY } from "../../../config/uniswap.config";
+import { create2Deploy } from "./help";
+
+
+async function deployDemo() {
+    const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+    const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+    const walletAddress = await wallet.getAddress();
+
+    const name: string = "MockDaiToken";
+    const symbol: string = "MOCKDAI";
+    const initialSupply = BigInt(1);
+
+    console.log(`Deployer: ${walletAddress}, Deployer balance: ${ethers.utils.formatEther(await wallet.getBalance())} ETH`);
+    // 1. Contract factory deploy, normally deploy
+    // const MockERC20 = await ethers.getContractFactory("MockERC20", wallet);
+    // const mockERC20 = await MockERC20.deploy(name, symbol, initialSupply);
+    // await mockERC20.deployed();
+    // const tokenAddress = mockERC20.address;
+    // console.log("deploy to address:", tokenAddress);
+    // const deployerBalance = await mockERC20.balanceOf(wallet.address);
+    // console.log(`deployer ${symbol} balance: ${ethers.utils.formatUnits(deployerBalance, 18)}`);
+
+    // 2. Deploy with create2
+    deployMockERC20(name,symbol,initialSupply);
+}
+// Deploy MockERC20 contract using Create2
+export async function deployMockERC20(name:string,symbol:string,initialSupply:bigint) : Promise<string> {
+    const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+    const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+    const create2Contract=await ethers.getContractAt("Create2",CONTRACT_ADDRESSES.Create2, wallet);
+    let deployAddress=await create2Deploy(create2Contract,"MockERC20",["string","string","uint256"],[name,symbol,initialSupply],BigInt(123456789));
+    console.log(`MockERC20Custom deployed by Create2 to: ${deployAddress}`);
+    return deployAddress;
+}
+
+
+if (require.main === module) {
+    deployDemo();
+}