@galacticcouncil/sdk 0.0.1-beta.1 → 0.0.1-beta.10

package/src/api/router.ts

@@ -1,359 +0,0 @@
-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

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

package/src/client/polkadot.ts

@@ -1,47 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

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

package/src/pool/index.ts

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

package/src/pool/polkadotPoolService.ts

@@ -1,19 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

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