@sun-protocol/sun-sdk-sunswap-v3 0.1.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,1236 @@
+import { BigintIsh, Token, Price, CurrencyAmount, Percent, Currency, TradeType, Network, TronAddress, ContractCallAction, NativeCurrency, ContractParameter } from '@sun-protocol/sun-sdk-core';
+import JSBI from 'jsbi';
+import { Interface } from '@ethersproject/abi';
+import { BytesLike } from '@ethersproject/bytes';
+
+declare const IS_TVM = true;
+declare const FACTORY_ADDRESS = "0xc2708485c99cd8cf058de1a9a7e3c2d8261a995c";
+declare const ADDRESS_ZERO = "0x0000000000000000000000000000000000000000";
+declare const POOL_INIT_CODE_HASH = "0xba928a717d71946d75999ef1adef801a79cd34a20efecea8b2876b85f5f49580";
+/**
+ * SunSwap V3 factory-enabled fee amounts, denominated in hundredths of bips.
+ *
+ * Migrated from `@sunio/sun-sdk@1.0.9`.
+ */
+declare enum FeeAmount {
+    LOWEST = 100,
+    LOW = 500,
+    MEDIUM = 3000,
+    HIGH = 10000
+}
+/**
+ * Default tick spacing for each supported fee amount.
+ */
+declare const TICK_SPACINGS: Record<FeeAmount, number>;
+
+interface TickConstructorArgs {
+    index: number;
+    liquidityGross: BigintIsh;
+    liquidityNet: BigintIsh;
+}
+declare class Tick {
+    readonly index: number;
+    readonly liquidityGross: JSBI;
+    readonly liquidityNet: JSBI;
+    constructor({ index, liquidityGross, liquidityNet }: TickConstructorArgs);
+}
+
+/**
+ * Provides information about ticks
+ */
+interface TickDataProvider {
+    /**
+     * Return information corresponding to a specific tick
+     * @param tick the tick to load
+     */
+    getTick(tick: number): Promise<{
+        liquidityNet: BigintIsh;
+    }>;
+    /**
+     * Return the next tick that is initialized within a single word
+     * @param tick The current tick
+     * @param lte Whether the next tick should be lte the current tick
+     * @param tickSpacing The tick spacing of the pool
+     */
+    nextInitializedTickWithinOneWord(tick: number, lte: boolean, tickSpacing: number): Promise<[number, boolean]>;
+}
+/**
+ * This tick data provider does not know how to fetch any tick data. It throws whenever it is required. Useful if you
+ * do not need to load tick data for your use case.
+ */
+declare class NoTickDataProvider implements TickDataProvider {
+    private static ERROR_MESSAGE;
+    getTick(_tick: number): Promise<{
+        liquidityNet: BigintIsh;
+    }>;
+    nextInitializedTickWithinOneWord(_tick: number, _lte: boolean, _tickSpacing: number): Promise<[number, boolean]>;
+}
+
+interface PoolConstructorArgs {
+    readonly tokenA: Token;
+    readonly tokenB: Token;
+    readonly fee: FeeAmount;
+    readonly sqrtRatioX96: BigintIsh;
+    readonly liquidity: BigintIsh;
+    readonly tickCurrent: number;
+    readonly ticks?: TickDataProvider | (Tick | TickConstructorArgs)[];
+    readonly isV4?: boolean;
+    readonly tickSpacing?: number;
+}
+/**
+ * Represents a V3 pool
+ */
+declare class Pool {
+    readonly token0: Token;
+    readonly token1: Token;
+    readonly fee: FeeAmount;
+    readonly sqrtRatioX96: JSBI;
+    readonly liquidity: JSBI;
+    readonly tickCurrent: number;
+    readonly tickDataProvider: TickDataProvider;
+    readonly _tickSpacing: number | undefined;
+    readonly isV4: undefined | boolean;
+    private _token0Price?;
+    private _token1Price?;
+    static getAddress(tokenA: Token, tokenB: Token, fee: FeeAmount, initCodeHashManualOverride?: string, factoryAddressOverride?: string): string;
+    /**
+     * Construct a pool
+     * @param tokenA One of the tokens in the pool
+     * @param tokenB The other token in the pool
+     * @param fee The fee in hundredths of a bips of the input amount of every swap that is collected by the pool
+     * @param sqrtRatioX96 The sqrt of the current ratio of amounts of token1 to token0
+     * @param liquidity The current value of in range liquidity
+     * @param tickCurrent The current tick of the pool
+     * @param ticks The current state of the pool ticks or a data provider that can return tick data
+     * @param isV4 v3 or v4
+     * @param tickSpacing number
+     */
+    constructor(args: PoolConstructorArgs);
+    constructor(tokenA: Token, tokenB: Token, fee: FeeAmount, sqrtRatioX96: BigintIsh, liquidity: BigintIsh, tickCurrent: number, ticks?: TickDataProvider | (Tick | TickConstructorArgs)[], isV4?: boolean, tickSpacing?: number);
+    /**
+     * Returns true if the token is either token0 or token1
+     * @param token The token to check
+     * @returns True if token is either token0 or token
+     */
+    involvesToken(token: Token): boolean;
+    /**
+     * Returns the current mid price of the pool in terms of token0, i.e. the ratio of token1 over token0
+     */
+    get token0Price(): Price<Token, Token>;
+    /**
+     * Returns the current mid price of the pool in terms of token1, i.e. the ratio of token0 over token1
+     */
+    get token1Price(): Price<Token, Token>;
+    /**
+     * Return the price of the given token in terms of the other token in the pool.
+     * @param token The token to return price of
+     * @returns The price of the given token, in terms of the other.
+     */
+    priceOf(token: Token): Price<Token, Token>;
+    /**
+     * Returns the chain ID of the tokens in the pool.
+     */
+    get chainId(): number;
+    /**
+     * Given an input amount of a token, return the computed output amount, and a pool with state updated after the trade
+     * @param inputAmount The input amount for which to quote the output amount
+     * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit
+     * @returns The output amount and the pool with updated state
+     */
+    getOutputAmount(inputAmount: CurrencyAmount<Token>, sqrtPriceLimitX96?: JSBI): Promise<[CurrencyAmount<Token>, Pool]>;
+    /**
+     * Given a desired output amount of a token, return the computed input amount and a pool with state updated after the trade
+     * @param outputAmount the output amount for which to quote the input amount
+     * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+     * @returns The input amount and the pool with updated state
+     */
+    getInputAmount(outputAmount: CurrencyAmount<Token>, sqrtPriceLimitX96?: JSBI): Promise<[CurrencyAmount<Token>, Pool]>;
+    /**
+     * Executes a swap
+     * @param zeroForOne Whether the amount in is token0 or token1
+     * @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
+     * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+     * @returns amountCalculated
+     * @returns sqrtRatioX96
+     * @returns liquidity
+     * @returns tickCurrent
+     */
+    private swap;
+    get tickSpacing(): number;
+}
+
+interface PositionConstructorArgs {
+    pool: Pool;
+    tickLower: number;
+    tickUpper: number;
+    liquidity: BigintIsh;
+}
+/**
+ * Represents a position on a Uniswap V3 Pool
+ */
+declare class Position {
+    readonly pool: Pool;
+    readonly tickLower: number;
+    readonly tickUpper: number;
+    readonly liquidity: JSBI;
+    private _token0Amount;
+    private _token1Amount;
+    private _mintAmounts;
+    /**
+     * Constructs a position for a given pool with the given liquidity
+     * @param pool For which pool the liquidity is assigned
+     * @param liquidity The amount of liquidity that is in the position
+     * @param tickLower The lower tick of the position
+     * @param tickUpper The upper tick of the position
+     */
+    constructor({ pool, liquidity, tickLower, tickUpper }: PositionConstructorArgs);
+    /**
+     * Returns the price of token0 at the lower tick
+     */
+    get token0PriceLower(): Price<Token, Token>;
+    /**
+     * Returns the price of token0 at the upper tick
+     */
+    get token0PriceUpper(): Price<Token, Token>;
+    /**
+     * Returns the amount of token0 that this position's liquidity could be burned for at the current pool price
+     */
+    get amount0(): CurrencyAmount<Token>;
+    /**
+     * Returns the amount of token1 that this position's liquidity could be burned for at the current pool price
+     */
+    get amount1(): CurrencyAmount<Token>;
+    /**
+     * Returns the lower and upper sqrt ratios if the price 'slips' up to slippage tolerance percentage
+     * @param slippageTolerance The amount by which the price can 'slip' before the transaction will revert
+     * @returns The sqrt ratios after slippage
+     */
+    private ratiosAfterSlippage;
+    /**
+     * Returns the minimum amounts that must be sent in order to safely mint the amount of liquidity held by the position
+     * with the given slippage tolerance
+     * @param slippageTolerance Tolerance of unfavorable slippage from the current price
+     * @returns The amounts, with slippage
+     */
+    mintAmountsWithSlippage(slippageTolerance: Percent): Readonly<{
+        amount0: JSBI;
+        amount1: JSBI;
+    }>;
+    /**
+     * Returns the minimum amounts that should be requested in order to safely burn the amount of liquidity held by the
+     * position with the given slippage tolerance
+     * @param slippageTolerance tolerance of unfavorable slippage from the current price
+     * @returns The amounts, with slippage
+     */
+    burnAmountsWithSlippage(slippageTolerance: Percent): Readonly<{
+        amount0: JSBI;
+        amount1: JSBI;
+    }>;
+    /**
+     * Returns the minimum amounts that must be sent in order to mint the amount of liquidity held by the position at
+     * the current price for the pool
+     */
+    get mintAmounts(): Readonly<{
+        amount0: JSBI;
+        amount1: JSBI;
+    }>;
+    /**
+     * Computes the maximum amount of liquidity received for a given amount of token0, token1,
+     * and the prices at the tick boundaries.
+     * @param pool The pool for which the position should be created
+     * @param tickLower The lower tick of the position
+     * @param tickUpper The upper tick of the position
+     * @param amount0 token0 amount
+     * @param amount1 token1 amount
+     * @param useFullPrecision If false, liquidity will be maximized according to what the router can calculate,
+     * not what core can theoretically support
+     * @returns The amount of liquidity for the position
+     */
+    static fromAmounts({ pool, tickLower, tickUpper, amount0, amount1, useFullPrecision }: {
+        pool: Pool;
+        tickLower: number;
+        tickUpper: number;
+        amount0: BigintIsh;
+        amount1: BigintIsh;
+        useFullPrecision: boolean;
+    }): Position;
+    /**
+     * Computes a position with the maximum amount of liquidity received for a given amount of token0, assuming an unlimited amount of token1
+     * @param pool The pool for which the position is created
+     * @param tickLower The lower tick
+     * @param tickUpper The upper tick
+     * @param amount0 The desired amount of token0
+     * @param useFullPrecision If true, liquidity will be maximized according to what the router can calculate,
+     * not what core can theoretically support
+     * @returns The position
+     */
+    static fromAmount0({ pool, tickLower, tickUpper, amount0, useFullPrecision }: {
+        pool: Pool;
+        tickLower: number;
+        tickUpper: number;
+        amount0: BigintIsh;
+        useFullPrecision: boolean;
+    }): Position;
+    /**
+     * Computes a position with the maximum amount of liquidity received for a given amount of token1, assuming an unlimited amount of token0
+     * @param pool The pool for which the position is created
+     * @param tickLower The lower tick
+     * @param tickUpper The upper tick
+     * @param amount1 The desired amount of token1
+     * @returns The position
+     */
+    static fromAmount1({ pool, tickLower, tickUpper, amount1 }: {
+        pool: Pool;
+        tickLower: number;
+        tickUpper: number;
+        amount1: BigintIsh;
+    }): Position;
+}
+
+/**
+ * Represents a list of pools through which a swap can occur
+ * @template TInput The input token
+ * @template TOutput The output token
+ */
+declare class Route<TInput extends Currency, TOutput extends Currency> {
+    readonly pools: Pool[];
+    readonly tokenPath: Token[];
+    readonly input: TInput;
+    readonly output: TOutput;
+    private _midPrice;
+    /**
+     * Creates an instance of route.
+     * @param pools An array of `Pool` objects, ordered by the route the swap will take
+     * @param input The input token
+     * @param output The output token
+     */
+    constructor(pools: Pool[], input: TInput, output: TOutput);
+    get chainId(): number;
+    /**
+     * Returns the mid price of the route
+     */
+    get midPrice(): Price<TInput, TOutput>;
+}
+
+/**
+ * A data provider for ticks that is backed by an in-memory array of ticks.
+ */
+declare class TickListDataProvider implements TickDataProvider {
+    private ticks;
+    constructor(ticks: (Tick | TickConstructorArgs)[], tickSpacing: number);
+    getTick(tick: number): Promise<{
+        liquidityNet: BigintIsh;
+        liquidityGross: BigintIsh;
+    }>;
+    nextInitializedTickWithinOneWord(tick: number, lte: boolean, tickSpacing: number): Promise<[number, boolean]>;
+}
+
+/**
+ * Trades comparator, an extension of the input output comparator that also considers other dimensions of the trade in ranking them
+ * @template TInput The input token, either Ether or an ERC-20
+ * @template TOutput The output token, either Ether or an ERC-20
+ * @template TTradeType The trade type, either exact input or exact output
+ * @param a The first trade to compare
+ * @param b The second trade to compare
+ * @returns A sorted ordering for two neighboring elements in a trade array
+ */
+declare function tradeComparator<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(a: Trade<TInput, TOutput, TTradeType>, b: Trade<TInput, TOutput, TTradeType>): number;
+interface BestTradeOptions {
+    maxNumResults?: number;
+    maxHops?: number;
+}
+/**
+ * Represents a trade executed against a set of routes where some percentage of the input is
+ * split across each route.
+ *
+ * Each route has its own set of pools. Pools can not be re-used across routes.
+ *
+ * Does not account for slippage, i.e., changes in price environment that can occur between
+ * the time the trade is submitted and when it is executed.
+ * @template TInput The input token, either Ether or an ERC-20
+ * @template TOutput The output token, either Ether or an ERC-20
+ * @template TTradeType The trade type, either exact input or exact output
+ */
+declare class Trade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
+    /**
+     * @deprecated Deprecated in favor of 'swaps' property. If the trade consists of multiple routes
+     * this will return an error.
+     *
+     * When the trade consists of just a single route, this returns the route of the trade,
+     * i.e. which pools the trade goes through.
+     */
+    get route(): Route<TInput, TOutput>;
+    /**
+     * The swaps of the trade, i.e. which routes and how much is swapped in each that
+     * make up the trade.
+     */
+    readonly swaps: {
+        route: Route<TInput, TOutput>;
+        inputAmount: CurrencyAmount<TInput>;
+        outputAmount: CurrencyAmount<TOutput>;
+    }[];
+    /**
+     * The type of the trade, either exact in or exact out.
+     */
+    readonly tradeType: TTradeType;
+    /**
+     * The cached result of the input amount computation
+     * @private
+     */
+    private _inputAmount;
+    /**
+     * The input amount for the trade assuming no slippage.
+     */
+    get inputAmount(): CurrencyAmount<TInput>;
+    /**
+     * The cached result of the output amount computation
+     * @private
+     */
+    private _outputAmount;
+    /**
+     * The output amount for the trade assuming no slippage.
+     */
+    get outputAmount(): CurrencyAmount<TOutput>;
+    /**
+     * The cached result of the computed execution price
+     * @private
+     */
+    private _executionPrice;
+    /**
+     * The price expressed in terms of output amount/input amount.
+     */
+    get executionPrice(): Price<TInput, TOutput>;
+    /**
+     * The cached result of the price impact computation
+     * @private
+     */
+    private _priceImpact;
+    /**
+     * Returns the percent difference between the route's mid price and the price impact
+     */
+    get priceImpact(): Percent;
+    /**
+     * Constructs an exact in trade with the given amount in and route
+     * @template TInput The input token, either Ether or an ERC-20
+     * @template TOutput The output token, either Ether or an ERC-20
+     * @param route The route of the exact in trade
+     * @param amountIn The amount being passed in
+     * @returns The exact in trade
+     */
+    static exactIn<TInput extends Currency, TOutput extends Currency>(route: Route<TInput, TOutput>, amountIn: CurrencyAmount<TInput>): Promise<Trade<TInput, TOutput, TradeType.EXACT_INPUT>>;
+    /**
+     * Constructs an exact out trade with the given amount out and route
+     * @template TInput The input token, either Ether or an ERC-20
+     * @template TOutput The output token, either Ether or an ERC-20
+     * @param route The route of the exact out trade
+     * @param amountOut The amount returned by the trade
+     * @returns The exact out trade
+     */
+    static exactOut<TInput extends Currency, TOutput extends Currency>(route: Route<TInput, TOutput>, amountOut: CurrencyAmount<TOutput>): Promise<Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>>;
+    /**
+     * Constructs a trade by simulating swaps through the given route
+     * @template TInput The input token, either Ether or an ERC-20.
+     * @template TOutput The output token, either Ether or an ERC-20.
+     * @template TTradeType The type of the trade, either exact in or exact out.
+     * @param route route to swap through
+     * @param amount the amount specified, either input or output, depending on tradeType
+     * @param tradeType whether the trade is an exact input or exact output swap
+     * @returns The route
+     */
+    static fromRoute<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(route: Route<TInput, TOutput>, amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>, tradeType: TTradeType): Promise<Trade<TInput, TOutput, TTradeType>>;
+    /**
+     * Constructs a trade from routes by simulating swaps
+     *
+     * @template TInput The input token, either Ether or an ERC-20.
+     * @template TOutput The output token, either Ether or an ERC-20.
+     * @template TTradeType The type of the trade, either exact in or exact out.
+     * @param routes the routes to swap through and how much of the amount should be routed through each
+     * @param tradeType whether the trade is an exact input or exact output swap
+     * @returns The trade
+     */
+    static fromRoutes<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(routes: {
+        amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>;
+        route: Route<TInput, TOutput>;
+    }[], tradeType: TTradeType): Promise<Trade<TInput, TOutput, TTradeType>>;
+    /**
+     * Creates a trade without computing the result of swapping through the route. Useful when you have simulated the trade
+     * elsewhere and do not have any tick data
+     * @template TInput The input token, either Ether or an ERC-20
+     * @template TOutput The output token, either Ether or an ERC-20
+     * @template TTradeType The type of the trade, either exact in or exact out
+     * @param constructorArguments The arguments passed to the trade constructor
+     * @returns The unchecked trade
+     */
+    static createUncheckedTrade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(constructorArguments: {
+        route: Route<TInput, TOutput>;
+        inputAmount: CurrencyAmount<TInput>;
+        outputAmount: CurrencyAmount<TOutput>;
+        tradeType: TTradeType;
+    }): Trade<TInput, TOutput, TTradeType>;
+    /**
+     * Creates a trade without computing the result of swapping through the routes. Useful when you have simulated the trade
+     * elsewhere and do not have any tick data
+     * @template TInput The input token, either Ether or an ERC-20
+     * @template TOutput The output token, either Ether or an ERC-20
+     * @template TTradeType The type of the trade, either exact in or exact out
+     * @param constructorArguments The arguments passed to the trade constructor
+     * @returns The unchecked trade
+     */
+    static createUncheckedTradeWithMultipleRoutes<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(constructorArguments: {
+        routes: {
+            route: Route<TInput, TOutput>;
+            inputAmount: CurrencyAmount<TInput>;
+            outputAmount: CurrencyAmount<TOutput>;
+        }[];
+        tradeType: TTradeType;
+    }): Trade<TInput, TOutput, TTradeType>;
+    /**
+     * Construct a trade by passing in the pre-computed property values
+     * @param routes The routes through which the trade occurs
+     * @param tradeType The type of trade, exact input or exact output
+     */
+    private constructor();
+    /**
+     * Get the minimum amount that must be received from this trade for the given slippage tolerance
+     * @param slippageTolerance The tolerance of unfavorable slippage from the execution price of this trade
+     * @returns The amount out
+     */
+    minimumAmountOut(slippageTolerance: Percent, amountOut?: CurrencyAmount<TOutput>): CurrencyAmount<TOutput>;
+    /**
+     * Get the maximum amount in that can be spent via this trade for the given slippage tolerance
+     * @param slippageTolerance The tolerance of unfavorable slippage from the execution price of this trade
+     * @returns The amount in
+     */
+    maximumAmountIn(slippageTolerance: Percent, amountIn?: CurrencyAmount<TInput>): CurrencyAmount<TInput>;
+    /**
+     * Return the execution price after accounting for slippage tolerance
+     * @param slippageTolerance the allowed tolerated slippage
+     * @returns The execution price
+     */
+    worstExecutionPrice(slippageTolerance: Percent): Price<TInput, TOutput>;
+    /**
+     * Given a list of pools, and a fixed amount in, returns the top `maxNumResults` trades that go from an input token
+     * amount to an output token, making at most `maxHops` hops.
+     * Note this does not consider aggregation, as routes are linear. It's possible a better route exists by splitting
+     * the amount in among multiple routes.
+     * @param pools the pools to consider in finding the best trade
+     * @param nextAmountIn exact amount of input currency to spend
+     * @param currencyOut the desired currency out
+     * @param maxNumResults maximum number of results to return
+     * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pool
+     * @param currentPools used in recursion; the current list of pools
+     * @param currencyAmountIn used in recursion; the original value of the currencyAmountIn parameter
+     * @param bestTrades used in recursion; the current list of best trades
+     * @returns The exact in trade
+     */
+    static bestTradeExactIn<TInput extends Currency, TOutput extends Currency>(pools: Pool[], currencyAmountIn: CurrencyAmount<TInput>, currencyOut: TOutput, { maxNumResults, maxHops }?: BestTradeOptions, currentPools?: Pool[], nextAmountIn?: CurrencyAmount<Currency>, bestTrades?: Trade<TInput, TOutput, TradeType.EXACT_INPUT>[]): Promise<Trade<TInput, TOutput, TradeType.EXACT_INPUT>[]>;
+    /**
+     * similar to the above method but instead targets a fixed output amount
+     * given a list of pools, and a fixed amount out, returns the top `maxNumResults` trades that go from an input token
+     * to an output token amount, making at most `maxHops` hops
+     * note this does not consider aggregation, as routes are linear. it's possible a better route exists by splitting
+     * the amount in among multiple routes.
+     * @param pools the pools to consider in finding the best trade
+     * @param currencyIn the currency to spend
+     * @param currencyAmountOut the desired currency amount out
+     * @param nextAmountOut the exact amount of currency out
+     * @param maxNumResults maximum number of results to return
+     * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pool
+     * @param currentPools used in recursion; the current list of pools
+     * @param bestTrades used in recursion; the current list of best trades
+     * @returns The exact out trade
+     */
+    static bestTradeExactOut<TInput extends Currency, TOutput extends Currency>(pools: Pool[], currencyIn: TInput, currencyAmountOut: CurrencyAmount<TOutput>, { maxNumResults, maxHops }?: BestTradeOptions, currentPools?: Pool[], nextAmountOut?: CurrencyAmount<Currency>, bestTrades?: Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[]): Promise<Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[]>;
+}
+
+declare const V3_POSITION_MANAGER_SELECTORS: {
+    readonly createAndInitializePoolIfNecessary: "createAndInitializePoolIfNecessary(address,address,uint24,uint160)";
+    readonly mint: "mint((address,address,uint24,int24,int24,uint256,uint256,uint256,uint256,address,uint256))";
+    readonly increaseLiquidity: "increaseLiquidity((uint256,uint256,uint256,uint256,uint256,uint256))";
+    readonly decreaseLiquidity: "decreaseLiquidity((uint256,uint128,uint256,uint256,uint256))";
+    readonly collect: "collect((uint256,address,uint128,uint128))";
+};
+declare const MaxUint128: JSBI;
+interface V3ActionOptions {
+    readonly network: Network;
+    readonly positionManager?: TronAddress;
+    readonly feeLimit?: number;
+    readonly id?: string;
+}
+interface BuildV3CreatePoolActionParams extends V3ActionOptions {
+    readonly pool: Pool;
+}
+interface BuildV3MintPositionActionParams extends V3ActionOptions {
+    readonly position: Position;
+    readonly recipient: TronAddress;
+    readonly amount0Min: BigintIsh;
+    readonly amount1Min: BigintIsh;
+    readonly deadline: BigintIsh;
+}
+interface BuildV3IncreaseLiquidityActionParams extends V3ActionOptions {
+    readonly tokenId: BigintIsh;
+    readonly position: Position;
+    readonly amount0Min: BigintIsh;
+    readonly amount1Min: BigintIsh;
+    readonly deadline: BigintIsh;
+}
+interface BuildV3DecreaseLiquidityActionParams extends V3ActionOptions {
+    readonly tokenId: BigintIsh;
+    readonly liquidity: BigintIsh;
+    readonly amount0Min: BigintIsh;
+    readonly amount1Min: BigintIsh;
+    readonly deadline: BigintIsh;
+}
+interface BuildV3CollectActionParams extends V3ActionOptions {
+    readonly tokenId: BigintIsh;
+    readonly recipient: TronAddress;
+    readonly amount0Max?: BigintIsh;
+    readonly amount1Max?: BigintIsh;
+}
+declare function buildV3CreatePoolAction(params: BuildV3CreatePoolActionParams): ContractCallAction;
+declare function buildV3MintPositionAction(params: BuildV3MintPositionActionParams): ContractCallAction;
+declare function buildV3IncreaseLiquidityAction(params: BuildV3IncreaseLiquidityActionParams): ContractCallAction;
+declare function buildV3DecreaseLiquidityAction(params: BuildV3DecreaseLiquidityActionParams): ContractCallAction;
+declare function buildV3CollectAction(params: BuildV3CollectActionParams): ContractCallAction;
+
+declare const V3_POOL_SLOT0_ABI: {
+    readonly type: "function";
+    readonly name: "slot0";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "sqrtPriceX96";
+        readonly type: "uint160";
+    }, {
+        readonly name: "tick";
+        readonly type: "int24";
+    }, {
+        readonly name: "observationIndex";
+        readonly type: "uint16";
+    }, {
+        readonly name: "observationCardinality";
+        readonly type: "uint16";
+    }, {
+        readonly name: "observationCardinalityNext";
+        readonly type: "uint16";
+    }, {
+        readonly name: "feeProtocol";
+        readonly type: "uint8";
+    }, {
+        readonly name: "unlocked";
+        readonly type: "bool";
+    }];
+};
+declare const V3_POOL_LIQUIDITY_ABI: {
+    readonly type: "function";
+    readonly name: "liquidity";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint128";
+    }];
+};
+declare const V3_POOL_FEE_ABI: {
+    readonly type: "function";
+    readonly name: "fee";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint24";
+    }];
+};
+declare const V3_POOL_TICK_SPACING_ABI: {
+    readonly type: "function";
+    readonly name: "tickSpacing";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "int24";
+    }];
+};
+declare const V3_POSITION_MANAGER_POSITIONS_ABI: {
+    readonly type: "function";
+    readonly name: "positions";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "nonce";
+        readonly type: "uint96";
+    }, {
+        readonly name: "operator";
+        readonly type: "address";
+    }, {
+        readonly name: "token0";
+        readonly type: "address";
+    }, {
+        readonly name: "token1";
+        readonly type: "address";
+    }, {
+        readonly name: "fee";
+        readonly type: "uint24";
+    }, {
+        readonly name: "tickLower";
+        readonly type: "int24";
+    }, {
+        readonly name: "tickUpper";
+        readonly type: "int24";
+    }, {
+        readonly name: "liquidity";
+        readonly type: "uint128";
+    }, {
+        readonly name: "feeGrowthInside0LastX128";
+        readonly type: "uint256";
+    }, {
+        readonly name: "feeGrowthInside1LastX128";
+        readonly type: "uint256";
+    }, {
+        readonly name: "tokensOwed0";
+        readonly type: "uint128";
+    }, {
+        readonly name: "tokensOwed1";
+        readonly type: "uint128";
+    }];
+};
+declare const V3_POSITION_MANAGER_OWNER_OF_ABI: {
+    readonly type: "function";
+    readonly name: "ownerOf";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+};
+declare const V3_POSITION_MANAGER_GET_APPROVED_ABI: {
+    readonly type: "function";
+    readonly name: "getApproved";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+};
+declare const V3_POSITION_MANAGER_IS_APPROVED_FOR_ALL_ABI: {
+    readonly type: "function";
+    readonly name: "isApprovedForAll";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "operator";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+};
+
+declare abstract class Multicall {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static encodeMulticall(calldatas: string | string[]): string;
+}
+
+/**
+ * Generated method parameters for executing a call.
+ */
+interface MethodParameters {
+    /**
+     * The hex encoded calldata to perform the given operation
+     */
+    calldata: string;
+    /**
+     * The amount of ether (wei) to send in hex.
+     */
+    value: string;
+    /**
+     * function_selector
+     */
+    function_selector: string;
+    /**
+     * parameter
+     */
+    parameter: Array<object>;
+}
+/**
+ * Converts a big int to a hex string
+ * @param bigintIsh
+ * @returns The hex encoded calldata
+ */
+declare function toHex(bigintIsh: BigintIsh): string;
+
+interface StandardPermitArguments {
+    v: 0 | 1 | 27 | 28;
+    r: string;
+    s: string;
+    amount: BigintIsh;
+    deadline: BigintIsh;
+}
+interface AllowedPermitArguments {
+    v: 0 | 1 | 27 | 28;
+    r: string;
+    s: string;
+    nonce: BigintIsh;
+    expiry: BigintIsh;
+}
+type PermitOptions = StandardPermitArguments | AllowedPermitArguments;
+declare abstract class SelfPermit {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static encodePermit(token: Token, options: PermitOptions): string;
+}
+
+interface MintSpecificOptions {
+    /**
+     * The account that should receive the minted NFT.
+     */
+    recipient: string;
+    /**
+     * Creates pool if not initialized before mint.
+     */
+    createPool?: boolean;
+}
+interface IncreaseSpecificOptions {
+    /**
+     * Indicates the ID of the position to increase liquidity for.
+     */
+    tokenId: BigintIsh;
+}
+/**
+ * Options for producing the calldata to add liquidity.
+ */
+interface CommonAddLiquidityOptions {
+    /**
+     * How much the pool price is allowed to move.
+     */
+    slippageTolerance: Percent;
+    /**
+     * When the transaction expires, in epoch seconds.
+     */
+    deadline: BigintIsh;
+    /**
+     * Whether to spend ether. If true, one of the pool tokens must be WETH, by default false
+     */
+    useNative?: NativeCurrency;
+    /**
+     * The optional permit parameters for spending token0
+     */
+    token0Permit?: PermitOptions;
+    /**
+     * The optional permit parameters for spending token1
+     */
+    token1Permit?: PermitOptions;
+}
+type MintOptions = CommonAddLiquidityOptions & MintSpecificOptions;
+type IncreaseOptions = CommonAddLiquidityOptions & IncreaseSpecificOptions;
+type AddLiquidityOptions = MintOptions | IncreaseOptions;
+interface SafeTransferOptions {
+    /**
+     * The account sending the NFT.
+     */
+    sender: string;
+    /**
+     * The account that should receive the NFT.
+     */
+    recipient: string;
+    /**
+     * The id of the token being sent.
+     */
+    tokenId: BigintIsh;
+    /**
+     * The optional parameter that passes data to the `onERC721Received` call for the staker
+     */
+    data?: string;
+}
+interface CollectOptions {
+    /**
+     * Indicates the ID of the position to collect for.
+     */
+    tokenId: BigintIsh;
+    /**
+     * Expected value of tokensOwed0, including as-of-yet-unaccounted-for fees/liquidity value to be burned
+     */
+    expectedCurrencyOwed0: CurrencyAmount<Currency>;
+    /**
+     * Expected value of tokensOwed1, including as-of-yet-unaccounted-for fees/liquidity value to be burned
+     */
+    expectedCurrencyOwed1: CurrencyAmount<Currency>;
+    /**
+     * The account that should receive the tokens.
+     */
+    recipient: string;
+}
+interface NFTPermitOptions {
+    v: 0 | 1 | 27 | 28;
+    r: string;
+    s: string;
+    deadline: BigintIsh;
+    spender: string;
+}
+/**
+ * Options for producing the calldata to exit a position.
+ */
+interface RemoveLiquidityOptions {
+    /**
+     * The ID of the token to exit
+     */
+    tokenId: BigintIsh;
+    /**
+     * The percentage of position liquidity to exit.
+     */
+    liquidityPercentage: Percent;
+    /**
+     * How much the pool price is allowed to move.
+     */
+    slippageTolerance: Percent;
+    /**
+     * When the transaction expires, in epoch seconds.
+     */
+    deadline: BigintIsh;
+    /**
+     * Whether the NFT should be burned if the entire position is being exited, by default false.
+     */
+    burnToken?: boolean;
+    /**
+     * The optional permit of the token ID being exited, in case the exit transaction is being sent by an account that does not own the NFT
+     */
+    permit?: NFTPermitOptions;
+    /**
+     * Parameters to be passed on to collect
+     */
+    collectOptions: Omit<CollectOptions, 'tokenId'>;
+}
+declare abstract class NonfungiblePositionManager {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    private static encodeCreate;
+    static createCallParameters(pool: Pool): MethodParameters;
+    static addCallParameters(position: Position, options: AddLiquidityOptions): MethodParameters;
+    private static encodeCollect;
+    static collectCallParameters(options: CollectOptions): MethodParameters;
+    /**
+     * Produces the calldata for completely or partially exiting a position
+     * @param position The position to exit
+     * @param options Additional information necessary for generating the calldata
+     * @returns The call parameters
+     */
+    static removeCallParameters(position: Position, options: RemoveLiquidityOptions): MethodParameters;
+    static safeTransferFromParameters(options: SafeTransferOptions): MethodParameters;
+}
+
+interface FeeOptions {
+    /**
+     * The percent of the output that will be taken as a fee.
+     */
+    fee: Percent;
+    /**
+     * The recipient of the fee.
+     */
+    recipient: string;
+}
+declare abstract class Payments {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    private static encodeFeeBips;
+    static encodeUnwrapWETH9(amountMinimum: JSBI, recipient: string, feeOptions?: FeeOptions): string;
+    static encodeSweepToken(token: Token, amountMinimum: JSBI, recipient: string, feeOptions?: FeeOptions): string;
+    static encodeRefundETH(): string;
+}
+
+declare const V3_INIT_CODE_HASH: Record<Network, `0x${string}`>;
+interface ComputeV3PoolAddressParams {
+    readonly network: Network;
+    readonly tokenA: Token | TronAddress | string;
+    readonly tokenB: Token | TronAddress | string;
+    readonly fee: number;
+    readonly factory?: TronAddress | string;
+    readonly initCodeHash?: string;
+    readonly wrappedNative?: TronAddress | string;
+}
+declare function computeV3PoolAddress(params: ComputeV3PoolAddressParams): TronAddress;
+
+interface V3ContractReadSpec {
+    readonly target: TronAddress;
+    readonly functionSelector: string;
+    readonly parameters?: readonly ContractParameter[];
+    readonly abiFunction?: unknown;
+    readonly metadata?: Record<string, unknown>;
+}
+declare const V3_POOL_READ_SELECTORS: {
+    readonly slot0: "slot0()";
+    readonly liquidity: "liquidity()";
+    readonly fee: "fee()";
+    readonly tickSpacing: "tickSpacing()";
+};
+declare const V3_POSITION_MANAGER_READ_SELECTORS: {
+    readonly positions: "positions(uint256)";
+    readonly ownerOf: "ownerOf(uint256)";
+    readonly getApproved: "getApproved(uint256)";
+    readonly isApprovedForAll: "isApprovedForAll(address,address)";
+};
+interface V3ReadOptions {
+    readonly network: Network;
+    readonly positionManager?: TronAddress;
+}
+interface BuildV3PoolReadParams {
+    readonly pool: TronAddress;
+}
+interface BuildV3PositionReadParams extends V3ReadOptions {
+    readonly tokenId: BigintIsh;
+}
+interface BuildV3PositionApprovalReadParams extends V3ReadOptions {
+    readonly owner: TronAddress;
+    readonly operator: TronAddress;
+}
+declare function buildV3PoolSlot0Read(params: BuildV3PoolReadParams): V3ContractReadSpec;
+declare function buildV3PoolLiquidityRead(params: BuildV3PoolReadParams): V3ContractReadSpec;
+declare function buildV3PoolFeeRead(params: BuildV3PoolReadParams): V3ContractReadSpec;
+declare function buildV3PoolTickSpacingRead(params: BuildV3PoolReadParams): V3ContractReadSpec;
+declare function buildV3PoolStateReads(params: BuildV3PoolReadParams): readonly V3ContractReadSpec[];
+declare function buildV3PositionRead(params: BuildV3PositionReadParams): V3ContractReadSpec;
+declare function buildV3PositionOwnerRead(params: BuildV3PositionReadParams): V3ContractReadSpec;
+declare function buildV3PositionApprovedRead(params: BuildV3PositionReadParams): V3ContractReadSpec;
+declare function buildV3PositionApprovalForAllRead(params: BuildV3PositionApprovalReadParams): V3ContractReadSpec;
+declare function buildV3PositionReads(params: BuildV3PositionReadParams): readonly V3ContractReadSpec[];
+
+interface V3PoolKey {
+    readonly network: Network;
+    readonly token0: Token;
+    readonly token1: Token;
+    readonly fee: FeeAmount;
+}
+interface V3PoolState {
+    readonly poolKey: V3PoolKey;
+    readonly sqrtRatioX96: JSBI;
+    readonly liquidity: JSBI;
+    readonly tickCurrent: number;
+    readonly tickSpacing: number;
+}
+interface V3TickRange {
+    readonly tickLower: number;
+    readonly tickUpper: number;
+}
+interface V3Position {
+    readonly tokenId: BigintIsh;
+    readonly poolKey: V3PoolKey;
+    readonly liquidity: JSBI;
+    readonly tickLower: number;
+    readonly tickUpper: number;
+    readonly tokensOwed0?: JSBI;
+    readonly tokensOwed1?: JSBI;
+    readonly feeGrowthInside0LastX128?: JSBI;
+    readonly feeGrowthInside1LastX128?: JSBI;
+}
+
+/**
+ * Computes a pool address
+ * @param factoryAddress The Uniswap V3 factory address
+ * @param tokenA The first token of the pair, irrespective of sort order
+ * @param tokenB The second token of the pair, irrespective of sort order
+ * @param fee The fee tier of the pool
+ * @param initCodeHashManualOverride Override the init code hash used to compute the pool address if necessary
+ * @returns The pool address
+ */
+declare function computePoolAddress({ factoryAddress, tokenA, tokenB, fee, initCodeHashManualOverride }: {
+    factoryAddress: string;
+    tokenA: Token;
+    tokenB: Token;
+    fee: FeeAmount;
+    initCodeHashManualOverride?: string;
+}): string;
+
+declare function getTronCreate2Address(from: string, salt: BytesLike, initCodeHash: BytesLike): string;
+
+/**
+ * Returns the sqrt ratio as a Q64.96 corresponding to amount1 / amount0.
+ *
+ * Migrated from `@sunio/sun-sdk@1.0.9`.
+ */
+declare function encodeSqrtRatioX96(amount1: BigintIsh, amount0: BigintIsh): JSBI;
+
+/**
+ * Converts a route to a hex encoded path
+ * @param route the v3 path to convert to an encoded path
+ * @param exactOutput whether the route should be encoded in reverse, for making exact output swaps
+ */
+declare function encodeRouteToPath(route: Route<Currency, Currency>, exactOutput: boolean): string;
+
+/**
+ * Fixed-point multiplication/division helpers.
+ *
+ * Migrated from `@sunio/sun-sdk@1.0.9`.
+ */
+declare abstract class FullMath {
+    private constructor();
+    static mulDivRoundingUp(a: JSBI, b: JSBI, denominator: JSBI): JSBI;
+}
+
+/**
+ * Determines if a tick list is sorted
+ * @param list The tick list
+ * @param comparator The comparator
+ * @returns true if sorted
+ */
+declare function isSorted<T>(list: Array<T>, comparator: (a: T, b: T) => number): boolean;
+
+declare abstract class LiquidityMath {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static addDelta(x: JSBI, y: JSBI): JSBI;
+}
+
+/**
+ * Computes the maximum liquidity received for token0/token1 amounts.
+ *
+ * Migrated from `@sunio/sun-sdk@1.0.9`.
+ */
+declare function maxLiquidityForAmounts(sqrtRatioCurrentX96: JSBI, sqrtRatioAX96: JSBI, sqrtRatioBX96: JSBI, amount0: BigintIsh, amount1: BigintIsh, useFullPrecision: boolean): JSBI;
+
+/**
+ * Returns the index of the most significant bit of the input.
+ *
+ * Migrated from `@sunio/sun-sdk@1.0.9`.
+ */
+declare function mostSignificantBit(x: JSBI): number;
+
+/**
+ * Returns the closest usable tick for the given tick spacing.
+ *
+ * Migrated from `@sunio/sun-sdk@1.0.9`.
+ */
+declare function nearestUsableTick(tick: number, tickSpacing: number): number;
+
+declare abstract class PositionLibrary {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static getTokensOwed(feeGrowthInside0LastX128: JSBI, feeGrowthInside1LastX128: JSBI, liquidity: JSBI, feeGrowthInside0X128: JSBI, feeGrowthInside1X128: JSBI): JSBI[];
+}
+
+/**
+ * Returns a price object corresponding to the input tick and the base/quote token
+ * Inputs must be tokens because the address order is used to interpret the price represented by the tick
+ * @param baseToken the base token of the price
+ * @param quoteToken the quote token of the price
+ * @param tick the tick for which to return the price
+ */
+declare function tickToPrice(baseToken: Token, quoteToken: Token, tick: number): Price<Token, Token>;
+/**
+ * Returns the first tick for which the given price is greater than or equal to the tick price
+ * @param price for which to return the closest tick that represents a price less than or equal to the input price,
+ * i.e. the price of the returned tick is less than or equal to the input price
+ */
+declare function priceToClosestTick(price: Price<Token, Token>): number;
+
+/**
+ * Sqrt price delta and next-price math for V3 pools.
+ *
+ * Migrated from `@sunio/sun-sdk@1.0.9`.
+ */
+declare abstract class SqrtPriceMath {
+    private constructor();
+    static getAmount0Delta(sqrtRatioAX96: JSBI, sqrtRatioBX96: JSBI, liquidity: JSBI, roundUp: boolean): JSBI;
+    static getAmount1Delta(sqrtRatioAX96: JSBI, sqrtRatioBX96: JSBI, liquidity: JSBI, roundUp: boolean): JSBI;
+    static getNextSqrtPriceFromInput(sqrtPX96: JSBI, liquidity: JSBI, amountIn: JSBI, zeroForOne: boolean): JSBI;
+    static getNextSqrtPriceFromOutput(sqrtPX96: JSBI, liquidity: JSBI, amountOut: JSBI, zeroForOne: boolean): JSBI;
+    private static getNextSqrtPriceFromAmount0RoundingUp;
+    private static getNextSqrtPriceFromAmount1RoundingDown;
+}
+
+declare abstract class SwapMath {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static computeSwapStep(sqrtRatioCurrentX96: JSBI, sqrtRatioTargetX96: JSBI, liquidity: JSBI, amountRemaining: JSBI, feePips: FeeAmount): [JSBI, JSBI, JSBI, JSBI];
+}
+
+interface FeeGrowthOutside {
+    feeGrowthOutside0X128: JSBI;
+    feeGrowthOutside1X128: JSBI;
+}
+declare function subIn256(x: JSBI, y: JSBI): JSBI;
+declare abstract class TickLibrary {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static getFeeGrowthInside(feeGrowthOutsideLower: FeeGrowthOutside, feeGrowthOutsideUpper: FeeGrowthOutside, tickLower: number, tickUpper: number, tickCurrent: number, feeGrowthGlobal0X128: JSBI, feeGrowthGlobal1X128: JSBI): JSBI[];
+}
+
+/**
+ * Utility methods for interacting with sorted lists of ticks
+ */
+declare abstract class TickList {
+    /**
+     * Cannot be constructed
+     */
+    private constructor();
+    static validateList(ticks: Tick[], tickSpacing: number): void;
+    static isBelowSmallest(ticks: readonly Tick[], tick: number): boolean;
+    static isAtOrAboveLargest(ticks: readonly Tick[], tick: number): boolean;
+    static getTick(ticks: readonly Tick[], index: number): Tick;
+    /**
+     * Finds the largest tick in the list of ticks that is less than or equal to tick
+     * @param ticks list of ticks
+     * @param tick tick to find the largest tick that is less than or equal to tick
+     * @private
+     */
+    private static binarySearch;
+    static nextInitializedTick(ticks: readonly Tick[], tick: number, lte: boolean): Tick;
+    static nextInitializedTickWithinOneWord(ticks: readonly Tick[], tick: number, lte: boolean, tickSpacing: number): [number, boolean];
+}
+
+/**
+ * Math library for converting between ticks and sqrt ratios.
+ *
+ * Migrated from `@sunio/sun-sdk@1.0.9`.
+ */
+declare abstract class TickMath {
+    private constructor();
+    static MIN_TICK: number;
+    static MAX_TICK: number;
+    static MIN_SQRT_RATIO: JSBI;
+    static MAX_SQRT_RATIO: JSBI;
+    static getSqrtRatioAtTick(tick: number): JSBI;
+    static getTickAtSqrtRatio(sqrtRatioX96: JSBI): number;
+}
+
+declare function isSupportedFeeAmount(fee: number): fee is FeeAmount;
+declare function getTickSpacing(fee: FeeAmount): number;
+declare function validateTickSpacing(tickSpacing: number): number;
+declare function validateTickRange(tickLower: number, tickUpper: number, tickSpacing: number): {
+    tickLower: number;
+    tickUpper: number;
+};
+declare function validateTickRangeForFee(tickLower: number, tickUpper: number, fee: FeeAmount): {
+    tickLower: number;
+    tickUpper: number;
+    tickSpacing: number;
+};
+
+export { ADDRESS_ZERO, type AddLiquidityOptions, type AllowedPermitArguments, type BestTradeOptions, type BuildV3CollectActionParams, type BuildV3CreatePoolActionParams, type BuildV3DecreaseLiquidityActionParams, type BuildV3IncreaseLiquidityActionParams, type BuildV3MintPositionActionParams, type BuildV3PoolReadParams, type BuildV3PositionApprovalReadParams, type BuildV3PositionReadParams, type CollectOptions, type CommonAddLiquidityOptions, type ComputeV3PoolAddressParams, FACTORY_ADDRESS, FeeAmount, type FeeOptions, FullMath, IS_TVM, type IncreaseOptions, type IncreaseSpecificOptions, LiquidityMath, MaxUint128, type MethodParameters, type MintOptions, type MintSpecificOptions, Multicall, type NFTPermitOptions, NoTickDataProvider, NonfungiblePositionManager, POOL_INIT_CODE_HASH, Payments, type PermitOptions, Pool, type PoolConstructorArgs, Position, PositionLibrary, type RemoveLiquidityOptions, Route, type SafeTransferOptions, SelfPermit, SqrtPriceMath, type StandardPermitArguments, SwapMath, TICK_SPACINGS, Tick, type TickConstructorArgs, type TickDataProvider, TickLibrary, TickList, TickListDataProvider, TickMath, Trade, type V3ActionOptions, type V3ContractReadSpec, type V3PoolKey, type V3PoolState, type V3Position, type V3ReadOptions, type V3TickRange, V3_INIT_CODE_HASH, V3_POOL_FEE_ABI, V3_POOL_LIQUIDITY_ABI, V3_POOL_READ_SELECTORS, V3_POOL_SLOT0_ABI, V3_POOL_TICK_SPACING_ABI, V3_POSITION_MANAGER_GET_APPROVED_ABI, V3_POSITION_MANAGER_IS_APPROVED_FOR_ALL_ABI, V3_POSITION_MANAGER_OWNER_OF_ABI, V3_POSITION_MANAGER_POSITIONS_ABI, V3_POSITION_MANAGER_READ_SELECTORS, V3_POSITION_MANAGER_SELECTORS, buildV3CollectAction, buildV3CreatePoolAction, buildV3DecreaseLiquidityAction, buildV3IncreaseLiquidityAction, buildV3MintPositionAction, buildV3PoolFeeRead, buildV3PoolLiquidityRead, buildV3PoolSlot0Read, buildV3PoolStateReads, buildV3PoolTickSpacingRead, buildV3PositionApprovalForAllRead, buildV3PositionApprovedRead, buildV3PositionOwnerRead, buildV3PositionRead, buildV3PositionReads, computePoolAddress, computeV3PoolAddress, encodeRouteToPath, encodeSqrtRatioX96, getTickSpacing, getTronCreate2Address, isSorted, isSupportedFeeAmount, maxLiquidityForAmounts, mostSignificantBit, nearestUsableTick, priceToClosestTick, subIn256, tickToPrice, toHex, tradeComparator, validateTickRange, validateTickRangeForFee, validateTickSpacing };