@galacticcouncil/sdk-next 1.0.0-beta.0

package/build/types/pool/omni/OmniPool.d.ts

@@ -0,0 +1,45 @@
+import { BuyCtx, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
+export type OmniPoolPair = PoolPair & {
+    hubReservesIn: bigint;
+    hubReservesOut: bigint;
+    sharesIn: bigint;
+    sharesOut: bigint;
+    tradeableIn: number;
+    tradeableOut: number;
+};
+export type OmniPoolToken = PoolToken & {
+    cap: bigint;
+    hubReserves: bigint;
+    protocolShares: bigint;
+    shares: bigint;
+};
+export type OmniPoolFees = PoolFees & {
+    assetFee: PoolFee;
+    protocolFee: PoolFee;
+};
+export type OmniPoolBase = PoolBase & {
+    hubAssetId: number;
+};
+export declare class OmniPool implements Pool {
+    type: PoolType;
+    address: string;
+    tokens: OmniPoolToken[];
+    maxInRatio: bigint;
+    maxOutRatio: bigint;
+    minTradingLimit: bigint;
+    hubAssetId: number;
+    static fromPool(pool: OmniPoolBase): OmniPool;
+    constructor(address: string, tokens: OmniPoolToken[], maxInRation: bigint, maxOutRatio: bigint, minTradeLimit: bigint, hubAssetId: number);
+    validatePair(_tokenIn: number, tokenOut: number): boolean;
+    parsePair(tokenIn: number, tokenOut: number): OmniPoolPair;
+    validateAndBuy(poolPair: OmniPoolPair, amountOut: bigint, fees: OmniPoolFees): BuyCtx;
+    validateAndSell(poolPair: OmniPoolPair, amountIn: bigint, fees: OmniPoolFees): SellCtx;
+    calculateInGivenOut(poolPair: OmniPoolPair, amountOut: bigint, fees?: OmniPoolFees): bigint;
+    calculateLrnaInGivenOut(poolPair: OmniPoolPair, amountOut: bigint, fees?: OmniPoolFees): bigint;
+    calculateOutGivenIn(poolPair: OmniPoolPair, amountIn: bigint, fees?: OmniPoolFees): bigint;
+    calculateOutGivenLrnaIn(poolPair: OmniPoolPair, amountIn: bigint, fees?: OmniPoolFees): bigint;
+    spotPriceInGivenOut(poolPair: OmniPoolPair): bigint;
+    spotPriceLrnaInGivenOut(poolPair: OmniPoolPair): bigint;
+    spotPriceOutGivenIn(poolPair: OmniPoolPair): bigint;
+    spotPriceOutGivenLrnaIn(poolPair: OmniPoolPair): bigint;
+}

package/build/types/pool/omni/OmniPoolClient.d.ts

@@ -0,0 +1,13 @@
+import { type Observable } from 'rxjs';
+import { PoolType, PoolFees } from '../types';
+import { PoolClient } from '../PoolClient';
+import { OmniPoolBase } from './OmniPool';
+export declare class OmniPoolClient extends PoolClient<OmniPoolBase> {
+    protected loadPools(): Promise<OmniPoolBase[]>;
+    private getPoolAddress;
+    private getPoolLimits;
+    getPoolFees(_pool: OmniPoolBase, feeAsset: number): Promise<PoolFees>;
+    getPoolType(): PoolType;
+    isSupported(): Promise<boolean>;
+    subscribePoolChange(pool: OmniPoolBase): Observable<OmniPoolBase>;
+}

package/build/types/pool/omni/index.d.ts

@@ -0,0 +1,3 @@
+export * from './OmniMath';
+export * from './OmniPool';
+export * from './OmniPoolClient';

package/build/types/pool/stable/StableMath.d.ts

@@ -0,0 +1,14 @@
+export declare class StableMath {
+    static getPoolAddress(assetId: number): Uint8Array;
+    static defaultPegs(size: number): string[][];
+    static calculateAmplification(initialAmp: string, finalAmp: string, initialBlock: string, finalBlock: string, currentBlock: string): string;
+    static calculateInGivenOut(reserves: string, assetIn: number, assetOut: number, amountOut: string, amplification: string, fee: string, pegs: string): string;
+    static calculateAddOneAsset(reserves: string, shares: string, assetIn: number, amplification: string, shareIssuance: string, fee: string, pegs: string): string;
+    static calculateSharesForAmount(reserves: string, assetIn: number, amount: string, amplification: string, shareIssuance: string, fee: string, pegs: string): string;
+    static calculateOutGivenIn(reserves: string, assetIn: number, assetOut: number, amountIn: string, amplification: string, fee: string, pegs: string): string;
+    static calculateLiquidityOutOneAsset(reserves: string, shares: string, assetOut: number, amplification: string, shareIssuance: string, withdrawFee: string, pegs: string): string;
+    static calculateShares(reserves: string, assets: string, amplification: string, shareIssuance: string, fee: string, pegs: string): string;
+    static calculateSpotPriceWithFee(poolId: string, reserves: string, amplification: string, assetIn: string, assetOut: string, shareIssuance: string, fee: string, pegs: string): string;
+    static calculatePoolTradeFee(amount: string, feeNumerator: number, feeDenominator: number): string;
+    static recalculatePegs(currentPegs: string, targetPegs: string, currentBlock: string, maxPegUpdate: string, poolFee: string): string;
+}

package/build/types/pool/stable/StableSwap.d.ts

@@ -0,0 +1,46 @@
+import { BuyCtx, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
+export type StableSwapPair = PoolPair & {
+    tradeableIn: number;
+    tradeableOut: number;
+};
+export type StableSwapFees = PoolFees & {
+    fee: PoolFee;
+};
+export type StableSwapBase = PoolBase & {
+    amplification: bigint;
+    id: string;
+    fee: PoolFee;
+    totalIssuance: bigint;
+};
+export declare class StableSwap implements Pool {
+    type: PoolType;
+    address: string;
+    tokens: PoolToken[];
+    maxInRatio: bigint;
+    maxOutRatio: bigint;
+    minTradingLimit: bigint;
+    amplification: bigint;
+    id: number;
+    fee: PoolFee;
+    totalIssuance: bigint;
+    static fromPool(pool: StableSwapBase): StableSwap;
+    constructor(address: string, tokens: PoolToken[], maxInRation: bigint, maxOutRatio: bigint, minTradeLimit: bigint, amplification: bigint, id: number, fee: PoolFee, totalIssuance: bigint);
+    validatePair(_tokenIn: number, _tokenOut: number): boolean;
+    parsePair(tokenIn: number, tokenOut: number): StableSwapPair;
+    validateAndBuy(poolPair: StableSwapPair, amountOut: bigint, fees: StableSwapFees): BuyCtx;
+    validateAndSell(poolPair: StableSwapPair, amountIn: bigint, fees: StableSwapFees): SellCtx;
+    private calculateIn;
+    private calculateAddOneAsset;
+    private calculateSharesForAmount;
+    calculateInGivenOut(poolPair: PoolPair, amountOut: bigint, fees?: StableSwapFees): bigint;
+    spotPriceInGivenOut(poolPair: PoolPair): bigint;
+    private calculateOut;
+    private calculateWithdrawOneAsset;
+    private calculateShares;
+    calculateOutGivenIn(poolPair: PoolPair, amountIn: bigint, fees?: StableSwapFees): bigint;
+    spotPriceOutGivenIn(poolPair: PoolPair): bigint;
+    calculateTradeFee(amount: bigint, fees: StableSwapFees): bigint;
+    private getPegs;
+    private getReserves;
+    private getAssets;
+}

package/build/types/pool/stable/StableSwapClient.d.ts

@@ -0,0 +1,16 @@
+import { type Observable } from 'rxjs';
+import { PoolType, PoolFees } from '../types';
+import { PoolClient } from '../PoolClient';
+import { StableSwapBase } from './StableSwap';
+export declare class StableSwapClient extends PoolClient<StableSwapBase> {
+    private poolsData;
+    protected loadPools(): Promise<StableSwapBase[]>;
+    private getPoolDelta;
+    private getPoolTokens;
+    private getPoolAddress;
+    private getPoolLimits;
+    getPoolFees(pool: StableSwapBase): Promise<PoolFees>;
+    getPoolType(): PoolType;
+    isSupported(): Promise<boolean>;
+    subscribePoolChange(pool: StableSwapBase): Observable<StableSwapBase>;
+}

package/build/types/pool/stable/index.d.ts

@@ -0,0 +1,3 @@
+export * from './StableMath';
+export * from './StableSwap';
+export * from './StableSwapClient';

package/build/types/pool/types.d.ts

@@ -0,0 +1,84 @@
+import type { AssetType } from '../types';
+export declare enum PoolType {
+    Aave = "Aave",
+    LBP = "LBP",
+    Omni = "Omnipool",
+    Stable = "Stableswap",
+    XYK = "XYK"
+}
+export declare enum PoolError {
+    InsufficientTradingAmount = "InsufficientTradingAmount",
+    MaxInRatioExceeded = "MaxInRatioExceeded",
+    MaxOutRatioExceeded = "MaxOutRatioExceeded",
+    TradeNotAllowed = "TradeNotAllowed",
+    UnknownError = "UnknownError"
+}
+export interface PoolPair {
+    assetIn: number;
+    assetOut: number;
+    decimalsIn: number;
+    decimalsOut: number;
+    balanceIn: bigint;
+    balanceOut: bigint;
+    assetInEd: bigint;
+    assetOutEd: bigint;
+}
+export type PoolBase = {
+    address: string;
+    id?: number;
+    type: PoolType;
+    tokens: PoolToken[];
+    maxInRatio: bigint;
+    maxOutRatio: bigint;
+    minTradingLimit: bigint;
+};
+export interface PoolToken {
+    id: number;
+    balance: bigint;
+    decimals?: number;
+    existentialDeposit: bigint;
+    tradeable?: number;
+    type: AssetType;
+}
+export type PoolTokenOverride = Pick<PoolToken, 'id' | 'decimals'>;
+export type PoolLimits = Pick<PoolBase, 'maxInRatio' | 'maxOutRatio' | 'minTradingLimit'>;
+export type PoolFee = [numerator: number, denominator: number];
+export type PoolFees = {
+    min?: PoolFee;
+    max?: PoolFee;
+};
+export type PoolSell = {
+    calculatedOut: bigint;
+};
+export type PoolBuy = {
+    calculatedIn: bigint;
+};
+export type PoolSwap = {
+    amountIn: bigint;
+    amountOut: bigint;
+    feePct: number;
+    errors: PoolError[];
+};
+export type SellCtx = PoolSwap & PoolSell;
+export type BuyCtx = PoolSwap & PoolBuy;
+export interface Pool extends PoolBase {
+    validatePair(tokenIn: number, tokenOut: number): boolean;
+    parsePair(tokenIn: number, tokenOut: number): PoolPair;
+    validateAndBuy(poolPair: PoolPair, amountOut: bigint, dynamicFees: PoolFees | null): BuyCtx;
+    validateAndSell(poolPair: PoolPair, amountOut: bigint, dynamicFees: PoolFees | null): SellCtx;
+    calculateInGivenOut(poolPair: PoolPair, amountOut: bigint): bigint;
+    calculateOutGivenIn(poolPair: PoolPair, amountIn: bigint): bigint;
+    spotPriceInGivenOut(poolPair: PoolPair): bigint;
+    spotPriceOutGivenIn(poolPair: PoolPair): bigint;
+}
+export interface IPoolCtxProvider {
+    getPools(): Promise<PoolBase[]>;
+    getPoolFees(pool: PoolBase, feeAsset: number): Promise<PoolFees>;
+}
+export type Hop = {
+    pool: PoolType;
+    poolAddress: string;
+    poolId?: number;
+    assetIn: number;
+    assetOut: number;
+};

package/build/types/pool/xyk/XykMath.d.ts

@@ -0,0 +1,12 @@
+export declare class XykMath {
+    static getSpotPrice(balanceA: string, balanceB: string, amount: string): string;
+    static calculateInGivenOut(balanceIn: string, balanceOut: string, amountOut: string): string;
+    static calculateOutGivenIn(balanceIn: string, balanceOut: string, amountIn: string): string;
+    static calculatePoolTradeFee(amount: string, feeNumerator: number, feeDenominator: number): string;
+    static calculateLiquidityIn(reserveA: string, reserveB: string, amountA: string): string;
+    static calculateSpotPrice(balanceA: string, balanceB: string): string;
+    static calculateSpotPriceWithFee(balanceA: string, balanceB: string, feeNumerator: string, feeDenominator: string): string;
+    static calculateShares(reserveA: string, amountA: string, totalShares: string): string;
+    static calculateLiquidityOutAssetA(reserveA: string, reserveB: string, shares: string, totalShares: string): string;
+    static calculateLiquidityOutAssetB(reserveA: string, reserveB: string, shares: string, totalShares: string): string;
+}

package/build/types/pool/xyk/XykPool.d.ts

@@ -0,0 +1,23 @@
+import { BuyCtx, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
+export type XykPoolFees = PoolFees & {
+    exchangeFee: PoolFee;
+};
+export declare class XykPool implements Pool {
+    type: PoolType;
+    address: string;
+    tokens: PoolToken[];
+    maxInRatio: bigint;
+    maxOutRatio: bigint;
+    minTradingLimit: bigint;
+    static fromPool(pool: PoolBase): XykPool;
+    constructor(address: string, tokens: PoolToken[], maxInRation: bigint, maxOutRatio: bigint, minTradeLimit: bigint);
+    validatePair(_tokenIn: number, _tokenOut: number): boolean;
+    parsePair(tokenIn: number, tokenOut: number): PoolPair;
+    validateAndBuy(poolPair: PoolPair, amountOut: bigint, fees: XykPoolFees): BuyCtx;
+    validateAndSell(poolPair: PoolPair, amountIn: bigint, fees: XykPoolFees): SellCtx;
+    calculateInGivenOut(poolPair: PoolPair, amountOut: bigint): bigint;
+    calculateOutGivenIn(poolPair: PoolPair, amountIn: bigint): bigint;
+    spotPriceInGivenOut(poolPair: PoolPair): bigint;
+    spotPriceOutGivenIn(poolPair: PoolPair): bigint;
+    calculateTradeFee(amount: bigint, fees: XykPoolFees): bigint;
+}

package/build/types/pool/xyk/XykPoolClient.d.ts

@@ -0,0 +1,12 @@
+import { type Observable } from 'rxjs';
+import { PoolBase, PoolType, PoolFees } from '../types';
+import { PoolClient } from '../PoolClient';
+export declare class XykPoolClient extends PoolClient<PoolBase> {
+    protected loadPools(): Promise<PoolBase[]>;
+    private getExchangeFee;
+    private getPoolLimits;
+    getPoolFees(): Promise<PoolFees>;
+    getPoolType(): PoolType;
+    isSupported(): Promise<boolean>;
+    subscribePoolChange(pool: PoolBase): Observable<PoolBase>;
+}

package/build/types/pool/xyk/index.d.ts

@@ -0,0 +1,3 @@
+export * from './XykMath';
+export * from './XykPool';
+export * from './XykPoolClient';

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

@@ -0,0 +1,66 @@
+import { Hop, IPoolCtxProvider, Pool, PoolBase, PoolType } from '../pool';
+export type RouterOptions = {
+    useOnly: PoolType[];
+};
+export declare class Router {
+    private readonly routeSuggester;
+    private readonly routerOptions;
+    protected readonly ctx: IPoolCtxProvider;
+    private readonly defaultRouterOptions;
+    constructor(ctx: IPoolCtxProvider, routerOptions?: RouterOptions);
+    /**
+     * List trading pools
+     */
+    getPools(): Promise<PoolBase[]>;
+    /**
+     * List all possible trading routes for given pair
+     *
+     * @param {number} assetIn - assetIn id
+     * @param {number} assetOut - assetOut id
+     */
+    getRoutes(assetIn: number, assetOut: number): Promise<Hop[][]>;
+    /**
+     * List tradeable assets
+     */
+    getTradeableAssets(): Promise<number[]>;
+    /**
+     * Ckeck if asset pair is valid
+     *
+     * @param {number} assetIn - assetIn id
+     * @param {number} assetOut - assetOut id
+     * @param {PoolBase[]} pools - trading pools
+     */
+    protected validateInput(assetIn: number, assetOut: number, pools: PoolBase[]): Map<string, Pool>;
+    /**
+     * List tradeable assets ASC
+     *
+     * @param {PoolBase[]} pools - trading pools
+     */
+    protected getAssets(pools: PoolBase[]): Set<number>;
+    /**
+     * List all possible routes between assetIn & assetOut
+     *
+     * @param {number} assetIn - assetIn id
+     * @param {number} assetOut - assetOut id
+     * @param {PoolBase[]} pools - trading pools
+     */
+    protected getPaths(assetIn: number, assetOut: number | null, pools: PoolBase[]): Hop[][];
+    /**
+     * Check if path is valid -> all edges are valid asset pairs
+     *
+     * @param proposedPath - proposed path
+     * @param poolsMap - pools map
+     * @returns only valid paths
+     */
+    private validPath;
+    /**
+     * Check if edge (asset pair) of corresponding pool is valid
+     *
+     * @param edge - current edge (asset pair)
+     * @param poolsMap - pools map
+     * @returns true if edge (asset pair) is valid, otherwise false
+     */
+    private validEdge;
+    private toPoolsMap;
+    private toHops;
+}

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 {string} assetIn - assetIn id
+     * @param {string} 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 {string} assetIn - assetIn id
+     * @param {string} 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 tokenOut to buy for tokenIn
+     * @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[];
+}