@alcorexchange/alcor-swap-sdk 1.0.24 → 1.0.26

package/build/entities/pool.d.ts

@@ -69,14 +69,14 @@ export declare class Pool {
      * @param sqrtPriceLimitX64 The Q64.96 sqrt price limit
      * @returns The output amount and the pool with updated state
      */
-    getOutputAmount(inputAmount: CurrencyAmount<Token>, sqrtPriceLimitX64?: JSBI): Promise<[CurrencyAmount<Token>, Pool]>;
+    getOutputAmount(inputAmount: CurrencyAmount<Token>, sqrtPriceLimitX64?: JSBI): [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 sqrtPriceLimitX64 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>, sqrtPriceLimitX64?: JSBI): Promise<[CurrencyAmount<Token>, Pool]>;
+    getInputAmount(outputAmount: CurrencyAmount<Token>, sqrtPriceLimitX64?: JSBI): [CurrencyAmount<Token>, Pool];
     /**
      * Executes a swap
      * @param zeroForOne Whether the amount in is tokenA or tokenB

package/build/entities/pool.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -100,27 +91,25 @@ class Pool {
      * @returns The output amount and the pool with updated state
      */
     getOutputAmount(inputAmount, sqrtPriceLimitX64) {
-        return __awaiter(this, void 0, void 0, function* () {
-            (0, tiny_invariant_1.default)(this.involvesToken(inputAmount.currency), "TOKEN");
-            const zeroForOne = inputAmount.currency.equals(this.tokenA);
-            const { amountCalculated: outputAmount, sqrtPriceX64, liquidity, tickCurrent, } = yield this.swap(zeroForOne, inputAmount.quotient, sqrtPriceLimitX64);
-            const outputToken = zeroForOne ? this.tokenB : this.tokenA;
-            return [
-                fractions_1.CurrencyAmount.fromRawAmount(outputToken, jsbi_1.default.multiply(outputAmount, internalConstants_2.NEGATIVE_ONE)),
-                new Pool({
-                    id: this.id,
-                    tokenA: this.tokenA,
-                    tokenB: this.tokenB,
-                    fee: this.fee,
-                    sqrtPriceX64,
-                    liquidity,
-                    tickCurrent,
-                    ticks: this.tickDataProvider,
-                    feeGrowthGlobalAX64: this.feeGrowthGlobalAX64,
-                    feeGrowthGlobalBX64: this.feeGrowthGlobalBX64,
-                })
-            ];
-        });
+        (0, tiny_invariant_1.default)(this.involvesToken(inputAmount.currency), "TOKEN");
+        const zeroForOne = inputAmount.currency.equals(this.tokenA);
+        const { amountCalculated: outputAmount, sqrtPriceX64, liquidity, tickCurrent, } = this.swap(zeroForOne, inputAmount.quotient, sqrtPriceLimitX64);
+        const outputToken = zeroForOne ? this.tokenB : this.tokenA;
+        return [
+            fractions_1.CurrencyAmount.fromRawAmount(outputToken, jsbi_1.default.multiply(outputAmount, internalConstants_2.NEGATIVE_ONE)),
+            new Pool({
+                id: this.id,
+                tokenA: this.tokenA,
+                tokenB: this.tokenB,
+                fee: this.fee,
+                sqrtPriceX64,
+                liquidity,
+                tickCurrent,
+                ticks: this.tickDataProvider,
+                feeGrowthGlobalAX64: this.feeGrowthGlobalAX64,
+                feeGrowthGlobalBX64: this.feeGrowthGlobalBX64,
+            })
+        ];
     }
     /**
      * Given a desired output amount of a token, return the computed input amount and a pool with state updated after the trade
@@ -129,26 +118,24 @@ class Pool {
      * @returns The input amount and the pool with updated state
      */
     getInputAmount(outputAmount, sqrtPriceLimitX64) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const zeroForOne = outputAmount.currency.equals(this.tokenB);
-            const { amountCalculated: inputAmount, sqrtPriceX64, liquidity, tickCurrent, } = yield this.swap(zeroForOne, jsbi_1.default.multiply(outputAmount.quotient, internalConstants_2.NEGATIVE_ONE), sqrtPriceLimitX64);
-            const inputToken = zeroForOne ? this.tokenA : this.tokenB;
-            return [
-                fractions_1.CurrencyAmount.fromRawAmount(inputToken, inputAmount),
-                new Pool({
-                    id: this.id,
-                    tokenA: this.tokenA,
-                    tokenB: this.tokenB,
-                    fee: this.fee,
-                    sqrtPriceX64,
-                    liquidity,
-                    tickCurrent,
-                    ticks: this.tickDataProvider,
-                    feeGrowthGlobalAX64: this.feeGrowthGlobalAX64,
-                    feeGrowthGlobalBX64: this.feeGrowthGlobalBX64,
-                }),
-            ];
-        });
+        const zeroForOne = outputAmount.currency.equals(this.tokenB);
+        const { amountCalculated: inputAmount, sqrtPriceX64, liquidity, tickCurrent, } = this.swap(zeroForOne, jsbi_1.default.multiply(outputAmount.quotient, internalConstants_2.NEGATIVE_ONE), sqrtPriceLimitX64);
+        const inputToken = zeroForOne ? this.tokenA : this.tokenB;
+        return [
+            fractions_1.CurrencyAmount.fromRawAmount(inputToken, inputAmount),
+            new Pool({
+                id: this.id,
+                tokenA: this.tokenA,
+                tokenB: this.tokenB,
+                fee: this.fee,
+                sqrtPriceX64,
+                liquidity,
+                tickCurrent,
+                ticks: this.tickDataProvider,
+                feeGrowthGlobalAX64: this.feeGrowthGlobalAX64,
+                feeGrowthGlobalBX64: this.feeGrowthGlobalBX64,
+            }),
+        ];
     }
     /**
      * Executes a swap
@@ -161,85 +148,83 @@ class Pool {
      * @returns tickCurrent
      */
     swap(zeroForOne, amountSpecified, sqrtPriceLimitX64) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!sqrtPriceLimitX64)
-                sqrtPriceLimitX64 = zeroForOne
-                    ? jsbi_1.default.add(tickMath_1.TickMath.MIN_SQRT_RATIO, internalConstants_2.ONE)
-                    : jsbi_1.default.subtract(tickMath_1.TickMath.MAX_SQRT_RATIO, internalConstants_2.ONE);
-            if (zeroForOne) {
-                (0, tiny_invariant_1.default)(jsbi_1.default.greaterThan(sqrtPriceLimitX64, tickMath_1.TickMath.MIN_SQRT_RATIO), "RATIO_MIN");
-                (0, tiny_invariant_1.default)(jsbi_1.default.lessThan(sqrtPriceLimitX64, this.sqrtPriceX64), "RATIO_CURRENT");
+        if (!sqrtPriceLimitX64)
+            sqrtPriceLimitX64 = zeroForOne
+                ? jsbi_1.default.add(tickMath_1.TickMath.MIN_SQRT_RATIO, internalConstants_2.ONE)
+                : jsbi_1.default.subtract(tickMath_1.TickMath.MAX_SQRT_RATIO, internalConstants_2.ONE);
+        if (zeroForOne) {
+            (0, tiny_invariant_1.default)(jsbi_1.default.greaterThan(sqrtPriceLimitX64, tickMath_1.TickMath.MIN_SQRT_RATIO), "RATIO_MIN");
+            (0, tiny_invariant_1.default)(jsbi_1.default.lessThan(sqrtPriceLimitX64, this.sqrtPriceX64), "RATIO_CURRENT");
+        }
+        else {
+            (0, tiny_invariant_1.default)(jsbi_1.default.lessThan(sqrtPriceLimitX64, tickMath_1.TickMath.MAX_SQRT_RATIO), "RATIO_MAX");
+            (0, tiny_invariant_1.default)(jsbi_1.default.greaterThan(sqrtPriceLimitX64, this.sqrtPriceX64), "RATIO_CURRENT");
+        }
+        const exactInput = jsbi_1.default.greaterThanOrEqual(amountSpecified, internalConstants_2.ZERO);
+        // keep track of swap state
+        const state = {
+            amountSpecifiedRemaining: amountSpecified,
+            amountCalculated: internalConstants_2.ZERO,
+            sqrtPriceX64: this.sqrtPriceX64,
+            tick: this.tickCurrent,
+            liquidity: this.liquidity,
+        };
+        // start swap while loop
+        while (jsbi_1.default.notEqual(state.amountSpecifiedRemaining, internalConstants_2.ZERO) &&
+            state.sqrtPriceX64 != sqrtPriceLimitX64) {
+            const step = {};
+            step.sqrtPriceStartX64 = state.sqrtPriceX64;
+            // because each iteration of the while loop rounds, we can't optimize this code (relative to the smart contract)
+            // by simply traversing to the next available tick, we instead need to exactly replicate
+            // tickBitmap.nextInitializedTickWithinOneWord
+            [step.tickNext, step.initialized] =
+                this.tickDataProvider.nextInitializedTickWithinOneWord(state.tick, zeroForOne, this.tickSpacing);
+            if (step.tickNext < tickMath_1.TickMath.MIN_TICK) {
+                step.tickNext = tickMath_1.TickMath.MIN_TICK;
+            }
+            else if (step.tickNext > tickMath_1.TickMath.MAX_TICK) {
+                step.tickNext = tickMath_1.TickMath.MAX_TICK;
+            }
+            step.sqrtPriceNextX64 = tickMath_1.TickMath.getSqrtRatioAtTick(step.tickNext);
+            [state.sqrtPriceX64, step.amountIn, step.amountOut, step.feeAmount] =
+                swapMath_1.SwapMath.computeSwapStep(state.sqrtPriceX64, (zeroForOne
+                    ? jsbi_1.default.lessThan(step.sqrtPriceNextX64, sqrtPriceLimitX64)
+                    : jsbi_1.default.greaterThan(step.sqrtPriceNextX64, sqrtPriceLimitX64))
+                    ? sqrtPriceLimitX64
+                    : step.sqrtPriceNextX64, state.liquidity, state.amountSpecifiedRemaining, this.fee);
+            if (exactInput) {
+                state.amountSpecifiedRemaining = jsbi_1.default.subtract(state.amountSpecifiedRemaining, jsbi_1.default.add(step.amountIn, step.feeAmount));
+                state.amountCalculated = jsbi_1.default.subtract(state.amountCalculated, step.amountOut);
             }
             else {
-                (0, tiny_invariant_1.default)(jsbi_1.default.lessThan(sqrtPriceLimitX64, tickMath_1.TickMath.MAX_SQRT_RATIO), "RATIO_MAX");
-                (0, tiny_invariant_1.default)(jsbi_1.default.greaterThan(sqrtPriceLimitX64, this.sqrtPriceX64), "RATIO_CURRENT");
+                state.amountSpecifiedRemaining = jsbi_1.default.add(state.amountSpecifiedRemaining, step.amountOut);
+                state.amountCalculated = jsbi_1.default.add(state.amountCalculated, jsbi_1.default.add(step.amountIn, step.feeAmount));
             }
-            const exactInput = jsbi_1.default.greaterThanOrEqual(amountSpecified, internalConstants_2.ZERO);
-            // keep track of swap state
-            const state = {
-                amountSpecifiedRemaining: amountSpecified,
-                amountCalculated: internalConstants_2.ZERO,
-                sqrtPriceX64: this.sqrtPriceX64,
-                tick: this.tickCurrent,
-                liquidity: this.liquidity,
-            };
-            // start swap while loop
-            while (jsbi_1.default.notEqual(state.amountSpecifiedRemaining, internalConstants_2.ZERO) &&
-                state.sqrtPriceX64 != sqrtPriceLimitX64) {
-                const step = {};
-                step.sqrtPriceStartX64 = state.sqrtPriceX64;
-                // because each iteration of the while loop rounds, we can't optimize this code (relative to the smart contract)
-                // by simply traversing to the next available tick, we instead need to exactly replicate
-                // tickBitmap.nextInitializedTickWithinOneWord
-                [step.tickNext, step.initialized] =
-                    yield this.tickDataProvider.nextInitializedTickWithinOneWord(state.tick, zeroForOne, this.tickSpacing);
-                if (step.tickNext < tickMath_1.TickMath.MIN_TICK) {
-                    step.tickNext = tickMath_1.TickMath.MIN_TICK;
-                }
-                else if (step.tickNext > tickMath_1.TickMath.MAX_TICK) {
-                    step.tickNext = tickMath_1.TickMath.MAX_TICK;
-                }
-                step.sqrtPriceNextX64 = tickMath_1.TickMath.getSqrtRatioAtTick(step.tickNext);
-                [state.sqrtPriceX64, step.amountIn, step.amountOut, step.feeAmount] =
-                    swapMath_1.SwapMath.computeSwapStep(state.sqrtPriceX64, (zeroForOne
-                        ? jsbi_1.default.lessThan(step.sqrtPriceNextX64, sqrtPriceLimitX64)
-                        : jsbi_1.default.greaterThan(step.sqrtPriceNextX64, sqrtPriceLimitX64))
-                        ? sqrtPriceLimitX64
-                        : step.sqrtPriceNextX64, state.liquidity, state.amountSpecifiedRemaining, this.fee);
-                if (exactInput) {
-                    state.amountSpecifiedRemaining = jsbi_1.default.subtract(state.amountSpecifiedRemaining, jsbi_1.default.add(step.amountIn, step.feeAmount));
-                    state.amountCalculated = jsbi_1.default.subtract(state.amountCalculated, step.amountOut);
-                }
-                else {
-                    state.amountSpecifiedRemaining = jsbi_1.default.add(state.amountSpecifiedRemaining, step.amountOut);
-                    state.amountCalculated = jsbi_1.default.add(state.amountCalculated, jsbi_1.default.add(step.amountIn, step.feeAmount));
-                }
-                // TODO
-                if (jsbi_1.default.equal(state.sqrtPriceX64, step.sqrtPriceNextX64)) {
-                    // if the tick is initialized, run the tick transition
-                    if (step.initialized) {
-                        let liquidityNet = jsbi_1.default.BigInt((yield this.tickDataProvider.getTick(step.tickNext)).liquidityNet);
-                        // if we're moving leftward, we interpret liquidityNet as the opposite sign
-                        // safe because liquidityNet cannot be type(int128).min
-                        if (zeroForOne)
-                            liquidityNet = jsbi_1.default.multiply(liquidityNet, internalConstants_2.NEGATIVE_ONE);
-                        state.liquidity = liquidityMath_1.LiquidityMath.addDelta(state.liquidity, liquidityNet);
-                    }
-                    state.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;
-                }
-                else if (jsbi_1.default.notEqual(state.sqrtPriceX64, step.sqrtPriceStartX64)) {
-                    // updated comparison function
-                    // recompute unless we're on a lower tick boundary (i.e. already transitioned ticks), and haven't moved
-                    state.tick = tickMath_1.TickMath.getTickAtSqrtRatio(state.sqrtPriceX64);
+            // TODO
+            if (jsbi_1.default.equal(state.sqrtPriceX64, step.sqrtPriceNextX64)) {
+                // if the tick is initialized, run the tick transition
+                if (step.initialized) {
+                    let liquidityNet = jsbi_1.default.BigInt((this.tickDataProvider.getTick(step.tickNext)).liquidityNet);
+                    // if we're moving leftward, we interpret liquidityNet as the opposite sign
+                    // safe because liquidityNet cannot be type(int128).min
+                    if (zeroForOne)
+                        liquidityNet = jsbi_1.default.multiply(liquidityNet, internalConstants_2.NEGATIVE_ONE);
+                    state.liquidity = liquidityMath_1.LiquidityMath.addDelta(state.liquidity, liquidityNet);
                 }
+                state.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;
+            }
+            else if (jsbi_1.default.notEqual(state.sqrtPriceX64, step.sqrtPriceStartX64)) {
+                // updated comparison function
+                // recompute unless we're on a lower tick boundary (i.e. already transitioned ticks), and haven't moved
+                state.tick = tickMath_1.TickMath.getTickAtSqrtRatio(state.sqrtPriceX64);
             }
-            return {
-                amountCalculated: state.amountCalculated,
-                sqrtPriceX64: state.sqrtPriceX64,
-                liquidity: state.liquidity,
-                tickCurrent: state.tick,
-            };
-        });
+        }
+        return {
+            amountCalculated: state.amountCalculated,
+            sqrtPriceX64: state.sqrtPriceX64,
+            liquidity: state.liquidity,
+            tickCurrent: state.tick,
+        };
     }
     get tickSpacing() {
         return internalConstants_1.TICK_SPACINGS[this.fee];

package/build/entities/position.js

@@ -364,8 +364,16 @@ class Position {
     getFees() {
         return __awaiter(this, void 0, void 0, function* () {
             const { liquidity, tickLower, tickUpper, feeGrowthInsideALastX64, feeGrowthInsideBLastX64, pool } = this;
-            const lower = yield this.pool.tickDataProvider.getTick(tickLower);
-            const upper = yield this.pool.tickDataProvider.getTick(tickUpper);
+            if (jsbi_1.default.equal(liquidity, internalConstants_2.ZERO) &&
+                jsbi_1.default.equal(this.feesA, internalConstants_2.ZERO) &&
+                jsbi_1.default.equal(this.feesB, internalConstants_2.ZERO)) {
+                return {
+                    feesA: fractions_1.CurrencyAmount.fromRawAmount(this.pool.tokenA, internalConstants_2.ZERO),
+                    feesB: fractions_1.CurrencyAmount.fromRawAmount(this.pool.tokenB, internalConstants_2.ZERO)
+                };
+            }
+            const lower = this.pool.tickDataProvider.getTick(tickLower);
+            const upper = this.pool.tickDataProvider.getTick(tickUpper);
             const { feeGrowthGlobalAX64, feeGrowthGlobalBX64 } = pool;
             const [feeGrowthInsideAX64, feeGrowthInsideBX64] = utils_1.TickLibrary.getFeeGrowthInside(lower, upper, tickLower, tickUpper, pool.tickCurrent, feeGrowthGlobalAX64, feeGrowthGlobalBX64);
             const tokensOwedA = jsbi_1.default.divide(jsbi_1.default.multiply((0, utils_1.subIn128)(feeGrowthInsideAX64, feeGrowthInsideALastX64), liquidity), internalConstants_1.Q64);

package/build/entities/tickDataProvider.d.ts

@@ -7,14 +7,14 @@ export interface TickDataProvider {
      * Return information corresponding to a specific tick
      * @param tick the tick to load
      */
-    getTick(tick: number): Promise<Tick>;
+    getTick(tick: number): Tick;
     /**
      * 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]>;
+    nextInitializedTickWithinOneWord(tick: number, lte: boolean, tickSpacing: number): [number, boolean];
 }
 /**
  * This tick data provider does not know how to fetch any tick data. It throws whenever it is required. Useful if you
@@ -22,6 +22,6 @@ export interface TickDataProvider {
  */
 export declare class NoTickDataProvider implements TickDataProvider {
     private static ERROR_MESSAGE;
-    getTick(_tick: number): Promise<Tick>;
-    nextInitializedTickWithinOneWord(_tick: number, _lte: boolean, _tickSpacing: number): Promise<[number, boolean]>;
+    getTick(_tick: number): Tick;
+    nextInitializedTickWithinOneWord(_tick: number, _lte: boolean, _tickSpacing: number): [number, boolean];
 }

package/build/entities/tickDataProvider.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NoTickDataProvider = void 0;
 /**
@@ -16,14 +7,10 @@ exports.NoTickDataProvider = void 0;
  */
 class NoTickDataProvider {
     getTick(_tick) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error(NoTickDataProvider.ERROR_MESSAGE);
-        });
+        throw new Error(NoTickDataProvider.ERROR_MESSAGE);
     }
     nextInitializedTickWithinOneWord(_tick, _lte, _tickSpacing) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error(NoTickDataProvider.ERROR_MESSAGE);
-        });
+        throw new Error(NoTickDataProvider.ERROR_MESSAGE);
     }
 }
 exports.NoTickDataProvider = NoTickDataProvider;

package/build/entities/tickListDataProvider.d.ts

@@ -6,6 +6,6 @@ import { TickDataProvider } from "./tickDataProvider";
 export declare class TickListDataProvider implements TickDataProvider {
     private ticks;
     constructor(ticks: (Tick | TickConstructorArgs)[], tickSpacing: number);
-    getTick(tick: number): Promise<Tick>;
-    nextInitializedTickWithinOneWord(tick: number, lte: boolean, tickSpacing: number): Promise<[number, boolean]>;
+    getTick(tick: number): Tick;
+    nextInitializedTickWithinOneWord(tick: number, lte: boolean, tickSpacing: number): [number, boolean];
 }

package/build/entities/tickListDataProvider.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TickListDataProvider = void 0;
 const tickList_1 = require("../utils/tickList");
@@ -22,14 +13,10 @@ class TickListDataProvider {
         this.ticks = ticksMapped;
     }
     getTick(tick) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return tickList_1.TickList.getTick(this.ticks, tick);
-        });
+        return tickList_1.TickList.getTick(this.ticks, tick);
     }
     nextInitializedTickWithinOneWord(tick, lte, tickSpacing) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return tickList_1.TickList.nextInitializedTickWithinOneWord(this.ticks, tick, lte, tickSpacing);
-        });
+        return tickList_1.TickList.nextInitializedTickWithinOneWord(this.ticks, tick, lte, tickSpacing);
     }
 }
 exports.TickListDataProvider = TickListDataProvider;

package/build/entities/trade.d.ts

@@ -95,7 +95,7 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
      * @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>>;
+    static exactIn<TInput extends Currency, TOutput extends Currency>(route: Route<TInput, TOutput>, amountIn: CurrencyAmount<TInput>): 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
@@ -104,7 +104,7 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
      * @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>>;
+    static exactOut<TInput extends Currency, TOutput extends Currency>(route: Route<TInput, TOutput>, amountOut: CurrencyAmount<TOutput>): 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.
@@ -115,7 +115,7 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
      * @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>>;
+    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): Trade<TInput, TOutput, TTradeType>;
     /**
      * Constructs a trade from routes by simulating swaps
      *
@@ -129,7 +129,7 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
     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>>;
+    }[], tradeType: TTradeType): 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
@@ -186,39 +186,6 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
      * @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>[]>;
-    static bestTradeExactIn2<TInput extends Currency, TOutput extends Currency>(routes: Route<TInput, TOutput>[], pools: Pool[], currencyAmountIn: CurrencyAmount<TInput>, maxNumResults?: number): Promise<Trade<TInput, TOutput, TradeType.EXACT_INPUT>[]>;
-    static bestTradeExactOut2<TInput extends Currency, TOutput extends Currency>(routes: Route<TInput, TOutput>[], pools: Pool[], currencyAmountOut: CurrencyAmount<TOutput>, maxNumResults?: number): Promise<Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[]>;
+    static bestTradeExactIn<TInput extends Currency, TOutput extends Currency>(routes: Route<TInput, TOutput>[], pools: Pool[], currencyAmountIn: CurrencyAmount<TInput>, maxNumResults?: number): Trade<TInput, TOutput, TradeType.EXACT_INPUT>[];
+    static bestTradeExactOut<TInput extends Currency, TOutput extends Currency>(routes: Route<TInput, TOutput>[], pools: Pool[], currencyAmountOut: CurrencyAmount<TOutput>, maxNumResults?: number): Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[];
 }