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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacticcouncil/sdk",
-  "version": "0.0.1-beta.1",
+  "version": "0.0.1-beta.2",
   "private": false,
   "description": "Galactic SDK",
   "author": "Pavol Noha <palo@hydradx.io>",
@@ -10,7 +10,8 @@
   "scripts": {
     "test": "jest",
     "build": "node ./esbuild.mjs && tsc --emitDeclarationOnly --outDir dist/types/",
-    "cleanup": "rimraf out && rimraf dist"
+    "cleanup": "rimraf out && rimraf dist",
+    "publish": "cp ./package.json ./dist/package.json && cd dist && npm publish"
   },
   "devDependencies": {
     "@types/jest": "^28.1.8",

package/.eslintignore

@@ -1 +0,0 @@
-node_modules/

package/.eslintrc.json

@@ -1,20 +0,0 @@
-{
-  "root": true,
-  "env": {
-    "browser": true,
-    "es6": true,
-    "node": true
-  },
-  "plugins": [
-    "es",
-    "prettier",
-    "promise"
-  ],
-  "extends": [
-    "prettier",
-    "plugin:promise/recommended"
-  ],
-  "rules": {
-    "prettier/prettier": "error"
-  }
-}

package/.nvmrc

@@ -1 +0,0 @@
-18

package/.prettierrc.json

@@ -1,12 +0,0 @@
-{
-  "trailingComma": "es5",
-  "printWidth": 80,
-  "tabWidth": 2,
-  "singleQuote": true,
-  "bracketSpacing": true,
-  "arrowParens": "always",
-  "semi": true,
-  "newline-before-return": true,
-  "no-duplicate-variable": [true, "check-parameters"],
-  "no-var-keyword": true
-}

package/.vscode/settings.json

@@ -1,15 +0,0 @@
-{
-  "[jsonc]": {
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
-  },
-  "[yaml]": {
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
-  },
-  "[typescript]": {
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
-  },
-  "editor.defaultFormatter": "esbenp.prettier-vscode",
-  "editor.formatOnSave": true,
-  "editor.tabSize": 2,
-  "prettier.printWidth": 100
-}

package/README.md

@@ -1,101 +0,0 @@
-<h1><code>Galactic SDK</code></h1>
-Galactic SDK is collection of components crafted to ease Basilisk & HydraDX chains integration.
-<br />
-<br />
-Table of content:
-
-- [Components](#components)
-  - [Router](#router)
-  - [Trader](#trader)
-- [Examples](#examples)
-- [Packaging](#packaging)
-- [Roadmap](#roadmap)
-- [Issue reporting](#issue-reporting)
-
-## Components
-
-### Router
-
-Off-chain optimization of orders across pools for best price execution. Router does not perform any on-chain transations.
-
-#### API
-
-```typescript
-getPools(): PoolBase[]
-getAllAssets(): PoolAsset[]
-getAssetPairs(token: string): PoolAsset[]
-getAllPaths(tokenIn: string, tokenOut: string): Hop[][]
-getBestSellPrice(tokenIn: string, tokenOut: string, amountIn: BigNumber): Swap[]
-getBestBuyPrice(tokenIn: string, tokenOut: string, amountOut: BigNumber): Swap[]
-```
-
-For type signature visit [types.ts](src/types.ts)<br />
-**Note:** All amount args are formatted as bignumber 1^12!!!
-
-#### Usage
-
-```typescript
-// Import
-import { ApiPromise, WsProvider } from '@polkadot/api';
-import { PolkadotPoolService } from '@galactic/pool';
-import { Router } from '@galactic/api';
-
-// Initialize Polkadot API
-const wsProvider = new WsProvider('wss://rpc.basilisk.cloud');
-const api = await ApiPromise.create({ provider: wsProvider });
-
-// Initialize Router
-const poolService = new PolkadotPoolService(api);
-const router = new Router(poolService);
-
-// Do something
-const result = await router.getAllAssets();
-console.log(result);
-```
-
-### Trader
-
-On-chain transaction executor using data from router to perform best possible trade.
-
-Not supported yet. 🛠
-
-## Examples
-
-SDK Examples and testing helpers.
-
-### Run
-
-Run: `$ npx tsx ./test/script/examples/${{examplePackage}}/${{exampleName}}.ts` with valid example package & name.
-
-To demonstrate full working examples on real chain see [script](test/script/examples) section.
-
-## Packaging
-
-- api - Router & Trader impl
-- client - Substrate chain based clients
-- pool - Pool specific logic, math, clients
-- suggester - Route proposing, graph utils, BFS, DFS
-- utils - bignumber, math, collections
-
-## Roadmap
-
-Component list and current status ⬇️
-
-- 🧪 Done
-- 🛠 Work in progress
-- ⏳ Planning to build
-
-| Name     |  Type  |     |
-| -------- | :----: | --: |
-| Router   |  API   |  🧪 |
-| Trader   |  API   |   🛠 |
-| Polkadot | Client |  🧪 |
-| Capi     | Client |  ⏳ |
-| XYK      |  Pool  |  🧪 |
-| LBP      |  Pool  |  ⏳ |
-| Stable   |  Pool  |  ⏳ |
-| Omni     |  Pool  |  ⏳ |
-
-## Issue reporting
-
-In case of unexpected sdk behaviour, please create well-written issue [here](https://https://github.com/nohaapav/router-sdk/issues/new). It makes it easier to find & fix the problem accordingly.

package/esbuild.mjs

@@ -1,36 +0,0 @@
-import esbuild from 'esbuild';
-import resolve from 'esbuild-plugin-resolve';
-import { wasmLoader } from 'esbuild-plugin-wasm';
-
-// ESM bundle
-esbuild
-  .build({
-    entryPoints: ['src/index.ts'],
-    outdir: 'dist/esm',
-    bundle: true,
-    sourcemap: true,
-    minify: true,
-    splitting: true,
-    plugins: [
-      resolve({
-        './math/nodejs': './math/bundler',
-      }),
-      wasmLoader({ mode: 'deferred' }),
-    ],
-    format: 'esm',
-    target: ['esnext'],
-  })
-  .catch(() => process.exit(1));
-
-// CJS bundle
-esbuild
-  .build({
-    entryPoints: ['src/index.ts'],
-    outfile: 'dist/cjs/index.js',
-    bundle: true,
-    sourcemap: true,
-    minify: true,
-    platform: 'node',
-    target: ['node18'],
-  })
-  .catch(() => process.exit(1));

package/jest.config.mjs

@@ -1,16 +0,0 @@
-export default {
-  roots: ['<rootDir>/test'],
-  modulePaths: ['<rootDir>'],
-  moduleDirectories: ['node_modules'],
-  moduleNameMapper: {},
-  testMatch: ['**/__tests__/**/*.+(ts|js)', '**/?(*.)+(spec|test).+(ts|js)'],
-  transform: {
-    '^.+\\.(ts)$': 'es-jest',
-  },
-  collectCoverageFrom: ['**/*.{js,ts}', '!**/*.d.ts', '!**/node_modules/**'],
-  globals: {
-    'ts-jest': {
-      tsconfig: 'tsconfig.json',
-    },
-  },
-};

package/src/api/index.ts

@@ -1 +0,0 @@
-export { Router } from './router';

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';