@galacticcouncil/sdk-next 0.0.0

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

@@ -0,0 +1,24 @@
+import { BuyCtx, Pool, PoolBase, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
+import { XcmV3Multilocation } from '../../types';
+export type AavePoolToken = PoolToken & {
+    location: XcmV3Multilocation;
+};
+export declare class AavePool implements Pool {
+    type: PoolType;
+    address: string;
+    tokens: AavePoolToken[];
+    maxInRatio: bigint;
+    maxOutRatio: bigint;
+    minTradingLimit: bigint;
+    static fromPool(pool: PoolBase): AavePool;
+    constructor(address: string, tokens: AavePoolToken[], maxInRation: bigint, maxOutRatio: bigint, minTradeLimit: bigint);
+    validatePair(_tokenIn: number, _tokenOut: number): boolean;
+    parsePair(tokenIn: number, tokenOut: number): PoolPair;
+    validateAndBuy(poolPair: PoolPair, amountOut: bigint, _fees: PoolFees): BuyCtx;
+    validateAndSell(poolPair: PoolPair, amountIn: bigint, _fees: PoolFees): 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: PoolFees): bigint;
+}

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

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+import { PoolBase, PoolFees, PoolType } from '../types';
+import { PoolClient } from '../PoolClient';
+export declare class AavePoolClient extends PoolClient<PoolBase> {
+    loadPools(): Promise<PoolBase[]>;
+    private getPoolDelta;
+    private getPoolId;
+    private getPoolLimits;
+    getPoolFees(_pool: PoolBase, _feeAsset: number): Promise<PoolFees>;
+    getPoolType(): PoolType;
+    isSupported(): Promise<boolean>;
+    subscribePoolChange(pool: PoolBase): Observable<PoolBase>;
+    private getReserveH160Id;
+}

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

@@ -0,0 +1,2 @@
+export * from './AavePool';
+export * from './AavePoolClient';

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

@@ -0,0 +1,8 @@
+export { PoolFactory } from './PoolFactory';
+export { PoolContextProvider } from './PoolContextProvider';
+export * as aave from './aave';
+export * as xyk from './xyk';
+export * as omni from './omni';
+export * as lbp from './lbp';
+export * as stable from './stable';
+export * from './types';

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

@@ -0,0 +1,7 @@
+export declare class LbpMath {
+    static getSpotPrice(balanceA: string, balanceB: string, weightA: string, weightB: string, amount: string): string;
+    static calculateInGivenOut(balanceIn: string, balanceOut: string, weightIn: string, weightOut: string, amountOut: string): string;
+    static calculateOutGivenIn(balanceIn: string, balanceOut: string, weightIn: string, weightOut: string, amountIn: string): string;
+    static calculateLinearWeights(start: string, end: string, initialWeight: string, finalWeight: string, at: string): string;
+    static calculatePoolTradeFee(amount: string, feeNumerator: number, feeDenominator: number): string;
+}

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

@@ -0,0 +1,49 @@
+import { BuyCtx, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
+export type WeightedPoolPair = PoolPair & {
+    weightIn: bigint;
+    weightOut: bigint;
+};
+export type WeightedPoolToken = PoolToken & {
+    weight: bigint;
+};
+export type LbpPoolFees = PoolFees & {
+    exchangeFee: PoolFee;
+    repayFee: PoolFee;
+};
+export type LbpPoolBase = PoolBase & {
+    fee: PoolFee;
+    repayFeeApply: boolean;
+};
+export declare class LbpPool implements Pool {
+    type: PoolType;
+    address: string;
+    tokens: WeightedPoolToken[];
+    maxInRatio: bigint;
+    maxOutRatio: bigint;
+    minTradingLimit: bigint;
+    fee: PoolFee;
+    repayFeeApply: boolean;
+    static fromPool(pool: LbpPoolBase): LbpPool;
+    constructor(address: string, tokens: WeightedPoolToken[], maxInRatio: bigint, maxOutRatio: bigint, minTradingLimit: bigint, fee: PoolFee, repayFeeApply: boolean);
+    validatePair(_tokenIn: number, _tokenOut: number): boolean;
+    parsePair(tokenIn: number, tokenOut: number): WeightedPoolPair;
+    /**
+     * Validate buy transfer
+     *
+     * a) Accumulated asset is bought (out) from the pool for distributed asset (in) - User(Buyer) bears the fee
+     * b) Distributed asset is bought (out) from the pool for accumualted asset (in) - Pool bears the fee
+     */
+    validateAndBuy(poolPair: WeightedPoolPair, amountOut: bigint, fees: LbpPoolFees): BuyCtx;
+    /**
+     * Validate sell transfer
+     *
+     * a) Accumulated asset is sold (in) to the pool for distributed asset (out) - Pool bears the fee
+     * b) Distributed asset is sold (in) to the pool for accumualted asset (out) - User(Seller) bears the fee
+     */
+    validateAndSell(poolPair: WeightedPoolPair, amountIn: bigint, fees: LbpPoolFees): SellCtx;
+    calculateInGivenOut(poolPair: WeightedPoolPair, amountOut: bigint): bigint;
+    calculateOutGivenIn(poolPair: WeightedPoolPair, amountIn: bigint): bigint;
+    spotPriceInGivenOut(poolPair: WeightedPoolPair): bigint;
+    spotPriceOutGivenIn(poolPair: WeightedPoolPair): bigint;
+    calculateTradeFee(amount: bigint, fees: LbpPoolFees): bigint;
+}

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

@@ -0,0 +1,18 @@
+import { type Observable } from 'rxjs';
+import { PoolType, PoolFees } from '../types';
+import { PoolClient } from '../PoolClient';
+import { LbpPoolBase } from './LbpPool';
+export declare class LbpPoolClient extends PoolClient<LbpPoolBase> {
+    private readonly MAX_FINAL_WEIGHT;
+    private poolsData;
+    protected loadPools(): Promise<LbpPoolBase[]>;
+    private getPoolDelta;
+    private isActivePool;
+    private isRepayFeeApplied;
+    private getRepayFee;
+    private getPoolLimits;
+    getPoolFees(pool: LbpPoolBase): Promise<PoolFees>;
+    getPoolType(): PoolType;
+    isSupported(): Promise<boolean>;
+    subscribePoolChange(pool: LbpPoolBase): Observable<LbpPoolBase>;
+}

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

@@ -0,0 +1,3 @@
+export * from './LbpMath';
+export * from './LbpPool';
+export * from './LbpPoolClient';

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

@@ -0,0 +1,19 @@
+export declare class OmniMath {
+    static calculateSpotPrice(assetInBalance: string, assetInHubReserve: string, assetOutBalance: string, assetOutHubReserve: string): string;
+    static calculateLrnaSpotPrice(assetBalance: string, assetHubReserve: string): string;
+    static calculateInGivenOut(assetInBalance: string, assetInHubReserve: string, assetInShares: string, assetOutBalance: string, assetOutHubReserve: string, assetOutShares: string, amountOut: string, assetFee: string, protocolFee: string): string;
+    static calculateLrnaInGivenOut(assetOutBalance: string, assetOutHubReserve: string, assetOutShares: string, amountOut: string, assetFee: string): string;
+    static calculateOutGivenIn(assetInBalance: string, assetInHubReserve: string, assetInShares: string, assetOutBalance: string, assetOutHubReserve: string, assetOutShares: string, amountIn: string, assetFee: string, protocolFee: string): string;
+    static calculateOutGivenLrnaIn(assetOutBalance: string, assetOutHubReserve: string, assetOutShares: string, amountOut: string, assetFee: string): string;
+    static calculatePoolTradeFee(amount: string, feeNumerator: number, feeDenominator: number): string;
+    static calculateShares(assetReserve: string, assetHubReserve: string, assetShares: string, amountIn: string): string;
+    static calculateLiquidityOut(assetReserve: string, assetHubReserve: string, assetShares: string, positionAmount: string, positionShares: string, positionPrice: string, sharesToRemove: string, withdrawalFee: string): string;
+    static calculateLiquidityLRNAOut(assetReserve: string, assetHubReserve: string, assetShares: string, positionAmount: string, positionShares: string, positionPrice: string, sharesToRemove: string, withdrawalFee: string): string;
+    static calculateCapDifference(assetReserve: string, assetHubReserve: string, assetCap: string, totalHubReserve: string): string;
+    static verifyAssetCap(assetReserve: string, assetCap: string, hubAdded: string, totalHubReserve: string): boolean;
+    static calculateLimitHubIn(assetReserve: string, assetHubReserve: string, assetShares: string, amountIn: string): string;
+    static isSellAllowed(bits: number): boolean;
+    static isBuyAllowed(bits: number): boolean;
+    static isAddLiquidityAllowed(bits: number): boolean;
+    static isRemoveLiquidityAllowed(bits: number): boolean;
+}

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;
+}