@alcorexchange/alcor-swap-sdk 1.0.392 → 1.0.393

package/build/entities/baseCurrency.d.ts

@@ -0,0 +1,32 @@
+import { Currency } from "./currency";
+/**
+ * A currency is any fungible financial instrument, including Ether, all ERC20 tokens, and other chain-native currencies
+ */
+export declare abstract class BaseCurrency {
+    /**
+     * The contract address of the currency
+     */
+    readonly contract: string;
+    /**
+     * The decimals used in representing currency amounts
+     */
+    readonly decimals: number;
+    /**
+     * The symbol of the currency, i.e. a short textual non-unique identifier
+     */
+    readonly symbol: string;
+    readonly id: string;
+    /**
+     * Constructs an instance of the base class `BaseCurrency`.
+     * @param chainId the chain ID on which this currency resides
+     * @param decimals decimals of the currency
+     * @param symbol symbol of the currency
+     * @param name of the currency
+     */
+    protected constructor(contract: string, decimals: number, symbol: string);
+    /**
+     * Returns whether this currency is functionally equivalent to the other currency
+     * @param other the other currency
+     */
+    abstract equals(other: Currency): boolean;
+}

package/build/entities/currency.d.ts

@@ -0,0 +1,2 @@
+import { Token } from "./token";
+export type Currency = Token;

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

@@ -0,0 +1,38 @@
+/// <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 {
+    readonly currency: T;
+    readonly decimalScale: JSBI;
+    /**
+     * Returns a new currency amount instance from the unitless amount of token, i.e. the raw amount
+     * @param currency the currency in the amount
+     * @param rawAmount the raw token or ether amount
+     */
+    static fromRawAmount<T extends Currency>(currency: T, rawAmount: BigintIsh): CurrencyAmount<T>;
+    /**
+     * Construct a currency amount with a denominator that is not equal to 1
+     * @param currency the currency
+     * @param numerator the numerator of the fractional token amount
+     * @param denominator the denominator of the fractional token amount
+     */
+    static fromFractionalAmount<T extends Currency>(currency: T, numerator: BigintIsh, denominator: BigintIsh): CurrencyAmount<T>;
+    protected constructor(currency: T, numerator: BigintIsh, denominator?: BigintIsh);
+    add(other: CurrencyAmount<T>): CurrencyAmount<T>;
+    subtract(other: CurrencyAmount<T>): CurrencyAmount<T>;
+    multiply(other: Fraction | BigintIsh): CurrencyAmount<T>;
+    divide(other: Fraction | BigintIsh): CurrencyAmount<T>;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+    toExact(format?: object): string;
+    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/fraction.d.ts

@@ -0,0 +1,24 @@
+import JSBI from "jsbi";
+import { BigintIsh, Rounding } from "../../internalConstants";
+export declare class Fraction {
+    readonly numerator: JSBI;
+    readonly denominator: JSBI;
+    constructor(numerator: BigintIsh, denominator?: BigintIsh);
+    private static tryParseFraction;
+    get quotient(): JSBI;
+    get remainder(): Fraction;
+    invert(): Fraction;
+    add(other: Fraction | BigintIsh): Fraction;
+    subtract(other: Fraction | BigintIsh): Fraction;
+    lessThan(other: Fraction | BigintIsh): boolean;
+    equalTo(other: Fraction | BigintIsh): boolean;
+    greaterThan(other: Fraction | BigintIsh): boolean;
+    multiply(other: Fraction | BigintIsh): Fraction;
+    divide(other: Fraction | BigintIsh): Fraction;
+    toSignificant(significantDigits: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces: number, format?: object, rounding?: Rounding): string;
+    /**
+     * Helper method for converting any super class back to a fraction
+     */
+    get asFraction(): Fraction;
+}

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

@@ -0,0 +1,4 @@
+export { CurrencyAmount } from "./currencyAmount";
+export { Fraction } from "./fraction";
+export { Percent } from "./percent";
+export { Price } from "./price";

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

@@ -0,0 +1,14 @@
+import { BigintIsh, Rounding } from "../../internalConstants";
+import { Fraction } from "./fraction";
+export declare class Percent extends Fraction {
+    /**
+     * This boolean prevents a fraction from being interpreted as a Percent
+     */
+    readonly isPercent: true;
+    add(other: Fraction | BigintIsh): Percent;
+    subtract(other: Fraction | BigintIsh): Percent;
+    multiply(other: Fraction | BigintIsh): Percent;
+    divide(other: Fraction | BigintIsh): Percent;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+}

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

@@ -0,0 +1,40 @@
+import { BigintIsh, Rounding } from "../../internalConstants";
+import { Currency } from "../currency";
+import { Fraction } from "./fraction";
+import { CurrencyAmount } from "./currencyAmount";
+export declare class Price<TBase extends Currency, TQuote extends Currency> extends Fraction {
+    readonly baseCurrency: TBase;
+    readonly quoteCurrency: TQuote;
+    readonly scalar: Fraction;
+    /**
+     * Construct a price, either with the base and quote currency amount, or the
+     * @param args
+     */
+    constructor(...args: [TBase, TQuote, BigintIsh, BigintIsh] | [
+        {
+            baseAmount: CurrencyAmount<TBase>;
+            quoteAmount: CurrencyAmount<TQuote>;
+        }
+    ]);
+    /**
+     * Flip the price, switching the base and quote currency
+     */
+    invert(): Price<TQuote, TBase>;
+    /**
+     * Multiply the price by another price, returning a new price. The other price must have the same base currency as this price's quote currency
+     * @param other the other price
+     */
+    multiply<TOtherQuote extends Currency>(other: Price<TQuote, TOtherQuote>): Price<TBase, TOtherQuote>;
+    /**
+     * Return the amount of quote currency corresponding to a given amount of the base currency
+     * @param currencyAmount the amount of base currency to quote against the price
+     */
+    quote(currencyAmount: CurrencyAmount<TBase>): CurrencyAmount<TQuote>;
+    /**
+     * Get the value scaled by decimals for formatting
+     * @private
+     */
+    private get adjustedForDecimals();
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+}

package/build/entities/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./fractions";
+export * from "./tick";
+export * from "./tickDataProvider";
+export * from "./tickListDataProvider";
+export * from "./currency";
+export * from "./token";
+export * from "./pool";
+export * from "./position";
+export * from "./route";
+export * from "./trade";

package/build/entities/pool.d.ts

@@ -0,0 +1,118 @@
+/// <reference types="node" />
+import { CurrencyAmount, Price } from "./fractions";
+import { Token } from "./token";
+import { BigintIsh, FeeAmount } from "../internalConstants";
+import JSBI from "jsbi";
+import { Tick, TickConstructorArgs } from "./tick";
+import { TickDataProvider } from "./tickDataProvider";
+export interface PoolConstructorArgs {
+    id: number;
+    active: boolean;
+    tokenA: Token;
+    tokenB: Token;
+    fee: FeeAmount;
+    sqrtPriceX64: BigintIsh;
+    liquidity: BigintIsh;
+    tickCurrent: number;
+    feeGrowthGlobalAX64: BigintIsh;
+    feeGrowthGlobalBX64: BigintIsh;
+    ticks: TickDataProvider | (Tick | TickConstructorArgs)[];
+}
+/**
+ * Represents a V3 pool
+ */
+export declare class Pool {
+    readonly id: number;
+    readonly active: boolean;
+    readonly tokenA: Token;
+    readonly tokenB: Token;
+    readonly fee: FeeAmount;
+    readonly sqrtPriceX64: JSBI;
+    readonly liquidity: JSBI;
+    readonly tickCurrent: number;
+    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?;
+    /**
+     * Construct a pool
+     * @param tokenA One of the tokens in the pool
+     * @param tokenB The other token in the pool
+     * @param fee The fee in hundredths of a bips of the input amount of every swap that is collected by the pool
+     * @param sqrtPriceX64 The sqrt of the current ratio of amounts of tokenB to tokenA
+     * @param liquidity The current value of in range liquidity
+     * @param tickCurrent The current tick of the pool
+     * @param ticks The current state of the pool ticks or a data provider that can return tick data
+     */
+    constructor({ id, active, tokenA, tokenB, fee, sqrtPriceX64, liquidity, tickCurrent, ticks, feeGrowthGlobalAX64, feeGrowthGlobalBX64, }: PoolConstructorArgs);
+    /**
+     * Returns true if the token is either tokenA or tokenB
+     * @param token The token to check
+     * @returns True if token is either tokenA or token
+     */
+    involvesToken(token: Token): boolean;
+    /**
+     * Returns the current mid price of the pool in terms of tokenA, i.e. the ratio of tokenB over tokenA
+     */
+    get tokenAPrice(): Price<Token, Token>;
+    /**
+     * Returns the current mid price of the pool in terms of tokenB, i.e. the ratio of tokenA over tokenB
+     */
+    get tokenBPrice(): Price<Token, Token>;
+    /**
+     * Return the price of the given token in terms of the other token in the pool.
+     * @param token The token to return price of
+     * @returns The price of the given token, in terms of the other.
+     */
+    priceOf(token: Token): Price<Token, Token>;
+    /**
+     * Given an input amount of a token, return the computed output amount, and a pool with state updated after the trade
+     * @param inputAmount The input amount for which to quote the output amount
+     * @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>;
+    /**
+     * 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>;
+    /**
+     * Executes a swap
+     * @param zeroForOne Whether the amount in is tokenA or tokenB
+     * @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
+     * @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 amountCalculated
+     * @returns sqrtPriceX64
+     * @returns liquidity
+     * @returns tickCurrent
+     */
+    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/position.d.ts

@@ -0,0 +1,170 @@
+import { CurrencyAmount, Price, Percent } from "./fractions";
+import { Token } from "./token";
+import { BigintIsh } from "../internalConstants";
+import JSBI from "jsbi";
+import { Pool } from "./pool";
+interface PositionConstructorArgs {
+    id: number;
+    owner: string;
+    pool: Pool;
+    tickLower: number;
+    tickUpper: number;
+    liquidity: BigintIsh;
+    feeGrowthInsideALastX64: BigintIsh;
+    feeGrowthInsideBLastX64: BigintIsh;
+    feesA: BigintIsh;
+    feesB: BigintIsh;
+}
+interface Fees {
+    feesA: CurrencyAmount<Token>;
+    feesB: CurrencyAmount<Token>;
+}
+export declare class Position {
+    readonly id: number;
+    readonly owner: string;
+    readonly pool: Pool;
+    readonly tickLower: number;
+    readonly tickUpper: number;
+    readonly liquidity: JSBI;
+    readonly feesA: JSBI;
+    readonly feesB: JSBI;
+    readonly feeGrowthInsideALastX64: JSBI;
+    readonly feeGrowthInsideBLastX64: JSBI;
+    private _tokenAAmount;
+    private _tokenBAmount;
+    private _mintAmounts;
+    /**
+     * Constructs a position for a given pool with the given liquidity
+     * @param pool For which pool the liquidity is assigned
+     * @param liquidity The amount of liquidity that is in the position
+     * @param lower The lower tick of the position
+     * @param upper The upper tick of the position
+     */
+    constructor({ id, owner, pool, liquidity, tickLower, tickUpper, feeGrowthInsideALastX64, feeGrowthInsideBLastX64, feesA, feesB, }: PositionConstructorArgs);
+    get inRange(): boolean;
+    /**
+     * Returns the price of tokenA at the lower tick
+     */
+    get tokenAPriceLower(): Price<Token, Token>;
+    /**
+     * Returns the price of tokenA at the upper tick
+     */
+    get tokenAPriceUpper(): Price<Token, Token>;
+    /**
+     * Returns the amount of tokenA that this position's liquidity could be burned for at the current pool price
+     */
+    get amountA(): CurrencyAmount<Token>;
+    /**
+     * Returns the amount of tokenB that this position's liquidity could be burned for at the current pool price
+     */
+    get amountB(): CurrencyAmount<Token>;
+    /**
+     * Returns the lower and upper sqrt ratios if the price 'slips' up to slippage tolerance percentage
+     * @param slippageTolerance The amount by which the price can 'slip' before the transaction will revert
+     * @returns The sqrt ratios after slippage
+     */
+    private ratiosAfterSlippage;
+    /**
+     * Returns the minimum amounts that must be sent in order to safely mint the amount of liquidity held by the position
+     * with the given slippage tolerance
+     * @param slippageTolerance Tolerance of unfavorable slippage from the current price
+     * @returns The amounts, with slippage
+     */
+    mintAmountsWithSlippage(slippageTolerance: Percent): Readonly<{
+        amountA: JSBI;
+        amountB: JSBI;
+    }>;
+    /**
+     * Returns the minimum amounts that should be requested in order to safely burn the amount of liquidity held by the
+     * position with the given slippage tolerance
+     * @param slippageTolerance tolerance of unfavorable slippage from the current price
+     * @returns The amounts, with slippage
+     */
+    burnAmountsWithSlippage(slippageTolerance: Percent): Readonly<{
+        amountA: CurrencyAmount<Token>;
+        amountB: CurrencyAmount<Token>;
+    }>;
+    /**
+     * Returns the minimum amounts that must be sent in order to mint the amount of liquidity held by the position at
+     * the current price for the pool
+     */
+    get mintAmounts(): Readonly<{
+        amountA: JSBI;
+        amountB: JSBI;
+    }>;
+    /**
+     * Computes the maximum amount of liquidity received for a given amount of tokenA, tokenB,
+     * and the prices at the tick boundaries.
+     * @param pool The pool for which the position should be created
+     * @param lower The lower tick of the position
+     * @param upper The upper tick of the position
+     * @param amountA tokenA amount
+     * @param amountB tokenB amount
+     * @param useFullPrecision If false, liquidity will be maximized according to what the router can calculate,
+     * not what core can theoretically support
+     * @returns The amount of liquidity for the position
+     */
+    static fromAmounts({ id, owner, pool, tickLower, tickUpper, amountA, amountB, useFullPrecision, feeGrowthInsideALastX64, feeGrowthInsideBLastX64, feesA, feesB }: {
+        id: number;
+        owner: string;
+        pool: Pool;
+        tickLower: number;
+        tickUpper: number;
+        amountA: BigintIsh;
+        amountB: BigintIsh;
+        useFullPrecision: boolean;
+        feeGrowthInsideALastX64: BigintIsh;
+        feeGrowthInsideBLastX64: BigintIsh;
+        feesA: BigintIsh;
+        feesB: BigintIsh;
+    }): Position;
+    /**
+     * Computes a position with the maximum amount of liquidity received for a given amount of tokenA, assuming an unlimited amount of tokenB
+     * @param pool The pool for which the position is created
+     * @param lower The lower tick
+     * @param upper The upper tick
+     * @param amountA The desired amount of tokenA
+     * @param useFullPrecision If true, liquidity will be maximized according to what the router can calculate,
+     * not what core can theoretically support
+     * @returns The position
+     */
+    static fromAmountA({ id, owner, pool, tickLower, tickUpper, amountA, useFullPrecision, feeGrowthInsideALastX64, feeGrowthInsideBLastX64, feesA, feesB }: {
+        id: number;
+        owner: string;
+        pool: Pool;
+        tickLower: number;
+        tickUpper: number;
+        amountA: BigintIsh;
+        useFullPrecision: boolean;
+        feeGrowthInsideALastX64: BigintIsh;
+        feeGrowthInsideBLastX64: BigintIsh;
+        feesA: BigintIsh;
+        feesB: BigintIsh;
+    }): Position;
+    /**
+     * Computes a position with the maximum amount of liquidity received for a given amount of tokenB, assuming an unlimited amount of tokenA
+     * @param pool The pool for which the position is created
+     * @param lower The lower tick
+     * @param upper The upper tick
+     * @param amountB The desired amount of tokenB
+     * @returns The position
+     */
+    static fromAmountB({ id, owner, pool, tickLower, tickUpper, amountB, feeGrowthInsideALastX64, feeGrowthInsideBLastX64, feesA, feesB }: {
+        id: number;
+        owner: string;
+        pool: Pool;
+        tickLower: number;
+        tickUpper: number;
+        amountB: BigintIsh;
+        feeGrowthInsideALastX64: BigintIsh;
+        feeGrowthInsideBLastX64: BigintIsh;
+        feesA: BigintIsh;
+        feesB: BigintIsh;
+    }): Position;
+    /**
+     * Computes a position fees
+     * @returns The position
+     */
+    getFees(): Promise<Fees>;
+}
+export {};

package/build/entities/route.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+import { Currency } from './currency';
+import { Price } from './fractions';
+import { Token } from './token';
+import { Pool } from './pool';
+/**
+ * Represents a list of pools through which a swap can occur
+ * @template TInput The input token
+ * @template TOutput The output token
+ */
+export declare class Route<TInput extends Currency, TOutput extends Currency> {
+    readonly pools: Pool[];
+    readonly tokenPath: Token[];
+    readonly input: TInput;
+    readonly output: TOutput;
+    private _midPrice;
+    /**
+     * Creates an instance of route.
+     * @param pools An array of `Pool` objects, ordered by the route the swap will take
+     * @param input The input token
+     * @param output The output token
+     */
+    constructor(pools: Pool[], input: TInput, output: TOutput);
+    /**
+     * 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/tick.d.ts

@@ -0,0 +1,25 @@
+import JSBI from "jsbi";
+import { BigintIsh } from "../internalConstants";
+export interface TickConstructorArgs {
+    id: number;
+    liquidityGross: BigintIsh;
+    liquidityNet: BigintIsh;
+    feeGrowthOutsideAX64: BigintIsh;
+    feeGrowthOutsideBX64: BigintIsh;
+    tickCumulativeOutside: BigintIsh;
+    secondsPerLiquidityOutsideX64: BigintIsh;
+    secondsOutside: BigintIsh;
+}
+export declare class Tick {
+    readonly id: number;
+    readonly liquidityGross: JSBI;
+    readonly liquidityNet: JSBI;
+    readonly feeGrowthOutsideAX64: JSBI;
+    readonly feeGrowthOutsideBX64: JSBI;
+    readonly tickCumulativeOutside: JSBI;
+    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/tickDataProvider.d.ts

@@ -0,0 +1,27 @@
+import { Tick } from "./tick";
+/**
+ * Provides information about ticks
+ */
+export interface TickDataProvider {
+    /**
+     * Return information corresponding to a specific tick
+     * @param tick the tick to load
+     */
+    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): [number, boolean];
+}
+/**
+ * This tick data provider does not know how to fetch any tick data. It throws whenever it is required. Useful if you
+ * do not need to load tick data for your use case.
+ */
+export declare class NoTickDataProvider implements TickDataProvider {
+    private static ERROR_MESSAGE;
+    getTick(_tick: number): Tick;
+    nextInitializedTickWithinOneWord(_tick: number, _lte: boolean, _tickSpacing: number): [number, boolean];
+}

package/build/entities/tickListDataProvider.d.ts

@@ -0,0 +1,13 @@
+import { Tick, TickConstructorArgs } from "./tick";
+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 {
+    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/token.d.ts

@@ -0,0 +1,30 @@
+import { BaseCurrency } from "./baseCurrency";
+/**
+ * Represents an ERC20 token with a unique address and some metadata.
+ */
+export declare class Token extends BaseCurrency {
+    /**
+     * @param contract {@link BaseCurrency#contract}
+     * @param decimals {@link BaseCurrency#decimals}
+     * @param symbol {@link BaseCurrency#symbol}
+     */
+    constructor(contract: string, decimals: number, symbol: string);
+    get name(): string;
+    /**
+     * Returns true if the two tokens are equivalent, i.e. have the same contract and symbol.
+     * @param other other token to compare
+     */
+    equals(other: Token): boolean;
+    /**
+     * Returns true if the address of this token sorts before the address of the other token
+     * @param other other token to compare
+     * @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/trade.d.ts

@@ -0,0 +1,198 @@
+import { Currency } from './currency';
+import { Percent, Price, CurrencyAmount } from './fractions';
+import { TradeType } from '../internalConstants';
+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 token, either Ether or an ERC-20
+ * @template TOutput The output token, 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 token, either Ether or an ERC-20
+ * @template TOutput The output token, 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: {
+        percent: number;
+        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 token, either Ether or an ERC-20
+     * @template TOutput The output token, 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>): 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
+     * @template TOutput The output token, 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>): 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.
+     * @template TOutput The output token, 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, percent?: number): Trade<TInput, TOutput, TTradeType>;
+    /**
+     * Constructs a trade from routes by simulating swaps
+     *
+     * @template TInput The input token, either Ether or an ERC-20.
+     * @template TOutput The output token, 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>;
+        percent: number;
+    }[], 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
+     * @template TInput The input token, either Ether or an ERC-20
+     * @template TOutput The output token, 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: {
+        percent: number;
+        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 token, either Ether or an ERC-20
+     * @template TOutput The output token, 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: {
+            percent: number;
+            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>;
+    static bestTradeExactIn<TInput extends Currency, TOutput extends Currency>(routes: Route<TInput, TOutput>[], currencyAmountIn: CurrencyAmount<TInput>, maxNumResults?: number): Trade<TInput, TOutput, TradeType.EXACT_INPUT>[];
+    static bestTradeExactOut<TInput extends Currency, TOutput extends Currency>(routes: Route<TInput, TOutput>[], currencyAmountOut: CurrencyAmount<TOutput>, maxNumResults?: number): Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[];
+    static bestTradeWithSplit<TInput extends Currency, TOutput extends Currency>(_routes: Route<TInput, TOutput>[], amount: CurrencyAmount<Currency>, percents: number[], tradeType: TradeType, swapConfig?: {
+        minSplits: number;
+        maxSplits: number;
+    }): Trade<Currency, Currency, TradeType> | null;
+}

package/build/errors.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Indicates that the pair has insufficient reserves for a desired output amount. I.e. the amount of output cannot be
+ * obtained by sending any amount of input.
+ */
+export declare class InsufficientReservesError extends Error {
+    readonly isInsufficientReservesError = true;
+    constructor();
+}
+/**
+ * Indicates that the input amount is too small to produce any amount of output. I.e. the amount of input sent is less
+ * than the price of a single unit of output after fees.
+ */
+export declare class InsufficientInputAmountError extends Error {
+    readonly isInsufficientInputAmountError = true;
+    constructor();
+}

package/build/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./utils";
+export * from "./entities";
+export * from "./internalConstants";

package/build/internalConstants.d.ts

@@ -0,0 +1,37 @@
+import JSBI from "jsbi";
+export declare const NEGATIVE_ONE: JSBI;
+export declare const ZERO: JSBI;
+export declare const ONE: JSBI;
+export declare const Q32: JSBI;
+export declare const Q64: JSBI;
+export declare const Q96: JSBI;
+export declare const Q128: JSBI;
+export declare const Q192: JSBI;
+export declare const Q256: JSBI;
+export declare const MaxUint256: JSBI;
+export declare const MaxUint128: JSBI;
+export declare const MaxUint64: JSBI;
+export type BigintIsh = JSBI | string | number;
+export declare enum TradeType {
+    EXACT_INPUT = 0,
+    EXACT_OUTPUT = 1
+}
+/**
+ * The default factory enabled fee amounts, denominated in hundredths of bips.
+ */
+export declare enum FeeAmount {
+    LOW = 500,
+    MEDIUM = 3000,
+    HIGH = 10000
+}
+export declare enum Rounding {
+    ROUND_DOWN = 0,
+    ROUND_HALF_UP = 1,
+    ROUND_UP = 2
+}
+/**
+ * The default factory tick spacings by fee amount.
+ */
+export declare const TICK_SPACINGS: {
+    [amount in FeeAmount]: number;
+};

package/build/utils/common.d.ts

@@ -0,0 +1,14 @@
+export declare function parseTrade(trade: any): {
+    route: never[];
+    memo: string;
+    swaps: any;
+    input: any;
+    output: any;
+    minReceived: any;
+    maxSent: any;
+    priceImpact: any;
+    executionPrice: {
+        numerator: any;
+        denominator: any;
+    };
+};

package/build/utils/computeAllRoutes.d.ts

@@ -0,0 +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/encodeSqrtRatioX64.d.ts

@@ -0,0 +1,9 @@
+import JSBI from "jsbi";
+import { BigintIsh } from "../internalConstants";
+/**
+ * Returns the sqrt ratio as a Q64.64 corresponding to a given ratio of amountB and amountA
+ * @param amountB The numerator amount i.e., the amount of tokenB
+ * @param amountA The denominator amount i.e., the amount of tokenA
+ * @returns The sqrt ratio
+ */
+export declare function encodeSqrtRatioX64(amountB: BigintIsh, amountA: BigintIsh): JSBI;

package/build/utils/fullMath.d.ts

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

package/build/utils/getBestSwapRoute.d.ts

@@ -0,0 +1,9 @@
+import { Currency } from '../entities/currency';
+import { Trade } from '../entities/trade';
+import { TradeType } from '../internalConstants';
+export declare function getBestSwapRoute(routeType: TradeType, percentToQuotes: {
+    [percent: number]: Trade<Currency, Currency, TradeType>[];
+}, percents: number[], swapRouteConfig?: {
+    minSplits: number;
+    maxSplits: number;
+}): Trade<Currency, Currency, TradeType>[] | null;

package/build/utils/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./tickMath";
+export * from "./mostSignificantBit";
+export * from "./tickLibrary";
+export * from "./positionLibrary";
+export * from "./sqrt";
+export * from "./encodeSqrtRatioX64";
+export * from "./maxLiquidityForAmounts";
+export * from "./nearestUsableTick";
+export * from "./fullMath";
+export * from "./isSorted";
+export * from "./tickList";
+export * from "./priceTickConversions";
+export * from "./sqrtPriceMath";
+export * from "./sortedInsert";
+export * from "./computeAllRoutes";
+export * from "./common";
+export * from "./getBestSwapRoute";

package/build/utils/isSorted.d.ts

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

package/build/utils/liquidityMath.d.ts

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

package/build/utils/maxLiquidityForAmounts.d.ts

@@ -0,0 +1,14 @@
+import JSBI from "jsbi";
+import { BigintIsh } from "../internalConstants";
+/**
+ * Computes the maximum amount of liquidity received for a given amount of token0, token1,
+ * and the prices at the tick boundaries.
+ * @param sqrtRatioCurrentX64 the current price
+ * @param sqrtRatioLX64 price at lower boundary
+ * @param sqrtRatioUX64 price at upper boundary
+ * @param amountA token0 amount
+ * @param amountB token1 amount
+ * @param useFullPrecision if false, liquidity will be maximized according to what the router can calculate,
+ * not what core can theoretically support
+ */
+export declare function maxLiquidityForAmounts(sqrtRatioCurrentX64: JSBI, sqrtRatioLX64: JSBI, sqrtRatioUX64: JSBI, amountA: BigintIsh, amountB: BigintIsh, useFullPrecision: boolean): JSBI;

package/build/utils/mostSignificantBit.d.ts

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

package/build/utils/nearestUsableTick.d.ts

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

package/build/utils/positionLibrary.d.ts

@@ -0,0 +1,8 @@
+import JSBI from "jsbi";
+export declare abstract class PositionLibrary {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static getTokensOwed(feeGrowthInsideALastX64: JSBI, feeGrowthInsideBLastX64: JSBI, liquidity: JSBI, feeGrowthInsideAX64: JSBI, feeGrowthInsideBX64: JSBI): JSBI[];
+}

package/build/utils/priceTickConversions.d.ts

@@ -0,0 +1,16 @@
+import { Token } from "../entities/token";
+import { Price } from "../entities/fractions/price";
+/**
+ * Returns a price object corresponding to the input tick and the base/quote token
+ * Inputs must be tokens because the address order is used to interpret the price represented by the tick
+ * @param baseToken the base token of the price
+ * @param quoteToken the quote token of the price
+ * @param tick the tick for which to return the price
+ */
+export declare function tickToPrice(baseToken: Token, quoteToken: Token, tick: number): Price<Token, Token>;
+/**
+ * Returns the first tick for which the given price is greater than or equal to the tick price
+ * @param price for which to return the closest tick that represents a price less than or equal to the input price,
+ * i.e. the price of the returned tick is less than or equal to the input price
+ */
+export declare function priceToClosestTick(price: Price<Token, Token>): number;

package/build/utils/sortedInsert.d.ts

@@ -0,0 +1 @@
+export declare function sortedInsert<T>(items: T[], add: T, maxSize: number, comparator: (a: T, b: T) => number): T | null;

package/build/utils/sqrt.d.ts

@@ -0,0 +1,7 @@
+import JSBI from "jsbi";
+export declare const MAX_SAFE_INTEGER: JSBI;
+/**
+ * Computes floor(sqrt(value))
+ * @param value the value for which to compute the square root, rounded down
+ */
+export declare function sqrt(value: JSBI): JSBI;

package/build/utils/sqrtPriceMath.d.ts

@@ -0,0 +1,13 @@
+import JSBI from "jsbi";
+export declare abstract class SqrtPriceMath {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static getAmountADelta(sqrtRatioLX64: JSBI, sqrtRatioUX64: JSBI, liquidity: JSBI, roundUp: boolean): JSBI;
+    static getAmountBDelta(sqrtRatioLX64: JSBI, sqrtRatioUX64: JSBI, liquidity: JSBI, roundUp: boolean): JSBI;
+    static getNextSqrtPriceFromInput(sqrtPX64: JSBI, liquidity: JSBI, amountIn: JSBI, zeroForOne: boolean): JSBI;
+    static getNextSqrtPriceFromOutput(sqrtPX64: JSBI, liquidity: JSBI, amountOut: JSBI, zeroForOne: boolean): JSBI;
+    private static getNextSqrtPriceFromAmountARoundingUp;
+    private static getNextSqrtPriceFromAmountBRoundingDown;
+}

package/build/utils/swapMath.d.ts

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

package/build/utils/tickLibrary.d.ts

@@ -0,0 +1,15 @@
+import JSBI from "jsbi";
+interface FeeGrowthOutside {
+    feeGrowthOutsideAX64: JSBI;
+    feeGrowthOutsideBX64: JSBI;
+}
+export declare function subIn256(x: JSBI, y: JSBI): JSBI;
+export declare function subIn128(x: JSBI, y: JSBI): JSBI;
+export declare abstract class TickLibrary {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static getFeeGrowthInside(feeGrowthOutsideLower: FeeGrowthOutside, feeGrowthOutsideUpper: FeeGrowthOutside, tickLower: number, tickUpper: number, tickCurrent: number, feeGrowthGlobalAX64: JSBI, feeGrowthGlobalBX64: JSBI): JSBI[];
+}
+export {};

package/build/utils/tickList.d.ts

@@ -0,0 +1,23 @@
+import { Tick } from "../entities/tick";
+/**x
+ * Utility methods for interacting with sorted lists of ticks
+ */
+export declare abstract class TickList {
+    /**
+     * Cannot be constructed
+     */
+    private constructor();
+    static validateList(ticks: Tick[], tickSpacing: number): void;
+    static isBelowSmallest(ticks: readonly Tick[], tick: number): boolean;
+    static isAtOrAboveLargest(ticks: readonly Tick[], tick: number): boolean;
+    static getTick(ticks: readonly Tick[], id: number): Tick;
+    /**
+     * Finds the largest tick in the list of ticks that is less than or equal to tick
+     * @param ticks list of ticks
+     * @param tick tick to find the largest tick that is less than or equal to tick
+     * @private
+     */
+    private static binarySearch;
+    static nextInitializedTick(ticks: readonly Tick[], tick: number, lte: boolean): Tick;
+    static nextInitializedTickWithinOneWord(ticks: readonly Tick[], tick: number, lte: boolean, tickSpacing: number): [number, boolean];
+}

package/build/utils/tickMath.d.ts

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

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@alcorexchange/alcor-swap-sdk",
-  "version": "1.0.392",
+  "version": "1.0.393",
   "description": "",
   "main": "build/index.js",
   "scripts": {
     "start:dev": "npx nodemon",
-    "build": "rimraf ./build && babel src --out-dir build --extensions \".ts\"",
+    "build": "rimraf ./build && babel src --out-dir build --extensions \".ts\" && tsc --emitDeclarationOnly",
     "start": "npm run build && node build/index.js",
     "lint": "eslint . --ext .ts",
     "prettier": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",