@galacticcouncil/sdk 0.0.1-beta.1

package/src/api/router.ts

@@ -0,0 +1,359 @@
+import { PoolService, PoolBase, Hop, Pool, PoolAsset, Swap } from '../types';
+import { RouteSuggester } from '../suggester';
+import { Edge } from '../suggester';
+import { PoolFactory } from '../pool';
+import { BigNumber } from '../utils/bignumber';
+import { calculateTradeFee } from '../utils/math';
+
+export class Router {
+  private readonly routeSuggester: RouteSuggester;
+  private readonly poolService: PoolService;
+
+  /**
+   * @param poolService - Fetch pool data from substrate based pools
+   */
+  constructor(poolService: PoolService) {
+    this.poolService = poolService;
+    this.routeSuggester = new RouteSuggester();
+  }
+
+  /**
+   * Return all pools
+   *
+   * @returns {PoolBase[]} List of all substrate based pools
+   */
+  getPools(): Promise<PoolBase[]> {
+    return this.poolService.getPools();
+  }
+
+  /**
+   * Return list of all available assets from substrate based pools
+   *
+   * @returns {PoolAsset[]} List of all available assets
+   */
+  async getAllAssets(): Promise<PoolAsset[]> {
+    const asset = await this.getAssets();
+    return [...new Map(asset).values()];
+  }
+
+  /**
+   * Calculate and return list of all assets, given token can be trade with
+   *
+   * @param {string} token - Storage key of token
+   * @returns {PoolAsset[]} List of all available assets, given token can be trade with
+   */
+  async getAssetPairs(token: string): Promise<PoolAsset[]> {
+    const pools = await this.poolService.getPools();
+    if (pools.length === 0) return [];
+    const { assets, poolsMap } = await this.validateToken(token, pools);
+    const hops = this.getPaths(token, null, poolsMap, pools);
+    const dest = hops.map((hop) => hop[hop.length - 1].tokenOut);
+    return this.toPoolAssets([...new Set(dest)], assets);
+  }
+
+  /**
+   * Calculate and return all possible paths for best swap tokenIn>tokenOut
+   *
+   * @param {string} tokenIn - Storage key of tokenIn
+   * @param {string} tokenOut - Storage key of tokenOut
+   * @returns {<Hop[][]>} All possible paths containing route hops
+   */
+  async getAllPaths(tokenIn: string, tokenOut: string): Promise<Hop[][]> {
+    const pools = await this.poolService.getPools();
+    if (pools.length === 0) return [];
+    const { poolsMap } = await this.validateTokenPair(tokenIn, tokenOut, pools);
+    return this.getPaths(tokenIn, tokenOut, poolsMap, pools);
+  }
+
+  /**
+   * Calculate and return best possible sell price for tokenIn>tokenOut
+   *
+   * @param {string} tokenIn - Storage key of tokenIn
+   * @param {string} tokenOut - Storage key of tokenOut
+   * @param {BigNumber} amountIn - Amount of tokenIn to sell for tokenOut
+   * @returns Best possible swaps(sells) of given token pair
+   */
+  async getBestSellPrice(
+    tokenIn: string,
+    tokenOut: string,
+    amountIn: BigNumber
+  ): Promise<Swap[]> {
+    const pools = await this.poolService.getPools();
+    if (pools.length === 0) return [];
+    const { poolsMap } = await this.validateTokenPair(tokenIn, tokenOut, pools);
+    const paths = this.getPaths(tokenIn, tokenOut, poolsMap, pools);
+    const swaps = paths.map((path) =>
+      this.toSellSwaps(amountIn, path, poolsMap)
+    );
+    const sorted = swaps.sort((a, b) => {
+      const swapAFinal = a[a.length - 1].returnFinalAmount;
+      const swapBFinal = b[b.length - 1].returnFinalAmount;
+      return swapAFinal.isGreaterThan(swapBFinal) ? -1 : 1;
+    });
+    return sorted[0];
+  }
+
+  /**
+   * Calculate and return sell swaps for given path
+   * - final amount of previous swap is entry to next one
+   *
+   * @param amountIn - Amount of tokenIn to sell for tokenOut
+   * @param path - current path
+   * @param poolsMap - pools map
+   * @returns Sell swaps for given path
+   */
+  private toSellSwaps(
+    amountIn: BigNumber,
+    path: Hop[],
+    poolsMap: Map<string, Pool>
+  ): Swap[] {
+    const swaps: Swap[] = [];
+    for (let i = 0; i < path.length; i++) {
+      const hop = path[i];
+      const pool = poolsMap.get(hop.poolId);
+      if (pool == null) throw new Error('Pool does not exit');
+
+      let aIn: BigNumber;
+      if (i > 0) {
+        aIn = swaps[i - 1].returnFinalAmount;
+      } else {
+        aIn = amountIn;
+      }
+
+      const poolPair = pool.parsePoolPair(hop.tokenIn, hop.tokenOut);
+      const calculated = pool.calculateOutGivenIn(poolPair, aIn);
+      const fee = calculateTradeFee(calculated, poolPair.swapFee);
+      const spotPrice = pool.getSpotPriceOut(poolPair);
+
+      swaps.push({
+        ...hop,
+        swapAmount: aIn,
+        returnAmount: calculated,
+        returnFinalAmount: calculated.minus(fee),
+        swapFee: fee,
+        spotPrice: spotPrice,
+      } as Swap);
+    }
+    return swaps;
+  }
+
+  /**
+   * Calculate and return best possible buy price for tokenIn>tokenOut
+   *
+   * @param {string} tokenIn - Storage key of tokenIn
+   * @param {string} tokenOut - Storage key of tokenOut
+   * @param {BigNumber} amountOut - Amount of tokenOut to buy for tokenIn
+   * @returns Best possible swaps(buys) of given token pair
+   */
+  async getBestBuyPrice(
+    tokenIn: string,
+    tokenOut: string,
+    amountOut: BigNumber
+  ): Promise<Swap[]> {
+    const pools = await this.poolService.getPools();
+    if (pools.length === 0) return [];
+    const { poolsMap } = await this.validateTokenPair(tokenIn, tokenOut, pools);
+    const paths = this.getPaths(tokenIn, tokenOut, poolsMap, pools);
+    const swaps = paths.map((path) =>
+      this.toBuySwaps(amountOut, path, poolsMap)
+    );
+    const sorted = swaps.sort((a, b) => {
+      const swapAFinal = a[0].returnFinalAmount;
+      const swapBFinal = b[0].returnFinalAmount;
+      return swapAFinal.isGreaterThan(swapBFinal) ? 1 : -1;
+    });
+    return sorted[0];
+  }
+
+  /**
+   * Calculate and return buy swaps for given path
+   * - final amount of previous swap is entry to next one
+   * - calculation is done backwards
+   *
+   * @param amountOut - Amount of tokenOut to buy for tokenIn
+   * @param path - current path
+   * @param poolsMap - pools map
+   * @returns Buy swaps for given path
+   */
+  private toBuySwaps(
+    amountOut: BigNumber,
+    path: Hop[],
+    poolsMap: Map<string, Pool>
+  ): Swap[] {
+    const swaps: Swap[] = [];
+    for (let i = path.length - 1; i >= 0; i--) {
+      const hop = path[i];
+      const pool = poolsMap.get(hop.poolId);
+      if (pool == null) throw new Error('Pool does not exit');
+
+      let aOut: BigNumber;
+      if (i == path.length - 1) {
+        aOut = amountOut;
+      } else {
+        aOut = swaps[0].returnFinalAmount;
+      }
+
+      const poolPair = pool.parsePoolPair(hop.tokenIn, hop.tokenOut);
+      const calculated = pool.calculateInGivenOut(poolPair, aOut);
+      const fee = calculateTradeFee(calculated, poolPair.swapFee);
+      const spotPrice = pool.getSpotPriceIn(poolPair);
+
+      swaps.unshift({
+        ...hop,
+        swapAmount: aOut,
+        returnAmount: calculated,
+        returnFinalAmount: calculated.plus(fee),
+        swapFee: fee,
+        spotPrice: spotPrice,
+      } as Swap);
+    }
+    return swaps;
+  }
+
+  /**
+   * Return map of all available assets from substrate based pools
+   *
+   * @returns Map of all available assets
+   */
+  private async getAssets(): Promise<Map<string, PoolAsset>> {
+    const pools = await this.poolService.getPools();
+    if (pools.length === 0) return new Map<string, PoolAsset>();
+    const assets = pools
+      .map((pool: PoolBase) => {
+        return pool.tokens.map(({ id, symbol }) => {
+          return { token: id, symbol } as PoolAsset;
+        });
+      })
+      .flat();
+    return new Map(assets.map((asset) => [asset.token, asset]));
+  }
+
+  /**
+   * Calculate and return all possible paths for best swap tokenIn>tokenOut
+   *
+   * @param tokenIn - Storage key of tokenIn
+   * @param tokenOut - Storage key of tokenOut
+   * @param poolsMap - pools map
+   * @param pools - pools
+   * @returns All possible paths containing route hops
+   */
+  private getPaths(
+    tokenIn: string,
+    tokenOut: string | null,
+    poolsMap: Map<string, Pool>,
+    pools: PoolBase[]
+  ): Hop[][] {
+    const routeProposals = this.routeSuggester.getProposals(
+      tokenIn,
+      tokenOut,
+      pools
+    );
+    const routes = routeProposals
+      .filter((path: Edge[]) => this.validPath(path, poolsMap))
+      .map((path: Edge[]) => this.toHops(path, poolsMap));
+    return routes;
+  }
+
+  /**
+   * Ckeck if input asset pair is valid and throw expection if not
+   *
+   * @param tokenIn - Storage key of tokenIn
+   * @param tokenOut - Storage key of tokenOut
+   * @returns Pool assets & map
+   */
+  private async validateTokenPair(
+    tokenIn: string,
+    tokenOut: string,
+    pools: PoolBase[]
+  ) {
+    const assets = await this.getAssets();
+    if (assets.get(tokenIn) == null)
+      throw new Error(tokenIn + ' is not supported token');
+    if (assets.get(tokenOut) == null)
+      throw new Error(tokenOut + ' is not supported token');
+    const poolsMap = this.getPoolMap(pools);
+    return { assets, poolsMap };
+  }
+
+  /**
+   * Ckeck if input asset is valid and throw expection if not
+   *
+   * @param token - Storage key of token
+   * @returns Pool assets & map
+   */
+  private async validateToken(token: string, pools: PoolBase[]) {
+    const assets = await this.getAssets();
+    if (assets.get(token) == null)
+      throw new Error(token + ' is not supported token');
+    const poolsMap = this.getPoolMap(pools);
+    return { assets, poolsMap };
+  }
+
+  /**
+   * Create pool map from substrate based pools
+   */
+  private getPoolMap(pools: PoolBase[]): Map<string, Pool> {
+    return new Map<string, Pool>(
+      pools.map((i) => [i.address, PoolFactory.get(i)])
+    );
+  }
+
+  /**
+   * Check if path is valid -> all edges are valid token pairs
+   *
+   * @param proposedPath - proposed path
+   * @param poolsMap - pools map
+   * @returns only valid paths
+   */
+  private validPath(
+    proposedPath: Edge[],
+    poolsMap: Map<string, Pool>
+  ): boolean {
+    return (
+      proposedPath.length > 0 &&
+      proposedPath
+        .map((edge: Edge) => this.validEdge(edge, poolsMap))
+        .reduce((prev, curr) => prev && curr)
+    );
+  }
+
+  /**
+   * Check if edge (token pair) of corresponding pool is valid combination
+   *
+   * @param edge - current edge (token pair)
+   * @param poolsMap - pools map
+   * @returns true if edge (token pair) is valid, otherwise false
+   */
+  private validEdge(
+    [id, from, to]: Edge,
+    poolsMap: Map<string, Pool>
+  ): boolean {
+    return poolsMap.get(id)?.validPair(from, to) || false;
+  }
+
+  private toHops(path: Edge[], poolsMap: Map<string, Pool>): Hop[] {
+    return path.map(([id, from, to]: Edge) => {
+      const pool = poolsMap.get(id);
+      return {
+        poolId: id,
+        poolType: pool?.type,
+        tokenIn: from,
+        tokenOut: to,
+        fee: pool?.swapFee,
+      } as Hop;
+    });
+  }
+
+  private toPoolAssets(
+    tokens: string[],
+    assets: Map<string, PoolAsset>
+  ): PoolAsset[] {
+    return tokens.map((token) => {
+      const asset = assets.get(token);
+      return {
+        token: token,
+        symbol: asset?.symbol,
+      } as PoolAsset;
+    });
+  }
+}

package/src/client/index.ts

@@ -0,0 +1 @@
+export { PolkadotClient } from './polkadot';

package/src/client/polkadot.ts

@@ -0,0 +1,47 @@
+import { ApiPromise } from '@polkadot/api';
+
+import type { StorageKey } from '@polkadot/types';
+import type { AnyTuple, Codec } from '@polkadot/types/types';
+import type { AssetMetadata } from '@polkadot/types/interfaces';
+import type { TokensAccountData } from './types';
+import '@polkadot/api-augment';
+
+export class PolkadotClient {
+  protected readonly api: ApiPromise;
+
+  constructor(api: ApiPromise) {
+    this.api = api;
+  }
+
+  getStorageKey(asset: [StorageKey<AnyTuple>, Codec], index: number): string {
+    return (asset[0].toHuman() as string[])[index];
+  }
+
+  getStorageEntryArray(asset: [StorageKey<AnyTuple>, Codec]): string[] {
+    return asset[1].toHuman() as string[];
+  }
+
+  async getAssetMetadata(tokenKey: string): Promise<AssetMetadata> {
+    return await this.api.query.assetRegistry.assetMetadataMap<AssetMetadata>(
+      tokenKey
+    );
+  }
+
+  async getSystemAccountBalance(accountId: string): Promise<string> {
+    const {
+      data: { free },
+    } = await this.api.query.system.account(accountId);
+    return free.toString();
+  }
+
+  async getTokenAccountBalance(
+    accountId: string,
+    tokenKey: string
+  ): Promise<string> {
+    const { free } = await this.api.query.tokens.accounts<TokensAccountData>(
+      accountId,
+      tokenKey
+    );
+    return free.toString();
+  }
+}

package/src/client/types.ts

@@ -0,0 +1,8 @@
+import type { Struct } from '@polkadot/types-codec';
+import type { Balance } from '@polkadot/types/interfaces/runtime';
+
+export interface TokensAccountData extends Struct {
+  readonly free: Balance;
+  readonly reserved: Balance;
+  readonly frozen: Balance;
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { Router } from './api';
+export { PolkadotPoolService, PoolFactory, XykPool } from './pool';
+export * from './utils/bignumber';
+export * from './utils/math';

package/src/pool/index.ts

@@ -0,0 +1,3 @@
+export { PolkadotPoolService } from './polkadotPoolService';
+export { PoolFactory } from './poolFactory';
+export { XykPool } from './xyk/xykPool';

package/src/pool/polkadotPoolService.ts

@@ -0,0 +1,19 @@
+import { PoolBase, PoolService } from '../types';
+import { XykPolkadotClient } from './xyk/xykPolkadotClient';
+
+import { ApiPromise } from '@polkadot/api';
+
+export class PolkadotPoolService implements PoolService {
+  private readonly api: ApiPromise;
+
+  constructor(api: ApiPromise) {
+    this.api = api;
+  }
+
+  async getPools(): Promise<PoolBase[]> {
+    const pools: PoolBase[][] = [];
+    const xykPools = await new XykPolkadotClient(this.api).getPools();
+    pools.push(xykPools);
+    return pools.flat();
+  }
+}

package/src/pool/poolFactory.ts

@@ -0,0 +1,14 @@
+import { Pool, PoolBase, PoolType } from '../types';
+import { XykPool } from './xyk/xykPool';
+
+export class PoolFactory {
+  static get(pool: PoolBase): Pool {
+    switch (pool.type) {
+      case PoolType.XYK:
+        return XykPool.fromPool(pool);
+      default: {
+        throw new Error('Pool type ' + pool.type + ' is not supported yet');
+      }
+    }
+  }
+}

package/src/pool/xyk/math/bundler.ts

@@ -0,0 +1,19 @@
+import {
+  calculate_in_given_out,
+  calculate_out_given_in,
+  get_spot_price,
+} from 'hydra-dx-wasm/build/xyk/bundler';
+
+function getSpotPrice(a: string, b: string, c: string): string {
+  return get_spot_price(a, b, c);
+}
+
+function calculateInGivenOut(a: string, b: string, c: string): string {
+  return calculate_in_given_out(a, b, c);
+}
+
+function calculateOutGivenIn(a: string, b: string, c: string): string {
+  return calculate_out_given_in(a, b, c);
+}
+
+export default { getSpotPrice, calculateInGivenOut, calculateOutGivenIn };

package/src/pool/xyk/math/nodejs.ts

@@ -0,0 +1,19 @@
+import {
+  calculate_in_given_out,
+  calculate_out_given_in,
+  get_spot_price,
+} from 'hydra-dx-wasm/build/xyk/nodejs';
+
+function getSpotPrice(a: string, b: string, c: string): string {
+  return get_spot_price(a, b, c);
+}
+
+function calculateInGivenOut(a: string, b: string, c: string): string {
+  return calculate_in_given_out(a, b, c);
+}
+
+function calculateOutGivenIn(a: string, b: string, c: string): string {
+  return calculate_out_given_in(a, b, c);
+}
+
+export default { getSpotPrice, calculateInGivenOut, calculateOutGivenIn };

package/src/pool/xyk/xykPolkadotClient.ts

@@ -0,0 +1,58 @@
+import { PolkadotClient } from '../../client';
+import type { StorageKey } from '@polkadot/types';
+import type { AnyTuple, Codec } from '@polkadot/types/types';
+import { PoolBase, PoolToken, PoolType } from '../../types';
+
+export class XykPolkadotClient extends PolkadotClient {
+  async getPools(): Promise<PoolBase[]> {
+    const poolAssets = await this.api.query.xyk.poolAssets.entries();
+    const pools = poolAssets.map(
+      async (asset: [StorageKey<AnyTuple>, Codec]) => {
+        const poolAddress = this.getStorageKey(asset, 0);
+        const poolEntries = this.getStorageEntryArray(asset);
+        const poolTokens = await this.getPoolTokens(poolAddress, poolEntries);
+        return {
+          address: poolAddress,
+          type: PoolType.XYK,
+          swapFee: this.getSwapFee(),
+          tokens: poolTokens,
+        } as PoolBase;
+      }
+    );
+    return Promise.all(pools);
+  }
+
+  async getPoolTokens(
+    poolAddress: string,
+    assetKeys: string[]
+  ): Promise<PoolToken[]> {
+    const poolTokens = assetKeys.map(async (id) => {
+      const balance = await this.getBalance(poolAddress, id);
+      const metadata = await super.getAssetMetadata(id);
+      const metadataJson = metadata.toHuman();
+      return {
+        id,
+        balance: balance,
+        decimals: metadataJson ? metadataJson.decimals : '12',
+        symbol: metadataJson ? metadataJson.symbol : 'BSX',
+      } as PoolToken;
+    });
+    return Promise.all(poolTokens);
+  }
+
+  getBalance(poolAddress: string, assetKey: string): Promise<string> {
+    if (assetKey === '0') {
+      return this.getSystemAccountBalance(poolAddress);
+    } else {
+      return this.getTokenAccountBalance(poolAddress, assetKey);
+    }
+  }
+
+  getSwapFee(): string {
+    const exchangeFee = this.api.consts.xyk.getExchangeFee;
+    return (
+      (exchangeFee[0].toNumber() / exchangeFee[1].toNumber()) *
+      100
+    ).toString();
+  }
+}

package/src/pool/xyk/xykPool.ts

@@ -0,0 +1,82 @@
+import { Pool, PoolBase, PoolPair, PoolToken, PoolType } from '../../types';
+import { BigNumber, bnum, scale } from '../../utils/bignumber';
+import math from './math/nodejs';
+import { tradeFee, normalizeAmount } from '../../utils/math';
+
+export class XykPool implements Pool {
+  type: PoolType;
+  address: string;
+  swapFee: string;
+  tokens: PoolToken[];
+
+  static fromPool(pool: PoolBase): XykPool {
+    return new XykPool(pool.address, pool.swapFee, pool.tokens);
+  }
+
+  constructor(address: string, swapFee: string, tokens: PoolToken[]) {
+    this.type = PoolType.XYK;
+    this.address = address;
+    this.swapFee = swapFee;
+    this.tokens = tokens;
+  }
+
+  validPair(_tokenIn: string, _tokenOut: string): boolean {
+    return true;
+  }
+
+  parsePoolPair(tokenIn: string, tokenOut: string): PoolPair {
+    const tokensMap = new Map(this.tokens.map((token) => [token.id, token]));
+    const tokenInMeta = tokensMap.get(tokenIn);
+    const tokenOutMeta = tokensMap.get(tokenOut);
+
+    if (tokenInMeta == null) throw new Error('Pool does not contain tokenIn');
+    if (tokenOutMeta == null) throw new Error('Pool does not contain tokenOut');
+
+    const balanceIn = bnum(tokenInMeta.balance);
+    const balanceOut = bnum(tokenOutMeta.balance);
+
+    return {
+      swapFee: tradeFee(this.swapFee),
+      tokenIn: tokenIn,
+      tokenOut: tokenOut,
+      balanceIn: normalizeAmount(balanceIn, tokenInMeta.decimals),
+      balanceOut: normalizeAmount(balanceOut, tokenOutMeta.decimals),
+    } as PoolPair;
+  }
+
+  calculateInGivenOut(poolPair: PoolPair, amountOut: BigNumber): BigNumber {
+    const price = math.calculateInGivenOut(
+      poolPair.balanceIn.toString(),
+      poolPair.balanceOut.toString(),
+      amountOut.toString()
+    );
+    return bnum(price);
+  }
+
+  getSpotPriceIn(poolPair: PoolPair): BigNumber {
+    const price = math.getSpotPrice(
+      poolPair.balanceOut.toString(),
+      poolPair.balanceIn.toString(),
+      scale(bnum(1), 12).toString()
+    );
+    return bnum(price);
+  }
+
+  calculateOutGivenIn(poolPair: PoolPair, amountIn: BigNumber): BigNumber {
+    const price = math.calculateOutGivenIn(
+      poolPair.balanceIn.toString(),
+      poolPair.balanceOut.toString(),
+      amountIn.toString()
+    );
+    return bnum(price);
+  }
+
+  getSpotPriceOut(poolPair: PoolPair): BigNumber {
+    const price = math.getSpotPrice(
+      poolPair.balanceIn.toString(),
+      poolPair.balanceOut.toString(),
+      scale(bnum(1), 12).toString()
+    );
+    return bnum(price);
+  }
+}