@alcorexchange/alcor-swap-sdk 1.0.1 → 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/position.d.ts

@@ -12,6 +12,8 @@ interface PositionConstructorArgs {
     liquidity: BigintIsh;
     feeGrowthInsideALastX64: BigintIsh;
     feeGrowthInsideBLastX64: BigintIsh;
+    feesA: BigintIsh;
+    feesB: BigintIsh;
 }
 interface Fees {
     feesA: CurrencyAmount<Token>;
@@ -24,6 +26,8 @@ export declare class Position {
     readonly tickLower: number;
     readonly tickUpper: number;
     readonly liquidity: JSBI;
+    readonly feesA: JSBI;
+    readonly feesB: JSBI;
     readonly feeGrowthInsideALastX64: JSBI;
     readonly feeGrowthInsideBLastX64: JSBI;
     private _tokenAAmount;
@@ -36,7 +40,7 @@ export declare 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, feeGrowthInsideBLastX64, }: PositionConstructorArgs);
+    constructor({ id, owner, pool, liquidity, tickLower, tickUpper, feeGrowthInsideALastX64, feeGrowthInsideBLastX64, feesA, feesB, }: PositionConstructorArgs);
     get inRange(): boolean;
     /**
      * Returns the price of tokenA at the lower tick
@@ -100,7 +104,7 @@ export declare 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 }: {
         id: number;
         owner: string;
         pool: Pool;
@@ -111,6 +115,8 @@ export declare class Position {
         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
@@ -122,7 +128,7 @@ export declare 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 }: {
         id: number;
         owner: string;
         pool: Pool;
@@ -132,6 +138,8 @@ export declare class Position {
         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
@@ -141,7 +149,7 @@ export declare 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 }: {
         id: number;
         owner: string;
         pool: Pool;
@@ -150,6 +158,8 @@ export declare class Position {
         amountB: BigintIsh;
         feeGrowthInsideALastX64: BigintIsh;
         feeGrowthInsideBLastX64: BigintIsh;
+        feesA: BigintIsh;
+        feesB: BigintIsh;
     }): Position;
     /**
      * Computes a position fees

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/examples/getPoolPrices.ts

@@ -0,0 +1,45 @@
+import fetch from 'node-fetch'
+
+// Alcor v2 sdk: https://github.com/alcorexchange/alcor-v2-sdk
+import { Token, Pool  } from '../src'
+
+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',
+  })
+
+  // First pool for example
+  const { tokenA, tokenB, currSlot: { sqrtPriceX64, tick } } = rows[0]
+
+  const pool = new Pool({
+    ...rows[0],
+    tokenA: parseToken(tokenA),
+    tokenB: parseToken(tokenB),
+    sqrtPriceX64,
+    tickCurrent: tick
+  })
+
+  console.log('priceA', pool.tokenAPrice.toFixed())
+  console.log('priceB', pool.tokenBPrice.toFixed())
+}
+
+main()
+
+//priceA 0.2820
+//priceB 3.5466

package/examples/getPositionAmounts.ts

@@ -0,0 +1,105 @@
+import fetch from 'node-fetch'
+
+// Alcor v2 sdk: https://github.com/alcorexchange/alcor-v2-sdk
+import { Token, Position, Pool } from '../src'
+import { fetchAllRows } from './utils/rpc'
+
+import { asset } from 'eos-common'
+import { JsonRpc } from 'eosjs'
+import { Serialize } 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://wax-api.alcor.exchange', { fetch });
+
+const types: any = Serialize.createInitialTypes()
+
+export const nameToUint64 = (name) => {
+  const ser = new Serialize.SerialBuffer()
+  ser.pushName(name)
+  return types.get('uint64').deserialize(ser)
+}
+
+async function main() {
+  const account = '3mob2.wam'
+
+  const pools = await fetchAllRows(rpc, {
+    scope: 'swap.alcor',
+    table: 'pools',
+    code: 'swap.alcor',
+  })
+
+  // First pool for example (TLM / WAX)
+  // const poolRow= pools[0]
+
+  // Or Specific pool
+  const poolRow= pools.find(p => p.id == 205)
+
+  //const { id, tokenA, tokenB, currSlot: { sqrtPriceX64, tick } } = poolRow
+
+  // Or Specific pool
+  const { id, tokenA, tokenB, currSlot: { sqrtPriceX64, tick } } = poolRow
+
+  const ticks = await fetchAllRows(rpc, {
+    scope: id,
+    table: 'ticks',
+    code: 'swap.alcor',
+  })
+
+  const pool = new Pool({
+    ...poolRow,
+    tokenA: parseToken(tokenA),
+    tokenB: parseToken(tokenB),
+    sqrtPriceX64,
+    tickCurrent: tick,
+    ticks: ticks.sort((a, b) => a.id - b.id)
+  })
+
+  // const { rows: positions } = await rpc.get_table_rows({
+  //   scope: pool.id,
+  //   table: 'positions',
+  //   code: 'swap.alcor',
+  //   key_type: 'i64',
+  //   index_position: 3,
+  //   lower_bound: nameToUint64(account),
+  //   upper_bound: nameToUint64(account)
+  // })
+
+  // or Specific position by id
+  const { rows: positions } = await rpc.get_table_rows({
+    scope: pool.id,
+    table: 'positions',
+    code: 'swap.alcor',
+    lower_bound: 14235,
+    upper_bound: 14235
+  })
+
+  //console.log({ pool: pool.id, positions })
+
+  const position = new Position({
+    ...positions[0], // Only first of account position
+    pool
+  })
+
+  // console.log('amountA:', position.amountA.toAsset())
+  // console.log('amountB:', position.amountB.toAsset())
+
+  // fees:
+  const { feesA, feesB } = await position.getFees()
+
+  console.log('feesA', feesA.toAsset())
+  console.log('feesB', feesB.toAsset())
+}
+
+main()
+
+// amountA: 103.4332 TLM
+// amountB: 29.16056021 WAX

package/examples/getTrateRoute.ts

@@ -0,0 +1,95 @@
+import fetch from 'node-fetch'
+import { fetchAllRows } from './utils/rpc'
+
+// Alcor v2 sdk: https://github.com/alcorexchange/alcor-v2-sdk
+import { Token, Pool, Trade, CurrencyAmount, Percent } from '../src'
+
+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://eos-api.alcor.exchange', { fetch });
+
+async function main() {
+  const rows = await fetchAllRows(rpc, {
+    scope: 'swap.alcor',
+    table: 'pools',
+    code: 'swap.alcor',
+  })
+
+  const pools: Pool[] = []
+
+  // We have to get all pools with fetched ticks for them
+  for (const p of rows) {
+    const { id, tokenA, tokenB, currSlot: { sqrtPriceX64, tick } } = p
+
+    const ticks = await fetchAllRows(rpc, {
+      scope: id,
+      table: 'ticks',
+      code: 'swap.alcor',
+    })
+
+    pools.push(new Pool({
+      ...p,
+      tokenA: parseToken(tokenA),
+      tokenB: parseToken(tokenB),
+      sqrtPriceX64,
+      tickCurrent: tick,
+      ticks: ticks.sort((a, b) => a.id - b.id)
+    }))
+  }
+
+  // 1.0000 EOS
+  const amountIn = CurrencyAmount.fromRawAmount(new Token('eosio.token', 4, 'EOS'), 1_0000)
+  const tokenOut = new Token('tethertether', 4, 'USDT')
+  const slippage = new Percent(3, 100) // 0.3%
+  const receiver = 'myaccount'
+
+  // First trade sorted by biggest output
+  const [trade] = await Trade.bestTradeExactIn(pools, amountIn, tokenOut, { maxHops: 3 })
+
+  const route = trade.route.pools.map(p => p.id)
+
+  const maxSent = trade.inputAmount
+  const minReceived = trade.minimumAmountOut(slippage)
+
+  // Memo Format <Service Name>#<Pool ID's>#<Recipient>#<Output Token>#<Deadline>
+  const memo = `swapexactin#${route.join(',')}#${receiver}#${minReceived.toExtendedAsset()}#0`
+
+  const result = {
+    input: trade.inputAmount.toFixed(),
+    output: trade.outputAmount.toFixed(),
+    minReceived: minReceived.toFixed(),
+    maxSent: maxSent.toFixed(),
+    priceImpact: trade.priceImpact.toSignificant(2),
+    memo,
+    route,
+    executionPrice: {
+      numerator: trade.executionPrice.numerator.toString(),
+      denominator: trade.executionPrice.denominator.toString()
+    }
+  }
+
+  console.log(result)
+}
+
+main()
+
+// {
+//   input: '1.0000',
+//   output: '1.0314 USDT',
+//   minReceived: '1.0013',
+//   maxSent: '1.0000',
+//   priceImpact: '0.44',
+//   memo: 'swapexactin#2#myaccount#1.0013 USDT@tethertether#0',
+//   route: [ 2 ],
+//   executionPrice: { numerator: '10314', denominator: '10000' }
+// }

package/examples/utils/rpc.ts

@@ -0,0 +1,39 @@
+const MAX_PAGINATION_FETCHES = 99
+
+export const fetchAllRows =
+  async (rpc, options, indexName = 'id'): Promise<any> => {
+    const mergedOptions = {
+      json: true,
+      lower_bound: 0,
+      upper_bound: undefined,
+      limit: 9999,
+      ...options
+    }
+
+    let rows = []
+    let lowerBound = mergedOptions.lower_bound
+
+    for (let i = 0; i < MAX_PAGINATION_FETCHES; i += 1) {
+      const result = await rpc.get_table_rows({
+        ...mergedOptions,
+        lower_bound: lowerBound
+      })
+      rows = rows.concat(result.rows)
+
+      if (!result.more || result.rows.length === 0) break
+
+      // EOS 2.0 api
+      // TODO Add 'more' key
+      if (typeof result.next_key !== 'undefined') {
+        lowerBound = result.next_key
+      } else {
+        lowerBound =
+          Number.parseInt(
+            `${result.rows[result.rows.length - 1][indexName]}`,
+            10
+          ) + 1
+      }
+    }
+
+    return rows
+  }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alcorexchange/alcor-swap-sdk",
-  "version": "1.0.1",
+  "version": "1.0.5",
   "description": "",
   "main": "build/index.js",
   "scripts": {
@@ -15,7 +15,13 @@
     "type": "git",
     "url": "git+https://github.com/alcorexchange/alcor-v2-sdk"
   },
-  "keywords": ["alcor", "antelope", "eosio", "amm", "dex"],
+  "keywords": [
+    "alcor",
+    "antelope",
+    "eosio",
+    "amm",
+    "dex"
+  ],
   "author": "alcorexchange",
   "license": "ISC",
   "bugs": {

package/src/entities/position.ts

@@ -20,7 +20,9 @@ interface PositionConstructorArgs {
   tickUpper: number;
   liquidity: BigintIsh;
   feeGrowthInsideALastX64: BigintIsh,
-  feeGrowthInsideBLastX64: BigintIsh
+  feeGrowthInsideBLastX64: BigintIsh,
+  feesA: BigintIsh,
+  feesB: BigintIsh,
 }
 
 interface Fees {
@@ -35,6 +37,8 @@ export class Position {
   public readonly tickLower: number;
   public readonly tickUpper: number;
   public readonly liquidity: JSBI;
+  public readonly feesA: JSBI;
+  public readonly feesB: JSBI;
   public readonly feeGrowthInsideALastX64: JSBI;
   public readonly feeGrowthInsideBLastX64: JSBI;
 
@@ -60,6 +64,8 @@ export class Position {
     tickUpper,
     feeGrowthInsideALastX64 = 0,
     feeGrowthInsideBLastX64 = 0,
+    feesA = 0,
+    feesB = 0,
   }: PositionConstructorArgs) {
     invariant(tickLower < tickUpper, "TICK_ORDER");
     invariant(
@@ -79,6 +85,8 @@ export class Position {
     this.liquidity = JSBI.BigInt(liquidity);
     this.feeGrowthInsideALastX64 = JSBI.BigInt(feeGrowthInsideALastX64);
     this.feeGrowthInsideBLastX64 = JSBI.BigInt(feeGrowthInsideBLastX64);
+    this.feesA = JSBI.BigInt(feesA)
+    this.feesB = JSBI.BigInt(feesB)
   }
 
   public get inRange(): boolean {
@@ -260,6 +268,8 @@ export class Position {
       useFullPrecision: false,
       feeGrowthInsideALastX64: this.feeGrowthInsideALastX64,
       feeGrowthInsideBLastX64: this.feeGrowthInsideBLastX64,
+      feesA: this.feesA,
+      feesB: this.feesB,
     });
 
     // we want the smaller amounts...
@@ -273,6 +283,8 @@ export 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({
@@ -284,6 +296,8 @@ export class Position {
       tickUpper: this.tickUpper,
       feeGrowthInsideALastX64: this.feeGrowthInsideALastX64,
       feeGrowthInsideBLastX64: this.feeGrowthInsideBLastX64,
+      feesA: this.feesA,
+      feesB: this.feesB,
     }).mintAmounts;
 
     return { amountA, amountB };
@@ -339,6 +353,8 @@ export 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({
@@ -350,6 +366,8 @@ export class Position {
       tickUpper: this.tickUpper,
       feeGrowthInsideALastX64: this.feeGrowthInsideALastX64,
       feeGrowthInsideBLastX64: this.feeGrowthInsideBLastX64,
+      feesA: this.feesA,
+      feesB: this.feesB,
     }).amountB;
 
     return { amountA: amountA, amountB: amountB };
@@ -424,6 +442,8 @@ export class Position {
     useFullPrecision,
     feeGrowthInsideALastX64,
     feeGrowthInsideBLastX64,
+    feesA,
+    feesB
   }: {
     id: number,
     owner: string,
@@ -434,7 +454,9 @@ export class Position {
     amountB: BigintIsh;
     useFullPrecision: boolean;
     feeGrowthInsideALastX64: | BigintIsh,
-    feeGrowthInsideBLastX64: | BigintIsh
+    feeGrowthInsideBLastX64: | BigintIsh,
+    feesA: BigintIsh,
+    feesB: BigintIsh
   }) {
     const sqrtRatioLX64 = TickMath.getSqrtRatioAtTick(tickLower);
     const sqrtRatioUX64 = TickMath.getSqrtRatioAtTick(tickUpper);
@@ -453,7 +475,9 @@ export class Position {
         useFullPrecision
       ),
       feeGrowthInsideALastX64,
-      feeGrowthInsideBLastX64
+      feeGrowthInsideBLastX64,
+      feesA,
+      feesB
     });
   }
 
@@ -476,7 +500,9 @@ export class Position {
     amountA,
     useFullPrecision,
     feeGrowthInsideALastX64,
-    feeGrowthInsideBLastX64
+    feeGrowthInsideBLastX64,
+    feesA,
+    feesB
   }: {
     id: number,
     owner: string,
@@ -487,6 +513,8 @@ export class Position {
     useFullPrecision: boolean;
     feeGrowthInsideALastX64: | BigintIsh;
     feeGrowthInsideBLastX64: | BigintIsh;
+    feesA: | BigintIsh;
+    feesB: | BigintIsh;
   }) {
     return Position.fromAmounts({
       id,
@@ -498,7 +526,9 @@ export class Position {
       amountB: MaxUint64,
       useFullPrecision,
       feeGrowthInsideALastX64,
-      feeGrowthInsideBLastX64
+      feeGrowthInsideBLastX64,
+      feesA,
+      feesB
     });
   }
 
@@ -519,6 +549,8 @@ export class Position {
     amountB,
     feeGrowthInsideALastX64,
     feeGrowthInsideBLastX64,
+    feesA,
+    feesB
   }: {
     id: number,
     owner: string,
@@ -528,6 +560,8 @@ export class Position {
     amountB: BigintIsh;
     feeGrowthInsideALastX64: | BigintIsh;
     feeGrowthInsideBLastX64: | BigintIsh;
+    feesA: BigintIsh
+    feesB: BigintIsh
   }) {
     // this function always uses full precision,
     return Position.fromAmounts({
@@ -541,6 +575,8 @@ export class Position {
       useFullPrecision: true,
       feeGrowthInsideALastX64,
       feeGrowthInsideBLastX64,
+      feesA,
+      feesB
     });
   }
 
@@ -584,8 +620,8 @@ export class Position {
     );
 
     return {
-      feesA: CurrencyAmount.fromRawAmount(this.pool.tokenA, tokensOwedA),
-      feesB: CurrencyAmount.fromRawAmount(this.pool.tokenB, tokensOwedB),
+      feesA: CurrencyAmount.fromRawAmount(this.pool.tokenA, JSBI.add(tokensOwedA, this.feesA)),
+      feesB: CurrencyAmount.fromRawAmount(this.pool.tokenB, JSBI.add(tokensOwedB, this.feesB))
     }
   }
 }

package/test2.ts

@@ -1,73 +0,0 @@
-import fetch from 'node-fetch'
-
-// Alcor v2 sdk: https://github.com/alcorexchange/alcor-v2-sdk
-import { Token, Position, Pool } from './src'
-
-import { asset } from 'eos-common'
-import { JsonRpc } from 'eosjs'
-import { Serialize } 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 });
-
-const types: any = Serialize.createInitialTypes()
-
-export const nameToUint64 = (name) => {
-  const ser = new Serialize.SerialBuffer()
-  ser.pushName(name)
-  return types.get('uint64').deserialize(ser)
-}
-
-async function main() {
-  const account = '3mob2.wam'
-
-  const { rows: pools } = await rpc.get_table_rows({
-    scope: 'swap.alcor',
-    table: 'pools',
-    code: 'swap.alcor',
-  })
-
-  // First pool for example (TLM / WAX)
-  const { tokenA, tokenB, currSlot: { sqrtPriceX64, tick } } = pools[0]
-
-  const pool = new Pool({
-    ...pools[0],
-    tokenA: parseToken(tokenA),
-    tokenB: parseToken(tokenB),
-    sqrtPriceX64,
-    tickCurrent: tick
-  })
-
-  const { rows: positions } = await rpc.get_table_rows({
-    scope: pool.id,
-    table: 'positions',
-    code: 'swap.alcor',
-    key_type: 'i64',
-    index_position: 3,
-    lower_bound: nameToUint64(account),
-    upper_bound: nameToUint64(account)
-  })
-
-
-  const position = new Position({
-    ...positions[0], // Only first of account position
-    pool
-  })
-
-  console.log('amountA:', position.amountA.toAsset())
-  console.log('amountB:', position.amountB.toAsset())
-}
-
-main()
-
-// amountA: 103.4332 TLM
-// amountB: 29.16056021 WAX

package/test3.ts

@@ -1,73 +0,0 @@
-import fetch from 'node-fetch'
-
-// Alcor v2 sdk: https://github.com/alcorexchange/alcor-v2-sdk
-import { Token, Position, Pool } from './src'
-
-import { asset } from 'eos-common'
-import { JsonRpc } from 'eosjs'
-import { Serialize } 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 });
-
-const types: any = Serialize.createInitialTypes()
-
-export const nameToUint64 = (name) => {
-  const ser = new Serialize.SerialBuffer()
-  ser.pushName(name)
-  return types.get('uint64').deserialize(ser)
-}
-
-async function main() {
-  const account = '3mob2.wam'
-
-  const { rows: pools } = await rpc.get_table_rows({
-    scope: 'swap.alcor',
-    table: 'pools',
-    code: 'swap.alcor',
-  })
-
-  // First pool for example (TLM / WAX)
-  const { tokenA, tokenB, currSlot: { sqrtPriceX64, tick } } = pools[0]
-
-  const pool = new Pool({
-    ...pools[0],
-    tokenA: parseToken(tokenA),
-    tokenB: parseToken(tokenB),
-    sqrtPriceX64,
-    tickCurrent: tick
-  })
-
-  const { rows: positions } = await rpc.get_table_rows({
-    scope: pool.id,
-    table: 'positions',
-    code: 'swap.alcor',
-    key_type: 'i64',
-    index_position: 3,
-    lower_bound: nameToUint64(account),
-    upper_bound: nameToUint64(account)
-  })
-
-
-  const position = new Position({
-    ...positions[0], // Only first of account position
-    pool
-  })
-
-  console.log('amountA:', position.amountA.toAsset())
-  console.log('amountB:', position.amountB.toAsset())
-}
-
-main()
-
-// amountA: 103.4332 TLM
-// amountB: 29.16056021 WAX