@alcorexchange/alcor-swap-sdk 1.0.26 → 1.0.28

package/build/entities/fractions/currencyAmount.d.ts

@@ -1,5 +1,7 @@
+/// <reference types="node" />
 import JSBI from "jsbi";
 import { Currency } from "../currency";
+import { Token } from "../token";
 import { Fraction } from "./fraction";
 import { BigintIsh, Rounding } from "../../internalConstants";
 export declare class CurrencyAmount<T extends Currency> extends Fraction {
@@ -29,4 +31,8 @@ export declare class CurrencyAmount<T extends Currency> extends Fraction {
     toAsset(...args: any[]): string;
     toExtendedAsset(...args: any[]): string;
     toExtendedAssetObject(...args: any[]): object;
+    static toJSON<T extends Currency>(amount: CurrencyAmount<T>): object;
+    static fromJSON(json: any): CurrencyAmount<Token>;
+    static toBuffer<T extends Currency>(amount: CurrencyAmount<T>): object;
+    static fromBuffer(buffer: Buffer): CurrencyAmount<Token>;
 }

package/build/entities/fractions/currencyAmount.js

@@ -4,8 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CurrencyAmount = void 0;
+const msgpack_lite_1 = __importDefault(require("msgpack-lite"));
 const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
 const jsbi_1 = __importDefault(require("jsbi"));
+const token_1 = require("../token");
 const fraction_1 = require("./fraction");
 const big_js_1 = __importDefault(require("big.js"));
 const toformat_1 = __importDefault(require("toformat"));
@@ -79,5 +81,30 @@ class CurrencyAmount extends fraction_1.Fraction {
     toExtendedAssetObject(...args) {
         return { quantity: `${this.toFixed(...args)} ${this.currency.symbol}`, contract: this.currency.contract };
     }
+    static toJSON(amount) {
+        return {
+            currency: token_1.Token.toJSON(amount.currency),
+            numerator: amount.numerator.toString(),
+            denominator: amount.denominator.toString(),
+        };
+    }
+    static fromJSON(json) {
+        const currency = token_1.Token.fromJSON(json.currency);
+        const numerator = jsbi_1.default.BigInt(json.numerator);
+        const denominator = jsbi_1.default.BigInt(json.denominator);
+        return new CurrencyAmount(currency, numerator, denominator);
+    }
+    static toBuffer(amount) {
+        const json = {
+            currency: token_1.Token.toJSON(amount.currency),
+            numerator: amount.numerator.toString(),
+            denominator: amount.denominator.toString(),
+        };
+        return msgpack_lite_1.default.encode(json);
+    }
+    static fromBuffer(buffer) {
+        const json = msgpack_lite_1.default.decode(buffer);
+        return this.fromJSON(json);
+    }
 }
 exports.CurrencyAmount = CurrencyAmount;

package/build/entities/pool.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { CurrencyAmount, Price } from "./fractions";
 import { Token } from "./token";
 import { BigintIsh, FeeAmount } from "../internalConstants";
@@ -30,6 +31,11 @@ export declare class Pool {
     readonly feeGrowthGlobalAX64: JSBI;
     readonly feeGrowthGlobalBX64: JSBI;
     readonly tickDataProvider: TickDataProvider;
+    json?: any;
+    buffer?: Buffer;
+    bufferHash?: string;
+    static hashToPoolMap: Map<string, Pool>;
+    static idToPoolMap: Map<number, Pool>;
     private _tokenAPrice?;
     private _tokenBPrice?;
     /**
@@ -69,14 +75,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): [CurrencyAmount<Token>, Pool];
+    getOutputAmount(inputAmount: CurrencyAmount<Token>, sqrtPriceLimitX64?: JSBI): CurrencyAmount<Token>;
     /**
      * 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): [CurrencyAmount<Token>, Pool];
+    getInputAmount(outputAmount: CurrencyAmount<Token>, sqrtPriceLimitX64?: JSBI): CurrencyAmount<Token>;
     /**
      * Executes a swap
      * @param zeroForOne Whether the amount in is tokenA or tokenB
@@ -89,4 +95,22 @@ export declare class Pool {
      */
     private swap;
     get tickSpacing(): number;
+    static toJSON(pool: Pool): object;
+    static fromJSON(json: any): Pool;
+    /**
+     * Converts the pool to a Buffer using msgpack encoding.
+     * @param {Pool} pool - The pool instance to convert.
+     * @returns {Buffer} The encoded buffer.
+     */
+    static toBuffer(pool: Pool): Buffer;
+    /**
+     * Creates a Pool instance from a Buffer or serialized data.
+     * @param {Buffer | any} data - The buffer or serialized data.
+     * @returns {Pool} The pool instance.
+     */
+    static fromBuffer(data: Buffer | any): Pool;
+    static fromId(id: number): Pool;
+    static createHash(buffer: Buffer, pool?: Pool): string;
+    static hashEquals(pool: Pool, hash: string): boolean;
+    equals(other: Pool): boolean;
 }

package/build/entities/pool.js

@@ -4,7 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Pool = void 0;
+const msgpack_lite_1 = __importDefault(require("msgpack-lite"));
+const crypto_1 = __importDefault(require("crypto"));
 const fractions_1 = require("./fractions");
+const token_1 = require("./token");
 const internalConstants_1 = require("../internalConstants");
 const jsbi_1 = __importDefault(require("jsbi"));
 const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
@@ -93,23 +96,9 @@ class Pool {
     getOutputAmount(inputAmount, sqrtPriceLimitX64) {
         (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 { amountCalculated: outputAmount, } = 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,
-            })
-        ];
+        return fractions_1.CurrencyAmount.fromRawAmount(outputToken, jsbi_1.default.multiply(outputAmount, internalConstants_2.NEGATIVE_ONE));
     }
     /**
      * Given a desired output amount of a token, return the computed input amount and a pool with state updated after the trade
@@ -119,23 +108,9 @@ class Pool {
      */
     getInputAmount(outputAmount, sqrtPriceLimitX64) {
         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 { amountCalculated: inputAmount, } = 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,
-            }),
-        ];
+        return fractions_1.CurrencyAmount.fromRawAmount(inputToken, inputAmount);
     }
     /**
      * Executes a swap
@@ -229,5 +204,111 @@ class Pool {
     get tickSpacing() {
         return internalConstants_1.TICK_SPACINGS[this.fee];
     }
+    static toJSON(pool) {
+        if (pool.json)
+            return pool.json;
+        pool.json = {
+            id: pool.id,
+            tokenA: token_1.Token.toJSON(pool.tokenA),
+            tokenB: token_1.Token.toJSON(pool.tokenB),
+            fee: pool.fee,
+            sqrtPriceX64: pool.sqrtPriceX64.toString(),
+            liquidity: pool.liquidity.toString(),
+            tickCurrent: pool.tickCurrent,
+            feeGrowthGlobalAX64: pool.feeGrowthGlobalAX64.toString(),
+            feeGrowthGlobalBX64: pool.feeGrowthGlobalBX64.toString(),
+            tickDataProvider: tickListDataProvider_1.TickListDataProvider.toJSON(pool.tickDataProvider.ticks)
+        };
+        return pool.json;
+    }
+    static fromJSON(json) {
+        return new Pool({
+            id: json.id,
+            tokenA: token_1.Token.fromJSON(json.tokenA),
+            tokenB: token_1.Token.fromJSON(json.tokenB),
+            fee: json.fee,
+            sqrtPriceX64: jsbi_1.default.BigInt(json.sqrtPriceX64),
+            liquidity: jsbi_1.default.BigInt(json.liquidity),
+            tickCurrent: json.tickCurrent,
+            feeGrowthGlobalAX64: jsbi_1.default.BigInt(json.feeGrowthGlobalAX64),
+            feeGrowthGlobalBX64: jsbi_1.default.BigInt(json.feeGrowthGlobalBX64),
+            ticks: tickListDataProvider_1.TickListDataProvider.fromJSON(json.tickDataProvider)
+        });
+    }
+    /**
+     * Converts the pool to a Buffer using msgpack encoding.
+     * @param {Pool} pool - The pool instance to convert.
+     * @returns {Buffer} The encoded buffer.
+     */
+    static toBuffer(pool) {
+        if (pool.buffer)
+            return pool.buffer;
+        const json = Pool.toJSON(pool);
+        pool.buffer = msgpack_lite_1.default.encode(json);
+        pool.bufferHash = Pool.createHash(pool.buffer);
+        return pool.buffer;
+    }
+    /**
+     * Creates a Pool instance from a Buffer or serialized data.
+     * @param {Buffer | any} data - The buffer or serialized data.
+     * @returns {Pool} The pool instance.
+     */
+    static fromBuffer(data) {
+        const bufferHash = Pool.createHash(data instanceof Buffer ? data : data.buffer);
+        if (this.hashToPoolMap.has(bufferHash)) {
+            return this.hashToPoolMap.get(bufferHash);
+        }
+        const json = msgpack_lite_1.default.decode(data instanceof Buffer ? data : data.buffer);
+        const pool = Pool.fromJSON(json);
+        this.hashToPoolMap.set(bufferHash, pool);
+        this.idToPoolMap.set(pool.id, pool);
+        return pool;
+    }
+    static fromId(id) {
+        //console.log('fromId', id)
+        const pool = Pool.idToPoolMap.get(id);
+        if (!pool)
+            throw new Error('pool does not exist in idToPoolMap');
+        return pool;
+    }
+    static createHash(buffer, pool) {
+        if (pool && pool.bufferHash) {
+            return pool.bufferHash;
+        }
+        const hash = crypto_1.default.createHash('sha256');
+        hash.update(buffer);
+        const hexHash = hash.digest('hex');
+        if (pool) {
+            pool.bufferHash = hexHash;
+        }
+        return hexHash;
+    }
+    static hashEquals(pool, hash) {
+        return pool.bufferHash === hash;
+    }
+    equals(other) {
+        // Сравниваем id пулов
+        if (this.id !== other.id)
+            return false;
+        // Сравниваем fee
+        if (this.fee !== other.fee)
+            return false;
+        // Сравниваем sqrtPriceX64
+        if (!jsbi_1.default.equal(this.sqrtPriceX64, other.sqrtPriceX64))
+            return false;
+        // Сравниваем liquidity
+        if (!jsbi_1.default.equal(this.liquidity, other.liquidity))
+            return false;
+        // Сравниваем tickCurrent
+        if (this.tickCurrent !== other.tickCurrent)
+            return false;
+        // Сравниваем токены (предполагается, что у Token есть метод equals)
+        if (!this.tokenA.equals(other.tokenA) || !this.tokenB.equals(other.tokenB))
+            return false;
+        // Если все проверки прошли, объекты считаются равными
+        return true;
+    }
 }
 exports.Pool = Pool;
+Pool.hashToPoolMap = new Map();
+Pool.idToPoolMap = new Map();

package/build/entities/route.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { Currency } from './currency';
 import { Price } from './fractions';
 import { Token } from './token';
@@ -24,4 +25,23 @@ export declare class Route<TInput extends Currency, TOutput extends Currency> {
      * Returns the mid price of the route
      */
     get midPrice(): Price<TInput, TOutput>;
+    static toJSON(route: Route<Currency, Currency>, lightWeightVersion?: boolean): {
+        pools: (number | Buffer)[];
+        input: {
+            contract: string;
+            decimals: number;
+            symbol: string;
+        };
+        output: {
+            contract: string;
+            decimals: number;
+            symbol: string;
+        };
+        _midPrice: Price<Token, Token> | null;
+    };
+    static fromJSON(json: any): Route<Token, Token>;
+    static toBuffer(route: Route<Currency, Currency>, lightWeightVersion?: boolean): any;
+    static fromBuffer(buffer: Buffer): Route<Token, Token>;
+    static toBufferAdvanced(route: Route<Currency, Currency>, pools: any[]): any;
+    equals(other: Route<Currency, Currency>): boolean;
 }

package/build/entities/route.js

@@ -4,8 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Route = void 0;
+const msgpack_lite_1 = __importDefault(require("msgpack-lite"));
 const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
 const fractions_1 = require("./fractions");
+const token_1 = require("./token");
+const pool_1 = require("./pool");
 /**
  * Represents a list of pools through which a swap can occur
  * @template TInput The input token
@@ -30,8 +33,11 @@ class Route {
         const tokenPath = [wrappedInput];
         for (const [i, pool] of pools.entries()) {
             const currentInputToken = tokenPath[i];
-            (0, tiny_invariant_1.default)(currentInputToken.equals(pool.tokenA) || currentInputToken.equals(pool.tokenB), 'PATH');
-            const nextToken = currentInputToken.equals(pool.tokenA) ? pool.tokenB : pool.tokenA;
+            (0, tiny_invariant_1.default)(currentInputToken.equals(pool.tokenA) ||
+                currentInputToken.equals(pool.tokenB), 'PATH');
+            const nextToken = currentInputToken.equals(pool.tokenA)
+                ? pool.tokenB
+                : pool.tokenA;
             tokenPath.push(nextToken);
         }
         this.pools = pools;
@@ -49,22 +55,83 @@ class Route {
             return nextInput.equals(pool.tokenA)
                 ? {
                     nextInput: pool.tokenB,
-                    price: price.multiply(pool.tokenAPrice)
+                    price: price.multiply(pool.tokenAPrice),
                 }
                 : {
                     nextInput: pool.tokenA,
-                    price: price.multiply(pool.tokenBPrice)
+                    price: price.multiply(pool.tokenBPrice),
                 };
         }, this.pools[0].tokenA.equals(this.input)
             ? {
                 nextInput: this.pools[0].tokenB,
-                price: this.pools[0].tokenAPrice
+                price: this.pools[0].tokenAPrice,
             }
             : {
                 nextInput: this.pools[0].tokenA,
-                price: this.pools[0].tokenBPrice
+                price: this.pools[0].tokenBPrice,
             }).price;
         return (this._midPrice = new fractions_1.Price(this.input, this.output, price.denominator, price.numerator));
     }
+    static toJSON(route, lightWeightVersion = false) {
+        return {
+            pools: route.pools.map((pool) => {
+                if (lightWeightVersion) {
+                    return pool.id;
+                }
+                else {
+                    return pool_1.Pool.toBuffer(pool);
+                }
+            }),
+            input: token_1.Token.toJSON(route.input),
+            output: token_1.Token.toJSON(route.output),
+            _midPrice: route._midPrice,
+        };
+    }
+    static fromJSON(json) {
+        const pools = json.pools.map((pool) => {
+            if (typeof pool === 'number') {
+                return pool_1.Pool.fromId(pool);
+            }
+            else {
+                return pool_1.Pool.fromBuffer(Buffer.from(pool));
+            }
+        });
+        const input = token_1.Token.fromJSON(json.input);
+        const output = token_1.Token.fromJSON(json.output);
+        return new Route(pools, input, output);
+    }
+    static toBuffer(route, lightWeightVersion = false) {
+        const json = this.toJSON(route, lightWeightVersion);
+        return msgpack_lite_1.default.encode(json);
+    }
+    static fromBuffer(buffer) {
+        const json = msgpack_lite_1.default.decode(buffer);
+        return this.fromJSON(json);
+    }
+    static toBufferAdvanced(route, pools) {
+        const json = {
+            pools: pools.map((pool) => {
+                if (typeof pool === 'number' || Buffer.isBuffer(pool)) {
+                    return pool;
+                }
+                else {
+                    return pool_1.Pool.toBuffer(pool);
+                }
+            }),
+            input: token_1.Token.toJSON(route.input),
+            output: token_1.Token.toJSON(route.output),
+            _midPrice: route._midPrice,
+        };
+        return msgpack_lite_1.default.encode(json);
+    }
+    equals(other) {
+        if (this.pools.length !== other.pools.length)
+            return false;
+        for (let i = 0; i < this.pools.length; i++) {
+            if (!this.pools[i].equals(other.pools[i]))
+                return false;
+        }
+        return this.input.equals(other.input) && this.output.equals(other.output);
+    }
 }
 exports.Route = Route;

package/build/entities/tick.d.ts

@@ -20,4 +20,6 @@ export declare class Tick {
     readonly secondsOutside: JSBI;
     readonly secondsPerLiquidityOutsideX64: JSBI;
     constructor({ id, liquidityGross, liquidityNet, feeGrowthOutsideAX64, feeGrowthOutsideBX64, tickCumulativeOutside, secondsOutside, secondsPerLiquidityOutsideX64, }: TickConstructorArgs);
+    static toJSON(tick: Tick): object;
+    static fromJSON(json: any): Tick;
 }

package/build/entities/tick.js

@@ -19,5 +19,29 @@ class Tick {
         this.secondsOutside = jsbi_1.default.BigInt(secondsOutside);
         this.secondsPerLiquidityOutsideX64 = jsbi_1.default.BigInt(secondsPerLiquidityOutsideX64);
     }
+    static toJSON(tick) {
+        return {
+            id: tick.id,
+            liquidityGross: tick.liquidityGross.toString(),
+            liquidityNet: tick.liquidityNet.toString(),
+            feeGrowthOutsideAX64: tick.feeGrowthOutsideAX64.toString(),
+            feeGrowthOutsideBX64: tick.feeGrowthOutsideBX64.toString(),
+            tickCumulativeOutside: tick.tickCumulativeOutside.toString(),
+            secondsOutside: tick.secondsOutside.toString(),
+            secondsPerLiquidityOutsideX64: tick.secondsPerLiquidityOutsideX64.toString(),
+        };
+    }
+    static fromJSON(json) {
+        return new Tick({
+            id: json.id,
+            liquidityGross: jsbi_1.default.BigInt(json.liquidityGross),
+            liquidityNet: jsbi_1.default.BigInt(json.liquidityNet),
+            feeGrowthOutsideAX64: jsbi_1.default.BigInt(json.feeGrowthOutsideAX64),
+            feeGrowthOutsideBX64: jsbi_1.default.BigInt(json.feeGrowthOutsideBX64),
+            tickCumulativeOutside: jsbi_1.default.BigInt(json.tickCumulativeOutside),
+            secondsOutside: jsbi_1.default.BigInt(json.secondsOutside),
+            secondsPerLiquidityOutsideX64: jsbi_1.default.BigInt(json.secondsPerLiquidityOutsideX64),
+        });
+    }
 }
 exports.Tick = Tick;

package/build/entities/tickListDataProvider.d.ts

@@ -4,8 +4,10 @@ import { TickDataProvider } from "./tickDataProvider";
  * A data provider for ticks that is backed by an in-memory array of ticks.
  */
 export declare class TickListDataProvider implements TickDataProvider {
-    private ticks;
+    ticks: readonly Tick[];
     constructor(ticks: (Tick | TickConstructorArgs)[], tickSpacing: number);
     getTick(tick: number): Tick;
     nextInitializedTickWithinOneWord(tick: number, lte: boolean, tickSpacing: number): [number, boolean];
+    static toJSON(ticks: Tick[]): object;
+    static fromJSON(ticksArray: any): TickListDataProvider;
 }

package/build/entities/tickListDataProvider.js

@@ -18,5 +18,11 @@ class TickListDataProvider {
     nextInitializedTickWithinOneWord(tick, lte, tickSpacing) {
         return tickList_1.TickList.nextInitializedTickWithinOneWord(this.ticks, tick, lte, tickSpacing);
     }
+    static toJSON(ticks) {
+        return ticks.map((tick) => tick_1.Tick.toJSON(tick));
+    }
+    static fromJSON(ticksArray) {
+        return ticksArray.map(tick_1.Tick.fromJSON);
+    }
 }
 exports.TickListDataProvider = TickListDataProvider;

package/build/entities/token.d.ts

@@ -21,4 +21,10 @@ export declare class Token extends BaseCurrency {
      * @throws if the tokens have the same contract and symbol
      */
     sortsBefore(other: Token): boolean;
+    static toJSON(token: Token): {
+        contract: string;
+        decimals: number;
+        symbol: string;
+    };
+    static fromJSON(json: any): Token;
 }

package/build/entities/token.js

@@ -48,5 +48,15 @@ class Token extends baseCurrency_1.BaseCurrency {
             return (0, eos_common_1.name)(this.contract).raw().lt((0, eos_common_1.name)(other.contract).raw());
         }
     }
+    static toJSON(token) {
+        return {
+            contract: token.contract,
+            decimals: token.decimals,
+            symbol: token.symbol,
+        };
+    }
+    static fromJSON(json) {
+        return new Token(json.contract, json.decimals, json.symbol);
+    }
 }
 exports.Token = Token;

package/build/entities/trade.js

@@ -164,7 +164,7 @@ class Trade {
             amounts[0] = amount;
             for (let i = 0; i < route.tokenPath.length - 1; i++) {
                 const pool = route.pools[i];
-                const [outputAmount] = pool.getOutputAmount(amounts[i]);
+                const outputAmount = pool.getOutputAmount(amounts[i]);
                 amounts[i + 1] = outputAmount;
             }
             inputAmount = fractions_1.CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
@@ -175,7 +175,7 @@ class Trade {
             amounts[amounts.length - 1] = amount;
             for (let i = route.tokenPath.length - 1; i > 0; i--) {
                 const pool = route.pools[i - 1];
-                const [inputAmount] = pool.getInputAmount(amounts[i]);
+                const inputAmount = pool.getInputAmount(amounts[i]);
                 amounts[i - 1] = inputAmount;
             }
             inputAmount = fractions_1.CurrencyAmount.fromFractionalAmount(route.input, amounts[0].numerator, amounts[0].denominator);
@@ -208,7 +208,7 @@ class Trade {
                 amounts[0] = fractions_1.CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
                 for (let i = 0; i < route.tokenPath.length - 1; i++) {
                     const pool = route.pools[i];
-                    const [outputAmount] = pool.getOutputAmount(amounts[i]);
+                    const outputAmount = pool.getOutputAmount(amounts[i]);
                     amounts[i + 1] = outputAmount;
                 }
                 outputAmount = fractions_1.CurrencyAmount.fromFractionalAmount(route.output, amounts[amounts.length - 1].numerator, amounts[amounts.length - 1].denominator);
@@ -219,7 +219,7 @@ class Trade {
                 amounts[amounts.length - 1] = fractions_1.CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
                 for (let i = route.tokenPath.length - 1; i > 0; i--) {
                     const pool = route.pools[i - 1];
-                    const [inputAmount] = pool.getInputAmount(amounts[i]);
+                    const inputAmount = pool.getInputAmount(amounts[i]);
                     amounts[i - 1] = inputAmount;
                 }
                 inputAmount = fractions_1.CurrencyAmount.fromFractionalAmount(route.input, amounts[0].numerator, amounts[0].denominator);

package/build/utils/computeAllRoutes.d.ts

@@ -1,2 +1,5 @@
 import { Token, Pool, Route } from '../entities';
 export declare function computeAllRoutes(tokenIn: Token, tokenOut: Token, pools: Pool[], maxHops: number): Route<Token, Token>[];
+export declare function computeAllRoutesFromMap(tokenIn: Token, tokenOut: Token, poolMap: {
+    [tokenId: string]: Pool[];
+}, maxHops: number): Route<Token, Token>[];

package/build/utils/computeAllRoutes.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.computeAllRoutes = void 0;
+exports.computeAllRoutesFromMap = exports.computeAllRoutes = void 0;
 const entities_1 = require("../entities");
 function computeAllRoutes(tokenIn, tokenOut, pools, maxHops) {
     const poolsUsed = Array(pools.length).fill(false);
@@ -37,3 +37,34 @@ function computeAllRoutes(tokenIn, tokenOut, pools, maxHops) {
     return routes;
 }
 exports.computeAllRoutes = computeAllRoutes;
+function computeAllRoutesFromMap(tokenIn, tokenOut, poolMap, maxHops) {
+    const routes = [];
+    const computeRoutes = (tokenIn, tokenOut, currentRoute, visitedPools, _previousTokenOut) => {
+        if (currentRoute.length > maxHops) {
+            return;
+        }
+        if (currentRoute.length > 0 &&
+            currentRoute[currentRoute.length - 1].involvesToken(tokenOut)) {
+            routes.push(new entities_1.Route([...currentRoute], tokenIn, tokenOut));
+            return;
+        }
+        const previousTokenOut = _previousTokenOut ? _previousTokenOut : tokenIn;
+        const relevantPools = poolMap[previousTokenOut.id] || [];
+        for (const curPool of relevantPools) {
+            if (visitedPools.has(curPool)) {
+                continue;
+            }
+            const currentTokenOut = curPool.tokenA.equals(previousTokenOut)
+                ? curPool.tokenB
+                : curPool.tokenA;
+            currentRoute.push(curPool);
+            visitedPools.add(curPool);
+            computeRoutes(tokenIn, tokenOut, currentRoute, visitedPools, currentTokenOut);
+            visitedPools.delete(curPool);
+            currentRoute.pop();
+        }
+    };
+    computeRoutes(tokenIn, tokenOut, [], new Set());
+    return routes;
+}
+exports.computeAllRoutesFromMap = computeAllRoutesFromMap;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alcorexchange/alcor-swap-sdk",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "description": "",
   "main": "build/index.js",
   "scripts": {
@@ -55,6 +55,7 @@
     "eosjs": "^22.1.0",
     "eosjs-account-name": "2.3.0",
     "jsbi": "^4.3.0",
+    "msgpack-lite": "^0.1.26",
     "node-fetch": "2",
     "tiny-invariant": "^1.1.0",
     "tiny-warning": "^1.0.3",

package/src/entities/fractions/currencyAmount.ts

@@ -1,3 +1,5 @@
+import msgpack from "msgpack-lite"
+
 import invariant from "tiny-invariant";
 import JSBI from "jsbi";
 import { Currency } from "../currency";
@@ -130,4 +132,34 @@ export class CurrencyAmount<T extends Currency> extends Fraction {
   public toExtendedAssetObject(...args): object {
     return { quantity: `${this.toFixed(...args)} ${this.currency.symbol}`, contract: this.currency.contract }
   }
+
+  static toJSON<T extends Currency>(amount: CurrencyAmount<T>): object {
+    return {
+      currency: Token.toJSON(amount.currency),
+      numerator: amount.numerator.toString(),
+      denominator: amount.denominator.toString(),
+    };
+  }
+
+  static fromJSON(json: any) {
+    const currency = Token.fromJSON(json.currency);
+    const numerator = JSBI.BigInt(json.numerator);
+    const denominator = JSBI.BigInt(json.denominator);
+    return new CurrencyAmount(currency, numerator, denominator);
+  }
+
+  static toBuffer<T extends Currency>(amount: CurrencyAmount<T>): object {
+    const json = {
+      currency: Token.toJSON(amount.currency),
+      numerator: amount.numerator.toString(),
+      denominator: amount.denominator.toString(),
+    }
+
+    return msgpack.encode(json);
+  }
+
+  static fromBuffer(buffer: Buffer) {
+    const json = msgpack.decode(buffer)
+    return this.fromJSON(json)
+  }
 }

package/src/entities/pool.ts

@@ -1,3 +1,6 @@
+import msgpack from "msgpack-lite";
+import crypto, {createHash} from 'crypto';
+
 import { CurrencyAmount, Price } from "./fractions";
 import { Token } from "./token";
 import { BigintIsh, FeeAmount, TICK_SPACINGS } from "../internalConstants";
@@ -57,6 +60,14 @@ export class Pool {
   public readonly feeGrowthGlobalBX64: JSBI;
   public readonly tickDataProvider: TickDataProvider;
 
+  public json?: any
+  public buffer?: Buffer
+  public bufferHash?: string
+
+  static hashToPoolMap: Map<string, Pool> = new Map()
+  public static idToPoolMap: Map<number, Pool> = new Map()
+
+
   private _tokenAPrice?: Price<Token, Token>;
   private _tokenBPrice?: Price<Token, Token>;
 
@@ -170,36 +181,19 @@ export class Pool {
   public getOutputAmount(
     inputAmount: CurrencyAmount<Token>,
     sqrtPriceLimitX64?: JSBI
-  ): [CurrencyAmount<Token>, Pool] {
+  ): CurrencyAmount<Token> {
     invariant(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 [
-      CurrencyAmount.fromRawAmount(
+    return CurrencyAmount.fromRawAmount(
         outputToken,
         JSBI.multiply(outputAmount, 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,
-      })
-    ];
+      )
   }
 
   /**
@@ -211,35 +205,18 @@ export class Pool {
   public getInputAmount(
     outputAmount: CurrencyAmount<Token>,
     sqrtPriceLimitX64?: JSBI
-  ): [CurrencyAmount<Token>, Pool] {
+  ): CurrencyAmount<Token> {
     const zeroForOne = outputAmount.currency.equals(this.tokenB);
 
     const {
       amountCalculated: inputAmount,
-      sqrtPriceX64,
-      liquidity,
-      tickCurrent,
     } = this.swap(
       zeroForOne,
       JSBI.multiply(outputAmount.quotient, NEGATIVE_ONE),
       sqrtPriceLimitX64
     );
     const inputToken = zeroForOne ? this.tokenA : this.tokenB;
-    return [
-      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,
-      }),
-    ];
+    return CurrencyAmount.fromRawAmount(inputToken, inputAmount)
   }
 
   /**
@@ -396,4 +373,118 @@ export class Pool {
   public get tickSpacing(): number {
     return TICK_SPACINGS[this.fee];
   }
+
+  static toJSON(pool: Pool): object {
+    if (pool.json) return pool.json
+    pool.json = {
+      id: pool.id,
+      tokenA: Token.toJSON(pool.tokenA),
+      tokenB: Token.toJSON(pool.tokenB),
+      fee: pool.fee,
+      sqrtPriceX64: pool.sqrtPriceX64.toString(),
+      liquidity: pool.liquidity.toString(),
+      tickCurrent: pool.tickCurrent,
+      feeGrowthGlobalAX64: pool.feeGrowthGlobalAX64.toString(),
+      feeGrowthGlobalBX64: pool.feeGrowthGlobalBX64.toString(),
+      tickDataProvider: TickListDataProvider.toJSON((pool.tickDataProvider as TickListDataProvider).ticks as Tick[])
+    }
+
+    return pool.json
+  }
+
+  static fromJSON(json: any): Pool {
+    return new Pool({
+      id: json.id,
+      tokenA: Token.fromJSON(json.tokenA),
+      tokenB: Token.fromJSON(json.tokenB),
+      fee: json.fee,
+      sqrtPriceX64: JSBI.BigInt(json.sqrtPriceX64),
+      liquidity: JSBI.BigInt(json.liquidity),
+      tickCurrent: json.tickCurrent,
+      feeGrowthGlobalAX64: JSBI.BigInt(json.feeGrowthGlobalAX64),
+      feeGrowthGlobalBX64: JSBI.BigInt(json.feeGrowthGlobalBX64),
+      ticks: TickListDataProvider.fromJSON(json.tickDataProvider)
+    });
+  }
+  /**
+   * Converts the pool to a Buffer using msgpack encoding.
+   * @param {Pool} pool - The pool instance to convert.
+   * @returns {Buffer} The encoded buffer.
+   */
+  static toBuffer(pool: Pool): Buffer {
+    if (pool.buffer) return pool.buffer;
+    
+    const json = Pool.toJSON(pool);
+    pool.buffer = msgpack.encode(json);
+    pool.bufferHash = Pool.createHash(pool.buffer as Buffer);
+    
+    return pool.buffer as Buffer;
+  }
+
+  /**
+   * Creates a Pool instance from a Buffer or serialized data.
+   * @param {Buffer | any} data - The buffer or serialized data.
+   * @returns {Pool} The pool instance.
+   */
+  static fromBuffer(data: Buffer | any): Pool {
+    const bufferHash = Pool.createHash(data instanceof Buffer ? data : data.buffer);
+
+    if (this.hashToPoolMap.has(bufferHash)) {
+      return <Pool>this.hashToPoolMap.get(bufferHash);
+    }
+
+    const json = msgpack.decode(data instanceof Buffer ? data : data.buffer);
+    const pool = Pool.fromJSON(json);
+
+    this.hashToPoolMap.set(bufferHash, pool);
+    this.idToPoolMap.set(pool.id, pool);
+    
+    return pool;
+  }
+
+  static fromId(id: number): Pool {
+    //console.log('fromId', id)
+    const pool = Pool.idToPoolMap.get(id)
+    if (!pool) throw new Error('pool does not exist in idToPoolMap')
+    return pool;
+  }
+
+  static createHash(buffer: Buffer, pool?: Pool) {
+    if (pool && pool.bufferHash) {
+      return pool.bufferHash
+    }
+    const hash = crypto.createHash('sha256');
+    hash.update(buffer);
+    const hexHash = hash.digest('hex');
+
+    if (pool) {
+      pool.bufferHash = hexHash
+    }
+    return hexHash
+  }
+  static hashEquals(pool: Pool, hash: string) {
+    return pool.bufferHash === hash
+  }
+  public equals(other: Pool): boolean {
+    // Сравниваем id пулов
+    if (this.id !== other.id) return false;
+
+    // Сравниваем fee
+    if (this.fee !== other.fee) return false;
+
+    // Сравниваем sqrtPriceX64
+    if (!JSBI.equal(this.sqrtPriceX64, other.sqrtPriceX64)) return false;
+
+    // Сравниваем liquidity
+    if (!JSBI.equal(this.liquidity, other.liquidity)) return false;
+
+    // Сравниваем tickCurrent
+    if (this.tickCurrent !== other.tickCurrent) return false;
+
+    // Сравниваем токены (предполагается, что у Token есть метод equals)
+    if (!this.tokenA.equals(other.tokenA) || !this.tokenB.equals(other.tokenB)) return false;
+
+    // Если все проверки прошли, объекты считаются равными
+    return true;
+  }
 }

package/src/entities/route.ts

@@ -1,3 +1,4 @@
+import msgpack from "msgpack-lite"
 import invariant from 'tiny-invariant'
 
 import { Currency } from './currency'
@@ -12,12 +13,12 @@ import { Pool } from './pool'
  * @template TOutput The output token
  */
 export class Route<TInput extends Currency, TOutput extends Currency> {
-  public readonly pools: Pool[]
-  public readonly tokenPath: Token[]
-  public readonly input: TInput
-  public readonly output: TOutput
+  public readonly pools: Pool[];
+  public readonly tokenPath: Token[];
+  public readonly input: TInput;
+  public readonly output: TOutput;
 
-  private _midPrice: Price<TInput, TOutput> | null = null
+  private _midPrice: Price<TInput, TOutput> | null = null;
 
   /**
    * Creates an instance of route.
@@ -26,59 +27,136 @@ export class Route<TInput extends Currency, TOutput extends Currency> {
    * @param output The output token
    */
   public constructor(pools: Pool[], input: TInput, output: TOutput) {
-    invariant(pools.length > 0, 'POOLS')
+    invariant(pools.length > 0, 'POOLS');
 
-    const wrappedInput = input
-    invariant(pools[0].involvesToken(wrappedInput), 'INPUT')
+    const wrappedInput = input;
+    invariant(pools[0].involvesToken(wrappedInput), 'INPUT');
 
-    invariant(pools[pools.length - 1].involvesToken(output), 'OUTPUT')
+    invariant(pools[pools.length - 1].involvesToken(output), 'OUTPUT');
 
     /**
      * Normalizes tokenA-tokenB order and selects the next token/fee step to add to the path
      * */
-    const tokenPath: Token[] = [wrappedInput]
+    const tokenPath: Token[] = [wrappedInput];
     for (const [i, pool] of pools.entries()) {
-      const currentInputToken = tokenPath[i]
-      invariant(currentInputToken.equals(pool.tokenA) || currentInputToken.equals(pool.tokenB), 'PATH')
-      const nextToken = currentInputToken.equals(pool.tokenA) ? pool.tokenB : pool.tokenA
-      tokenPath.push(nextToken)
+      const currentInputToken = tokenPath[i];
+      invariant(
+        currentInputToken.equals(pool.tokenA) ||
+          currentInputToken.equals(pool.tokenB),
+        'PATH'
+      );
+      const nextToken = currentInputToken.equals(pool.tokenA)
+        ? pool.tokenB
+        : pool.tokenA;
+      tokenPath.push(nextToken);
     }
 
-    this.pools = pools
-    this.tokenPath = tokenPath
-    this.input = input
-    this.output = output ?? tokenPath[tokenPath.length - 1]
+    this.pools = pools;
+    this.tokenPath = tokenPath;
+    this.input = input;
+    this.output = output ?? tokenPath[tokenPath.length - 1];
   }
 
   /**
    * Returns the mid price of the route
    */
   public get midPrice(): Price<TInput, TOutput> {
-    if (this._midPrice !== null) return this._midPrice
+    if (this._midPrice !== null) return this._midPrice;
 
     const price = this.pools.slice(1).reduce(
       ({ nextInput, price }, pool) => {
         return nextInput.equals(pool.tokenA)
           ? {
               nextInput: pool.tokenB,
-              price: price.multiply(pool.tokenAPrice)
+              price: price.multiply(pool.tokenAPrice),
             }
           : {
               nextInput: pool.tokenA,
-              price: price.multiply(pool.tokenBPrice)
-            }
+              price: price.multiply(pool.tokenBPrice),
+            };
       },
       this.pools[0].tokenA.equals(this.input)
         ? {
             nextInput: this.pools[0].tokenB,
-            price: this.pools[0].tokenAPrice
+            price: this.pools[0].tokenAPrice,
           }
         : {
             nextInput: this.pools[0].tokenA,
-            price: this.pools[0].tokenBPrice
+            price: this.pools[0].tokenBPrice,
           }
-    ).price
+    ).price;
+
+    return (this._midPrice = new Price(
+      this.input,
+      this.output,
+      price.denominator,
+      price.numerator
+    ));
+  }
+
+  static toJSON(route: Route<Currency, Currency>, lightWeightVersion = false) {
+    return {
+      pools: route.pools.map((pool) => {
+        if (lightWeightVersion) {
+          return pool.id;
+        } else {
+          return Pool.toBuffer(pool);
+        }
+      }),
+      input: Token.toJSON(route.input),
+      output: Token.toJSON(route.output),
+      _midPrice: route._midPrice,
+    };
+  }
+
+  static fromJSON(json: any) {
+    const pools = json.pools.map((pool) => {
+      if (typeof pool === 'number') {
+        return Pool.fromId(pool);
+      } else {
+        return Pool.fromBuffer(Buffer.from(pool));
+      }
+    });
+    const input = Token.fromJSON(json.input);
+    const output = Token.fromJSON(json.output);
+    return new Route(pools, input, output);
+  }
 
-    return (this._midPrice = new Price(this.input, this.output, price.denominator, price.numerator))
+  static toBuffer(
+    route: Route<Currency, Currency>,
+    lightWeightVersion = false
+  ) {
+    const json = this.toJSON(route, lightWeightVersion);
+    return msgpack.encode(json);
+  }
+
+  static fromBuffer(buffer: Buffer) {
+    const json = msgpack.decode(buffer);
+    return this.fromJSON(json);
+  }
+
+  static toBufferAdvanced(route: Route<Currency, Currency>, pools: any[]) {
+    const json = {
+      pools: pools.map((pool) => {
+        if (typeof pool === 'number' || Buffer.isBuffer(pool)) {
+          return pool;
+        } else {
+          return Pool.toBuffer(pool);
+        }
+      }),
+      input: Token.toJSON(route.input),
+      output: Token.toJSON(route.output),
+      _midPrice: route._midPrice,
+    };
+    return msgpack.encode(json);
+  }
+
+  public equals(other: Route<Currency, Currency>): boolean {
+    if (this.pools.length !== other.pools.length) return false;
+
+    for (let i = 0; i < this.pools.length; i++) {
+      if (!this.pools[i].equals(other.pools[i])) return false;
+    }
+    return this.input.equals(other.input) && this.output.equals(other.output);
   }
 }

package/src/entities/tick.ts

@@ -45,4 +45,30 @@ export class Tick {
     this.secondsOutside = JSBI.BigInt(secondsOutside);
     this.secondsPerLiquidityOutsideX64 = JSBI.BigInt(secondsPerLiquidityOutsideX64);
   }
+
+  static toJSON(tick: Tick): object {
+    return {
+      id: tick.id,
+      liquidityGross: tick.liquidityGross.toString(),
+      liquidityNet: tick.liquidityNet.toString(),
+      feeGrowthOutsideAX64: tick.feeGrowthOutsideAX64.toString(),
+      feeGrowthOutsideBX64: tick.feeGrowthOutsideBX64.toString(),
+      tickCumulativeOutside: tick.tickCumulativeOutside.toString(),
+      secondsOutside: tick.secondsOutside.toString(),
+      secondsPerLiquidityOutsideX64: tick.secondsPerLiquidityOutsideX64.toString(),
+    }
+  }
+
+  static fromJSON(json: any): Tick {
+    return new Tick({
+      id: json.id,
+      liquidityGross: JSBI.BigInt(json.liquidityGross),
+      liquidityNet: JSBI.BigInt(json.liquidityNet),
+      feeGrowthOutsideAX64: JSBI.BigInt(json.feeGrowthOutsideAX64),
+      feeGrowthOutsideBX64: JSBI.BigInt(json.feeGrowthOutsideBX64),
+      tickCumulativeOutside: JSBI.BigInt(json.tickCumulativeOutside),
+      secondsOutside: JSBI.BigInt(json.secondsOutside),
+      secondsPerLiquidityOutsideX64: JSBI.BigInt(json.secondsPerLiquidityOutsideX64),
+    });
+  }
 }

package/src/entities/tickListDataProvider.ts

@@ -6,7 +6,7 @@ import { TickDataProvider } from "./tickDataProvider";
  * A data provider for ticks that is backed by an in-memory array of ticks.
  */
 export class TickListDataProvider implements TickDataProvider {
-  private ticks: readonly Tick[];
+  public ticks: readonly Tick[];
 
   constructor(ticks: (Tick | TickConstructorArgs)[], tickSpacing: number) {
     const ticksMapped: Tick[] = ticks.map((t) =>
@@ -34,4 +34,12 @@ export class TickListDataProvider implements TickDataProvider {
       tickSpacing
     );
   }
+
+  static toJSON(ticks: Tick[]): object {
+    return ticks.map((tick) => Tick.toJSON(tick));
+  }
+
+  static fromJSON(ticksArray: any): TickListDataProvider {
+    return ticksArray.map(Tick.fromJSON);
+  }
 }

package/src/entities/token.ts

@@ -51,4 +51,16 @@ export class Token extends BaseCurrency {
         return name(this.contract).raw().lt(name(other.contract).raw());
     }
   }
+
+  static toJSON(token: Token) {
+    return {
+      contract: token.contract,
+      decimals: token.decimals,
+      symbol: token.symbol,
+    }
+  }
+
+  static fromJSON(json: any) {
+    return new Token(json.contract, json.decimals, json.symbol);
+  }
 }

package/src/entities/trade.ts

@@ -240,7 +240,7 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
       amounts[0] = amount
       for (let i = 0; i < route.tokenPath.length - 1; i++) {
         const pool = route.pools[i]
-        const [outputAmount] = pool.getOutputAmount(amounts[i])
+        const outputAmount = pool.getOutputAmount(amounts[i])
         amounts[i + 1] = outputAmount
       }
       inputAmount = CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator)
@@ -254,7 +254,7 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
       amounts[amounts.length - 1] = amount
       for (let i = route.tokenPath.length - 1; i > 0; i--) {
         const pool = route.pools[i - 1]
-        const [inputAmount] = pool.getInputAmount(amounts[i])
+        const inputAmount = pool.getInputAmount(amounts[i])
         amounts[i - 1] = inputAmount
       }
       inputAmount = CurrencyAmount.fromFractionalAmount(route.input, amounts[0].numerator, amounts[0].denominator)
@@ -302,7 +302,7 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
 
         for (let i = 0; i < route.tokenPath.length - 1; i++) {
           const pool = route.pools[i]
-          const [outputAmount] = pool.getOutputAmount(amounts[i])
+          const outputAmount = pool.getOutputAmount(amounts[i])
           amounts[i + 1] = outputAmount
         }
 
@@ -322,7 +322,7 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
 
         for (let i = route.tokenPath.length - 1; i > 0; i--) {
           const pool = route.pools[i - 1]
-          const [inputAmount] = pool.getInputAmount(amounts[i])
+          const inputAmount = pool.getInputAmount(amounts[i])
           amounts[i - 1] = inputAmount
         }
 

package/src/utils/computeAllRoutes.ts

@@ -62,3 +62,63 @@ export function computeAllRoutes(
 
   return routes;
 }
+
+export function computeAllRoutesFromMap(
+    tokenIn: Token,
+    tokenOut: Token,
+    poolMap: { [tokenId: string]: Pool[] },
+    maxHops: number
+): Route<Token , Token>[] {
+  const routes: Route<Token, Token>[] = [];
+
+  const computeRoutes = (
+      tokenIn: Token,
+      tokenOut: Token,
+      currentRoute: Pool[],
+      visitedPools: Set<Pool>,
+      _previousTokenOut?: Token
+  ) => {
+    if (currentRoute.length > maxHops) {
+      return;
+    }
+
+    if (
+        currentRoute.length > 0 &&
+        currentRoute[currentRoute.length - 1]!.involvesToken(tokenOut)
+    ) {
+      routes.push(new Route([...currentRoute], tokenIn, tokenOut));
+      return;
+    }
+
+    const previousTokenOut = _previousTokenOut ? _previousTokenOut : tokenIn;
+    const relevantPools = poolMap[previousTokenOut.id] || [];
+
+    for (const curPool of relevantPools) {
+      if (visitedPools.has(curPool)) {
+        continue;
+      }
+
+      const currentTokenOut = curPool.tokenA.equals(previousTokenOut)
+          ? curPool.tokenB
+          : curPool.tokenA;
+
+      currentRoute.push(curPool);
+      visitedPools.add(curPool);
+
+      computeRoutes(
+          tokenIn,
+          tokenOut,
+          currentRoute,
+          visitedPools,
+          currentTokenOut
+      );
+
+      visitedPools.delete(curPool);
+      currentRoute.pop();
+    }
+  };
+
+  computeRoutes(tokenIn, tokenOut, [], new Set());
+
+  return routes;
+}

package/test/pool.test.ts

@@ -292,14 +292,14 @@ describe("Pool", () => {
     describe("#getOutputAmount", () => {
       it("USDC -> DAI", async () => {
         const inputAmount = CurrencyAmount.fromRawAmount(USDC, 100);
-        const [outputAmount] = await pool.getOutputAmount(inputAmount);
+        const outputAmount = await pool.getOutputAmount(inputAmount);
         expect(outputAmount.currency.equals(DAI)).toBe(true);
         expect(outputAmount.quotient).toEqual(JSBI.BigInt(98));
       });
 
       it("DAI -> USDC", async () => {
         const inputAmount = CurrencyAmount.fromRawAmount(DAI, 100);
-        const [outputAmount] = await pool.getOutputAmount(inputAmount);
+        const outputAmount = await pool.getOutputAmount(inputAmount);
         expect(outputAmount.currency.equals(USDC)).toBe(true);
         expect(outputAmount.quotient).toEqual(JSBI.BigInt(98));
       });
@@ -308,14 +308,14 @@ describe("Pool", () => {
     describe("#getInputAmount", () => {
       it("USDC -> DAI", async () => {
         const outputAmount = CurrencyAmount.fromRawAmount(DAI, 98);
-        const [inputAmount] = await pool.getInputAmount(outputAmount);
+        const inputAmount = await pool.getInputAmount(outputAmount);
         expect(inputAmount.currency.equals(USDC)).toBe(true);
         expect(inputAmount.quotient).toEqual(JSBI.BigInt(100));
       });
 
       it("DAI -> USDC", async () => {
         const outputAmount = CurrencyAmount.fromRawAmount(USDC, 98);
-        const [inputAmount] = await pool.getInputAmount(outputAmount);
+        const inputAmount = await pool.getInputAmount(outputAmount);
         expect(inputAmount.currency.equals(DAI)).toBe(true);
         expect(inputAmount.quotient).toEqual(JSBI.BigInt(100));
       });
@@ -367,7 +367,7 @@ describe("Pool", () => {
       });
       it("correctly handles two BigIntegers", async () => {
         const inputAmount = CurrencyAmount.fromRawAmount(USDC, 100);
-        const [outputAmount] = await pool.getOutputAmount(inputAmount);
+        const outputAmount = await pool.getOutputAmount(inputAmount);
         pool.getInputAmount(outputAmount);
         expect(outputAmount.currency.equals(DAI)).toBe(true);
         // if output is correct, function has succeeded