@galacticcouncil/sdk-next 0.0.0

package/build/types/sor/TradeRouter.d.ts

@@ -0,0 +1,155 @@
+import { Router } from './Router';
+import { Trade } from './types';
+import { Hop } from '../pool';
+import { Amount } from '../types';
+export declare class TradeRouter extends Router {
+    /**
+     * Check whether trade is direct or not
+     *
+     * @param {Swap[]} swaps - trade route swaps
+     * @returns true if direct trade, otherwise false
+     */
+    private isDirectTrade;
+    /**
+     * Find the best sell swap without errors
+     *
+     * @param {SellSwap[]} swaps - all possible sell routes
+     * @returns best sell swap if exist, otherwise first one found
+     */
+    private findBestSellRoute;
+    /**
+     * Route fee range [min,max] in case pool is using dynamic fees
+     *
+     * @param {Swap[]} swaps - trade routes
+     * @returns min & max fee range if swapping through the pool with
+     * dynamic fees support
+     */
+    private getRouteFeeRange;
+    /**
+     * Pool fee range [min,max] in case pool is using dynamic fees
+     *
+     * @param {PoolFees} fees - pool fees
+     * @returns min & max fee range if swapping through the pool with
+     * dynamic fees support
+     */
+    private getPoolFeeRange;
+    /**
+     * Calculate and return best possible sell trade for assetIn>assetOut
+     *
+     * @param {number} assetIn - assetIn id
+     * @param {number} assetOut - assetOut id
+     * @param {bigint} amountIn - amount of assetIn to sell for assetOut
+     * @returns best possible sell trade of given token pair
+     */
+    getBestSell(assetIn: number, assetOut: number, amountIn: bigint | string): Promise<Trade>;
+    /**
+     * Calculate and return sell spot price for assetIn>assetOut
+     *
+     * @param route - best possible trade route (sell)
+     * @returns sell spot price
+     */
+    private getSellSpot;
+    /**
+     * Calculate and return sell trade for assetIn>assetOut
+     *
+     * @param {number} assetIn - assetIn id
+     * @param {number} assetOut - assetOut id
+     * @param {bigint} amountIn - amount of assetIn to sell for assetOut
+     * @param {Hop[]} route - explicit route to use for trade
+     * @returns sell trade of given token pair
+     */
+    getSell(assetIn: number, assetOut: number, amountIn: bigint | string, route?: Hop[]): Promise<Trade>;
+    /**
+     * Calculate the amount out for best possible trade if fees are zero
+     *
+     * @param amountIn - amount of assetIn to sell for assetOut
+     * @param route - best possible trade route (sell)
+     * @param poolsMap - pools map
+     * @returns the amount out for best possible trade if fees are zero
+     */
+    private calculateDelta0Y;
+    /**
+     * Calculate and return sell swaps for given path
+     * - final amount of previous swap is entry to next one
+     *
+     * @param amountIn - amount of assetIn to sell for assetOut
+     * @param path - current path
+     * @param poolsMap - pools map
+     * @returns sell swaps for given path
+     */
+    private toSellSwaps;
+    /**
+     * Calculate and return most liquid route for tokenIn>tokenOut
+     *
+     * To avoid routing through the pools with low liquidity, 0.1% from the
+     * most liquid pool asset is used as reference value to determine the
+     * sweet spot.
+     *
+     * @param {number} assetIn - assetIn id
+     * @param {number} assetOut - assetout id
+     * @return Most liquid route of given token pair
+     */
+    getMostLiquidRoute(assetIn: number, assetOut: number): Promise<Hop[]>;
+    /**
+     * Calculate and return best spot price for tokenIn>tokenOut
+     *
+     * @param {number} assetIn - assetIn id
+     * @param {number} assetOut - assetOut id
+     * @return best possible spot price of given asset pair, or undefined
+     * if given pair swap is not supported
+     */
+    getSpotPrice(assetIn: number, assetOut: number): Promise<Amount>;
+    /**
+     * Find the best buy swap without errors, if there is none return first one found
+     *
+     * @param {BuySwap[]} swaps - all possible buy routes
+     * @returns best buy swap if exist, otherwise first one found
+     */
+    private findBestBuyRoute;
+    /**
+     * Calculate and return best possible buy trade for assetIn>assetOut
+     *
+     * @param {number} assetIn - assetIn id
+     * @param {number} assetOut - assetOut id
+     * @param {bigint} amountOut - amount of tokenOut to buy for tokenIn
+     * @returns best possible buy trade of given token pair
+     */
+    getBestBuy(assetIn: number, assetOut: number, amountOut: bigint | string): Promise<Trade>;
+    /**
+     * Calculate and return buy spot price for assetIn>assetOut
+     *
+     * @param route - best possible trade route (buy)
+     * @returns buy spot price
+     */
+    private getBuySpot;
+    /**
+     * Calculate and return buy trade for assetIn>assetOut
+     *
+     * @param {number} assetIn - assetIn id
+     * @param {number} assetOut - assetOut id
+     * @param {bigint} amountOut - amount of assetOut to buy for assetIn
+     * @param {Hop[]} route - explicit route to use for trade
+     * @returns buy trade of given token pair
+     */
+    getBuy(assetIn: number, assetOut: number, amountOut: bigint | string, route?: Hop[]): Promise<Trade>;
+    /**
+     * Calculate the amount in for best possible trade if fees are zero
+     *
+     * @param amountOut - amount of assetOut to buy for assetIn
+     * @param bestRoute - best possible trade route (buy)
+     * @param poolsMap - pools map
+     * @returns the amount in for best possible trade if fees are zero
+     */
+    private calculateDelta0X;
+    /**
+     * Calculate and return buy swaps for given path
+     * - final amount of previous swap is entry to next one
+     * - calculation is done backwards (swaps in reversed order)
+     *
+     * @param amountOut - amount of assetOut to buy for assetIn
+     * @param path - current path
+     * @param poolsMap - pools map
+     * @returns buy swaps for given path
+     */
+    private toBuySwaps;
+}

package/build/types/sor/TradeUtils.d.ts

@@ -0,0 +1,12 @@
+import { Binary, PolkadotClient } from 'polkadot-api';
+import { Papi } from '../api';
+import { Trade } from './types';
+export declare class TradeUtils extends Papi {
+    constructor(client: PolkadotClient);
+    private isDirectOmnipoolTrade;
+    private tradeCheck;
+    buildBuyTx(trade: Trade, slippagePct?: number): Promise<Binary>;
+    buildSellTx(trade: Trade, slippagePct?: number): Promise<Binary>;
+    buildSellAllTx(trade: Trade, slippagePct?: number): Promise<Binary>;
+    private buildRoute;
+}

package/build/types/sor/index.d.ts

@@ -0,0 +1,4 @@
+export { Router } from './Router';
+export { TradeRouter } from './TradeRouter';
+export { TradeUtils } from './TradeUtils';
+export * from './types';

package/build/types/sor/route/bfs.d.ts

@@ -0,0 +1,37 @@
+export type Path = Node[];
+export 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 present in path or traversal within the same pool was already done
+     *
+     * @param x - current node
+     * @param path - path
+     * @returns true if node in path, otherwise false
+     */
+    isNotVisited(x: Node, 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: Map<number, 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, number, number][]): Map<number, Path>;
+}

package/build/types/sor/route/graph.d.ts

@@ -0,0 +1,12 @@
+import { PoolBase } from '../../pool';
+export type Edge = [address: string, from: number, to: number];
+export 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/build/types/sor/route/index.d.ts

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

package/build/types/sor/route/suggester.d.ts

@@ -0,0 +1,24 @@
+import { Edge } from './graph';
+import { PoolBase } from '../../pool';
+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: number, tokenOut: number | null, pools: PoolBase[]): Edge[][];
+    private parsePaths;
+    private toEdge;
+}

package/build/types/sor/types.d.ts

@@ -0,0 +1,31 @@
+import type { Hop, PoolBuy, PoolError, PoolSell } from '../pool';
+export interface Humanizer {
+    toHuman(): any;
+}
+export type Swap = Hop & Humanizer & {
+    assetInDecimals: number;
+    assetOutDecimals: number;
+    amountIn: bigint;
+    amountOut: bigint;
+    spotPrice: bigint;
+    tradeFeePct: number;
+    tradeFeeRange?: [number, number];
+    priceImpactPct: number;
+    errors: PoolError[];
+};
+export type SellSwap = Swap & PoolSell;
+export type BuySwap = Swap & PoolBuy;
+export declare enum TradeType {
+    Buy = "Buy",
+    Sell = "Sell"
+}
+export interface Trade extends Humanizer {
+    type: TradeType;
+    amountIn: bigint;
+    amountOut: bigint;
+    spotPrice: bigint;
+    tradeFee: bigint;
+    tradeFeePct: number;
+    priceImpactPct: number;
+    swaps: Swap[];
+}

package/build/types/types.d.ts

@@ -0,0 +1,40 @@
+import { XcmV3Junctions } from '@galacticcouncil/descriptors';
+export type Amount = {
+    amount: bigint;
+    decimals: number;
+};
+export interface AssetAmount {
+    id: number;
+    amount: bigint;
+}
+export interface AssetMetadata {
+    decimals: number;
+    symbol: string;
+}
+export type AssetType = 'StableSwap' | 'Bond' | 'Token' | 'External' | 'Erc20';
+export interface Asset extends AssetMetadata {
+    id: number;
+    name: string;
+    icon: string;
+    type: AssetType;
+    existentialDeposit: bigint;
+    isSufficient: boolean;
+    location?: XcmV3Multilocation;
+    meta?: Record<string, string>;
+    isWhiteListed?: boolean;
+}
+export interface Bond extends Asset {
+    underlyingAssetId: number;
+    maturity: number;
+}
+export interface ExternalAsset extends AssetMetadata {
+    id: string;
+    origin: number;
+    name: string;
+    internalId: number;
+    isWhiteListed?: boolean;
+}
+export type XcmV3Multilocation = {
+    parents: number;
+    interior: XcmV3Junctions;
+};

package/build/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/build/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/build/types/utils/big.d.ts

@@ -0,0 +1,3 @@
+import { RoundingMode } from 'big.js';
+export declare function toDecimal(amount: bigint, decimals: number, maxDecimal?: number, roundType?: RoundingMode): string;
+export declare function toBigInt(amount: string | number, decimals: number): bigint;

package/build/types/utils/erc20.d.ts

@@ -0,0 +1,5 @@
+export declare class ERC20Mapping {
+    static encodeEvmAddress(assetId: number): string;
+    static decodeEvmAddress(evmAddress: string): number;
+    static isAssetAddress(address: string): boolean;
+}

package/build/types/utils/evm.d.ts

@@ -0,0 +1,3 @@
+export declare function convertFromH160(h160addr: string, ss58prefix?: number): string;
+export declare function convertToH160(ss58addr: string): string;
+export declare function isEvmAccount(ss58addr: string): boolean;

package/build/types/utils/format.d.ts

@@ -0,0 +1,4 @@
+import { PoolFee } from '../pool';
+export declare function toPct(fee: PoolFee): number;
+export declare function toDecimals(fee: PoolFee): number;
+export declare function fromPermill(permill: number): PoolFee;

package/build/types/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * as big from './big';
+export * as erc20 from './erc20';
+export * as evm from './evm';
+export * as fmt from './format';
+export * as json from './json';
+export * as math from './math';
+export * as xc from './xc';

package/build/types/utils/json.d.ts

@@ -0,0 +1,3 @@
+export declare const findNestedKey: (obj: any, keyToFind: any) => any;
+export declare const findNestedObj: (obj: any, keyToFind: any, valToFind: any) => any;
+export declare const jsonFormatter: (_: any, nestedValue: any) => any;

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

@@ -0,0 +1,62 @@
+/**
+ * Percentage Difference Formula
+ *
+ * (|𝑉1−𝑉2| / [(𝑉1+𝑉2)/2]) × 100
+ *
+ * This formula calculates the percentage difference by comparing
+ * the absolute difference between the two values with their <b>average</b>.
+ *
+ * Usage: It's used when you want to find the percentage difference between
+ * two quantities where both quantities are significant.
+ *
+ * @param v1 - 1st value
+ * @param v2 - 2nd value
+ * @returns Difference between two values in relation to their average
+ */
+export declare function calculateDiffToAvg(v1: bigint, v2: bigint): number;
+/**
+ * Percentage Difference Formula (Relative Change)
+ *
+ * ((Vfin-Vref) / Vref) * 100
+ *
+ * This formula calculates the percentage difference by comparing
+ * the absolute difference between the two values with the <b>reference value</b>.
+ *
+ * Usage: This formula isn't suitable for finding percentage differences
+ * when the values being compared are not reference and final values of the
+ * same quantity.
+ *
+ * @param vFin - final value
+ * @param vRef - reference value
+ * @returns Difference between a final value and a reference value in relation to the reference value
+ */
+export declare function calculateDiffToRef(vFin: bigint, vRef: bigint): number;
+/**
+ * The total fee paid for a ‘sell’ transaction
+ * Suppose the trader is selling X for Y
+ *
+ * fee = 1 - (deltaY / delta0Y)
+ *
+ * @param delta0Y - the amount out if fees are zero
+ * @param deltaY - the amount out if the existing nonzero fees are included in the calculation
+ */
+export declare function calculateSellFee(delta0Y: bigint, deltaY: bigint): number;
+/**
+ * The total fee paid for a ‘buy‘ transaction
+ * Suppose the trader is buying Y using X
+ *
+ * fee = (deltaX / delta0X) - 1
+ *
+ * @param delta0X - the amount in if fees are zero
+ * @param deltaX - the amount in, inclusive of fees
+ */
+export declare function calculateBuyFee(delta0X: bigint, deltaX: bigint): number;
+/**
+ * Get % fraction from native value
+ *
+ * @param value - native amount
+ * @param pct - percentage value
+ * @param dp - safe decimals margin (2dp = 0.01%)
+ * @returns fraction of given amount
+ */
+export declare function getFraction(value: bigint, pct: number, dp?: number): bigint;

package/build/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/build/types/utils/xc.d.ts

@@ -0,0 +1 @@
+export declare function convertToId(xcAddress: string): number;

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@galacticcouncil/sdk-next",
+  "version": "0.0.0",
+  "description": "Galactic next gen sdk (papi)",
+  "author": "GalacticCouncil",
+  "repository": {
+    "directory": "packages/sdk-next",
+    "type": "git",
+    "url": "git+https://github.com/galacticcouncil/sdk.git"
+  },
+  "keywords": [
+    "hydration",
+    "api",
+    "router",
+    "sdk"
+  ],
+  "bugs": {
+    "url": "https://github.com/galacticcouncil/sdk/issues"
+  },
+  "files": [
+    "build"
+  ],
+  "main": "./build/index.cjs",
+  "module": "./build/index.mjs",
+  "types": "./build/types/index.d.ts",
+  "scripts": {
+    "build": "npm run clean && node ./esbuild.dist.mjs",
+    "build:watch": "node ./esbuild.dev.mjs",
+    "postbuild": "tsc --emitDeclarationOnly --outDir build/types/",
+    "clean": "rimraf build",
+    "link": "npm ln",
+    "test": "NODE_NO_WARNINGS=1 jest"
+  },
+  "devDependencies": {
+    "@types/big.js": "^6.2.2"
+  },
+  "dependencies": {
+    "@galacticcouncil/descriptors": "^1.1.1",
+    "@galacticcouncil/math-lbp": "^1.0.0",
+    "@galacticcouncil/math-liquidity-mining": "^1.0.0",
+    "@galacticcouncil/math-omnipool": "^1.1.0",
+    "@galacticcouncil/math-stableswap": "^2.0.0",
+    "@galacticcouncil/math-xyk": "^1.0.0",
+    "@noble/hashes": "^1.6.1",
+    "@thi.ng/cache": "^2.1.35",
+    "@thi.ng/memoize": "^4.0.2",
+    "big.js": "^6.2.1"
+  },
+  "peerDependencies": {
+    "polkadot-api": "^1.11.1",
+    "viem": "^2.23.7"
+  }
+}