@alephium/powfi-sdk 0.0.1-rc.1

package/clmm/artifacts/ts/Pool.ts

@@ -0,0 +1,2535 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import {
+  Address,
+  Contract,
+  ContractState,
+  TestContractResult,
+  HexString,
+  ContractFactory,
+  EventSubscribeOptions,
+  EventSubscription,
+  CallContractParams,
+  CallContractResult,
+  TestContractParams,
+  ContractEvent,
+  subscribeContractEvent,
+  subscribeContractEvents,
+  testMethod,
+  callMethod,
+  multicallMethods,
+  fetchContractState,
+  Asset,
+  ContractInstance,
+  getContractEventsCurrentCount,
+  TestContractParamsWithoutMaps,
+  TestContractResultWithoutMaps,
+  SignExecuteContractMethodParams,
+  SignExecuteScriptTxResult,
+  signExecuteMethod,
+  addStdIdToFields,
+  encodeContractFields,
+  Narrow,
+} from "@alephium/web3";
+import { default as PoolContractJson } from "../Pool.ral.json";
+import { getContractByCodeHash, registerContract } from "./contracts";
+import * as types from "./types";
+
+// Custom types for the contract
+export namespace PoolTypes {
+  export type Fields = {
+    parent: HexString;
+    positionTemplate: HexString;
+    dexAccountTemplate: HexString;
+    tickTemplate: HexString;
+    wordTemplate: HexString;
+    configIndex: bigint;
+    token0: HexString;
+    token1: HexString;
+    token2: HexString;
+    fee: bigint;
+    tickSpacing: bigint;
+    maxLiquidityPerTick: bigint;
+    nextNftIndex: bigint;
+    slot0: types.Slot0;
+    liquidity: bigint;
+    rewardInfos: [types.Reward, types.Reward, types.Reward];
+    feeGrowths: [bigint, bigint, bigint];
+    protocolFees: types.ProtocolFees;
+  };
+
+  export type State = ContractState<Fields>;
+
+  export type InitializeEvent = ContractEvent<{
+    sqrtPriceX96: bigint;
+    tick: bigint;
+  }>;
+  export type SwapStartEvent = ContractEvent<{ sqrtPriceX96: bigint }>;
+  export type SwapStepEvent = ContractEvent<{
+    sqrtPriceX96: bigint;
+    liquidity: bigint;
+  }>;
+  export type SwapEvent = ContractEvent<{
+    sender: Address;
+    recipient: Address;
+    amount0: bigint;
+    amount1: bigint;
+    sqrtPriceX96: bigint;
+    liquidity: bigint;
+    tick: bigint;
+  }>;
+  export type MintEvent = ContractEvent<{
+    sender: Address;
+    owner: Address;
+    tickLower: bigint;
+    tickUpper: bigint;
+    liquidity: bigint;
+    amount0: bigint;
+    amount1: bigint;
+    timestamp: bigint;
+  }>;
+  export type BurnEvent = ContractEvent<{
+    operator: Address;
+    owner: Address;
+    tickLower: bigint;
+    tickUpper: bigint;
+    liquidity: bigint;
+    amount0: bigint;
+    amount1: bigint;
+  }>;
+  export type CollectEvent = ContractEvent<{
+    operator: Address;
+    recipient: Address;
+    owner: Address;
+    tickLower: bigint;
+    tickUpper: bigint;
+    amount0: bigint;
+    amount1: bigint;
+    amount2: bigint;
+  }>;
+  export type FeesEvent = ContractEvent<{
+    owner: Address;
+    tickLower: bigint;
+    tickUpper: bigint;
+    amount0: bigint;
+    amount1: bigint;
+    amount2: bigint;
+    timestamp: bigint;
+  }>;
+  export type CollectProtocolEvent = ContractEvent<{
+    sender: Address;
+    recipient: Address;
+    amount0: bigint;
+    amount1: bigint;
+  }>;
+
+  export interface CallMethodTable {
+    getCollectionUri: {
+      params: Omit<CallContractParams<{}>, "args">;
+      result: CallContractResult<HexString>;
+    };
+    totalSupply: {
+      params: Omit<CallContractParams<{}>, "args">;
+      result: CallContractResult<bigint>;
+    };
+    nftByIndex: {
+      params: CallContractParams<{ index: bigint }>;
+      result: CallContractResult<HexString>;
+    };
+    validateNFT: {
+      params: CallContractParams<{ nftId: HexString; nftIndex: bigint }>;
+      result: CallContractResult<null>;
+    };
+    getSqrtRatioAtTick: {
+      params: CallContractParams<{ tick: bigint }>;
+      result: CallContractResult<bigint>;
+    };
+    getTickAtSqrtRatio: {
+      params: CallContractParams<{ sqrtPriceX96: bigint }>;
+      result: CallContractResult<bigint>;
+    };
+    computeSwapStep: {
+      params: CallContractParams<{
+        sqrtRatioCurrentX96: bigint;
+        sqrtRatioTargetX96: bigint;
+        liquidity_: bigint;
+        amountRemaining: bigint;
+        feePips: bigint;
+      }>;
+      result: CallContractResult<[bigint, bigint, bigint, bigint]>;
+    };
+    divRoundingUp: {
+      params: CallContractParams<{ x: bigint; y: bigint }>;
+      result: CallContractResult<bigint>;
+    };
+    getNextSqrtPriceFromAmount0RoundingUp: {
+      params: CallContractParams<{
+        sqrtPX96: bigint;
+        liquidity_: bigint;
+        amount: bigint;
+        add: boolean;
+      }>;
+      result: CallContractResult<bigint>;
+    };
+    getNextSqrtPriceFromAmount1RoundingDown: {
+      params: CallContractParams<{
+        sqrtPX96: bigint;
+        liquidity_: bigint;
+        amount: bigint;
+        add: boolean;
+      }>;
+      result: CallContractResult<bigint>;
+    };
+    getNextSqrtPriceFromInput: {
+      params: CallContractParams<{
+        sqrtPX96: bigint;
+        liquidity_: bigint;
+        amountIn: bigint;
+        zeroForOne: boolean;
+      }>;
+      result: CallContractResult<bigint>;
+    };
+    getNextSqrtPriceFromOutput: {
+      params: CallContractParams<{
+        sqrtPX96: bigint;
+        liquidity_: bigint;
+        amountOut: bigint;
+        zeroForOne: boolean;
+      }>;
+      result: CallContractResult<bigint>;
+    };
+    getAmount0DeltaEx: {
+      params: CallContractParams<{
+        sqrtRatioAX96: bigint;
+        sqrtRatioBX96: bigint;
+        liquidityDelta: bigint;
+        roundUp: boolean;
+      }>;
+      result: CallContractResult<bigint>;
+    };
+    getAmount0Delta: {
+      params: CallContractParams<{
+        sqrtRatioAX96: bigint;
+        sqrtRatioBX96: bigint;
+        liquidityDelta: bigint;
+      }>;
+      result: CallContractResult<bigint>;
+    };
+    getAmount1DeltaEx: {
+      params: CallContractParams<{
+        sqrtRatioAX96: bigint;
+        sqrtRatioBX96: bigint;
+        liquidityDelta: bigint;
+        roundUp: boolean;
+      }>;
+      result: CallContractResult<bigint>;
+    };
+    getAmount1Delta: {
+      params: CallContractParams<{
+        sqrtRatioAX96: bigint;
+        sqrtRatioBX96: bigint;
+        liquidityDelta: bigint;
+      }>;
+      result: CallContractResult<bigint>;
+    };
+    mulDiv: {
+      params: CallContractParams<{ a: bigint; b: bigint; denominator: bigint }>;
+      result: CallContractResult<bigint>;
+    };
+    mulDivRoundingUp: {
+      params: CallContractParams<{ a: bigint; b: bigint; denominator: bigint }>;
+      result: CallContractResult<bigint>;
+    };
+    wordPath: {
+      params: CallContractParams<{ compressed: bigint }>;
+      result: CallContractResult<HexString>;
+    };
+    getWord: {
+      params: CallContractParams<{ compressed: bigint }>;
+      result: CallContractResult<HexString>;
+    };
+    getWordOrTemplate: {
+      params: CallContractParams<{ compressed: bigint }>;
+      result: CallContractResult<HexString>;
+    };
+    flipTick: {
+      params: CallContractParams<{ tick: bigint }>;
+      result: CallContractResult<null>;
+    };
+    nextInitializedTickWithinOneWord: {
+      params: CallContractParams<{ tick: bigint; zeroForOne: boolean }>;
+      result: CallContractResult<[bigint, boolean]>;
+    };
+    positionPath: {
+      params: CallContractParams<{
+        o: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+      }>;
+      result: CallContractResult<HexString>;
+    };
+    positionContractId: {
+      params: CallContractParams<{
+        pool: HexString;
+        o: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+      }>;
+      result: CallContractResult<HexString>;
+    };
+    configPath: {
+      params: CallContractParams<{ configIndex_: bigint }>;
+      result: CallContractResult<HexString>;
+    };
+    poolPath: {
+      params: CallContractParams<{
+        factory: HexString;
+        tokens: HexString;
+        configIndex_: bigint;
+      }>;
+      result: CallContractResult<HexString>;
+    };
+    poolContractId: {
+      params: CallContractParams<{
+        factory: HexString;
+        tokens: HexString;
+        configIndex_: bigint;
+      }>;
+      result: CallContractResult<HexString>;
+    };
+    checkTicks: {
+      params: CallContractParams<{ tickLower: bigint; tickUpper: bigint }>;
+      result: CallContractResult<null>;
+    };
+    tickPath: {
+      params: CallContractParams<{ tick: bigint }>;
+      result: CallContractResult<HexString>;
+    };
+    toTick: {
+      params: CallContractParams<{ tick: bigint }>;
+      result: CallContractResult<HexString>;
+    };
+    getTick: {
+      params: CallContractParams<{ tick: bigint }>;
+      result: CallContractResult<[HexString, boolean]>;
+    };
+    toPosition: {
+      params: CallContractParams<{
+        owner: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+      }>;
+      result: CallContractResult<HexString>;
+    };
+    getPosition: {
+      params: CallContractParams<{
+        owner: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+      }>;
+      result: CallContractResult<[HexString, boolean]>;
+    };
+    getFeeGrowthInside: {
+      params: CallContractParams<{
+        tickLower: HexString;
+        tickUpper: HexString;
+      }>;
+      result: CallContractResult<[bigint, bigint, bigint]>;
+    };
+    updatePosition: {
+      params: CallContractParams<{
+        position: HexString;
+        owner: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+        liquidityDelta: bigint;
+      }>;
+      result: CallContractResult<[bigint, bigint, bigint]>;
+    };
+    modifyPosition: {
+      params: CallContractParams<{
+        position: HexString;
+        params: types.ModifyPositionParams;
+      }>;
+      result: CallContractResult<[bigint, bigint, [bigint, bigint, bigint]]>;
+    };
+    mint: {
+      params: CallContractParams<{
+        payer: Address;
+        owner: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+        amount: bigint;
+      }>;
+      result: CallContractResult<[bigint, bigint]>;
+    };
+    burn: {
+      params: CallContractParams<{
+        operator: Address;
+        owner: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+        amount: bigint;
+      }>;
+      result: CallContractResult<[bigint, bigint]>;
+    };
+    collect: {
+      params: CallContractParams<{
+        operator: Address;
+        recipient: Address;
+        owner: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+        maxAmounts: [bigint, bigint, bigint];
+      }>;
+      result: CallContractResult<[bigint, bigint, bigint]>;
+    };
+    withdraw: {
+      params: CallContractParams<{
+        recipient: Address;
+        amounts: [bigint, bigint, bigint];
+      }>;
+      result: CallContractResult<null>;
+    };
+    simulateSwap: {
+      params: CallContractParams<{
+        zeroForOne: boolean;
+        amountSpecified: bigint;
+        data: HexString;
+        maxSteps: bigint;
+      }>;
+      result: CallContractResult<null>;
+    };
+    swap: {
+      params: CallContractParams<{
+        payer: Address;
+        recipient: Address;
+        token: HexString;
+        zeroForOne: boolean;
+        amountSpecified: bigint;
+        sqrtPriceLimitX96: bigint;
+        data: HexString;
+      }>;
+      result: CallContractResult<[bigint, bigint]>;
+    };
+    pop: {
+      params: CallContractParams<{
+        data: HexString;
+        t: HexString;
+        exactInput: boolean;
+      }>;
+      result: CallContractResult<[boolean, bigint, HexString, HexString]>;
+    };
+    swapExactOut: {
+      params: CallContractParams<{ p: types.SwapParams; refRewards: bigint }>;
+      result: CallContractResult<null>;
+    };
+    swapExactIn: {
+      params: CallContractParams<{ p: types.SwapParams; refRewards: bigint }>;
+      result: CallContractResult<null>;
+    };
+    getSqrtPricesX96: {
+      params: CallContractParams<{ tickLower: bigint; tickUpper: bigint }>;
+      result: CallContractResult<[bigint, bigint, bigint]>;
+    };
+    updateReward: {
+      params: CallContractParams<{ index: bigint; blockTime: bigint }>;
+      result: CallContractResult<null>;
+    };
+    updateRewards: {
+      params: CallContractParams<{ blockTime: bigint }>;
+      result: CallContractResult<null>;
+    };
+    extendRewards: {
+      params: CallContractParams<{
+        payer: Address;
+        index: bigint;
+        amount: bigint;
+      }>;
+      result: CallContractResult<null>;
+    };
+    setRewardParams: {
+      params: CallContractParams<{
+        payer: Address;
+        index: bigint;
+        openTime: bigint;
+        endTime: bigint;
+        amount: bigint;
+      }>;
+      result: CallContractResult<null>;
+    };
+    collectProtocolFees: {
+      params: CallContractParams<{ recipient: Address }>;
+      result: CallContractResult<null>;
+    };
+    positionInfo: {
+      params: CallContractParams<{
+        owner: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+        acc: bigint;
+        iacc0: bigint;
+        iacc1: bigint;
+        t0: bigint;
+        acct0: bigint;
+      }>;
+      result: CallContractResult<types.PositionInfo>;
+    };
+    getTokenUri: {
+      params: Omit<CallContractParams<{}>, "args">;
+      result: CallContractResult<HexString>;
+    };
+  }
+  export type CallMethodParams<T extends keyof CallMethodTable> =
+    CallMethodTable[T]["params"];
+  export type CallMethodResult<T extends keyof CallMethodTable> =
+    CallMethodTable[T]["result"];
+  export type MultiCallParams = Partial<{
+    [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
+  }>;
+  export type MultiCallResults<T extends MultiCallParams> = {
+    [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable
+      ? CallMethodTable[MaybeName]["result"]
+      : undefined;
+  };
+  export type MulticallReturnType<Callss extends MultiCallParams[]> = {
+    [index in keyof Callss]: MultiCallResults<Callss[index]>;
+  };
+
+  export interface SignExecuteMethodTable {
+    getCollectionUri: {
+      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
+      result: SignExecuteScriptTxResult;
+    };
+    totalSupply: {
+      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
+      result: SignExecuteScriptTxResult;
+    };
+    nftByIndex: {
+      params: SignExecuteContractMethodParams<{ index: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    validateNFT: {
+      params: SignExecuteContractMethodParams<{
+        nftId: HexString;
+        nftIndex: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getSqrtRatioAtTick: {
+      params: SignExecuteContractMethodParams<{ tick: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getTickAtSqrtRatio: {
+      params: SignExecuteContractMethodParams<{ sqrtPriceX96: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    computeSwapStep: {
+      params: SignExecuteContractMethodParams<{
+        sqrtRatioCurrentX96: bigint;
+        sqrtRatioTargetX96: bigint;
+        liquidity_: bigint;
+        amountRemaining: bigint;
+        feePips: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    divRoundingUp: {
+      params: SignExecuteContractMethodParams<{ x: bigint; y: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getNextSqrtPriceFromAmount0RoundingUp: {
+      params: SignExecuteContractMethodParams<{
+        sqrtPX96: bigint;
+        liquidity_: bigint;
+        amount: bigint;
+        add: boolean;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getNextSqrtPriceFromAmount1RoundingDown: {
+      params: SignExecuteContractMethodParams<{
+        sqrtPX96: bigint;
+        liquidity_: bigint;
+        amount: bigint;
+        add: boolean;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getNextSqrtPriceFromInput: {
+      params: SignExecuteContractMethodParams<{
+        sqrtPX96: bigint;
+        liquidity_: bigint;
+        amountIn: bigint;
+        zeroForOne: boolean;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getNextSqrtPriceFromOutput: {
+      params: SignExecuteContractMethodParams<{
+        sqrtPX96: bigint;
+        liquidity_: bigint;
+        amountOut: bigint;
+        zeroForOne: boolean;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getAmount0DeltaEx: {
+      params: SignExecuteContractMethodParams<{
+        sqrtRatioAX96: bigint;
+        sqrtRatioBX96: bigint;
+        liquidityDelta: bigint;
+        roundUp: boolean;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getAmount0Delta: {
+      params: SignExecuteContractMethodParams<{
+        sqrtRatioAX96: bigint;
+        sqrtRatioBX96: bigint;
+        liquidityDelta: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getAmount1DeltaEx: {
+      params: SignExecuteContractMethodParams<{
+        sqrtRatioAX96: bigint;
+        sqrtRatioBX96: bigint;
+        liquidityDelta: bigint;
+        roundUp: boolean;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getAmount1Delta: {
+      params: SignExecuteContractMethodParams<{
+        sqrtRatioAX96: bigint;
+        sqrtRatioBX96: bigint;
+        liquidityDelta: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    mulDiv: {
+      params: SignExecuteContractMethodParams<{
+        a: bigint;
+        b: bigint;
+        denominator: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    mulDivRoundingUp: {
+      params: SignExecuteContractMethodParams<{
+        a: bigint;
+        b: bigint;
+        denominator: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    wordPath: {
+      params: SignExecuteContractMethodParams<{ compressed: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getWord: {
+      params: SignExecuteContractMethodParams<{ compressed: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getWordOrTemplate: {
+      params: SignExecuteContractMethodParams<{ compressed: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    flipTick: {
+      params: SignExecuteContractMethodParams<{ tick: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    nextInitializedTickWithinOneWord: {
+      params: SignExecuteContractMethodParams<{
+        tick: bigint;
+        zeroForOne: boolean;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    positionPath: {
+      params: SignExecuteContractMethodParams<{
+        o: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    positionContractId: {
+      params: SignExecuteContractMethodParams<{
+        pool: HexString;
+        o: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    configPath: {
+      params: SignExecuteContractMethodParams<{ configIndex_: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    poolPath: {
+      params: SignExecuteContractMethodParams<{
+        factory: HexString;
+        tokens: HexString;
+        configIndex_: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    poolContractId: {
+      params: SignExecuteContractMethodParams<{
+        factory: HexString;
+        tokens: HexString;
+        configIndex_: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    checkTicks: {
+      params: SignExecuteContractMethodParams<{
+        tickLower: bigint;
+        tickUpper: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    tickPath: {
+      params: SignExecuteContractMethodParams<{ tick: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    toTick: {
+      params: SignExecuteContractMethodParams<{ tick: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getTick: {
+      params: SignExecuteContractMethodParams<{ tick: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    toPosition: {
+      params: SignExecuteContractMethodParams<{
+        owner: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getPosition: {
+      params: SignExecuteContractMethodParams<{
+        owner: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getFeeGrowthInside: {
+      params: SignExecuteContractMethodParams<{
+        tickLower: HexString;
+        tickUpper: HexString;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    updatePosition: {
+      params: SignExecuteContractMethodParams<{
+        position: HexString;
+        owner: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+        liquidityDelta: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    modifyPosition: {
+      params: SignExecuteContractMethodParams<{
+        position: HexString;
+        params: types.ModifyPositionParams;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    mint: {
+      params: SignExecuteContractMethodParams<{
+        payer: Address;
+        owner: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+        amount: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    burn: {
+      params: SignExecuteContractMethodParams<{
+        operator: Address;
+        owner: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+        amount: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    collect: {
+      params: SignExecuteContractMethodParams<{
+        operator: Address;
+        recipient: Address;
+        owner: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+        maxAmounts: [bigint, bigint, bigint];
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    withdraw: {
+      params: SignExecuteContractMethodParams<{
+        recipient: Address;
+        amounts: [bigint, bigint, bigint];
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    simulateSwap: {
+      params: SignExecuteContractMethodParams<{
+        zeroForOne: boolean;
+        amountSpecified: bigint;
+        data: HexString;
+        maxSteps: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    swap: {
+      params: SignExecuteContractMethodParams<{
+        payer: Address;
+        recipient: Address;
+        token: HexString;
+        zeroForOne: boolean;
+        amountSpecified: bigint;
+        sqrtPriceLimitX96: bigint;
+        data: HexString;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    pop: {
+      params: SignExecuteContractMethodParams<{
+        data: HexString;
+        t: HexString;
+        exactInput: boolean;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    swapExactOut: {
+      params: SignExecuteContractMethodParams<{
+        p: types.SwapParams;
+        refRewards: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    swapExactIn: {
+      params: SignExecuteContractMethodParams<{
+        p: types.SwapParams;
+        refRewards: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getSqrtPricesX96: {
+      params: SignExecuteContractMethodParams<{
+        tickLower: bigint;
+        tickUpper: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    updateReward: {
+      params: SignExecuteContractMethodParams<{
+        index: bigint;
+        blockTime: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    updateRewards: {
+      params: SignExecuteContractMethodParams<{ blockTime: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    extendRewards: {
+      params: SignExecuteContractMethodParams<{
+        payer: Address;
+        index: bigint;
+        amount: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    setRewardParams: {
+      params: SignExecuteContractMethodParams<{
+        payer: Address;
+        index: bigint;
+        openTime: bigint;
+        endTime: bigint;
+        amount: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    collectProtocolFees: {
+      params: SignExecuteContractMethodParams<{ recipient: Address }>;
+      result: SignExecuteScriptTxResult;
+    };
+    positionInfo: {
+      params: SignExecuteContractMethodParams<{
+        owner: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+        acc: bigint;
+        iacc0: bigint;
+        iacc1: bigint;
+        t0: bigint;
+        acct0: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getTokenUri: {
+      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
+      result: SignExecuteScriptTxResult;
+    };
+  }
+  export type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> =
+    SignExecuteMethodTable[T]["params"];
+  export type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> =
+    SignExecuteMethodTable[T]["result"];
+}
+
+class Factory extends ContractFactory<PoolInstance, PoolTypes.Fields> {
+  encodeFields(fields: PoolTypes.Fields) {
+    return encodeContractFields(
+      addStdIdToFields(this.contract, fields),
+      this.contract.fieldsSig,
+      types.AllStructs
+    );
+  }
+
+  eventIndex = {
+    Initialize: 0,
+    SwapStart: 1,
+    SwapStep: 2,
+    Swap: 3,
+    Mint: 4,
+    Burn: 5,
+    Collect: 6,
+    Fees: 7,
+    CollectProtocol: 8,
+  };
+  consts = {
+    MAX_PIPS: BigInt("1000000"),
+    TickMathError: {
+      SqrtPriceX96OutOfBounds: BigInt("201"),
+      TickOutOfBounds: BigInt("202"),
+    },
+    SqrtPriceMathError: {
+      SqrtFromAmountOverflow: BigInt("221"),
+      QuotientTooHigh: BigInt("222"),
+      PriceZero: BigInt("223"),
+      NoLiquidity: BigInt("224"),
+      PriceNotFitIn160: BigInt("225"),
+    },
+    FullMathError: { MulDivOverflow: BigInt("351") },
+    TickBitmapError: { TickNotAligned: BigInt("301") },
+    PathPrefixes: {
+      Tick: BigInt("0"),
+      Position: BigInt("1"),
+      Word: BigInt("2"),
+    },
+    PoolError: {
+      TLU: BigInt("102"),
+      TLM: BigInt("103"),
+      TUM: BigInt("104"),
+      AS: BigInt("105"),
+      SPL: BigInt("106"),
+      NP: BigInt("107"),
+      UnauthorizedMint: BigInt("108"),
+      NFTNotPartOfCollection: BigInt("109"),
+      NFTByIndexNotSupported: BigInt("110"),
+      UnauthorizedRewardSender: BigInt("111"),
+      InvalidRewardParams: BigInt("112"),
+      DexAccountNotFound: BigInt("113"),
+      InvalidRewardIndex: BigInt("114"),
+      RewardPeriodEnded: BigInt("115"),
+      ZeroRewardAmount: BigInt("116"),
+    },
+  };
+
+  at(address: string): PoolInstance {
+    return new PoolInstance(address);
+  }
+
+  tests = {
+    getCollectionUri: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<PoolTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(
+        this,
+        "getCollectionUri",
+        params,
+        getContractByCodeHash
+      );
+    },
+    totalSupply: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<PoolTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "totalSupply", params, getContractByCodeHash);
+    },
+    nftByIndex: async (
+      params: TestContractParamsWithoutMaps<PoolTypes.Fields, { index: bigint }>
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "nftByIndex", params, getContractByCodeHash);
+    },
+    validateNFT: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { nftId: HexString; nftIndex: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "validateNFT", params, getContractByCodeHash);
+    },
+    getSqrtRatioAtTick: async (
+      params: TestContractParamsWithoutMaps<PoolTypes.Fields, { tick: bigint }>
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(
+        this,
+        "getSqrtRatioAtTick",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getTickAtSqrtRatio: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { sqrtPriceX96: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(
+        this,
+        "getTickAtSqrtRatio",
+        params,
+        getContractByCodeHash
+      );
+    },
+    computeSwapStep: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        {
+          sqrtRatioCurrentX96: bigint;
+          sqrtRatioTargetX96: bigint;
+          liquidity_: bigint;
+          amountRemaining: bigint;
+          feePips: bigint;
+        }
+      >
+    ): Promise<
+      TestContractResultWithoutMaps<[bigint, bigint, bigint, bigint]>
+    > => {
+      return testMethod(this, "computeSwapStep", params, getContractByCodeHash);
+    },
+    divRoundingUp: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { x: bigint; y: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "divRoundingUp", params, getContractByCodeHash);
+    },
+    getNextSqrtPriceFromAmount0RoundingUp: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { sqrtPX96: bigint; liquidity_: bigint; amount: bigint; add: boolean }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(
+        this,
+        "getNextSqrtPriceFromAmount0RoundingUp",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getNextSqrtPriceFromAmount1RoundingDown: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { sqrtPX96: bigint; liquidity_: bigint; amount: bigint; add: boolean }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(
+        this,
+        "getNextSqrtPriceFromAmount1RoundingDown",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getNextSqrtPriceFromInput: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        {
+          sqrtPX96: bigint;
+          liquidity_: bigint;
+          amountIn: bigint;
+          zeroForOne: boolean;
+        }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(
+        this,
+        "getNextSqrtPriceFromInput",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getNextSqrtPriceFromOutput: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        {
+          sqrtPX96: bigint;
+          liquidity_: bigint;
+          amountOut: bigint;
+          zeroForOne: boolean;
+        }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(
+        this,
+        "getNextSqrtPriceFromOutput",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getAmount0DeltaEx: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        {
+          sqrtRatioAX96: bigint;
+          sqrtRatioBX96: bigint;
+          liquidityDelta: bigint;
+          roundUp: boolean;
+        }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(
+        this,
+        "getAmount0DeltaEx",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getAmount0Delta: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { sqrtRatioAX96: bigint; sqrtRatioBX96: bigint; liquidityDelta: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "getAmount0Delta", params, getContractByCodeHash);
+    },
+    getAmount1DeltaEx: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        {
+          sqrtRatioAX96: bigint;
+          sqrtRatioBX96: bigint;
+          liquidityDelta: bigint;
+          roundUp: boolean;
+        }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(
+        this,
+        "getAmount1DeltaEx",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getAmount1Delta: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { sqrtRatioAX96: bigint; sqrtRatioBX96: bigint; liquidityDelta: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "getAmount1Delta", params, getContractByCodeHash);
+    },
+    mulDiv: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { a: bigint; b: bigint; denominator: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "mulDiv", params, getContractByCodeHash);
+    },
+    mulDivRoundingUp: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { a: bigint; b: bigint; denominator: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(
+        this,
+        "mulDivRoundingUp",
+        params,
+        getContractByCodeHash
+      );
+    },
+    wordPath: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { compressed: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "wordPath", params, getContractByCodeHash);
+    },
+    getWord: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { compressed: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "getWord", params, getContractByCodeHash);
+    },
+    getWordOrTemplate: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { compressed: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(
+        this,
+        "getWordOrTemplate",
+        params,
+        getContractByCodeHash
+      );
+    },
+    flipTick: async (
+      params: TestContractParamsWithoutMaps<PoolTypes.Fields, { tick: bigint }>
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "flipTick", params, getContractByCodeHash);
+    },
+    nextInitializedTickWithinOneWord: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { tick: bigint; zeroForOne: boolean }
+      >
+    ): Promise<TestContractResultWithoutMaps<[bigint, boolean]>> => {
+      return testMethod(
+        this,
+        "nextInitializedTickWithinOneWord",
+        params,
+        getContractByCodeHash
+      );
+    },
+    positionPath: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { o: Address; tickLower: bigint; tickUpper: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "positionPath", params, getContractByCodeHash);
+    },
+    positionContractId: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { pool: HexString; o: Address; tickLower: bigint; tickUpper: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(
+        this,
+        "positionContractId",
+        params,
+        getContractByCodeHash
+      );
+    },
+    configPath: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { configIndex_: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "configPath", params, getContractByCodeHash);
+    },
+    poolPath: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { factory: HexString; tokens: HexString; configIndex_: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "poolPath", params, getContractByCodeHash);
+    },
+    poolContractId: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { factory: HexString; tokens: HexString; configIndex_: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "poolContractId", params, getContractByCodeHash);
+    },
+    checkTicks: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { tickLower: bigint; tickUpper: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "checkTicks", params, getContractByCodeHash);
+    },
+    tickPath: async (
+      params: TestContractParamsWithoutMaps<PoolTypes.Fields, { tick: bigint }>
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "tickPath", params, getContractByCodeHash);
+    },
+    toTick: async (
+      params: TestContractParamsWithoutMaps<PoolTypes.Fields, { tick: bigint }>
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "toTick", params, getContractByCodeHash);
+    },
+    getTick: async (
+      params: TestContractParamsWithoutMaps<PoolTypes.Fields, { tick: bigint }>
+    ): Promise<TestContractResultWithoutMaps<[HexString, boolean]>> => {
+      return testMethod(this, "getTick", params, getContractByCodeHash);
+    },
+    toPosition: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { owner: Address; tickLower: bigint; tickUpper: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "toPosition", params, getContractByCodeHash);
+    },
+    getPosition: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { owner: Address; tickLower: bigint; tickUpper: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<[HexString, boolean]>> => {
+      return testMethod(this, "getPosition", params, getContractByCodeHash);
+    },
+    getFeeGrowthInside: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { tickLower: HexString; tickUpper: HexString }
+      >
+    ): Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>> => {
+      return testMethod(
+        this,
+        "getFeeGrowthInside",
+        params,
+        getContractByCodeHash
+      );
+    },
+    updatePosition: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        {
+          position: HexString;
+          owner: Address;
+          tickLower: bigint;
+          tickUpper: bigint;
+          liquidityDelta: bigint;
+        }
+      >
+    ): Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>> => {
+      return testMethod(this, "updatePosition", params, getContractByCodeHash);
+    },
+    modifyPosition: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { position: HexString; params: types.ModifyPositionParams }
+      >
+    ): Promise<
+      TestContractResultWithoutMaps<[bigint, bigint, [bigint, bigint, bigint]]>
+    > => {
+      return testMethod(this, "modifyPosition", params, getContractByCodeHash);
+    },
+    mint: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        {
+          payer: Address;
+          owner: Address;
+          tickLower: bigint;
+          tickUpper: bigint;
+          amount: bigint;
+        }
+      >
+    ): Promise<TestContractResultWithoutMaps<[bigint, bigint]>> => {
+      return testMethod(this, "mint", params, getContractByCodeHash);
+    },
+    burn: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        {
+          operator: Address;
+          owner: Address;
+          tickLower: bigint;
+          tickUpper: bigint;
+          amount: bigint;
+        }
+      >
+    ): Promise<TestContractResultWithoutMaps<[bigint, bigint]>> => {
+      return testMethod(this, "burn", params, getContractByCodeHash);
+    },
+    collect: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        {
+          operator: Address;
+          recipient: Address;
+          owner: Address;
+          tickLower: bigint;
+          tickUpper: bigint;
+          maxAmounts: [bigint, bigint, bigint];
+        }
+      >
+    ): Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>> => {
+      return testMethod(this, "collect", params, getContractByCodeHash);
+    },
+    withdraw: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { recipient: Address; amounts: [bigint, bigint, bigint] }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "withdraw", params, getContractByCodeHash);
+    },
+    simulateSwap: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        {
+          zeroForOne: boolean;
+          amountSpecified: bigint;
+          data: HexString;
+          maxSteps: bigint;
+        }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "simulateSwap", params, getContractByCodeHash);
+    },
+    swap: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        {
+          payer: Address;
+          recipient: Address;
+          token: HexString;
+          zeroForOne: boolean;
+          amountSpecified: bigint;
+          sqrtPriceLimitX96: bigint;
+          data: HexString;
+        }
+      >
+    ): Promise<TestContractResultWithoutMaps<[bigint, bigint]>> => {
+      return testMethod(this, "swap", params, getContractByCodeHash);
+    },
+    pop: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { data: HexString; t: HexString; exactInput: boolean }
+      >
+    ): Promise<
+      TestContractResultWithoutMaps<[boolean, bigint, HexString, HexString]>
+    > => {
+      return testMethod(this, "pop", params, getContractByCodeHash);
+    },
+    swapExactOut: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { p: types.SwapParams; refRewards: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "swapExactOut", params, getContractByCodeHash);
+    },
+    swapExactIn: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { p: types.SwapParams; refRewards: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "swapExactIn", params, getContractByCodeHash);
+    },
+    getSqrtPricesX96: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { tickLower: bigint; tickUpper: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>> => {
+      return testMethod(
+        this,
+        "getSqrtPricesX96",
+        params,
+        getContractByCodeHash
+      );
+    },
+    updateReward: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { index: bigint; blockTime: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "updateReward", params, getContractByCodeHash);
+    },
+    updateRewards: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { blockTime: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "updateRewards", params, getContractByCodeHash);
+    },
+    extendRewards: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { payer: Address; index: bigint; amount: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "extendRewards", params, getContractByCodeHash);
+    },
+    setRewardParams: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        {
+          payer: Address;
+          index: bigint;
+          openTime: bigint;
+          endTime: bigint;
+          amount: bigint;
+        }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "setRewardParams", params, getContractByCodeHash);
+    },
+    collectProtocolFees: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        { recipient: Address }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(
+        this,
+        "collectProtocolFees",
+        params,
+        getContractByCodeHash
+      );
+    },
+    positionInfo: async (
+      params: TestContractParamsWithoutMaps<
+        PoolTypes.Fields,
+        {
+          owner: Address;
+          tickLower: bigint;
+          tickUpper: bigint;
+          acc: bigint;
+          iacc0: bigint;
+          iacc1: bigint;
+          t0: bigint;
+          acct0: bigint;
+        }
+      >
+    ): Promise<TestContractResultWithoutMaps<types.PositionInfo>> => {
+      return testMethod(this, "positionInfo", params, getContractByCodeHash);
+    },
+    getTokenUri: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<PoolTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "getTokenUri", params, getContractByCodeHash);
+    },
+  };
+
+  stateForTest(initFields: PoolTypes.Fields, asset?: Asset, address?: string) {
+    return this.stateForTest_(initFields, asset, address, undefined);
+  }
+}
+
+// Use this object to test and deploy the contract
+export const Pool = new Factory(
+  Contract.fromJson(
+    PoolContractJson,
+    "",
+    "cdb37fb2772ba9c976a4dc34db15994ecaeef82d8690b9a94c600a81c67f98c4",
+    types.AllStructs
+  )
+);
+registerContract(Pool);
+
+// Use this class to interact with the blockchain
+export class PoolInstance extends ContractInstance {
+  constructor(address: Address) {
+    super(address);
+  }
+
+  async fetchState(): Promise<PoolTypes.State> {
+    return fetchContractState(Pool, this);
+  }
+
+  async getContractEventsCurrentCount(): Promise<number> {
+    return getContractEventsCurrentCount(this.address);
+  }
+
+  subscribeInitializeEvent(
+    options: EventSubscribeOptions<PoolTypes.InitializeEvent>,
+    fromCount?: number
+  ): EventSubscription {
+    return subscribeContractEvent(
+      Pool.contract,
+      this,
+      options,
+      "Initialize",
+      fromCount
+    );
+  }
+
+  subscribeSwapStartEvent(
+    options: EventSubscribeOptions<PoolTypes.SwapStartEvent>,
+    fromCount?: number
+  ): EventSubscription {
+    return subscribeContractEvent(
+      Pool.contract,
+      this,
+      options,
+      "SwapStart",
+      fromCount
+    );
+  }
+
+  subscribeSwapStepEvent(
+    options: EventSubscribeOptions<PoolTypes.SwapStepEvent>,
+    fromCount?: number
+  ): EventSubscription {
+    return subscribeContractEvent(
+      Pool.contract,
+      this,
+      options,
+      "SwapStep",
+      fromCount
+    );
+  }
+
+  subscribeSwapEvent(
+    options: EventSubscribeOptions<PoolTypes.SwapEvent>,
+    fromCount?: number
+  ): EventSubscription {
+    return subscribeContractEvent(
+      Pool.contract,
+      this,
+      options,
+      "Swap",
+      fromCount
+    );
+  }
+
+  subscribeMintEvent(
+    options: EventSubscribeOptions<PoolTypes.MintEvent>,
+    fromCount?: number
+  ): EventSubscription {
+    return subscribeContractEvent(
+      Pool.contract,
+      this,
+      options,
+      "Mint",
+      fromCount
+    );
+  }
+
+  subscribeBurnEvent(
+    options: EventSubscribeOptions<PoolTypes.BurnEvent>,
+    fromCount?: number
+  ): EventSubscription {
+    return subscribeContractEvent(
+      Pool.contract,
+      this,
+      options,
+      "Burn",
+      fromCount
+    );
+  }
+
+  subscribeCollectEvent(
+    options: EventSubscribeOptions<PoolTypes.CollectEvent>,
+    fromCount?: number
+  ): EventSubscription {
+    return subscribeContractEvent(
+      Pool.contract,
+      this,
+      options,
+      "Collect",
+      fromCount
+    );
+  }
+
+  subscribeFeesEvent(
+    options: EventSubscribeOptions<PoolTypes.FeesEvent>,
+    fromCount?: number
+  ): EventSubscription {
+    return subscribeContractEvent(
+      Pool.contract,
+      this,
+      options,
+      "Fees",
+      fromCount
+    );
+  }
+
+  subscribeCollectProtocolEvent(
+    options: EventSubscribeOptions<PoolTypes.CollectProtocolEvent>,
+    fromCount?: number
+  ): EventSubscription {
+    return subscribeContractEvent(
+      Pool.contract,
+      this,
+      options,
+      "CollectProtocol",
+      fromCount
+    );
+  }
+
+  subscribeAllEvents(
+    options: EventSubscribeOptions<
+      | PoolTypes.InitializeEvent
+      | PoolTypes.SwapStartEvent
+      | PoolTypes.SwapStepEvent
+      | PoolTypes.SwapEvent
+      | PoolTypes.MintEvent
+      | PoolTypes.BurnEvent
+      | PoolTypes.CollectEvent
+      | PoolTypes.FeesEvent
+      | PoolTypes.CollectProtocolEvent
+    >,
+    fromCount?: number
+  ): EventSubscription {
+    return subscribeContractEvents(Pool.contract, this, options, fromCount);
+  }
+
+  view = {
+    getCollectionUri: async (
+      params?: PoolTypes.CallMethodParams<"getCollectionUri">
+    ): Promise<PoolTypes.CallMethodResult<"getCollectionUri">> => {
+      return callMethod(
+        Pool,
+        this,
+        "getCollectionUri",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    totalSupply: async (
+      params?: PoolTypes.CallMethodParams<"totalSupply">
+    ): Promise<PoolTypes.CallMethodResult<"totalSupply">> => {
+      return callMethod(
+        Pool,
+        this,
+        "totalSupply",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    nftByIndex: async (
+      params: PoolTypes.CallMethodParams<"nftByIndex">
+    ): Promise<PoolTypes.CallMethodResult<"nftByIndex">> => {
+      return callMethod(
+        Pool,
+        this,
+        "nftByIndex",
+        params,
+        getContractByCodeHash
+      );
+    },
+    validateNFT: async (
+      params: PoolTypes.CallMethodParams<"validateNFT">
+    ): Promise<PoolTypes.CallMethodResult<"validateNFT">> => {
+      return callMethod(
+        Pool,
+        this,
+        "validateNFT",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getSqrtRatioAtTick: async (
+      params: PoolTypes.CallMethodParams<"getSqrtRatioAtTick">
+    ): Promise<PoolTypes.CallMethodResult<"getSqrtRatioAtTick">> => {
+      return callMethod(
+        Pool,
+        this,
+        "getSqrtRatioAtTick",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getTickAtSqrtRatio: async (
+      params: PoolTypes.CallMethodParams<"getTickAtSqrtRatio">
+    ): Promise<PoolTypes.CallMethodResult<"getTickAtSqrtRatio">> => {
+      return callMethod(
+        Pool,
+        this,
+        "getTickAtSqrtRatio",
+        params,
+        getContractByCodeHash
+      );
+    },
+    computeSwapStep: async (
+      params: PoolTypes.CallMethodParams<"computeSwapStep">
+    ): Promise<PoolTypes.CallMethodResult<"computeSwapStep">> => {
+      return callMethod(
+        Pool,
+        this,
+        "computeSwapStep",
+        params,
+        getContractByCodeHash
+      );
+    },
+    divRoundingUp: async (
+      params: PoolTypes.CallMethodParams<"divRoundingUp">
+    ): Promise<PoolTypes.CallMethodResult<"divRoundingUp">> => {
+      return callMethod(
+        Pool,
+        this,
+        "divRoundingUp",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getNextSqrtPriceFromAmount0RoundingUp: async (
+      params: PoolTypes.CallMethodParams<"getNextSqrtPriceFromAmount0RoundingUp">
+    ): Promise<
+      PoolTypes.CallMethodResult<"getNextSqrtPriceFromAmount0RoundingUp">
+    > => {
+      return callMethod(
+        Pool,
+        this,
+        "getNextSqrtPriceFromAmount0RoundingUp",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getNextSqrtPriceFromAmount1RoundingDown: async (
+      params: PoolTypes.CallMethodParams<"getNextSqrtPriceFromAmount1RoundingDown">
+    ): Promise<
+      PoolTypes.CallMethodResult<"getNextSqrtPriceFromAmount1RoundingDown">
+    > => {
+      return callMethod(
+        Pool,
+        this,
+        "getNextSqrtPriceFromAmount1RoundingDown",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getNextSqrtPriceFromInput: async (
+      params: PoolTypes.CallMethodParams<"getNextSqrtPriceFromInput">
+    ): Promise<PoolTypes.CallMethodResult<"getNextSqrtPriceFromInput">> => {
+      return callMethod(
+        Pool,
+        this,
+        "getNextSqrtPriceFromInput",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getNextSqrtPriceFromOutput: async (
+      params: PoolTypes.CallMethodParams<"getNextSqrtPriceFromOutput">
+    ): Promise<PoolTypes.CallMethodResult<"getNextSqrtPriceFromOutput">> => {
+      return callMethod(
+        Pool,
+        this,
+        "getNextSqrtPriceFromOutput",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getAmount0DeltaEx: async (
+      params: PoolTypes.CallMethodParams<"getAmount0DeltaEx">
+    ): Promise<PoolTypes.CallMethodResult<"getAmount0DeltaEx">> => {
+      return callMethod(
+        Pool,
+        this,
+        "getAmount0DeltaEx",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getAmount0Delta: async (
+      params: PoolTypes.CallMethodParams<"getAmount0Delta">
+    ): Promise<PoolTypes.CallMethodResult<"getAmount0Delta">> => {
+      return callMethod(
+        Pool,
+        this,
+        "getAmount0Delta",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getAmount1DeltaEx: async (
+      params: PoolTypes.CallMethodParams<"getAmount1DeltaEx">
+    ): Promise<PoolTypes.CallMethodResult<"getAmount1DeltaEx">> => {
+      return callMethod(
+        Pool,
+        this,
+        "getAmount1DeltaEx",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getAmount1Delta: async (
+      params: PoolTypes.CallMethodParams<"getAmount1Delta">
+    ): Promise<PoolTypes.CallMethodResult<"getAmount1Delta">> => {
+      return callMethod(
+        Pool,
+        this,
+        "getAmount1Delta",
+        params,
+        getContractByCodeHash
+      );
+    },
+    mulDiv: async (
+      params: PoolTypes.CallMethodParams<"mulDiv">
+    ): Promise<PoolTypes.CallMethodResult<"mulDiv">> => {
+      return callMethod(Pool, this, "mulDiv", params, getContractByCodeHash);
+    },
+    mulDivRoundingUp: async (
+      params: PoolTypes.CallMethodParams<"mulDivRoundingUp">
+    ): Promise<PoolTypes.CallMethodResult<"mulDivRoundingUp">> => {
+      return callMethod(
+        Pool,
+        this,
+        "mulDivRoundingUp",
+        params,
+        getContractByCodeHash
+      );
+    },
+    wordPath: async (
+      params: PoolTypes.CallMethodParams<"wordPath">
+    ): Promise<PoolTypes.CallMethodResult<"wordPath">> => {
+      return callMethod(Pool, this, "wordPath", params, getContractByCodeHash);
+    },
+    getWord: async (
+      params: PoolTypes.CallMethodParams<"getWord">
+    ): Promise<PoolTypes.CallMethodResult<"getWord">> => {
+      return callMethod(Pool, this, "getWord", params, getContractByCodeHash);
+    },
+    getWordOrTemplate: async (
+      params: PoolTypes.CallMethodParams<"getWordOrTemplate">
+    ): Promise<PoolTypes.CallMethodResult<"getWordOrTemplate">> => {
+      return callMethod(
+        Pool,
+        this,
+        "getWordOrTemplate",
+        params,
+        getContractByCodeHash
+      );
+    },
+    flipTick: async (
+      params: PoolTypes.CallMethodParams<"flipTick">
+    ): Promise<PoolTypes.CallMethodResult<"flipTick">> => {
+      return callMethod(Pool, this, "flipTick", params, getContractByCodeHash);
+    },
+    nextInitializedTickWithinOneWord: async (
+      params: PoolTypes.CallMethodParams<"nextInitializedTickWithinOneWord">
+    ): Promise<
+      PoolTypes.CallMethodResult<"nextInitializedTickWithinOneWord">
+    > => {
+      return callMethod(
+        Pool,
+        this,
+        "nextInitializedTickWithinOneWord",
+        params,
+        getContractByCodeHash
+      );
+    },
+    positionPath: async (
+      params: PoolTypes.CallMethodParams<"positionPath">
+    ): Promise<PoolTypes.CallMethodResult<"positionPath">> => {
+      return callMethod(
+        Pool,
+        this,
+        "positionPath",
+        params,
+        getContractByCodeHash
+      );
+    },
+    positionContractId: async (
+      params: PoolTypes.CallMethodParams<"positionContractId">
+    ): Promise<PoolTypes.CallMethodResult<"positionContractId">> => {
+      return callMethod(
+        Pool,
+        this,
+        "positionContractId",
+        params,
+        getContractByCodeHash
+      );
+    },
+    configPath: async (
+      params: PoolTypes.CallMethodParams<"configPath">
+    ): Promise<PoolTypes.CallMethodResult<"configPath">> => {
+      return callMethod(
+        Pool,
+        this,
+        "configPath",
+        params,
+        getContractByCodeHash
+      );
+    },
+    poolPath: async (
+      params: PoolTypes.CallMethodParams<"poolPath">
+    ): Promise<PoolTypes.CallMethodResult<"poolPath">> => {
+      return callMethod(Pool, this, "poolPath", params, getContractByCodeHash);
+    },
+    poolContractId: async (
+      params: PoolTypes.CallMethodParams<"poolContractId">
+    ): Promise<PoolTypes.CallMethodResult<"poolContractId">> => {
+      return callMethod(
+        Pool,
+        this,
+        "poolContractId",
+        params,
+        getContractByCodeHash
+      );
+    },
+    checkTicks: async (
+      params: PoolTypes.CallMethodParams<"checkTicks">
+    ): Promise<PoolTypes.CallMethodResult<"checkTicks">> => {
+      return callMethod(
+        Pool,
+        this,
+        "checkTicks",
+        params,
+        getContractByCodeHash
+      );
+    },
+    tickPath: async (
+      params: PoolTypes.CallMethodParams<"tickPath">
+    ): Promise<PoolTypes.CallMethodResult<"tickPath">> => {
+      return callMethod(Pool, this, "tickPath", params, getContractByCodeHash);
+    },
+    toTick: async (
+      params: PoolTypes.CallMethodParams<"toTick">
+    ): Promise<PoolTypes.CallMethodResult<"toTick">> => {
+      return callMethod(Pool, this, "toTick", params, getContractByCodeHash);
+    },
+    getTick: async (
+      params: PoolTypes.CallMethodParams<"getTick">
+    ): Promise<PoolTypes.CallMethodResult<"getTick">> => {
+      return callMethod(Pool, this, "getTick", params, getContractByCodeHash);
+    },
+    toPosition: async (
+      params: PoolTypes.CallMethodParams<"toPosition">
+    ): Promise<PoolTypes.CallMethodResult<"toPosition">> => {
+      return callMethod(
+        Pool,
+        this,
+        "toPosition",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getPosition: async (
+      params: PoolTypes.CallMethodParams<"getPosition">
+    ): Promise<PoolTypes.CallMethodResult<"getPosition">> => {
+      return callMethod(
+        Pool,
+        this,
+        "getPosition",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getFeeGrowthInside: async (
+      params: PoolTypes.CallMethodParams<"getFeeGrowthInside">
+    ): Promise<PoolTypes.CallMethodResult<"getFeeGrowthInside">> => {
+      return callMethod(
+        Pool,
+        this,
+        "getFeeGrowthInside",
+        params,
+        getContractByCodeHash
+      );
+    },
+    updatePosition: async (
+      params: PoolTypes.CallMethodParams<"updatePosition">
+    ): Promise<PoolTypes.CallMethodResult<"updatePosition">> => {
+      return callMethod(
+        Pool,
+        this,
+        "updatePosition",
+        params,
+        getContractByCodeHash
+      );
+    },
+    modifyPosition: async (
+      params: PoolTypes.CallMethodParams<"modifyPosition">
+    ): Promise<PoolTypes.CallMethodResult<"modifyPosition">> => {
+      return callMethod(
+        Pool,
+        this,
+        "modifyPosition",
+        params,
+        getContractByCodeHash
+      );
+    },
+    mint: async (
+      params: PoolTypes.CallMethodParams<"mint">
+    ): Promise<PoolTypes.CallMethodResult<"mint">> => {
+      return callMethod(Pool, this, "mint", params, getContractByCodeHash);
+    },
+    burn: async (
+      params: PoolTypes.CallMethodParams<"burn">
+    ): Promise<PoolTypes.CallMethodResult<"burn">> => {
+      return callMethod(Pool, this, "burn", params, getContractByCodeHash);
+    },
+    collect: async (
+      params: PoolTypes.CallMethodParams<"collect">
+    ): Promise<PoolTypes.CallMethodResult<"collect">> => {
+      return callMethod(Pool, this, "collect", params, getContractByCodeHash);
+    },
+    withdraw: async (
+      params: PoolTypes.CallMethodParams<"withdraw">
+    ): Promise<PoolTypes.CallMethodResult<"withdraw">> => {
+      return callMethod(Pool, this, "withdraw", params, getContractByCodeHash);
+    },
+    simulateSwap: async (
+      params: PoolTypes.CallMethodParams<"simulateSwap">
+    ): Promise<PoolTypes.CallMethodResult<"simulateSwap">> => {
+      return callMethod(
+        Pool,
+        this,
+        "simulateSwap",
+        params,
+        getContractByCodeHash
+      );
+    },
+    swap: async (
+      params: PoolTypes.CallMethodParams<"swap">
+    ): Promise<PoolTypes.CallMethodResult<"swap">> => {
+      return callMethod(Pool, this, "swap", params, getContractByCodeHash);
+    },
+    pop: async (
+      params: PoolTypes.CallMethodParams<"pop">
+    ): Promise<PoolTypes.CallMethodResult<"pop">> => {
+      return callMethod(Pool, this, "pop", params, getContractByCodeHash);
+    },
+    swapExactOut: async (
+      params: PoolTypes.CallMethodParams<"swapExactOut">
+    ): Promise<PoolTypes.CallMethodResult<"swapExactOut">> => {
+      return callMethod(
+        Pool,
+        this,
+        "swapExactOut",
+        params,
+        getContractByCodeHash
+      );
+    },
+    swapExactIn: async (
+      params: PoolTypes.CallMethodParams<"swapExactIn">
+    ): Promise<PoolTypes.CallMethodResult<"swapExactIn">> => {
+      return callMethod(
+        Pool,
+        this,
+        "swapExactIn",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getSqrtPricesX96: async (
+      params: PoolTypes.CallMethodParams<"getSqrtPricesX96">
+    ): Promise<PoolTypes.CallMethodResult<"getSqrtPricesX96">> => {
+      return callMethod(
+        Pool,
+        this,
+        "getSqrtPricesX96",
+        params,
+        getContractByCodeHash
+      );
+    },
+    updateReward: async (
+      params: PoolTypes.CallMethodParams<"updateReward">
+    ): Promise<PoolTypes.CallMethodResult<"updateReward">> => {
+      return callMethod(
+        Pool,
+        this,
+        "updateReward",
+        params,
+        getContractByCodeHash
+      );
+    },
+    updateRewards: async (
+      params: PoolTypes.CallMethodParams<"updateRewards">
+    ): Promise<PoolTypes.CallMethodResult<"updateRewards">> => {
+      return callMethod(
+        Pool,
+        this,
+        "updateRewards",
+        params,
+        getContractByCodeHash
+      );
+    },
+    extendRewards: async (
+      params: PoolTypes.CallMethodParams<"extendRewards">
+    ): Promise<PoolTypes.CallMethodResult<"extendRewards">> => {
+      return callMethod(
+        Pool,
+        this,
+        "extendRewards",
+        params,
+        getContractByCodeHash
+      );
+    },
+    setRewardParams: async (
+      params: PoolTypes.CallMethodParams<"setRewardParams">
+    ): Promise<PoolTypes.CallMethodResult<"setRewardParams">> => {
+      return callMethod(
+        Pool,
+        this,
+        "setRewardParams",
+        params,
+        getContractByCodeHash
+      );
+    },
+    collectProtocolFees: async (
+      params: PoolTypes.CallMethodParams<"collectProtocolFees">
+    ): Promise<PoolTypes.CallMethodResult<"collectProtocolFees">> => {
+      return callMethod(
+        Pool,
+        this,
+        "collectProtocolFees",
+        params,
+        getContractByCodeHash
+      );
+    },
+    positionInfo: async (
+      params: PoolTypes.CallMethodParams<"positionInfo">
+    ): Promise<PoolTypes.CallMethodResult<"positionInfo">> => {
+      return callMethod(
+        Pool,
+        this,
+        "positionInfo",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getTokenUri: async (
+      params?: PoolTypes.CallMethodParams<"getTokenUri">
+    ): Promise<PoolTypes.CallMethodResult<"getTokenUri">> => {
+      return callMethod(
+        Pool,
+        this,
+        "getTokenUri",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  transact = {
+    getCollectionUri: async (
+      params: PoolTypes.SignExecuteMethodParams<"getCollectionUri">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"getCollectionUri">> => {
+      return signExecuteMethod(Pool, this, "getCollectionUri", params);
+    },
+    totalSupply: async (
+      params: PoolTypes.SignExecuteMethodParams<"totalSupply">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"totalSupply">> => {
+      return signExecuteMethod(Pool, this, "totalSupply", params);
+    },
+    nftByIndex: async (
+      params: PoolTypes.SignExecuteMethodParams<"nftByIndex">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"nftByIndex">> => {
+      return signExecuteMethod(Pool, this, "nftByIndex", params);
+    },
+    validateNFT: async (
+      params: PoolTypes.SignExecuteMethodParams<"validateNFT">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"validateNFT">> => {
+      return signExecuteMethod(Pool, this, "validateNFT", params);
+    },
+    getSqrtRatioAtTick: async (
+      params: PoolTypes.SignExecuteMethodParams<"getSqrtRatioAtTick">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"getSqrtRatioAtTick">> => {
+      return signExecuteMethod(Pool, this, "getSqrtRatioAtTick", params);
+    },
+    getTickAtSqrtRatio: async (
+      params: PoolTypes.SignExecuteMethodParams<"getTickAtSqrtRatio">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"getTickAtSqrtRatio">> => {
+      return signExecuteMethod(Pool, this, "getTickAtSqrtRatio", params);
+    },
+    computeSwapStep: async (
+      params: PoolTypes.SignExecuteMethodParams<"computeSwapStep">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"computeSwapStep">> => {
+      return signExecuteMethod(Pool, this, "computeSwapStep", params);
+    },
+    divRoundingUp: async (
+      params: PoolTypes.SignExecuteMethodParams<"divRoundingUp">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"divRoundingUp">> => {
+      return signExecuteMethod(Pool, this, "divRoundingUp", params);
+    },
+    getNextSqrtPriceFromAmount0RoundingUp: async (
+      params: PoolTypes.SignExecuteMethodParams<"getNextSqrtPriceFromAmount0RoundingUp">
+    ): Promise<
+      PoolTypes.SignExecuteMethodResult<"getNextSqrtPriceFromAmount0RoundingUp">
+    > => {
+      return signExecuteMethod(
+        Pool,
+        this,
+        "getNextSqrtPriceFromAmount0RoundingUp",
+        params
+      );
+    },
+    getNextSqrtPriceFromAmount1RoundingDown: async (
+      params: PoolTypes.SignExecuteMethodParams<"getNextSqrtPriceFromAmount1RoundingDown">
+    ): Promise<
+      PoolTypes.SignExecuteMethodResult<"getNextSqrtPriceFromAmount1RoundingDown">
+    > => {
+      return signExecuteMethod(
+        Pool,
+        this,
+        "getNextSqrtPriceFromAmount1RoundingDown",
+        params
+      );
+    },
+    getNextSqrtPriceFromInput: async (
+      params: PoolTypes.SignExecuteMethodParams<"getNextSqrtPriceFromInput">
+    ): Promise<
+      PoolTypes.SignExecuteMethodResult<"getNextSqrtPriceFromInput">
+    > => {
+      return signExecuteMethod(Pool, this, "getNextSqrtPriceFromInput", params);
+    },
+    getNextSqrtPriceFromOutput: async (
+      params: PoolTypes.SignExecuteMethodParams<"getNextSqrtPriceFromOutput">
+    ): Promise<
+      PoolTypes.SignExecuteMethodResult<"getNextSqrtPriceFromOutput">
+    > => {
+      return signExecuteMethod(
+        Pool,
+        this,
+        "getNextSqrtPriceFromOutput",
+        params
+      );
+    },
+    getAmount0DeltaEx: async (
+      params: PoolTypes.SignExecuteMethodParams<"getAmount0DeltaEx">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"getAmount0DeltaEx">> => {
+      return signExecuteMethod(Pool, this, "getAmount0DeltaEx", params);
+    },
+    getAmount0Delta: async (
+      params: PoolTypes.SignExecuteMethodParams<"getAmount0Delta">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"getAmount0Delta">> => {
+      return signExecuteMethod(Pool, this, "getAmount0Delta", params);
+    },
+    getAmount1DeltaEx: async (
+      params: PoolTypes.SignExecuteMethodParams<"getAmount1DeltaEx">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"getAmount1DeltaEx">> => {
+      return signExecuteMethod(Pool, this, "getAmount1DeltaEx", params);
+    },
+    getAmount1Delta: async (
+      params: PoolTypes.SignExecuteMethodParams<"getAmount1Delta">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"getAmount1Delta">> => {
+      return signExecuteMethod(Pool, this, "getAmount1Delta", params);
+    },
+    mulDiv: async (
+      params: PoolTypes.SignExecuteMethodParams<"mulDiv">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"mulDiv">> => {
+      return signExecuteMethod(Pool, this, "mulDiv", params);
+    },
+    mulDivRoundingUp: async (
+      params: PoolTypes.SignExecuteMethodParams<"mulDivRoundingUp">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"mulDivRoundingUp">> => {
+      return signExecuteMethod(Pool, this, "mulDivRoundingUp", params);
+    },
+    wordPath: async (
+      params: PoolTypes.SignExecuteMethodParams<"wordPath">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"wordPath">> => {
+      return signExecuteMethod(Pool, this, "wordPath", params);
+    },
+    getWord: async (
+      params: PoolTypes.SignExecuteMethodParams<"getWord">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"getWord">> => {
+      return signExecuteMethod(Pool, this, "getWord", params);
+    },
+    getWordOrTemplate: async (
+      params: PoolTypes.SignExecuteMethodParams<"getWordOrTemplate">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"getWordOrTemplate">> => {
+      return signExecuteMethod(Pool, this, "getWordOrTemplate", params);
+    },
+    flipTick: async (
+      params: PoolTypes.SignExecuteMethodParams<"flipTick">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"flipTick">> => {
+      return signExecuteMethod(Pool, this, "flipTick", params);
+    },
+    nextInitializedTickWithinOneWord: async (
+      params: PoolTypes.SignExecuteMethodParams<"nextInitializedTickWithinOneWord">
+    ): Promise<
+      PoolTypes.SignExecuteMethodResult<"nextInitializedTickWithinOneWord">
+    > => {
+      return signExecuteMethod(
+        Pool,
+        this,
+        "nextInitializedTickWithinOneWord",
+        params
+      );
+    },
+    positionPath: async (
+      params: PoolTypes.SignExecuteMethodParams<"positionPath">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"positionPath">> => {
+      return signExecuteMethod(Pool, this, "positionPath", params);
+    },
+    positionContractId: async (
+      params: PoolTypes.SignExecuteMethodParams<"positionContractId">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"positionContractId">> => {
+      return signExecuteMethod(Pool, this, "positionContractId", params);
+    },
+    configPath: async (
+      params: PoolTypes.SignExecuteMethodParams<"configPath">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"configPath">> => {
+      return signExecuteMethod(Pool, this, "configPath", params);
+    },
+    poolPath: async (
+      params: PoolTypes.SignExecuteMethodParams<"poolPath">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"poolPath">> => {
+      return signExecuteMethod(Pool, this, "poolPath", params);
+    },
+    poolContractId: async (
+      params: PoolTypes.SignExecuteMethodParams<"poolContractId">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"poolContractId">> => {
+      return signExecuteMethod(Pool, this, "poolContractId", params);
+    },
+    checkTicks: async (
+      params: PoolTypes.SignExecuteMethodParams<"checkTicks">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"checkTicks">> => {
+      return signExecuteMethod(Pool, this, "checkTicks", params);
+    },
+    tickPath: async (
+      params: PoolTypes.SignExecuteMethodParams<"tickPath">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"tickPath">> => {
+      return signExecuteMethod(Pool, this, "tickPath", params);
+    },
+    toTick: async (
+      params: PoolTypes.SignExecuteMethodParams<"toTick">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"toTick">> => {
+      return signExecuteMethod(Pool, this, "toTick", params);
+    },
+    getTick: async (
+      params: PoolTypes.SignExecuteMethodParams<"getTick">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"getTick">> => {
+      return signExecuteMethod(Pool, this, "getTick", params);
+    },
+    toPosition: async (
+      params: PoolTypes.SignExecuteMethodParams<"toPosition">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"toPosition">> => {
+      return signExecuteMethod(Pool, this, "toPosition", params);
+    },
+    getPosition: async (
+      params: PoolTypes.SignExecuteMethodParams<"getPosition">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"getPosition">> => {
+      return signExecuteMethod(Pool, this, "getPosition", params);
+    },
+    getFeeGrowthInside: async (
+      params: PoolTypes.SignExecuteMethodParams<"getFeeGrowthInside">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"getFeeGrowthInside">> => {
+      return signExecuteMethod(Pool, this, "getFeeGrowthInside", params);
+    },
+    updatePosition: async (
+      params: PoolTypes.SignExecuteMethodParams<"updatePosition">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"updatePosition">> => {
+      return signExecuteMethod(Pool, this, "updatePosition", params);
+    },
+    modifyPosition: async (
+      params: PoolTypes.SignExecuteMethodParams<"modifyPosition">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"modifyPosition">> => {
+      return signExecuteMethod(Pool, this, "modifyPosition", params);
+    },
+    mint: async (
+      params: PoolTypes.SignExecuteMethodParams<"mint">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"mint">> => {
+      return signExecuteMethod(Pool, this, "mint", params);
+    },
+    burn: async (
+      params: PoolTypes.SignExecuteMethodParams<"burn">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"burn">> => {
+      return signExecuteMethod(Pool, this, "burn", params);
+    },
+    collect: async (
+      params: PoolTypes.SignExecuteMethodParams<"collect">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"collect">> => {
+      return signExecuteMethod(Pool, this, "collect", params);
+    },
+    withdraw: async (
+      params: PoolTypes.SignExecuteMethodParams<"withdraw">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"withdraw">> => {
+      return signExecuteMethod(Pool, this, "withdraw", params);
+    },
+    simulateSwap: async (
+      params: PoolTypes.SignExecuteMethodParams<"simulateSwap">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"simulateSwap">> => {
+      return signExecuteMethod(Pool, this, "simulateSwap", params);
+    },
+    swap: async (
+      params: PoolTypes.SignExecuteMethodParams<"swap">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"swap">> => {
+      return signExecuteMethod(Pool, this, "swap", params);
+    },
+    pop: async (
+      params: PoolTypes.SignExecuteMethodParams<"pop">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"pop">> => {
+      return signExecuteMethod(Pool, this, "pop", params);
+    },
+    swapExactOut: async (
+      params: PoolTypes.SignExecuteMethodParams<"swapExactOut">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"swapExactOut">> => {
+      return signExecuteMethod(Pool, this, "swapExactOut", params);
+    },
+    swapExactIn: async (
+      params: PoolTypes.SignExecuteMethodParams<"swapExactIn">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"swapExactIn">> => {
+      return signExecuteMethod(Pool, this, "swapExactIn", params);
+    },
+    getSqrtPricesX96: async (
+      params: PoolTypes.SignExecuteMethodParams<"getSqrtPricesX96">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"getSqrtPricesX96">> => {
+      return signExecuteMethod(Pool, this, "getSqrtPricesX96", params);
+    },
+    updateReward: async (
+      params: PoolTypes.SignExecuteMethodParams<"updateReward">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"updateReward">> => {
+      return signExecuteMethod(Pool, this, "updateReward", params);
+    },
+    updateRewards: async (
+      params: PoolTypes.SignExecuteMethodParams<"updateRewards">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"updateRewards">> => {
+      return signExecuteMethod(Pool, this, "updateRewards", params);
+    },
+    extendRewards: async (
+      params: PoolTypes.SignExecuteMethodParams<"extendRewards">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"extendRewards">> => {
+      return signExecuteMethod(Pool, this, "extendRewards", params);
+    },
+    setRewardParams: async (
+      params: PoolTypes.SignExecuteMethodParams<"setRewardParams">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"setRewardParams">> => {
+      return signExecuteMethod(Pool, this, "setRewardParams", params);
+    },
+    collectProtocolFees: async (
+      params: PoolTypes.SignExecuteMethodParams<"collectProtocolFees">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"collectProtocolFees">> => {
+      return signExecuteMethod(Pool, this, "collectProtocolFees", params);
+    },
+    positionInfo: async (
+      params: PoolTypes.SignExecuteMethodParams<"positionInfo">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"positionInfo">> => {
+      return signExecuteMethod(Pool, this, "positionInfo", params);
+    },
+    getTokenUri: async (
+      params: PoolTypes.SignExecuteMethodParams<"getTokenUri">
+    ): Promise<PoolTypes.SignExecuteMethodResult<"getTokenUri">> => {
+      return signExecuteMethod(Pool, this, "getTokenUri", params);
+    },
+  };
+
+  async multicall<Calls extends PoolTypes.MultiCallParams>(
+    calls: Calls
+  ): Promise<PoolTypes.MultiCallResults<Calls>>;
+  async multicall<Callss extends PoolTypes.MultiCallParams[]>(
+    callss: Narrow<Callss>
+  ): Promise<PoolTypes.MulticallReturnType<Callss>>;
+  async multicall<
+    Callss extends PoolTypes.MultiCallParams | PoolTypes.MultiCallParams[]
+  >(callss: Callss): Promise<unknown> {
+    return await multicallMethods(Pool, this, callss, getContractByCodeHash);
+  }
+}