@pancakeswap/v3-sdk 1.0.0 → 3.0.0

package/dist/swapRouter.d.ts

@@ -0,0 +1,502 @@
+import { BigintIsh, Currency, Percent, TradeType } from '@pancakeswap/sdk';
+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 Pancake V3 SwapRouter, and has static methods for helping execute trades.
+ */
+export declare abstract class SwapRouter {
+    static ABI: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "_deployer";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "_factory";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "_WETH9";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "nonpayable";
+        readonly type: "constructor";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "WETH9";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "deployer";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "bytes";
+                readonly name: "path";
+                readonly type: "bytes";
+            }, {
+                readonly internalType: "address";
+                readonly name: "recipient";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "deadline";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "amountIn";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "amountOutMinimum";
+                readonly type: "uint256";
+            }];
+            readonly internalType: "struct ISwapRouter.ExactInputParams";
+            readonly name: "params";
+            readonly type: "tuple";
+        }];
+        readonly name: "exactInput";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "amountOut";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "tokenIn";
+                readonly type: "address";
+            }, {
+                readonly internalType: "address";
+                readonly name: "tokenOut";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint24";
+                readonly name: "fee";
+                readonly type: "uint24";
+            }, {
+                readonly internalType: "address";
+                readonly name: "recipient";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "deadline";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "amountIn";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "amountOutMinimum";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "uint160";
+                readonly name: "sqrtPriceLimitX96";
+                readonly type: "uint160";
+            }];
+            readonly internalType: "struct ISwapRouter.ExactInputSingleParams";
+            readonly name: "params";
+            readonly type: "tuple";
+        }];
+        readonly name: "exactInputSingle";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "amountOut";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "bytes";
+                readonly name: "path";
+                readonly type: "bytes";
+            }, {
+                readonly internalType: "address";
+                readonly name: "recipient";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "deadline";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "amountOut";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "amountInMaximum";
+                readonly type: "uint256";
+            }];
+            readonly internalType: "struct ISwapRouter.ExactOutputParams";
+            readonly name: "params";
+            readonly type: "tuple";
+        }];
+        readonly name: "exactOutput";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "amountIn";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "tokenIn";
+                readonly type: "address";
+            }, {
+                readonly internalType: "address";
+                readonly name: "tokenOut";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint24";
+                readonly name: "fee";
+                readonly type: "uint24";
+            }, {
+                readonly internalType: "address";
+                readonly name: "recipient";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "deadline";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "amountOut";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "amountInMaximum";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "uint160";
+                readonly name: "sqrtPriceLimitX96";
+                readonly type: "uint160";
+            }];
+            readonly internalType: "struct ISwapRouter.ExactOutputSingleParams";
+            readonly name: "params";
+            readonly type: "tuple";
+        }];
+        readonly name: "exactOutputSingle";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "amountIn";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "factory";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes[]";
+            readonly name: "data";
+            readonly type: "bytes[]";
+        }];
+        readonly name: "multicall";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes[]";
+            readonly name: "results";
+            readonly type: "bytes[]";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "int256";
+            readonly name: "amount0Delta";
+            readonly type: "int256";
+        }, {
+            readonly internalType: "int256";
+            readonly name: "amount1Delta";
+            readonly type: "int256";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "_data";
+            readonly type: "bytes";
+        }];
+        readonly name: "pancakeV3SwapCallback";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "refundETH";
+        readonly outputs: readonly [];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint8";
+            readonly name: "v";
+            readonly type: "uint8";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "r";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "s";
+            readonly type: "bytes32";
+        }];
+        readonly name: "selfPermit";
+        readonly outputs: readonly [];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "expiry";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint8";
+            readonly name: "v";
+            readonly type: "uint8";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "r";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "s";
+            readonly type: "bytes32";
+        }];
+        readonly name: "selfPermitAllowed";
+        readonly outputs: readonly [];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "expiry";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint8";
+            readonly name: "v";
+            readonly type: "uint8";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "r";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "s";
+            readonly type: "bytes32";
+        }];
+        readonly name: "selfPermitAllowedIfNecessary";
+        readonly outputs: readonly [];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint8";
+            readonly name: "v";
+            readonly type: "uint8";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "r";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "s";
+            readonly type: "bytes32";
+        }];
+        readonly name: "selfPermitIfNecessary";
+        readonly outputs: readonly [];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "amountMinimum";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "recipient";
+            readonly type: "address";
+        }];
+        readonly name: "sweepToken";
+        readonly outputs: readonly [];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "amountMinimum";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "recipient";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "feeBips";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "feeRecipient";
+            readonly type: "address";
+        }];
+        readonly name: "sweepTokenWithFee";
+        readonly outputs: readonly [];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "amountMinimum";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "recipient";
+            readonly type: "address";
+        }];
+        readonly name: "unwrapWETH9";
+        readonly outputs: readonly [];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "amountMinimum";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "recipient";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "feeBips";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "feeRecipient";
+            readonly type: "address";
+        }];
+        readonly name: "unwrapWETH9WithFee";
+        readonly outputs: readonly [];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly stateMutability: "payable";
+        readonly type: "receive";
+    }];
+    /**
+     * 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;
+}
+//# sourceMappingURL=swapRouter.d.ts.map

package/dist/swapRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swapRouter.d.ts","sourceRoot":"","sources":["../src/swapRouter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAkB,OAAO,EAAE,SAAS,EAA2B,MAAM,kBAAkB,CAAA;AAInH,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAExC,OAAO,EAAE,aAAa,EAAc,MAAM,cAAc,CAAA;AAExD,OAAO,EAAE,gBAAgB,EAAS,MAAM,kBAAkB,CAAA;AAE1D,OAAO,EAAE,UAAU,EAAY,MAAM,YAAY,CAAA;AAEjD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,iBAAiB,EAAE,OAAO,CAAA;IAE1B;;OAEG;IACH,SAAS,EAAE,MAAM,CAAA;IAEjB;;OAEG;IACH,QAAQ,EAAE,SAAS,CAAA;IAEnB;;OAEG;IACH,gBAAgB,CAAC,EAAE,aAAa,CAAA;IAEhC;;OAEG;IACH,iBAAiB,CAAC,EAAE,SAAS,CAAA;IAE7B;;OAEG;IACH,GAAG,CAAC,EAAE,UAAU,CAAA;CACjB;AAED;;GAEG;AACH,8BAAsB,UAAU;IAE9B,OAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAAgB;IAEjC;;OAEG;IACH,OAAO;IAEP;;;;OAIG;WACW,kBAAkB,CAC9B,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,GAAG,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,EACrF,OAAO,EAAE,WAAW,GACnB,gBAAgB;CAgKpB"}

package/dist/utils/calldata.d.ts

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

package/dist/utils/calldata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calldata.d.ts","sourceRoot":"","sources":["../../src/utils/calldata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAC5C,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAE1B;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,QAAQ,EAAE,GAAG,CAAA;IACb;;OAEG;IACH,KAAK,EAAE,GAAG,CAAA;CACX;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,SAAS,EAAE,SAAS,GAAG,GAAG,CAO/C"}

package/dist/utils/computePoolAddress.d.ts

@@ -0,0 +1,20 @@
+import { Address, Hash } from 'viem';
+import { Token } from '@pancakeswap/sdk';
+import { FeeAmount } from '../constants';
+/**
+ * Computes a pool address
+ * @param deployerAddress The Pancake V3 deployer 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
+ */
+export declare function computePoolAddress({ deployerAddress, tokenA, tokenB, fee, initCodeHashManualOverride, }: {
+    deployerAddress: Address;
+    tokenA: Token;
+    tokenB: Token;
+    fee: FeeAmount;
+    initCodeHashManualOverride?: Hash;
+}): Address;
+//# sourceMappingURL=computePoolAddress.d.ts.map

package/dist/utils/computePoolAddress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computePoolAddress.d.ts","sourceRoot":"","sources":["../../src/utils/computePoolAddress.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,OAAO,EAGP,IAAI,EAUL,MAAM,MAAM,CAAA;AACb,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AACxC,OAAO,EAAE,SAAS,EAAuB,MAAM,cAAc,CAAA;AAe7D;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,eAAe,EACf,MAAM,EACN,MAAM,EACN,GAAG,EACH,0BAA0B,GAC3B,EAAE;IACD,eAAe,EAAE,OAAO,CAAA;IACxB,MAAM,EAAE,KAAK,CAAA;IACb,MAAM,EAAE,KAAK,CAAA;IACb,GAAG,EAAE,SAAS,CAAA;IACd,0BAA0B,CAAC,EAAE,IAAI,CAAA;CAClC,GAAG,OAAO,CAUV"}

package/dist/utils/encodeRouteToPath.d.ts

@@ -0,0 +1,10 @@
+import { Hash } from 'viem';
+import { Currency } from '@pancakeswap/swap-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): Hash;
+//# sourceMappingURL=encodeRouteToPath.d.ts.map

package/dist/utils/encodeRouteToPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encodeRouteToPath.d.ts","sourceRoot":"","sources":["../../src/utils/encodeRouteToPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,IAAI,EAAE,MAAM,MAAM,CAAA;AACzC,OAAO,EAAE,QAAQ,EAAS,MAAM,4BAA4B,CAAA;AAE5D,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAEzC;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE,WAAW,EAAE,OAAO,GAAG,IAAI,CA2B9F"}

package/dist/utils/encodeSqrtRatioX96.d.ts

@@ -0,0 +1,9 @@
+import { BigintIsh } from '@pancakeswap/swap-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): bigint;
+//# sourceMappingURL=encodeSqrtRatioX96.d.ts.map

package/dist/utils/encodeSqrtRatioX96.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encodeSqrtRatioX96.d.ts","sourceRoot":"","sources":["../../src/utils/encodeSqrtRatioX96.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAQ,MAAM,4BAA4B,CAAA;AAE5D;;;;;GAKG;AAEH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,GAAG,MAAM,CAKjF"}

package/dist/utils/feeCalculator.d.ts

@@ -0,0 +1,65 @@
+import { Currency, CurrencyAmount, Percent, Fraction } from '@pancakeswap/swap-sdk-core';
+import { Tick } from '../entities';
+export declare const FeeCalculator: {
+    getEstimatedLPFee: typeof getEstimatedLPFee;
+    getEstimatedLPFeeByAmounts: typeof getEstimatedLPFeeByAmounts;
+    getLiquidityFromTick: typeof getLiquidityFromTick;
+    getLiquidityFromSqrtRatioX96: typeof getLiquidityFromSqrtRatioX96;
+    getAverageLiquidity: typeof getAverageLiquidity;
+    getLiquidityBySingleAmount: typeof getLiquidityBySingleAmount;
+    getDependentAmount: typeof getDependentAmount;
+    getLiquidityByAmountsAndPrice: typeof getLiquidityByAmountsAndPrice;
+    getAmountsByLiquidityAndPrice: typeof getAmountsByLiquidityAndPrice;
+    getAmountsAtNewPrice: typeof getAmountsAtNewPrice;
+};
+interface EstimateFeeOptions {
+    amount: CurrencyAmount<Currency>;
+    currency: Currency;
+    tickLower: number;
+    tickUpper: number;
+    volume24H: number;
+    sqrtRatioX96: bigint;
+    mostActiveLiquidity: bigint;
+    fee: number;
+    insidePercentage?: Percent;
+    protocolFee?: Percent;
+}
+export declare function getEstimatedLPFeeWithProtocolFee({ amount, currency, ...rest }: EstimateFeeOptions): Fraction;
+export declare function getEstimatedLPFee({ amount, currency, ...rest }: EstimateFeeOptions): Fraction;
+interface EstimateFeeByAmountsOptions extends Omit<EstimateFeeOptions, 'amount' | 'currency'> {
+    amountA: CurrencyAmount<Currency>;
+    amountB: CurrencyAmount<Currency>;
+}
+export declare function getEstimatedLPFeeByAmountsWithProtocolFee(options: EstimateFeeByAmountsOptions): Fraction;
+export declare function getEstimatedLPFeeByAmounts({ protocolFee, ...rest }: EstimateFeeByAmountsOptions): Fraction;
+interface GetAmountOptions {
+    amount: CurrencyAmount<Currency>;
+    currency: Currency;
+    tickLower: number;
+    tickUpper: number;
+    sqrtRatioX96: bigint;
+}
+export declare function getDependentAmount(options: GetAmountOptions): CurrencyAmount<Currency>;
+export declare function getLiquidityBySingleAmount({ amount, currency, ...rest }: GetAmountOptions): bigint;
+interface GetLiquidityOptions extends Omit<GetAmountOptions, 'amount' | 'currency'> {
+    amountA: CurrencyAmount<Currency>;
+    amountB: CurrencyAmount<Currency>;
+}
+export declare function getLiquidityByAmountsAndPrice({ amountA, amountB, tickUpper, tickLower, sqrtRatioX96, }: GetLiquidityOptions): bigint;
+interface GetAmountsOptions extends Omit<GetAmountOptions, 'amount' | 'currency'> {
+    currencyA: Currency;
+    currencyB: Currency;
+    liquidity: bigint;
+}
+export declare function getAmountsByLiquidityAndPrice(options: GetAmountsOptions): CurrencyAmount<Currency>[];
+interface GetAmountsAtNewPriceOptions extends Omit<GetAmountOptions, 'amount' | 'currency'> {
+    amountA: CurrencyAmount<Currency>;
+    amountB: CurrencyAmount<Currency>;
+    newSqrtRatioX96: bigint;
+}
+export declare function getAmountsAtNewPrice({ newSqrtRatioX96, ...rest }: GetAmountsAtNewPriceOptions): CurrencyAmount<Currency>[];
+export declare function getAverageLiquidity(ticks: Tick[], tickSpacing: number, tickLower: number, tickUpper: number): bigint;
+export declare function getLiquidityFromSqrtRatioX96(ticks: Tick[], sqrtRatioX96: bigint): bigint;
+export declare function getLiquidityFromTick(ticks: Tick[], tick: number): bigint;
+export {};
+//# sourceMappingURL=feeCalculator.d.ts.map

package/dist/utils/feeCalculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feeCalculator.d.ts","sourceRoot":"","sources":["../../src/utils/feeCalculator.ts"],"names":[],"mappings":"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"}

package/dist/utils/fullMath.d.ts

@@ -0,0 +1,8 @@
+export declare abstract class FullMath {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static mulDivRoundingUp(a: bigint, b: bigint, denominator: bigint): bigint;
+}
+//# sourceMappingURL=fullMath.d.ts.map

package/dist/utils/fullMath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fullMath.d.ts","sourceRoot":"","sources":["../../src/utils/fullMath.ts"],"names":[],"mappings":"AAEA,8BAAsB,QAAQ;IAC5B;;OAEG;IACH,OAAO;WAEO,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM;CAOlF"}