@huuduynvc/v3-sdk 3.24.1

package/dist/nonfungiblePositionManager.d.ts

@@ -0,0 +1,159 @@
+import { BigintIsh, Percent, CurrencyAmount, Currency, NativeCurrency } from '@uniswap/sdk-core';
+import { Position } from './entities/position';
+import { MethodParameters } from './utils/calldata';
+import { Interface } from '@ethersproject/abi';
+import { TypedDataDomain, TypedDataField } from '@ethersproject/abstract-signer';
+import { PermitOptions } from './selfPermit';
+import { Pool } from './entities';
+export interface MintSpecificOptions {
+    /**
+     * The account that should receive the minted NFT.
+     */
+    recipient: string;
+    /**
+     * Creates pool if not initialized before mint.
+     */
+    createPool?: boolean;
+}
+export interface IncreaseSpecificOptions {
+    /**
+     * Indicates the ID of the position to increase liquidity for.
+     */
+    tokenId: BigintIsh;
+}
+/**
+ * Options for producing the calldata to add liquidity.
+ */
+export 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;
+}
+export declare type MintOptions = CommonAddLiquidityOptions & MintSpecificOptions;
+export declare type IncreaseOptions = CommonAddLiquidityOptions & IncreaseSpecificOptions;
+export declare type AddLiquidityOptions = MintOptions | IncreaseOptions;
+export 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;
+}
+export 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;
+}
+export interface NFTPermitValues {
+    spender: string;
+    tokenId: BigintIsh;
+    deadline: BigintIsh;
+    nonce: BigintIsh;
+}
+export interface NFTPermitData {
+    domain: TypedDataDomain;
+    types: Record<string, TypedDataField[]>;
+    values: NFTPermitValues;
+}
+export interface NFTPermitOptions {
+    v: 0 | 1 | 27 | 28;
+    r: string;
+    s: string;
+    deadline: BigintIsh;
+    spender: string;
+}
+/**
+ * Options for producing the calldata to exit a position.
+ */
+export 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'>;
+}
+export 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;
+    static getPermitData(permit: NFTPermitValues, positionManagerAddress: string, chainId: number): NFTPermitData;
+}

package/dist/payments.d.ts

@@ -0,0 +1,24 @@
+import JSBI from 'jsbi';
+import { Interface } from '@ethersproject/abi';
+import { Percent, Token } from '@uniswap/sdk-core';
+export interface FeeOptions {
+    /**
+     * The percent of the output that will be taken as a fee.
+     */
+    fee: Percent;
+    /**
+     * The recipient of the fee.
+     */
+    recipient: string;
+}
+export 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;
+}

package/dist/quoter.d.ts

@@ -0,0 +1,37 @@
+import { Interface } from '@ethersproject/abi';
+import { BigintIsh, Currency, CurrencyAmount, TradeType } from '@uniswap/sdk-core';
+import { MethodParameters } from './utils';
+import { Route } from './entities';
+/**
+ * Optional arguments to send to the quoter.
+ */
+export interface QuoteOptions {
+    /**
+     * The optional price limit for the trade.
+     */
+    sqrtPriceLimitX96?: BigintIsh;
+    /**
+     * The optional quoter interface to use
+     */
+    useQuoterV2?: boolean;
+}
+/**
+ * Represents the Uniswap V3 QuoterV1 contract with a method for returning the formatted
+ * calldata needed to call the quoter contract.
+ */
+export declare abstract class SwapQuoter {
+    static V1INTERFACE: Interface;
+    static V2INTERFACE: Interface;
+    /**
+     * Produces the on-chain method name of the appropriate function within QuoterV2,
+     * and the relevant hex encoded parameters.
+     * @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 swap route, a list of pools through which a swap can occur
+     * @param amount The amount of the quote, either an amount in, or an amount out
+     * @param tradeType The trade type, either exact input or exact output
+     * @param options The optional params including price limit and Quoter contract switch
+     * @returns The formatted calldata
+     */
+    static quoteCallParameters<TInput extends Currency, TOutput extends Currency>(route: Route<TInput, TOutput>, amount: CurrencyAmount<TInput | TOutput>, tradeType: TradeType, options?: QuoteOptions): MethodParameters;
+}

package/dist/selfPermit.d.ts

@@ -0,0 +1,25 @@
+import { BigintIsh, Token } from '@uniswap/sdk-core';
+import { Interface } from '@ethersproject/abi';
+export interface StandardPermitArguments {
+    v: 0 | 1 | 27 | 28;
+    r: string;
+    s: string;
+    amount: BigintIsh;
+    deadline: BigintIsh;
+}
+export interface AllowedPermitArguments {
+    v: 0 | 1 | 27 | 28;
+    r: string;
+    s: string;
+    nonce: BigintIsh;
+    expiry: BigintIsh;
+}
+export declare type PermitOptions = StandardPermitArguments | AllowedPermitArguments;
+export declare abstract class SelfPermit {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static encodePermit(token: Token, options: PermitOptions): string;
+}

package/dist/staker.d.ts

@@ -0,0 +1,101 @@
+import { BigintIsh, Token } from '@uniswap/sdk-core';
+import { MethodParameters } from './utils/calldata';
+import { Interface } from '@ethersproject/abi';
+import { Pool } from './entities';
+export declare type FullWithdrawOptions = ClaimOptions & WithdrawOptions;
+/**
+ * Represents a unique staking program.
+ */
+export interface IncentiveKey {
+    /**
+     * The token rewarded for participating in the staking program.
+     */
+    rewardToken: Token;
+    /**
+     * The pool that the staked positions must provide in.
+     */
+    pool: Pool;
+    /**
+     * The time when the incentive program begins.
+     */
+    startTime: BigintIsh;
+    /**
+     * The time that the incentive program ends.
+     */
+    endTime: BigintIsh;
+    /**
+     * The address which receives any remaining reward tokens at `endTime`.
+     */
+    refundee: string;
+}
+/**
+ * Options to specify when claiming rewards.
+ */
+export interface ClaimOptions {
+    /**
+     * The id of the NFT
+     */
+    tokenId: BigintIsh;
+    /**
+     * Address to send rewards to.
+     */
+    recipient: string;
+    /**
+     * The amount of `rewardToken` to claim. 0 claims all.
+     */
+    amount?: BigintIsh;
+}
+/**
+ * Options to specify when withdrawing a position.
+ */
+export interface WithdrawOptions {
+    /**
+     * Set when withdrawing. The position will be sent to `owner` on withdraw.
+     */
+    owner: string;
+    /**
+     * Set when withdrawing. `data` is passed to `safeTransferFrom` when transferring the position from contract back to owner.
+     */
+    data?: string;
+}
+export declare abstract class Staker {
+    static INTERFACE: Interface;
+    protected constructor();
+    private static INCENTIVE_KEY_ABI;
+    /**
+     *  To claim rewards, must unstake and then claim.
+     * @param incentiveKey The unique identifier of a staking program.
+     * @param options Options for producing the calldata to claim. Can't claim unless you unstake.
+     * @returns The calldatas for 'unstakeToken' and 'claimReward'.
+     */
+    private static encodeClaim;
+    /**
+     *
+     * Note:  A `tokenId` can be staked in many programs but to claim rewards and continue the program you must unstake, claim, and then restake.
+     * @param incentiveKeys An IncentiveKey or array of IncentiveKeys that `tokenId` is staked in.
+     * Input an array of IncentiveKeys to claim rewards for each program.
+     * @param options ClaimOptions to specify tokenId, recipient, and amount wanting to collect.
+     * Note that you can only specify one amount and one recipient across the various programs if you are collecting from multiple programs at once.
+     * @returns
+     */
+    static collectRewards(incentiveKeys: IncentiveKey | IncentiveKey[], options: ClaimOptions): MethodParameters;
+    /**
+     *
+     * @param incentiveKeys A list of incentiveKeys to unstake from. Should include all incentiveKeys (unique staking programs) that `options.tokenId` is staked in.
+     * @param withdrawOptions Options for producing claim calldata and withdraw calldata. Can't withdraw without unstaking all programs for `tokenId`.
+     * @returns Calldata for unstaking, claiming, and withdrawing.
+     */
+    static withdrawToken(incentiveKeys: IncentiveKey | IncentiveKey[], withdrawOptions: FullWithdrawOptions): MethodParameters;
+    /**
+     *
+     * @param incentiveKeys A single IncentiveKey or array of IncentiveKeys to be encoded and used in the data parameter in `safeTransferFrom`
+     * @returns An IncentiveKey as a string
+     */
+    static encodeDeposit(incentiveKeys: IncentiveKey | IncentiveKey[]): string;
+    /**
+     *
+     * @param incentiveKey An `IncentiveKey` which represents a unique staking program.
+     * @returns An encoded IncentiveKey to be read by ethers
+     */
+    private static _encodeIncentiveKey;
+}

package/dist/swapRouter.d.ts

@@ -0,0 +1,51 @@
+import { Interface } from '@ethersproject/abi';
+import { BigintIsh, Currency, Percent, TradeType } from '@uniswap/sdk-core';
+import { Trade } from './entities/trade';
+import { PermitOptions } from './selfPermit';
+import { MethodParameters } from './utils/calldata';
+import { FeeOptions } from './payments';
+/**
+ * Options for producing the arguments to send calls to the router.
+ */
+export interface SwapOptions {
+    /**
+     * How much the execution price is allowed to move unfavorably from the trade execution price.
+     */
+    slippageTolerance: Percent;
+    /**
+     * The account that should receive the output.
+     */
+    recipient: string;
+    /**
+     * When the transaction expires, in epoch seconds.
+     */
+    deadline: BigintIsh;
+    /**
+     * The optional permit parameters for spending the input.
+     */
+    inputTokenPermit?: PermitOptions;
+    /**
+     * The optional price limit for the trade.
+     */
+    sqrtPriceLimitX96?: BigintIsh;
+    /**
+     * Optional information for taking a fee on output.
+     */
+    fee?: FeeOptions;
+}
+/**
+ * Represents the Uniswap V3 SwapRouter, and has static methods for helping execute trades.
+ */
+export declare abstract class SwapRouter {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    /**
+     * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.
+     * @param trade to produce call parameters for
+     * @param options options for the call parameters
+     */
+    static swapCallParameters(trades: Trade<Currency, Currency, TradeType> | Trade<Currency, Currency, TradeType>[], options: SwapOptions): MethodParameters;
+}

package/dist/utils/calldata.d.ts

@@ -0,0 +1,20 @@
+import { BigintIsh } from '@uniswap/sdk-core';
+/**
+ * Generated method parameters for executing a call.
+ */
+export interface MethodParameters {
+    /**
+     * The hex encoded calldata to perform the given operation
+     */
+    calldata: string;
+    /**
+     * The amount of ether (wei) to send in hex.
+     */
+    value: string;
+}
+/**
+ * Converts a big int to a hex string
+ * @param bigintIsh
+ * @returns The hex encoded calldata
+ */
+export declare function toHex(bigintIsh: BigintIsh): string;

package/dist/utils/computePoolAddress.d.ts

@@ -0,0 +1,20 @@
+import { ChainId, Token } from '@uniswap/sdk-core';
+import { FeeAmount } from '../constants';
+/**
+ * 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
+ * @param chainId
+ * @returns The pool address
+ */
+export declare function computePoolAddress({ factoryAddress, tokenA, tokenB, fee, initCodeHashManualOverride, chainId, }: {
+    factoryAddress: string;
+    tokenA: Token;
+    tokenB: Token;
+    fee: FeeAmount;
+    initCodeHashManualOverride?: string;
+    chainId?: ChainId;
+}): string;

package/dist/utils/encodeRouteToPath.d.ts

@@ -0,0 +1,8 @@
+import { Currency } from '@uniswap/sdk-core';
+import { Route } from '../entities/route';
+/**
+ * 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
+ */
+export declare function encodeRouteToPath(route: Route<Currency, Currency>, exactOutput: boolean): string;

package/dist/utils/encodeSqrtRatioX96.d.ts

@@ -0,0 +1,9 @@
+import JSBI from 'jsbi';
+import { BigintIsh } from '@uniswap/sdk-core';
+/**
+ * Returns the sqrt ratio as a Q64.96 corresponding to a given ratio of amount1 and amount0
+ * @param amount1 The numerator amount i.e., the amount of token1
+ * @param amount0 The denominator amount i.e., the amount of token0
+ * @returns The sqrt ratio
+ */
+export declare function encodeSqrtRatioX96(amount1: BigintIsh, amount0: BigintIsh): JSBI;

package/dist/utils/fullMath.d.ts

@@ -0,0 +1,8 @@
+import JSBI from 'jsbi';
+export declare abstract class FullMath {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static mulDivRoundingUp(a: JSBI, b: JSBI, denominator: JSBI): JSBI;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,18 @@
+export * from './calldata';
+export * from './computePoolAddress';
+export * from './encodeRouteToPath';
+export * from './encodeSqrtRatioX96';
+export * from './fullMath';
+export * from './isSorted';
+export * from './liquidityMath';
+export * from './maxLiquidityForAmounts';
+export * from './mostSignificantBit';
+export * from './nearestUsableTick';
+export * from './position';
+export * from './priceTickConversions';
+export * from './sqrtPriceMath';
+export * from './v3swap';
+export * from './swapMath';
+export * from './tickLibrary';
+export * from './tickList';
+export * from './tickMath';

package/dist/utils/isSorted.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Determines if a tick list is sorted
+ * @param list The tick list
+ * @param comparator The comparator
+ * @returns true if sorted
+ */
+export declare function isSorted<T>(list: Array<T>, comparator: (a: T, b: T) => number): boolean;

package/dist/utils/liquidityMath.d.ts

@@ -0,0 +1,8 @@
+import JSBI from 'jsbi';
+export declare abstract class LiquidityMath {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static addDelta(x: JSBI, y: JSBI): JSBI;
+}

package/dist/utils/maxLiquidityForAmounts.d.ts

@@ -0,0 +1,14 @@
+import { BigintIsh } from '@uniswap/sdk-core';
+import JSBI from 'jsbi';
+/**
+ * Computes the maximum amount of liquidity received for a given amount of token0, token1,
+ * and the prices at the tick boundaries.
+ * @param sqrtRatioCurrentX96 the current price
+ * @param sqrtRatioAX96 price at lower boundary
+ * @param sqrtRatioBX96 price at upper boundary
+ * @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
+ */
+export declare function maxLiquidityForAmounts(sqrtRatioCurrentX96: JSBI, sqrtRatioAX96: JSBI, sqrtRatioBX96: JSBI, amount0: BigintIsh, amount1: BigintIsh, useFullPrecision: boolean): JSBI;

package/dist/utils/mostSignificantBit.d.ts

@@ -0,0 +1,2 @@
+import JSBI from 'jsbi';
+export declare function mostSignificantBit(x: JSBI): number;

package/dist/utils/nearestUsableTick.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the closest tick that is nearest a given tick and usable for the given tick spacing
+ * @param tick the target tick
+ * @param tickSpacing the spacing of the pool
+ */
+export declare function nearestUsableTick(tick: number, tickSpacing: number): number;

package/dist/utils/position.d.ts

@@ -0,0 +1,8 @@
+import JSBI from 'jsbi';
+export declare abstract class PositionLibrary {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static getTokensOwed(feeGrowthInside0LastX128: JSBI, feeGrowthInside1LastX128: JSBI, liquidity: JSBI, feeGrowthInside0X128: JSBI, feeGrowthInside1X128: JSBI): JSBI[];
+}

package/dist/utils/priceTickConversions.d.ts

@@ -0,0 +1,15 @@
+import { Price, Token } from '@uniswap/sdk-core';
+/**
+ * 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
+ */
+export 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
+ */
+export declare function priceToClosestTick(price: Price<Token, Token>): number;

package/dist/utils/sqrtPriceMath.d.ts

@@ -0,0 +1,13 @@
+import JSBI from 'jsbi';
+export declare abstract class SqrtPriceMath {
+    /**
+     * Cannot be constructed.
+     */
+    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;
+}

package/dist/utils/swapMath.d.ts

@@ -0,0 +1,9 @@
+import JSBI from 'jsbi';
+import { FeeAmount } from '../constants';
+export declare abstract class SwapMath {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static computeSwapStep(sqrtRatioCurrentX96: JSBI, sqrtRatioTargetX96: JSBI, liquidity: JSBI, amountRemaining: JSBI, feePips: JSBI | FeeAmount): [JSBI, JSBI, JSBI, JSBI];
+}

package/dist/utils/tickLibrary.d.ts

@@ -0,0 +1,14 @@
+import JSBI from 'jsbi';
+interface FeeGrowthOutside {
+    feeGrowthOutside0X128: JSBI;
+    feeGrowthOutside1X128: JSBI;
+}
+export declare function subIn256(x: JSBI, y: JSBI): JSBI;
+export 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[];
+}
+export {};

package/dist/utils/tickList.d.ts

@@ -0,0 +1,23 @@
+import { Tick } from '../entities/tick';
+/**
+ * Utility methods for interacting with sorted lists of ticks
+ */
+export 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];
+}

package/dist/utils/tickMath.d.ts

@@ -0,0 +1,34 @@
+import JSBI from 'jsbi';
+export declare abstract class TickMath {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    /**
+     * The minimum tick that can be used on any pool.
+     */
+    static MIN_TICK: number;
+    /**
+     * The maximum tick that can be used on any pool.
+     */
+    static MAX_TICK: number;
+    /**
+     * The sqrt ratio corresponding to the minimum tick that could be used on any pool.
+     */
+    static MIN_SQRT_RATIO: JSBI;
+    /**
+     * The sqrt ratio corresponding to the maximum tick that could be used on any pool.
+     */
+    static MAX_SQRT_RATIO: JSBI;
+    /**
+     * Returns the sqrt ratio as a Q64.96 for the given tick. The sqrt ratio is computed as sqrt(1.0001)^tick
+     * @param tick the tick for which to compute the sqrt ratio
+     */
+    static getSqrtRatioAtTick(tick: number): JSBI;
+    /**
+     * Returns the tick corresponding to a given sqrt ratio, s.t. #getSqrtRatioAtTick(tick) <= sqrtRatioX96
+     * and #getSqrtRatioAtTick(tick + 1) > sqrtRatioX96
+     * @param sqrtRatioX96 the sqrt ratio as a Q64.96 for which to compute the tick
+     */
+    static getTickAtSqrtRatio(sqrtRatioX96: JSBI): number;
+}