punkkit-sdk 1.0.0

package/src/uniswap/lib/pool.ts

@@ -0,0 +1,62 @@
+import { ethers } from "hardhat";
+import type { Contract } from "ethers";
+import { PoolKey, ModifyPositionParams } from "./types";
+
+export async function modifyPosition(contract: Contract, modifyPositionParams: ModifyPositionParams, hookData: string) {
+    // Add liquidity
+    const tx = await contract.addLiquidity(modifyPositionParams, hookData);
+    await tx.wait();
+}
+
+// Function to get Pool ID
+export function getPoolId(poolKey: PoolKey): string {
+    ;
+    return ethers.utils.keccak256(ethers.utils.solidityPack(
+        ["bytes"],
+        [ethers.utils.defaultAbiCoder.encode(
+            ["address", "address", "uint24", "int24", "address"],
+            [poolKey.currency0, poolKey.currency1, poolKey.fee, poolKey.tickSpacing, poolKey.hooks]
+        )]
+    ));
+}
+
+// Function to get Slot0 of the Pool
+async function getSlot0(contract: Contract) {
+    const slot0 = await contract.getSlot0();
+    // console.log(`Returned slot0: ${JSON.stringify(slot0)}`);
+    return slot0;
+}
+
+// Function to get Liquidity of the Pool
+export async function getLiquidity(contract: Contract, poolKey: PoolKey) {
+    const poolId = getPoolId(poolKey);
+    console.log(`PoolId: ${poolId}`);
+
+    const liquidity = await contract.getLiquidity(poolId);
+    console.log(`Returned liquidity: ${liquidity}`);
+    return liquidity;
+}
+
+export async function getPoolSqrtPrice(liqPool: Contract): Promise<bigint> {
+    const slot0 = await getSlot0(liqPool);
+    return slot0[0].toBigInt();
+}
+
+// Function to get Pool Price
+export async function getPoolPrice(liqPool: Contract): Promise<number> {
+    const slot0 = await getSlot0(liqPool);
+    const q96 = 2n ** 96n;
+    // slot0 type is @BigNumber
+    const sqrtPriceX96:bigint = slot0[0].toBigInt();
+
+    const priceX1e18 = (sqrtPriceX96 * sqrtPriceX96 * (10n ** 18n)) / (q96 * q96);
+    const result = Number(priceX1e18) / 10**18;
+    // console.log("price:", result.toString());
+    return result;
+}
+
+export async function getCurrentTick(liqPool: Contract): Promise<number> {
+    const slot0 = await getSlot0(liqPool);
+    const tick: number = slot0[1];
+    return tick;
+}

package/src/uniswap/lib/swap.ts

@@ -0,0 +1,8 @@
+import { Contract } from "ethers";
+import { SwapParams } from "./types";
+
+export async function executeSwap(contract: Contract, swapParams: SwapParams, hookData: string) {
+    let tx = await contract.executeSwap(swapParams, hookData);
+    await tx.wait();
+    console.log("Swap executed successfully");
+}

package/src/uniswap/lib/types.ts

@@ -0,0 +1,21 @@
+
+export interface PoolKey {
+    currency0: string;
+    currency1: string;
+    fee: number;
+    tickSpacing: number;
+    hooks: string;
+}
+
+export interface SwapParams {
+    zeroForOne: boolean;
+    amountSpecified: bigint;
+    sqrtPriceLimitX96: bigint;
+}
+
+export interface ModifyPositionParams {
+    tickLower: number; // 流动性生效最低价格
+    tickUpper: number; // 流动性生效最高价格
+    liquidityDelta: bigint;
+    salt?:string;
+}

package/src/uniswap/lib/utils.ts

@@ -0,0 +1,26 @@
+// JsonRpcProvider is runtime object
+import { JsonRpcProvider } from "@ethersproject/providers";
+import { ethers } from "hardhat"
+
+export async function isDeployed(provider: JsonRpcProvider, address: string) {
+    let code = await provider.getCode(address);
+    // console.log("code =", code);
+    return code !== "0x";
+}
+
+export function bigintToBytes32(value : bigint): string {
+    return ethers.utils.id(value.toString());   
+}
+
+// Function to encode the parameters
+export function abiEncode(types: string[], values: any[]): string {
+    const abiCoder = ethers.utils.defaultAbiCoder;
+    const encodedParams = abiCoder.encode(types, values);
+    return encodedParams;
+}
+
+export function bytecodeWithArgs(bytecode: string, types: string[], params: any[]): string {
+    const encodedParams = abiEncode(types, params);
+    const initCode = ethers.utils.hexConcat([bytecode, encodedParams]);
+    return initCode;
+}

package/src/uniswap/playgroud/abiencode.ts

@@ -0,0 +1,21 @@
+import { ethers } from "hardhat";
+import { ModifyPositionParams } from "../lib/types";
+
+// Example ModifyLiquidityParams
+const positionParams: ModifyPositionParams = {
+  tickLower: 84222,
+  tickUpper: 86129,
+  liquidityDelta: BigInt("1517882343751509868544"),
+  salt: ethers.utils.keccak256("0x00")
+};
+
+// Example hookData as a hex string
+const hookData = "0x10";
+
+// Get ABI encoding
+const encodedData = ethers.utils.defaultAbiCoder.encode(
+  ["tuple(int24,int24,int256,bytes32)", "bytes"],
+  [positionParams, hookData]
+);
+
+console.log("Encoded Data:", encodedData);

package/src/uniswap/playgroud/amount0.ts

@@ -0,0 +1,47 @@
+import { BigNumber } from 'ethers';
+import { amount0 } from '../lib/liqCalculation';
+
+// FullMath.mulDivRoundingUp: Multiplies two numbers and divides the result by a denominator, rounding up
+function mulDivRoundingUp(a: BigNumber, b: BigNumber, denominator: BigNumber): BigNumber {
+    const product = a.mul(b);
+    const remainder = product.mod(denominator);
+    const quotient = product.div(denominator);
+    return remainder.isZero() ? quotient : quotient.add(1);
+}
+
+// UnsafeMath.divRoundingUp: Divides two numbers, rounding up
+function divRoundingUp(a: BigNumber, b: BigNumber): BigNumber {
+    const remainder = a.mod(b);
+    const quotient = a.div(b);
+    return remainder.isZero() ? quotient : quotient.add(1);
+}
+
+// Example usage
+function calculateAmount0Delta(
+    numerator1: BigNumber,
+    numerator2: BigNumber,
+    sqrtPriceBX96: BigNumber,
+    sqrtPriceAX96: BigNumber
+): BigNumber {
+    // Equivalent to the Solidity code snippet
+    return divRoundingUp(mulDivRoundingUp(numerator1, numerator2, sqrtPriceBX96), sqrtPriceAX96);
+}
+
+// Define the FixedPoint96 resolution (2^96)
+const FixedPoint96_RESOLUTION = BigNumber.from(2).pow(96);
+
+// Example values for liquidity, sqrtPriceAX96, and sqrtPriceBX96
+// ref: test/libraries/SqrtPriceMath.t.sol, test_swapComputation_sqrtPTimessqrtQOverflows, line 337
+const liquidity = BigNumber.from("50015962439936049619261659728067971248"); // Example value
+const sqrtPriceAX96 = BigNumber.from("1025574284609383582644711336373707553698163132913"); // Example value
+const sqrtPriceBX96 = BigNumber.from("1025574284609383690408304870162715216695788925244"); // Example value
+
+// Calculate numerator1 and numerator2
+const numerator1 = liquidity.mul(FixedPoint96_RESOLUTION);  // This is equivalent to shifting left by the FixedPoint96 resolution
+const numerator2 = sqrtPriceBX96.sub(sqrtPriceAX96);
+
+const result = calculateAmount0Delta(numerator1, numerator2, sqrtPriceBX96, sqrtPriceAX96);
+console.log(result.toString());
+
+const result2 = amount0(liquidity.toBigInt(), sqrtPriceBX96.toBigInt(), sqrtPriceAX96.toBigInt());
+console.log(result2.toString());

package/src/uniswap/playgroud/errordecode.ts

@@ -0,0 +1,54 @@
+import { ethers } from "ethers";
+
+interface DecodedData {
+    functionSelector: string;
+    address: string;
+    fixedInteger: number;
+    offset: number;
+    errorFunctionSelector: string;
+    stringLength: number;
+    stringData: string;
+}
+
+function hexToString(hex: string): string {
+    // Remove the '0x' prefix if present
+    hex = hex.replace(/^0x/, '');
+
+    // Convert hex to bytes
+    const bytes = Buffer.from(hex, 'hex');
+
+    // Convert bytes to string using UTF-8 encoding
+    return bytes.toString('utf8');
+}
+
+function decodeData(encodedData: string): DecodedData {
+    const functionSelector = encodedData.slice(0, 10);
+    const address = `0x${encodedData.slice(34, 74)}`;
+    const fixedInteger = parseInt(encodedData.slice(74, 138), 16);
+    const offset = parseInt(encodedData.slice(138, 202), 16);
+    let errorFunctionSelector, stringLength, stringData; 
+    if (offset != 0 ) {
+        errorFunctionSelector = `0x${encodedData.slice(202, 210)}`;
+        const offset = parseInt(encodedData.slice(210, 274), 16);
+        stringLength = parseInt(encodedData.slice(274, 338), 16);
+        stringData = hexToString(`0x${encodedData.slice(338, 338 + stringLength * 2)}`);
+    }
+
+    return {
+        functionSelector,
+        address,
+        fixedInteger,
+        offset,
+        errorFunctionSelector,
+        stringLength,
+        stringData
+    };
+}
+
+// Test the function with the provided data
+const data1 = "0x319d54c3000000000000000000000000a1353ea8013d59ce815bf2fe7211e61e5519d0400000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000006408c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000c636f72726563742073616c74000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
+const data2 = "0x319d54c3000000000000000000000000a1353ea8013d59ce815bf2fe7211e61e5519d0400000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000006408c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000a77726f6e672073616c740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
+const data3 = "0x319d54c3000000000000000000000000867cd373c2567a10bc512f05771e55e73e67d0400000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000429c3b7ee00000000000000000000000000000000000000000000000000000000";
+const data4 = "0xb12c5f9c000000000000000000000000d9b3d09f662b3b5479a785ac6aba5dd17a132dc300000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000064e450d38c0000000000000000000000004132f0bebb312245fd4c33d1177a617a98691040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006db11235f6ec6a4c0100000000000000000000000000000000000000000000000000000000"
+
+console.log(decodeData(data4));

package/src/uniswap/playgroud/errorsigs.ts

@@ -0,0 +1,86 @@
+import { ethers } from "hardhat";
+
+// Define an array of error signatures
+// Error NotSelf(): 0x29c3b7ee
+// Error HookAddressNotValid(address): 0xe65af6a0
+// Error InvalidHookResponse(): 0x1e048e1d
+// Error Wrap__FailedHookCall(address,bytes): 0x319d54c3
+// Error ProtocolFeeCannotBeFetched(): 0x1ee49702
+// Error AlreadyUnlocked(): 0x5090d6c6
+// Error NotPoolManager(): 0xae18210a
+// Error CurrencyNotSettled: 0x5212cba1
+// Error PoolAlreadyInitialized(): 0x7983c051
+// Error PoolNotInitialized(): 0x486aa307
+// Error PriceLimitAlreadyExceeded(uint160,uint160): 0x7c9c6e8f
+// Error NonZeroNativeValue(): 0x19d245cf
+// Error ERC20InsufficientBalance(address,uint256,uint256): 0xe450d38c
+// Error ERC20InsufficientAllowance(address,uint256,uint256): 0xfb8f41b2
+// Error Wrap__NativeTransferFailed(address,bytes): 0x8549db59
+// Error Wrap__ERC20TransferFailed(address,bytes): 0xb12c5f9c
+// Error NotPoolManager(): 0xae18210a
+// Error NotFilled(): 0x6cb6fbf0
+// Error InvalidFunc(bytes4): 0x1f8f8d4b
+// Error ZeroLiquidity(): 0x10074548
+// Error InRange(): 0x23ac68e7
+// Error CrossedRange(): 0xb319920d
+const errorSignatures = [
+  // Hooks.sol
+  'NotSelf()',
+  'HookAddressNotValid(address)',
+  'InvalidHookResponse()',
+  'Wrap__FailedHookCall(address,bytes)',
+
+  'ProtocolFeeCannotBeFetched()',
+
+  // PoolManager.sol
+  'AlreadyUnlocked()',
+  'NotPoolManager()',
+  'CurrencyNotSettled()',
+  'PoolAlreadyInitialized()',
+  'PoolNotInitialized()',
+  'PriceLimitAlreadyExceeded(uint160,uint160)',
+  'NonZeroNativeValue()',
+
+  // ERC20.sol
+  'ERC20InsufficientBalance(address,uint256,uint256)',
+  'ERC20InsufficientAllowance(address,uint256,uint256)',
+
+  'Wrap__NativeTransferFailed(address,bytes)',
+  'Wrap__ERC20TransferFailed(address,bytes)',
+
+  // SafeCallBack.sol
+  'NotPoolManager()',
+
+  // LimitOrder.sol
+  'NotFilled()',
+  'InvalidFunc(bytes4)',
+  'ZeroLiquidity()',
+  'InRange()',
+  'CrossedRange()',
+];
+
+// FuncSig afterInitialize(address,PoolKey,uint160,int24,bytes): 0x105397c6
+// FuncSig lockAcquiredPlace((address,address,uint24,int24,address),int24,bool,int256,address,bytes32): 0x3f3e517d
+const funcSignatures = [
+    'afterInitialize(address,PoolKey,uint160,int24,bytes)',
+
+    // LimitOrder.sol    
+    'lockAcquiredPlace((address,address,uint24,int24,address),int24,bool,int256,address,bytes32)'
+]
+
+// Function to compute the function selector for an error signature
+const computeFunctionSelector = (signature: string): string => {
+  const hash = ethers.keccak256(ethers.toUtf8Bytes(signature));
+  return hash.slice(0, 10); // "0x" + 8 hex characters
+};
+
+// Iterate over the error signatures and compute their function selectors
+errorSignatures.forEach((signature) => {
+  const functionSelector = computeFunctionSelector(signature);
+  console.log(`Error ${signature}: ${functionSelector}`);
+});
+
+funcSignatures.forEach((signature) => {
+  const functionSelector = computeFunctionSelector(signature);
+  console.log(`FuncSig ${signature}: ${functionSelector}`);
+});

package/src/voucher.ts

@@ -0,0 +1,122 @@
+import {
+	BigNumber,
+	BigNumberish,
+	Contract,
+	ContractTransaction,
+	Signer,
+	providers,
+	utils,
+} from "ethers";
+
+import { MUTI_VOUCHER_ABI,MUTI_VOUCHER_ADDR } from "../config/voucher.config";
+
+
+export const mutiVoucherABI = MUTI_VOUCHER_ABI.abi;
+
+export type SignerOrProvider = Signer | providers.Provider;
+
+export function getVoucherContract(
+	contractAddress: string,
+	signerOrProvider: SignerOrProvider
+): Contract {
+	return new Contract(contractAddress, mutiVoucherABI, signerOrProvider);
+}
+
+export async function createVoucher(
+	contractAddress: string,
+	signer: Signer,
+	name: string,
+	conversionRate: BigNumberish
+): Promise<ContractTransaction> {
+	const contract = getVoucherContract(contractAddress, signer);
+	return contract.createVoucher(name, conversionRate);
+}
+
+export async function getVoucherInfo(
+	contractAddress: string,
+	provider: SignerOrProvider,
+	name: string
+): Promise<BigNumber> {
+	const contract = getVoucherContract(contractAddress, provider);
+	return contract.getVoucherInfo(name);
+}
+
+export async function buyVoucher(
+	contractAddress: string,
+	signer: Signer,
+	name: string,
+	valueWei: BigNumberish
+): Promise<ContractTransaction> {
+	const contract = getVoucherContract(contractAddress, signer);
+	return contract.buy(name, { value: valueWei });
+}
+
+export async function buyVoucherWithEth(
+	contractAddress: string,
+	signer: Signer,
+	name: string,
+	valueEth: string
+): Promise<ContractTransaction> {
+	const valueWei = utils.parseEther(valueEth);
+	return buyVoucher(contractAddress, signer, name, valueWei);
+}
+
+// UseVoucher不是直接调用的
+export async function useVoucher(
+	contractAddress: string,
+	signer: Signer,
+	name: string,
+	amount: BigNumberish
+): Promise<ContractTransaction> {
+	const contract = getVoucherContract(contractAddress, signer);
+	return contract.use(name, amount);
+}
+
+export async function balanceOf(
+	contractAddress: string,
+	provider: SignerOrProvider,
+	name: string,
+	user: string
+): Promise<BigNumber> {
+	const contract = getVoucherContract(contractAddress, provider);
+	return contract.balanceOf(name, user);
+}
+
+export async function getAllVouchers(
+	contractAddress: string,
+	provider: SignerOrProvider
+): Promise<string[]> {
+	const contract = getVoucherContract(contractAddress, provider);
+	return contract.getAllVouchers();
+}
+
+// 仅仅能够在punk链上使用
+function buildUseVoucherPrefix(voucherNameBytes32: string): string {
+	const nameHex = utils.hexlify(voucherNameBytes32).replace(
+		/^0x/,
+		""
+	);
+    
+	if (nameHex.length > 64) {
+		throw new Error("Voucher name too long for 32 bytes");
+	}
+	const paddedName = nameHex.padEnd(64, "0");
+    console.log(paddedName)
+	return `0x0A0D03${paddedName}`;
+}
+
+// 仅仅能够在punk链上使用
+export function BuildUseVoucherTx(
+	tx: providers.TransactionRequest,
+	voucherName: string
+): providers.TransactionRequest {
+	const prefix = buildUseVoucherPrefix(voucherName);
+	const rawData = tx.data ?? "0x";
+	const dataHex = utils.hexlify(rawData);
+	const mergedData = utils.hexConcat([prefix, dataHex]);
+
+	return {
+		...tx,
+		data: mergedData,
+	};
+}