@juiceswapxyz/v4-sdk 0.1.4-beta.0 → 3.0.0

package/dist/entities/trade.d.ts

@@ -1,220 +0,0 @@
-import { Currency, Percent, Price, CurrencyAmount, TradeType } from '@juiceswapxyz/sdk-core';
-import { Pool } from './pool';
-import { Route } from './route';
-/**
- * Trades comparator, an extension of the input output comparator that also considers other dimensions of the trade in ranking them
- * @template TInput The input currency, either Ether or an ERC-20
- * @template TOutput The output currency, 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
- */
-export declare function tradeComparator<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(a: Trade<TInput, TOutput, TTradeType>, b: Trade<TInput, TOutput, TTradeType>): number;
-export 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 currency, either Ether or an ERC-20
- * @template TOutput The output currency, either Ether or an ERC-20
- * @template TTradeType The trade type, either exact input or exact output
- */
-export 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 currency, either Ether or an ERC-20
-     * @template TOutput The output currency, 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 currency, either Ether or an ERC-20
-     * @template TOutput The output currency, 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 currency, either Ether or an ERC-20.
-     * @template TOutput The output currency, 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 currency, either Ether or an ERC-20.
-     * @template TOutput The output currency, 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 currency, either Ether or an ERC-20
-     * @template TOutput The output currency, 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 currency, either Ether or an ERC-20
-     * @template TOutput The output currency, 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 currency
-     * amount to an output currency, 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 currency
-     * to an output currency 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>[]>;
-}

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-export * from './entities';
-export * from './utils';
-export * from './PositionManager';

package/dist/index.js

@@ -1,8 +0,0 @@
-
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./v4-sdk.cjs.production.min.js')
-} else {
-  module.exports = require('./v4-sdk.cjs.development.js')
-}

package/dist/internalConstants.d.ts

@@ -1,46 +0,0 @@
-import JSBI from 'jsbi';
-export declare const ADDRESS_ZERO = "0x0000000000000000000000000000000000000000";
-export declare const NEGATIVE_ONE: JSBI;
-export declare const ZERO: JSBI;
-export declare const ONE: JSBI;
-export declare const ONE_ETHER: JSBI;
-export declare const EMPTY_BYTES = "0x";
-export declare const Q96: JSBI;
-export declare const Q192: JSBI;
-export declare const FEE_AMOUNT_LOW = 100;
-export declare const FEE_AMOUNT_MEDIUM = 3000;
-export declare const FEE_AMOUNT_HIGHEST = 10000;
-export declare const TICK_SPACING_TEN = 10;
-export declare const TICK_SPACING_SIXTY = 60;
-export declare const MIN_SLIPPAGE_DECREASE = 0;
-export declare const OPEN_DELTA: import("ethers").BigNumber;
-export declare const SQRT_PRICE_1_1: JSBI;
-export declare const EMPTY_HOOK = "0x0000000000000000000000000000000000000000";
-export declare const NATIVE_NOT_SET = "NATIVE_NOT_SET";
-export declare const ZERO_LIQUIDITY = "ZERO_LIQUIDITY";
-export declare const NO_SQRT_PRICE = "NO_SQRT_PRICE";
-export declare const CANNOT_BURN = "CANNOT_BURN";
-/**
- * Function fragments that exist on the PositionManager contract.
- */
-export declare enum PositionFunctions {
-    INITIALIZE_POOL = "initializePool",
-    MODIFY_LIQUIDITIES = "modifyLiquidities",
-    PERMIT_BATCH = "0x002a3e3a",
-    ERC721PERMIT_PERMIT = "0x0f5730f1"
-}
-/**
- * The default factory enabled fee amounts, denominated in hundredths of bips.
- */
-export declare enum FeeAmount {
-    LOWEST = 100,
-    LOW = 500,
-    MEDIUM = 3000,
-    HIGH = 10000
-}
-/**
- * The default factory tick spacings by fee amount.
- */
-export declare const TICK_SPACINGS: {
-    [amount in FeeAmount]: number;
-};

package/dist/multicall.d.ts

@@ -1,10 +0,0 @@
-import { Interface } from '@ethersproject/abi';
-export declare abstract class Multicall {
-    static INTERFACE: Interface;
-    /**
-     * Cannot be constructed.
-     */
-    private constructor();
-    static encodeMulticall(calldataList: string | string[]): string;
-    static decodeMulticall(encodedCalldata: string): string[];
-}

package/dist/utils/calldata.d.ts

@@ -1,20 +0,0 @@
-import { BigintIsh } from '@juiceswapxyz/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/currencyMap.d.ts

@@ -1,2 +0,0 @@
-import { Currency } from '@juiceswapxyz/sdk-core';
-export declare function toAddress(currency: Currency): string;

package/dist/utils/encodeRouteToPath.d.ts

@@ -1,10 +0,0 @@
-import { Currency } from '@juiceswapxyz/sdk-core';
-import { Route } from '../entities/route';
-export declare type PathKey = {
-    intermediateCurrency: string;
-    fee: number;
-    tickSpacing: number;
-    hooks: string;
-    hookData: string;
-};
-export declare const encodeRouteToPath: (route: Route<Currency, Currency>, exactOutput?: boolean | undefined) => PathKey[];

package/dist/utils/hook.d.ts

@@ -1,45 +0,0 @@
-export declare type HookPermissions = {
-    [key in HookOptions]: boolean;
-};
-export declare enum HookOptions {
-    AfterRemoveLiquidityReturnsDelta = "afterRemoveLiquidityReturnsDelta",
-    AfterAddLiquidityReturnsDelta = "afterAddLiquidityReturnsDelta",
-    AfterSwapReturnsDelta = "afterSwapReturnsDelta",
-    BeforeSwapReturnsDelta = "beforeSwapReturnsDelta",
-    AfterDonate = "afterDonate",
-    BeforeDonate = "beforeDonate",
-    AfterSwap = "afterSwap",
-    BeforeSwap = "beforeSwap",
-    AfterRemoveLiquidity = "afterRemoveLiquidity",
-    BeforeRemoveLiquidity = "beforeRemoveLiquidity",
-    AfterAddLiquidity = "afterAddLiquidity",
-    BeforeAddLiquidity = "beforeAddLiquidity",
-    AfterInitialize = "afterInitialize",
-    BeforeInitialize = "beforeInitialize"
-}
-export declare const hookFlagIndex: {
-    afterRemoveLiquidityReturnsDelta: number;
-    afterAddLiquidityReturnsDelta: number;
-    afterSwapReturnsDelta: number;
-    beforeSwapReturnsDelta: number;
-    afterDonate: number;
-    beforeDonate: number;
-    afterSwap: number;
-    beforeSwap: number;
-    afterRemoveLiquidity: number;
-    beforeRemoveLiquidity: number;
-    afterAddLiquidity: number;
-    beforeAddLiquidity: number;
-    afterInitialize: number;
-    beforeInitialize: number;
-};
-export declare class Hook {
-    static permissions(address: string): HookPermissions;
-    static hasPermission(address: string, hookOption: HookOptions): boolean;
-    static hasInitializePermissions(address: string): boolean;
-    static hasLiquidityPermissions(address: string): boolean;
-    static hasSwapPermissions(address: string): boolean;
-    static hasDonatePermissions(address: string): boolean;
-    private static _hasPermission;
-    private static _checkAddress;
-}

package/dist/utils/index.d.ts

@@ -1,11 +0,0 @@
-export * from './encodeRouteToPath';
-export * from './v4Planner';
-export * from './v4PositionPlanner';
-export * from './calldata';
-export * from './v4BaseActionsParser';
-export * from './currencyMap';
-export * from './encodeRouteToPath';
-export * from './pathCurrency';
-export * from './priceTickConversions';
-export * from './sortsBefore';
-export * from './hook';

package/dist/utils/pathCurrency.d.ts

@@ -1,4 +0,0 @@
-import { Currency, CurrencyAmount } from '@juiceswapxyz/sdk-core';
-import { Pool } from '../entities/pool';
-export declare function amountWithPathCurrency(amount: CurrencyAmount<Currency>, pool: Pool): CurrencyAmount<Currency>;
-export declare function getPathCurrency(currency: Currency, pool: Pool): Currency;

package/dist/utils/positionManagerAbi.d.ts

@@ -1,102 +0,0 @@
-export declare const positionManagerAbi: ({
-    type: string;
-    inputs: {
-        name: string;
-        type: string;
-        internalType: string;
-    }[];
-    stateMutability: string;
-    name?: undefined;
-    outputs?: undefined;
-    anonymous?: undefined;
-} | {
-    type: string;
-    stateMutability: string;
-    inputs?: undefined;
-    name?: undefined;
-    outputs?: undefined;
-    anonymous?: undefined;
-} | {
-    type: string;
-    name: string;
-    inputs: {
-        name: string;
-        type: string;
-        internalType: string;
-    }[];
-    outputs: ({
-        name: string;
-        type: string;
-        internalType: string;
-        components: {
-            name: string;
-            type: string;
-            internalType: string;
-        }[];
-    } | {
-        name: string;
-        type: string;
-        internalType: string;
-        components?: undefined;
-    })[];
-    stateMutability: string;
-    anonymous?: undefined;
-} | {
-    type: string;
-    name: string;
-    inputs: ({
-        name: string;
-        type: string;
-        internalType: string;
-        components?: undefined;
-    } | {
-        name: string;
-        type: string;
-        internalType: string;
-        components: ({
-            name: string;
-            type: string;
-            internalType: string;
-            components: {
-                name: string;
-                type: string;
-                internalType: string;
-            }[];
-        } | {
-            name: string;
-            type: string;
-            internalType: string;
-            components?: undefined;
-        })[];
-    })[];
-    outputs: {
-        name: string;
-        type: string;
-        internalType: string;
-    }[];
-    stateMutability: string;
-    anonymous?: undefined;
-} | {
-    type: string;
-    name: string;
-    inputs: {
-        name: string;
-        type: string;
-        indexed: boolean;
-        internalType: string;
-    }[];
-    anonymous: boolean;
-    stateMutability?: undefined;
-    outputs?: undefined;
-} | {
-    type: string;
-    name: string;
-    inputs: {
-        name: string;
-        type: string;
-        internalType: string;
-    }[];
-    stateMutability?: undefined;
-    outputs?: undefined;
-    anonymous?: undefined;
-})[];

package/dist/utils/priceTickConversions.d.ts

@@ -1,20 +0,0 @@
-import { Price, Currency } from '@juiceswapxyz/sdk-core';
-/**
- * This library is the almost the same as v3-sdk priceTickConversion except
- * that it accepts a Currency type instead of a Token type,
- * and thus uses some helper functions defined for the Currency type over the Token type.
- */
-/**
- * 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(baseCurrency: Currency, quoteCurrency: Currency, tick: number): Price<Currency, Currency>;
-/**
- * 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<Currency, Currency>): number;

package/dist/utils/sortsBefore.d.ts

@@ -1,2 +0,0 @@
-import { Currency } from '@juiceswapxyz/sdk-core';
-export declare function sortsBefore(currencyA: Currency, currencyB: Currency): boolean;

package/dist/utils/v4BaseActionsParser.d.ts

@@ -1,45 +0,0 @@
-import { PoolKey } from '../entities/pool';
-import { PathKey } from './encodeRouteToPath';
-import { Actions } from './v4Planner';
-export declare type Param = {
-    readonly name: string;
-    readonly value: any;
-};
-export declare type V4RouterAction = {
-    readonly actionName: string;
-    readonly actionType: Actions;
-    readonly params: readonly Param[];
-};
-export declare type V4RouterCall = {
-    readonly actions: readonly V4RouterAction[];
-};
-export declare type SwapExactInSingle = {
-    readonly poolKey: PoolKey;
-    readonly zeroForOne: boolean;
-    readonly amountIn: string;
-    readonly amountOutMinimum: string;
-    readonly hookData: string;
-};
-export declare type SwapExactIn = {
-    readonly currencyIn: string;
-    readonly path: readonly PathKey[];
-    readonly amountIn: string;
-    readonly amountOutMinimum: string;
-};
-export declare type SwapExactOutSingle = {
-    readonly poolKey: PoolKey;
-    readonly zeroForOne: boolean;
-    readonly amountOut: string;
-    readonly amountInMaximum: string;
-    readonly hookData: string;
-};
-export declare type SwapExactOut = {
-    readonly currencyOut: string;
-    readonly path: readonly PathKey[];
-    readonly amountOut: string;
-    readonly amountInMaximum: string;
-};
-export declare abstract class V4BaseActionsParser {
-    static parseCalldata(calldata: string): V4RouterCall;
-    private static getActions;
-}

package/dist/utils/v4Planner.d.ts

@@ -1,55 +0,0 @@
-import { BigNumber } from 'ethers';
-import { Currency, Percent, TradeType } from '@juiceswapxyz/sdk-core';
-import { Trade } from '../entities/trade';
-/**
- * Actions
- * @description Constants that define what action to perform
- * Not all actions are supported yet.
- * @enum {number}
- */
-export declare enum Actions {
-    INCREASE_LIQUIDITY = 0,
-    DECREASE_LIQUIDITY = 1,
-    MINT_POSITION = 2,
-    BURN_POSITION = 3,
-    SWAP_EXACT_IN_SINGLE = 6,
-    SWAP_EXACT_IN = 7,
-    SWAP_EXACT_OUT_SINGLE = 8,
-    SWAP_EXACT_OUT = 9,
-    SETTLE = 11,
-    SETTLE_ALL = 12,
-    SETTLE_PAIR = 13,
-    TAKE = 14,
-    TAKE_ALL = 15,
-    TAKE_PORTION = 16,
-    TAKE_PAIR = 17,
-    CLOSE_CURRENCY = 18,
-    SWEEP = 20,
-    UNWRAP = 22
-}
-export declare enum Subparser {
-    V4SwapExactInSingle = 0,
-    V4SwapExactIn = 1,
-    V4SwapExactOutSingle = 2,
-    V4SwapExactOut = 3,
-    PoolKey = 4
-}
-export declare type ParamType = {
-    readonly name: string;
-    readonly type: string;
-    readonly subparser?: Subparser;
-};
-export declare const V4_BASE_ACTIONS_ABI_DEFINITION: {
-    [key in Actions]: readonly ParamType[];
-};
-export declare class V4Planner {
-    actions: string;
-    params: string[];
-    constructor();
-    addAction(type: Actions, parameters: any[]): V4Planner;
-    addTrade(trade: Trade<Currency, Currency, TradeType>, slippageTolerance?: Percent): V4Planner;
-    addSettle(currency: Currency, payerIsUser: boolean, amount?: BigNumber): V4Planner;
-    addTake(currency: Currency, recipient: string, amount?: BigNumber): V4Planner;
-    addUnwrap(amount: BigNumber): V4Planner;
-    finalize(): string;
-}

package/dist/utils/v4PositionPlanner.d.ts

@@ -1,12 +0,0 @@
-import { V4Planner } from './v4Planner';
-import { Pool } from '../entities';
-import { BigintIsh, Currency } from '@juiceswapxyz/sdk-core';
-export declare class V4PositionPlanner extends V4Planner {
-    addMint(pool: Pool, tickLower: number, tickUpper: number, liquidity: BigintIsh, amount0Max: BigintIsh, amount1Max: BigintIsh, owner: string, hookData?: string): void;
-    addIncrease(tokenId: BigintIsh, liquidity: BigintIsh, amount0Max: BigintIsh, amount1Max: BigintIsh, hookData?: string): void;
-    addDecrease(tokenId: BigintIsh, liquidity: BigintIsh, amount0Min: BigintIsh, amount1Min: BigintIsh, hookData?: string): void;
-    addBurn(tokenId: BigintIsh, amount0Min: BigintIsh, amount1Min: BigintIsh, hookData?: string): void;
-    addSettlePair(currency0: Currency, currency1: Currency): void;
-    addTakePair(currency0: Currency, currency1: Currency, recipient: string): void;
-    addSweep(currency: Currency, to: string): void;
-}