@alcorexchange/alcor-swap-sdk 1.0.0 → 1.0.5

package/README.md

@@ -0,0 +1,70 @@
+# alcor-v2-sdk
+
+## Installation
+​​
+**npm** 
+```
+npm i @alcorexchange/alcor-swap-sdk
+``` 
+**yarn** 
+```
+yarn add @alcorexchange/alcor-swap-sdk
+``` 
+## Usage
+### Import:
+
+ES6
+
+```js
+import SwapSDK from '@alcorexchange/alcor-swap-sdk'
+```  
+
+CommonJS
+
+```js
+const SwapSDK = require('@alcorexchange/alcor-swap-sdk')
+```
+
+### Initialization:
+
+```ts 
+import fetch from 'node-fetch'
+
+import { Token, Pool  } from '@alcorexchange/alcor-swap-sdk'
+
+import { asset } from 'eos-common'
+import { JsonRpc } from 'eosjs'
+
+export function parseToken(token) {
+  return new Token(
+    token.contract,
+    asset(token.quantity).symbol.precision(),
+    asset(token.quantity).symbol.code().to_string(),
+    (asset(token.quantity).symbol.code().to_string() + '-' + token.contract).toLowerCase()
+  )
+}
+
+const rpc = new JsonRpc('https://waxnode02.alcor.exchange', { fetch });
+
+async function main() {
+  const { rows } = await rpc.get_table_rows({
+    scope: 'swap.alcor',
+    table: 'pools',
+    code: 'swap.alcor',
+  })
+
+  const { tokenA, tokenB, currSlot: { sqrtPriceX64, tick } } = rows[0]
+
+  const pool = new Pool({
+    ...rows[0],
+    tokenA: parseToken(tokenA),
+    tokenB: parseToken(tokenB),
+    sqrtPriceX64,
+    tickCurrent: tick
+  })
+  
+  // Do you thing with pool here
+}
+```
+## Examples
+The examples can be found in examples/ directory.

package/build/entities/baseCurrency.d.ts

@@ -0,0 +1,35 @@
+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;
+    /**
+     * The id of the currency(<symbol-contract>), i.e. eos-eosio.token
+     */
+    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, id?: 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,31 @@
+import JSBI from "jsbi";
+import { Currency } from "../currency";
+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;
+}

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,92 @@
+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;
+    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 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;
+    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, 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): Promise<[CurrencyAmount<Token>, Pool]>;
+    /**
+     * Given a desired output amount of a token, return the computed input amount and a pool with state updated after the trade
+     * @param outputAmount the output amount for which to quote the input amount
+     * @param sqrtPriceLimitX64 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+     * @returns The input amount and the pool with updated state
+     */
+    getInputAmount(outputAmount: CurrencyAmount<Token>, sqrtPriceLimitX64?: JSBI): Promise<[CurrencyAmount<Token>, Pool]>;
+    /**
+     * 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;
+}

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/position.js

@@ -33,7 +33,7 @@ class 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 = 0, feeGrowthInsideBLastX64 = 0, }) {
+    constructor({ id, owner, pool, liquidity, tickLower, tickUpper, feeGrowthInsideALastX64 = 0, feeGrowthInsideBLastX64 = 0, feesA = 0, feesB = 0, }) {
         // cached resuts for the getters
         this._tokenAAmount = null;
         this._tokenBAmount = null;
@@ -49,6 +49,8 @@ class Position {
         this.liquidity = jsbi_1.default.BigInt(liquidity);
         this.feeGrowthInsideALastX64 = jsbi_1.default.BigInt(feeGrowthInsideALastX64);
         this.feeGrowthInsideBLastX64 = jsbi_1.default.BigInt(feeGrowthInsideBLastX64);
+        this.feesA = jsbi_1.default.BigInt(feesA);
+        this.feesB = jsbi_1.default.BigInt(feesB);
     }
     get inRange() {
         return (this.tickLower < this.pool.tickCurrent &&
@@ -156,7 +158,7 @@ class Position {
             ticks: this.pool.tickDataProvider
         });
         // because the router is imprecise, we need to calculate the position that will be created (assuming no slippage)
-        const positionThatWillBeCreated = Position.fromAmounts(Object.assign(Object.assign({ id: this.id, owner: this.owner, pool: this.pool, tickLower: this.tickLower, tickUpper: this.tickUpper }, this.mintAmounts), { useFullPrecision: false, feeGrowthInsideALastX64: this.feeGrowthInsideALastX64, feeGrowthInsideBLastX64: this.feeGrowthInsideBLastX64 }));
+        const positionThatWillBeCreated = Position.fromAmounts(Object.assign(Object.assign({ id: this.id, owner: this.owner, pool: this.pool, tickLower: this.tickLower, tickUpper: this.tickUpper }, this.mintAmounts), { useFullPrecision: false, feeGrowthInsideALastX64: this.feeGrowthInsideALastX64, feeGrowthInsideBLastX64: this.feeGrowthInsideBLastX64, feesA: this.feesA, feesB: this.feesB }));
         // we want the smaller amounts...
         // ...which occurs at the upper price for amountA...
         const { amountA } = new Position({
@@ -168,6 +170,8 @@ class Position {
             tickUpper: this.tickUpper,
             feeGrowthInsideALastX64: this.feeGrowthInsideALastX64,
             feeGrowthInsideBLastX64: this.feeGrowthInsideBLastX64,
+            feesA: this.feesA,
+            feesB: this.feesB,
         }).mintAmounts;
         // ...and the lower for amountB
         const { amountB } = new Position({
@@ -179,6 +183,8 @@ class Position {
             tickUpper: this.tickUpper,
             feeGrowthInsideALastX64: this.feeGrowthInsideALastX64,
             feeGrowthInsideBLastX64: this.feeGrowthInsideBLastX64,
+            feesA: this.feesA,
+            feesB: this.feesB,
         }).mintAmounts;
         return { amountA, amountB };
     }
@@ -227,6 +233,8 @@ class Position {
             tickUpper: this.tickUpper,
             feeGrowthInsideALastX64: this.feeGrowthInsideALastX64,
             feeGrowthInsideBLastX64: this.feeGrowthInsideBLastX64,
+            feesA: this.feesA,
+            feesB: this.feesB,
         }).amountA;
         // ...and the lower for amountB
         const amountB = new Position({
@@ -238,6 +246,8 @@ class Position {
             tickUpper: this.tickUpper,
             feeGrowthInsideALastX64: this.feeGrowthInsideALastX64,
             feeGrowthInsideBLastX64: this.feeGrowthInsideBLastX64,
+            feesA: this.feesA,
+            feesB: this.feesB,
         }).amountB;
         return { amountA: amountA, amountB: amountB };
     }
@@ -280,7 +290,7 @@ class Position {
      * 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, }) {
+    static fromAmounts({ id, owner, pool, tickLower, tickUpper, amountA, amountB, useFullPrecision, feeGrowthInsideALastX64, feeGrowthInsideBLastX64, feesA, feesB }) {
         const sqrtRatioLX64 = tickMath_1.TickMath.getSqrtRatioAtTick(tickLower);
         const sqrtRatioUX64 = tickMath_1.TickMath.getSqrtRatioAtTick(tickUpper);
         return new Position({
@@ -291,7 +301,9 @@ class Position {
             tickUpper,
             liquidity: (0, maxLiquidityForAmounts_1.maxLiquidityForAmounts)(pool.sqrtPriceX64, sqrtRatioLX64, sqrtRatioUX64, amountA, amountB, useFullPrecision),
             feeGrowthInsideALastX64,
-            feeGrowthInsideBLastX64
+            feeGrowthInsideBLastX64,
+            feesA,
+            feesB
         });
     }
     /**
@@ -304,7 +316,7 @@ class Position {
      * not what core can theoretically support
      * @returns The position
      */
-    static fromAmountA({ id, owner, pool, tickLower, tickUpper, amountA, useFullPrecision, feeGrowthInsideALastX64, feeGrowthInsideBLastX64 }) {
+    static fromAmountA({ id, owner, pool, tickLower, tickUpper, amountA, useFullPrecision, feeGrowthInsideALastX64, feeGrowthInsideBLastX64, feesA, feesB }) {
         return Position.fromAmounts({
             id,
             owner,
@@ -315,7 +327,9 @@ class Position {
             amountB: internalConstants_1.MaxUint64,
             useFullPrecision,
             feeGrowthInsideALastX64,
-            feeGrowthInsideBLastX64
+            feeGrowthInsideBLastX64,
+            feesA,
+            feesB
         });
     }
     /**
@@ -326,7 +340,7 @@ class Position {
      * @param amountB The desired amount of tokenB
      * @returns The position
      */
-    static fromAmountB({ id, owner, pool, tickLower, tickUpper, amountB, feeGrowthInsideALastX64, feeGrowthInsideBLastX64, }) {
+    static fromAmountB({ id, owner, pool, tickLower, tickUpper, amountB, feeGrowthInsideALastX64, feeGrowthInsideBLastX64, feesA, feesB }) {
         // this function always uses full precision,
         return Position.fromAmounts({
             id,
@@ -339,6 +353,8 @@ class Position {
             useFullPrecision: true,
             feeGrowthInsideALastX64,
             feeGrowthInsideBLastX64,
+            feesA,
+            feesB
         });
     }
     /**
@@ -355,8 +371,8 @@ class Position {
             const tokensOwedA = jsbi_1.default.divide(jsbi_1.default.multiply((0, utils_1.subIn128)(feeGrowthInsideAX64, feeGrowthInsideALastX64), liquidity), internalConstants_1.Q64);
             const tokensOwedB = jsbi_1.default.divide(jsbi_1.default.multiply((0, utils_1.subIn128)(feeGrowthInsideBX64, feeGrowthInsideBLastX64), liquidity), internalConstants_1.Q64);
             return {
-                feesA: fractions_1.CurrencyAmount.fromRawAmount(this.pool.tokenA, tokensOwedA),
-                feesB: fractions_1.CurrencyAmount.fromRawAmount(this.pool.tokenB, tokensOwedB),
+                feesA: fractions_1.CurrencyAmount.fromRawAmount(this.pool.tokenA, jsbi_1.default.add(tokensOwedA, this.feesA)),
+                feesB: fractions_1.CurrencyAmount.fromRawAmount(this.pool.tokenB, jsbi_1.default.add(tokensOwedB, this.feesB))
             };
         });
     }

package/build/entities/route.d.ts

@@ -0,0 +1,27 @@
+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>;
+}