@galacticcouncil/sdk 0.0.1-beta.1

package/dist/types/client/polkadot.d.ts

@@ -0,0 +1,14 @@
+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 '@polkadot/api-augment';
+export declare class PolkadotClient {
+    protected readonly api: ApiPromise;
+    constructor(api: ApiPromise);
+    getStorageKey(asset: [StorageKey<AnyTuple>, Codec], index: number): string;
+    getStorageEntryArray(asset: [StorageKey<AnyTuple>, Codec]): string[];
+    getAssetMetadata(tokenKey: string): Promise<AssetMetadata>;
+    getSystemAccountBalance(accountId: string): Promise<string>;
+    getTokenAccountBalance(accountId: string, tokenKey: string): Promise<string>;
+}

package/dist/types/client/types.d.ts

@@ -0,0 +1,7 @@
+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/dist/types/index.d.ts

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

package/dist/types/pool/index.d.ts

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

package/dist/types/pool/polkadotPoolService.d.ts

@@ -0,0 +1,7 @@
+import { PoolBase, PoolService } from '../types';
+import { ApiPromise } from '@polkadot/api';
+export declare class PolkadotPoolService implements PoolService {
+    private readonly api;
+    constructor(api: ApiPromise);
+    getPools(): Promise<PoolBase[]>;
+}

package/dist/types/pool/poolFactory.d.ts

@@ -0,0 +1,4 @@
+import { Pool, PoolBase } from '../types';
+export declare class PoolFactory {
+    static get(pool: PoolBase): Pool;
+}

package/dist/types/pool/xyk/math/bundler.d.ts

@@ -0,0 +1,9 @@
+declare function getSpotPrice(a: string, b: string, c: string): string;
+declare function calculateInGivenOut(a: string, b: string, c: string): string;
+declare function calculateOutGivenIn(a: string, b: string, c: string): string;
+declare const _default: {
+    getSpotPrice: typeof getSpotPrice;
+    calculateInGivenOut: typeof calculateInGivenOut;
+    calculateOutGivenIn: typeof calculateOutGivenIn;
+};
+export default _default;

package/dist/types/pool/xyk/math/nodejs.d.ts

@@ -0,0 +1,9 @@
+declare function getSpotPrice(a: string, b: string, c: string): string;
+declare function calculateInGivenOut(a: string, b: string, c: string): string;
+declare function calculateOutGivenIn(a: string, b: string, c: string): string;
+declare const _default: {
+    getSpotPrice: typeof getSpotPrice;
+    calculateInGivenOut: typeof calculateInGivenOut;
+    calculateOutGivenIn: typeof calculateOutGivenIn;
+};
+export default _default;

package/dist/types/pool/xyk/xykPolkadotClient.d.ts

@@ -0,0 +1,8 @@
+import { PolkadotClient } from '../../client';
+import { PoolBase, PoolToken } from '../../types';
+export declare class XykPolkadotClient extends PolkadotClient {
+    getPools(): Promise<PoolBase[]>;
+    getPoolTokens(poolAddress: string, assetKeys: string[]): Promise<PoolToken[]>;
+    getBalance(poolAddress: string, assetKey: string): Promise<string>;
+    getSwapFee(): string;
+}

package/dist/types/pool/xyk/xykPool.d.ts

@@ -0,0 +1,16 @@
+import { Pool, PoolBase, PoolPair, PoolToken, PoolType } from '../../types';
+import { BigNumber } from '../../utils/bignumber';
+export declare class XykPool implements Pool {
+    type: PoolType;
+    address: string;
+    swapFee: string;
+    tokens: PoolToken[];
+    static fromPool(pool: PoolBase): XykPool;
+    constructor(address: string, swapFee: string, tokens: PoolToken[]);
+    validPair(_tokenIn: string, _tokenOut: string): boolean;
+    parsePoolPair(tokenIn: string, tokenOut: string): PoolPair;
+    calculateInGivenOut(poolPair: PoolPair, amountOut: BigNumber): BigNumber;
+    getSpotPriceIn(poolPair: PoolPair): BigNumber;
+    calculateOutGivenIn(poolPair: PoolPair, amountIn: BigNumber): BigNumber;
+    getSpotPriceOut(poolPair: PoolPair): BigNumber;
+}

package/dist/types/suggester/bfs.d.ts

@@ -0,0 +1,37 @@
+export declare type Path = Node[];
+export declare type Node = [id: number, from: string];
+/**
+ * Breadth First Search.
+ *
+ * - uses Queue to find the shortest path
+ * - slower than DFS (Depth First Search)
+ * - better when dst is closer to src
+ * - complexity O(N+E) where N are nodes and E are edges
+ */
+export declare class Bfs {
+    /**
+     * Check if current node is already present in path
+     *
+     * @param x - current node
+     * @param path - path
+     * @returns true if node in path, otherwise false
+     */
+    isNotVisited(x: number, path: Path): boolean;
+    /**
+     * Finding paths in graph from given source to destination
+     *
+     * @param g - routes graph containing nodes & corresponding edges
+     * @param src - source node
+     * @param dst - destination node or null if requesting all posible paths from src
+     * @returns paths
+     */
+    findPaths(g: Path[], src: number, dst: number | null): Path[];
+    /**
+     * Build and populate graph
+     *
+     * @param nodes - list of pool assets
+     * @param edges - list of all edges [id, from, to] between assets
+     * @returns - traversal graph
+     */
+    buildAndPopulateGraph(nodes: string[], edges: [string, string, string][]): Path[];
+}

package/dist/types/suggester/graph.d.ts

@@ -0,0 +1,12 @@
+import { PoolBase } from '../types';
+export declare type Edge = [address: string, from: string, to: string];
+export declare type NodeEdges = {
+    [node: string]: Edge[];
+};
+/**
+ * Calculate nodes & edges from substrate pools
+ *
+ * @param pools - given substrate pools
+ * @returns nodes & corresponding edges
+ */
+export declare function getNodesAndEdges(pools: PoolBase[]): NodeEdges;

package/dist/types/suggester/index.d.ts

@@ -0,0 +1,3 @@
+export { RouteSuggester } from './suggester';
+export { Bfs, Path } from './bfs';
+export { Edge, getNodesAndEdges } from './graph';

package/dist/types/suggester/suggester.d.ts

@@ -0,0 +1,24 @@
+import { PoolBase } from '../types';
+import { Edge } from './graph';
+export declare class RouteSuggester {
+    /**
+     * Proposals are ideal paths from
+     * 1) tokenIn to tokenOut
+     * 2) tokenIn to *(all possible paths are requested)
+     *
+     * calculated from all permutations of tokens of given pools.
+     *
+     * E.g. permutation of pool A={1,3} is 2, such as {1,3}, {3,1} where 1 are 3
+     * are pool assets(tokens)
+     *
+     * Filtering of valid paths and corresponding asset pairs is done by router itself!!!
+     *
+     * @param tokenIn - tokenIn
+     * @param tokenOut - tokenOut or null if all possible paths from tokenIn are requested
+     * @param pools - substrate based pools
+     * @returns all possible path proposals
+     */
+    getProposals(tokenIn: string, tokenOut: string | null, pools: PoolBase[]): Edge[][];
+    private parsePaths;
+    private toEdge;
+}

package/dist/types/types.d.ts

@@ -0,0 +1,55 @@
+import { BigNumber } from './utils/bignumber';
+export declare type PoolAsset = {
+    token: string;
+    symbol: string;
+};
+export declare enum PoolType {
+    XYK = "XYK",
+    LBP = "LBP",
+    Stable = "Stable",
+    Omni = "Omni"
+}
+export interface PoolPair {
+    swapFee: BigNumber;
+    tokenIn: string;
+    tokenOut: string;
+    balanceIn: BigNumber;
+    balanceOut: BigNumber;
+}
+export declare type PoolBase = {
+    address: string;
+    type: PoolType;
+    swapFee: string;
+    tokens: PoolToken[];
+};
+export declare type PoolToken = {
+    id: string;
+    balance: string;
+    decimals: number;
+    symbol: string;
+};
+export interface Pool extends PoolBase {
+    validPair(tokenIn: string, tokenOut: string): boolean;
+    parsePoolPair(tokenIn: string, tokenOut: string): PoolPair;
+    calculateInGivenOut(poolPair: PoolPair, amountOut: BigNumber): BigNumber;
+    calculateOutGivenIn(poolPair: PoolPair, amountIn: BigNumber): BigNumber;
+    getSpotPriceIn(poolPair: PoolPair): BigNumber;
+    getSpotPriceOut(poolPair: PoolPair): BigNumber;
+}
+export interface PoolService {
+    getPools(): Promise<PoolBase[]>;
+}
+export declare type Hop = {
+    poolType: PoolType;
+    poolId: string;
+    tokenIn: string;
+    tokenOut: string;
+    fee: string;
+};
+export declare type Swap = Hop & {
+    swapAmount: BigNumber;
+    returnAmount: BigNumber;
+    returnFinalAmount: BigNumber;
+    swapFee: BigNumber;
+    spotPrice: BigNumber;
+};

package/dist/types/utils/bignumber.d.ts

@@ -0,0 +1,8 @@
+import { BigNumber } from 'bignumber.js';
+export declare const DECIMAL_PLACES = 12;
+export declare const ZERO: BigNumber;
+export declare const ONE: BigNumber;
+export declare const INFINITY: BigNumber;
+export declare function scale(input: BigNumber, decimalPlaces: number): BigNumber;
+export declare function bnum(val: string | number | BigNumber): BigNumber;
+export { BigNumber };

package/dist/types/utils/math.d.ts

@@ -0,0 +1,4 @@
+import { BigNumber } from './bignumber';
+export declare function tradeFee(percentage: string): BigNumber;
+export declare function calculateTradeFee(amount: BigNumber, tradeFee: BigNumber): BigNumber;
+export declare function normalizeAmount(amount: BigNumber, decimals: number): BigNumber;

package/dist/types/utils/queue.d.ts

@@ -0,0 +1,13 @@
+export interface IQueue<T> {
+    enqueue(item: T): void;
+    dequeue(): T | undefined;
+    size(): number;
+}
+export declare class Queue<T> implements IQueue<T> {
+    private capacity;
+    private storage;
+    constructor(capacity?: number);
+    enqueue(item: T): void;
+    dequeue(): T | undefined;
+    size(): number;
+}

package/dist/types/utils/stack.d.ts

@@ -0,0 +1,15 @@
+export interface IStack<T> {
+    push(item: T): void;
+    pop(): T | undefined;
+    peek(): T | undefined;
+    size(): number;
+}
+export declare class Stack<T> implements IStack<T> {
+    private capacity;
+    private storage;
+    constructor(capacity?: number);
+    push(item: T): void;
+    pop(): T | undefined;
+    peek(): T | undefined;
+    size(): number;
+}

package/dist/types/utils/traversal/bfs.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Breadth First Search.
+ *
+ * - uses Queue to find the shortest path
+ * - slower than DFS (Depth First Search)
+ * - better when dst is closer to src
+ * - complexity O(N+E) where N are nodes and E are edges
+ */
+export declare class Bfs {
+    /**
+     * Check if current node is already present in path
+     *
+     * @param x - current node
+     * @param path - path
+     * @returns true if node in path, otherwise false
+     */
+    isNotVisited(x: number, path: number[]): boolean;
+    /**
+     * Finding paths in graph from given source to destination
+     *
+     * @param g - routes graph containing nodes & corresponding edges
+     * @param src - source node
+     * @param dst - destination node
+     * @returns paths
+     */
+    findPaths(g: number[][], src: number, dst: number): number[][];
+}

package/esbuild.mjs

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

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

@@ -0,0 +1,35 @@
+{
+  "name": "@galacticcouncil/sdk",
+  "version": "0.0.1-beta.1",
+  "private": false,
+  "description": "Galactic SDK",
+  "author": "Pavol Noha <palo@hydradx.io>",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "scripts": {
+    "test": "jest",
+    "build": "node ./esbuild.mjs && tsc --emitDeclarationOnly --outDir dist/types/",
+    "cleanup": "rimraf out && rimraf dist"
+  },
+  "devDependencies": {
+    "@types/jest": "^28.1.8",
+    "es-jest": "^2.0.0",
+    "esbuild": "^0.14.53",
+    "esbuild-plugin-resolve": "^1.0.3",
+    "esbuild-plugin-wasm": "^1.0.0",
+    "fs-extra": "^10.1.0",
+    "prettier": "^2.3.2",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^28.0.8",
+    "tsx": "^3.8.2",
+    "typescript": "^4.7.4"
+  },
+  "dependencies": {
+    "@polkadot/api": "^9.0.1",
+    "bignumber.js": "^9.1.0",
+    "capi": "^0.1.0-beta.12",
+    "hydra-dx-wasm": "https://github.com/galacticcouncil/HydraDX-wasm#0e3d625c22c32525a4619047223cac019c0cfa46",
+    "lodash.clonedeep": "^4.5.0"
+  }
+}

package/src/api/index.ts

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