@alcorexchange/alcor-swap-sdk 1.0.0

package/test/tickListDataProvider.test.ts

@@ -0,0 +1,64 @@
+import JSBI from "jsbi";
+import { TickListDataProvider } from "entities/tickListDataProvider";
+
+describe("TickListDataProvider", () => {
+  describe("constructor", () => {
+    it("can take an empty list of ticks", () => {
+      new TickListDataProvider([], 1);
+    });
+    it("throws for 0 tick spacing", () => {
+      expect(() => new TickListDataProvider([], 0)).toThrow(
+        "TICK_SPACING_NONZERO"
+      );
+    });
+    it("throws for uneven tick list", async () => {
+      await expect(
+        () =>
+          new TickListDataProvider(
+            [
+              { id: -1, liquidityNet: -1, liquidityGross: 1 },
+              { id: 1, liquidityNet: 2, liquidityGross: 1 },
+            ],
+            1
+          )
+      ).toThrow("ZERO_NET");
+    });
+  });
+
+  describe("#getTick", () => {
+    it("throws if tick not in list", async () => {
+      const provider = new TickListDataProvider(
+        [
+          { id: -1, liquidityNet: -1, liquidityGross: 1 },
+          { id: 1, liquidityNet: 1, liquidityGross: 1 },
+        ],
+        1
+      );
+      await expect(provider.getTick(0)).rejects.toThrow("NOT_CONTAINED");
+    });
+    it("gets the smallest tick from the list", async () => {
+      const provider = new TickListDataProvider(
+        [
+          { id: -1, liquidityNet: -1, liquidityGross: 1 },
+          { id: 1, liquidityNet: 1, liquidityGross: 1 },
+        ],
+        1
+      );
+      const { liquidityNet, liquidityGross } = await provider.getTick(-1);
+      expect(liquidityNet).toEqual(JSBI.BigInt(-1));
+      expect(liquidityGross).toEqual(JSBI.BigInt(1));
+    });
+    it("gets the largest tick from the list", async () => {
+      const provider = new TickListDataProvider(
+        [
+          { id: -1, liquidityNet: -1, liquidityGross: 1 },
+          { id: 1, liquidityNet: 1, liquidityGross: 1 },
+        ],
+        1
+      );
+      const { liquidityNet, liquidityGross } = await provider.getTick(1);
+      expect(liquidityNet).toEqual(JSBI.BigInt(1));
+      expect(liquidityGross).toEqual(JSBI.BigInt(1));
+    });
+  });
+});

package/test/tickMath.test.ts

@@ -0,0 +1,66 @@
+import JSBI from "jsbi";
+import { ONE } from "internalConstants";
+import { TickMath } from "utils/tickMath";
+
+describe("TickMath", () => {
+  describe("#MIN_TICK", () => {
+    it("equals correct value", () => {
+      expect(TickMath.MIN_TICK).toEqual(-443636);
+    });
+  });
+
+  describe("#MAX_TICK", () => {
+    it("equals correct value", () => {
+      expect(TickMath.MAX_TICK).toEqual(443636);
+    });
+  });
+
+  describe("#getSqrtRatioAtTick", () => {
+    it("throws for non integer", () => {
+      expect(() => TickMath.getSqrtRatioAtTick(1.5)).toThrow("TICK");
+    });
+
+    it("throws for tick too small", () => {
+      expect(() => TickMath.getSqrtRatioAtTick(TickMath.MIN_TICK - 1)).toThrow(
+        "TICK"
+      );
+    });
+
+    it("throws for tick too large", () => {
+      expect(() => TickMath.getSqrtRatioAtTick(TickMath.MAX_TICK + 1)).toThrow(
+        "TICK"
+      );
+    });
+
+    it("returns the correct value for min tick", () => {
+      expect(TickMath.getSqrtRatioAtTick(TickMath.MIN_TICK)).toEqual(
+        TickMath.MIN_SQRT_RATIO
+      );
+    });
+
+    it("returns the correct value for tick 0", () => {
+      expect(TickMath.getSqrtRatioAtTick(0)).toEqual(
+        JSBI.leftShift(JSBI.BigInt(1), JSBI.BigInt(64))
+      );
+    });
+
+    it("returns the correct value for max tick", () => {
+      expect(TickMath.getSqrtRatioAtTick(TickMath.MAX_TICK)).toEqual(
+        TickMath.MAX_SQRT_RATIO
+      );
+    });
+  });
+
+  describe("#getTickAtSqrtRatio", () => {
+    it("returns the correct value for sqrt ratio at min tick", () => {
+      expect(TickMath.getTickAtSqrtRatio(TickMath.MIN_SQRT_RATIO)).toEqual(
+        TickMath.MIN_TICK
+      );
+    });
+    it("returns the correct value for sqrt ratio at max tick", () => {
+      expect(
+        TickMath.getTickAtSqrtRatio(JSBI.subtract(TickMath.MAX_SQRT_RATIO, ONE))
+      ).toEqual(TickMath.MAX_TICK - 1);
+    });
+  });
+});

package/test/token.test.ts

@@ -0,0 +1,58 @@
+import { Token } from "entities/token";
+
+describe("Token", () => {
+  const CONTRACT_ONE = "contract1";
+  const CONTRACT_TWO = "contract2";
+
+  describe("#constructor", () => {
+    it("fails with negative decimals", () => {
+      expect(() => new Token(CONTRACT_ONE, -1, "ABC")).toThrow("DECIMALS");
+    });
+    it("fails with 256 decimals", () => {
+      expect(() => new Token(CONTRACT_ONE, 256, "ABC")).toThrow("DECIMALS");
+    });
+    it("fails with non-integer decimals", () => {
+      expect(() => new Token(CONTRACT_ONE, 1.5, "ABC")).toThrow("DECIMALS");
+    });
+  });
+
+  describe("#equals", () => {
+    it("fails if contract differs", () => {
+      expect(
+        new Token(CONTRACT_ONE, 8, "ABC").equals(
+          new Token(CONTRACT_TWO, 8, "ABC")
+        )
+      ).toBe(false);
+    });
+
+    it("true if contract and symbol are the same", () => {
+      expect(
+        new Token(CONTRACT_ONE, 8, "ABC").equals(
+          new Token(CONTRACT_ONE, 8, "ABC")
+        )
+      ).toBe(true);
+    });
+
+    it("true even if name differ", () => {
+      const tokenA = new Token(CONTRACT_ONE, 9, "abc", "def");
+      const tokenB = new Token(CONTRACT_ONE, 9, "abc", "jkl");
+      expect(tokenA.equals(tokenB)).toBe(true);
+    });
+  });
+
+  describe("#sortsBefore", () => {
+    it("correct cases", () => {
+      expect(
+        new Token('eosio.token', 4, "TLOS").sortsBefore(
+          new Token('vapaeetokens', 6, "GUX")
+        )
+      ).toBe(true);
+
+      expect(
+        new Token('vapaeetokens', 0, "SEXCOIN").sortsBefore(
+          new Token('vapaeetokens', 0, "PRTYFUN")
+        )
+      ).toBe(true);
+    });
+  });
+});

package/test/trade.test.ts

@@ -0,0 +1,210 @@
+import fs from "fs";
+import { Pool } from "entities/pool";
+import { Token } from "entities/token";
+import { Trade } from "entities/trade";
+import { asset, symbol } from "eos-common";
+import { CurrencyAmount } from "../src/entities/fractions/currencyAmount";
+import JSBI from "jsbi";
+import { FeeAmount, TICK_SPACINGS } from "internalConstants";
+import { encodeSqrtRatioX64 } from "utils/encodeSqrtRatioX64";
+import { TickMath } from "utils/tickMath";
+import { nearestUsableTick } from "utils/nearestUsableTick";
+import { sqrt } from "utils/sqrt";
+
+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()
+  );
+}
+
+describe("Trade", () => {
+  const token0 = new Token(
+    "0x0000000000000000000000000000000000000001",
+    8,
+    "t0",
+    "token0"
+  );
+  const token1 = new Token(
+    "0x0000000000000000000000000000000000000002",
+    8,
+    "t1",
+    "token1"
+  );
+  const token2 = new Token(
+    "0x0000000000000000000000000000000000000003",
+    8,
+    "t2",
+    "token2"
+  );
+  const token3 = new Token(
+    "0x0000000000000000000000000000000000000004",
+    8,
+    "t3",
+    "token3"
+  );
+
+  function v2StylePool(
+    id: number,
+    reserve0: CurrencyAmount<Token>,
+    reserve1: CurrencyAmount<Token>,
+    feeAmount: FeeAmount = FeeAmount.MEDIUM
+  ) {
+    console.log("feeAmount", feeAmount);
+    const sqrtRatioX64 = encodeSqrtRatioX64(
+      reserve1.quotient,
+      reserve0.quotient
+    );
+    const liquidity = sqrt(
+      JSBI.multiply(reserve0.quotient, reserve1.quotient)
+    );
+    return new Pool({
+      id,
+      tokenA: reserve0.currency,
+      tokenB: reserve1.currency,
+      fee: feeAmount,
+      sqrtPriceX64: sqrtRatioX64,
+      liquidity,
+      tickCurrent: TickMath.getTickAtSqrtRatio(sqrtRatioX64),
+      ticks: [
+        {
+          id: nearestUsableTick(TickMath.MIN_TICK, TICK_SPACINGS[feeAmount]),
+          liquidityNet: liquidity,
+          liquidityGross: liquidity,
+        },
+        {
+          id: nearestUsableTick(TickMath.MAX_TICK, TICK_SPACINGS[feeAmount]),
+          liquidityNet: JSBI.multiply(liquidity, JSBI.BigInt(-1)),
+          liquidityGross: liquidity,
+        },
+      ],
+    });
+  }
+  const pool_0_1 = v2StylePool(
+    0,
+    CurrencyAmount.fromRawAmount(token0, 100000),
+    CurrencyAmount.fromRawAmount(token1, 100000)
+  );
+  const pool_0_2 = v2StylePool(
+    1,
+    CurrencyAmount.fromRawAmount(token0, 100000),
+    CurrencyAmount.fromRawAmount(token2, 110000)
+  );
+  const pool_0_3 = v2StylePool(
+    2,
+    CurrencyAmount.fromRawAmount(token0, 100000),
+    CurrencyAmount.fromRawAmount(token3, 90000)
+  );
+  const pool_1_2 = v2StylePool(
+    3,
+    CurrencyAmount.fromRawAmount(token1, 120000),
+    CurrencyAmount.fromRawAmount(token2, 100000)
+  );
+  const pool_1_3 = v2StylePool(
+    4,
+    CurrencyAmount.fromRawAmount(token1, 120000),
+    CurrencyAmount.fromRawAmount(token3, 130000)
+  );
+  describe('#bestTradeExactIn', () => {
+    it('throws with empty pools', async () => {
+      await expect(
+        Trade.bestTradeExactIn([], CurrencyAmount.fromRawAmount(token0, JSBI.BigInt(10000)), token2)
+      ).rejects.toThrow('POOLS')
+    })
+    it('throws with max hops of 0', async () => {
+      await expect(
+        Trade.bestTradeExactIn([pool_0_2], CurrencyAmount.fromRawAmount(token0, JSBI.BigInt(10000)), token2, {
+          maxHops: 0
+        })
+      ).rejects.toThrow('MAX_HOPS')
+    })
+
+    it.only('provides best route', async () => {
+      const result = await Trade.bestTradeExactIn(
+        [pool_0_1, pool_0_2, pool_1_2],
+        CurrencyAmount.fromRawAmount(token0, 10000),
+        token2
+      )
+      console.log("result", result)
+      expect(result).toHaveLength(2)
+      console.log("result[0].swaps[0].route.tokenPath", result[0].swaps[0].route.tokenPath)
+      console.log("result[0].swaps[0].route.pools", result[0].swaps[0].route.pools)
+      expect(result[0].swaps[0].route.pools).toHaveLength(1) // 0 -> 2 at 10:11
+      expect(result[0].swaps[0].route.tokenPath).toEqual([token0, token2])
+      expect(result[0].inputAmount.equalTo(CurrencyAmount.fromRawAmount(token0, JSBI.BigInt(10000)))).toBeTruthy()
+      expect(result[0].outputAmount.equalTo(CurrencyAmount.fromRawAmount(token2, JSBI.BigInt(9971)))).toBeTruthy()
+      expect(result[1].swaps[0].route.pools).toHaveLength(2) // 0 -> 1 -> 2 at 12:12:10
+      expect(result[1].swaps[0].route.tokenPath).toEqual([token0, token1, token2])
+      expect(result[1].inputAmount.equalTo(CurrencyAmount.fromRawAmount(token0, JSBI.BigInt(10000)))).toBeTruthy()
+      expect(result[1].outputAmount.equalTo(CurrencyAmount.fromRawAmount(token2, JSBI.BigInt(7004)))).toBeTruthy()
+    })
+  })
+
+  describe("#bestTradeExactOut", () => {
+    it("throws with empty pools", async () => {
+      await expect(
+        Trade.bestTradeExactOut(
+          [],
+          token0,
+          CurrencyAmount.fromRawAmount(token2, JSBI.BigInt(100))
+        )
+      ).rejects.toThrow("POOLS");
+    });
+
+    it("throws with max hops of 0", async () => {
+      await expect(
+        Trade.bestTradeExactOut(
+          [pool_0_2],
+          token0,
+          CurrencyAmount.fromRawAmount(token2, JSBI.BigInt(100)),
+          {
+            maxHops: 0,
+          }
+        )
+      ).rejects.toThrow("MAX_HOPS");
+    });
+
+    it("provides best route", async () => {
+      const result = await Trade.bestTradeExactOut(
+        [pool_0_1, pool_0_2, pool_1_2],
+        token0,
+        CurrencyAmount.fromRawAmount(token2, 10000)
+      );
+      expect(result).toHaveLength(2);
+      expect(result[0].swaps[0].route.pools).toHaveLength(1); // 0 -> 2 at 10:11
+      expect(result[0].swaps[0].route.tokenPath).toEqual([token0, token2]);
+      expect(
+        result[0].inputAmount.equalTo(
+          CurrencyAmount.fromRawAmount(token0, 10032)
+        )
+      ).toBeTruthy();
+      expect(
+        result[0].outputAmount.equalTo(
+          CurrencyAmount.fromRawAmount(token2, 10000)
+        )
+      ).toBeTruthy();
+      expect(result[1].swaps[0].route.pools).toHaveLength(2); // 0 -> 1 -> 2 at 12:12:10
+      expect(result[1].swaps[0].route.tokenPath).toEqual([
+        token0,
+        token1,
+        token2,
+      ]);
+      expect(
+        result[1].inputAmount.equalTo(
+          CurrencyAmount.fromRawAmount(token0, 15488)
+        )
+      ).toBeTruthy();
+      expect(
+        result[1].outputAmount.equalTo(
+          CurrencyAmount.fromRawAmount(token2, 10000)
+        )
+      ).toBeTruthy();
+    });
+  });
+});

package/test2.ts

@@ -0,0 +1,73 @@
+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/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "lib": ["es6"],                                      /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    "rootDir": "src",                                    /* Specify the root folder within your source files. */
+    "resolveJsonModule": true,                           /* Enable importing .json files. */
+    "allowJs": true,                                     /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    "outDir": "build",                                   /* Specify an output folder for all emitted files. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    "noImplicitAny": false,                               /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    "types": [
+      "node"
+    ],
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  },
+  "include": [
+    "src/**/*.ts"],
+  "exclude": [
+    "node_modules"
+  ],
+}