@galacticcouncil/sdk-next 0.8.0-pr203-9b6a8a3 → 0.8.0

package/build/types/oracle/abi.d.ts

@@ -85,3 +85,112 @@ export declare const AGGREGATOR_V3_ABI: readonly [{
     readonly stateMutability: "view";
     readonly type: "function";
 }];
+export declare const DIA_ORACLE_ABI: readonly [{
+    readonly inputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "string";
+        readonly name: "key";
+        readonly type: "string";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint128";
+        readonly name: "value";
+        readonly type: "uint128";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint128";
+        readonly name: "timestamp";
+        readonly type: "uint128";
+    }];
+    readonly name: "OracleUpdate";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "address";
+        readonly name: "newUpdater";
+        readonly type: "address";
+    }];
+    readonly name: "UpdaterAddressChange";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "key";
+        readonly type: "string";
+    }];
+    readonly name: "getValue";
+    readonly outputs: readonly [{
+        readonly internalType: "uint128";
+        readonly name: "";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "";
+        readonly type: "uint128";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string[]";
+        readonly name: "keys";
+        readonly type: "string[]";
+    }, {
+        readonly internalType: "uint256[]";
+        readonly name: "compressedValues";
+        readonly type: "uint256[]";
+    }];
+    readonly name: "setMultipleValues";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "key";
+        readonly type: "string";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "value";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "timestamp";
+        readonly type: "uint128";
+    }];
+    readonly name: "setValue";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "newOracleUpdaterAddress";
+        readonly type: "address";
+    }];
+    readonly name: "updateOracleUpdaterAddress";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly name: "values";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];

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

@@ -1,2 +1,3 @@
 export { MmOracleClient } from './MmOracleClient';
+export * from './abi';
 export * from './types';

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

@@ -1,29 +1,29 @@
 import { PolkadotClient } from 'polkadot-api';
-import { type Observable } from 'rxjs';
+import { Observable, Subscription } from 'rxjs';
 import { BalanceClient } from '../client';
 import { EvmClient } from '../evm';
-import { MmOracleClient } from '../oracle';
-import { PoolBase, PoolFees, PoolTokenOverride, PoolType } from './types';
+import { PoolBase, PoolFees, PoolPair, PoolType } from './types';
+import { PoolStore } from './PoolStore';
 export declare abstract class PoolClient<T extends PoolBase> extends BalanceClient {
     protected evm: EvmClient;
-    protected mmOracle: MmOracleClient;
-    private override;
+    protected store: PoolStore<T>;
+    private shared$?;
     private mem;
+    private memPoolsCache;
     private memPools;
     constructor(client: PolkadotClient, evm: EvmClient);
-    protected abstract loadPools(): Promise<T[]>;
-    abstract getPoolFees(pool: T, feeAsset: number): Promise<PoolFees>;
-    abstract getPoolType(): PoolType;
     abstract isSupported(): Promise<boolean>;
-    abstract subscribePoolChange(pool: T): Observable<T>;
-    withOverride(override?: PoolTokenOverride[]): Promise<void>;
-    getPoolsMem(): Promise<T[]>;
+    abstract getPoolFees(pair: PoolPair, address: string): Promise<PoolFees>;
+    abstract getPoolType(): PoolType;
+    protected abstract loadPools(): Promise<T[]>;
+    protected abstract subscribeUpdates(): Subscription;
+    private getMemPools;
     getPools(): Promise<T[]>;
-    getSubscriber(): Observable<T>;
-    private subscribe;
-    private subscribePoolBalance;
+    getSubscriber(): Observable<T[]>;
+    private subscribeStore;
+    protected subscribeBalances(): Subscription;
     private hasSystemAsset;
     private hasErc20Asset;
     private hasValidAssets;
-    private updatePool;
+    private updateBalances;
 }

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

@@ -1,22 +1,27 @@
 import { PolkadotClient } from 'polkadot-api';
 import { Papi } from '../api';
 import { EvmClient } from '../evm';
-import { IPoolCtxProvider, PoolBase, PoolFees, PoolFilter, PoolTokenOverride } from './types';
+import { AavePoolClient } from './aave';
+import { LbpPoolClient } from './lbp';
+import { OmniPoolClient } from './omni';
+import { XykPoolClient } from './xyk';
+import { StableSwapClient } from './stable';
+import { IPoolCtxProvider, Pool, PoolBase, PoolFees, PoolPair, PoolTokenOverride } from './types';
 export declare class PoolContextProvider extends Papi implements IPoolCtxProvider {
     readonly evm: EvmClient;
-    private readonly lbpClient;
-    private readonly omniClient;
-    private readonly stableClient;
-    private readonly xykClient;
-    private readonly aaveClient;
+    readonly aave: AavePoolClient;
+    readonly omnipool: OmniPoolClient;
+    readonly stableswap: StableSwapClient;
+    readonly xyk: XykPoolClient;
+    readonly lbp: LbpPoolClient;
     private readonly active;
-    private readonly clients;
     private readonly pools;
-    private lbpSub;
+    private readonly clients;
+    private aaveSub;
     private omniSub;
     private stableSub;
     private xykSub;
-    private aaveSub;
+    private lbpSub;
     private isReady;
     private isDestroyed;
     constructor(client: PolkadotClient, evm: EvmClient);
@@ -27,7 +32,6 @@ export declare class PoolContextProvider extends Papi implements IPoolCtxProvide
     withAave(): this;
     withXyk(override?: PoolTokenOverride[]): this;
     destroy(): void;
-    getPools(filter?: PoolFilter): Promise<PoolBase[]>;
-    private getFilteredPools;
-    getPoolFees(pool: PoolBase, feeAsset: number): Promise<PoolFees>;
+    getPools(): Promise<PoolBase[]>;
+    getPoolFees(poolPair: PoolPair, pool: Pool): Promise<PoolFees>;
 }

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

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+import { PoolBase } from './types';
+export declare class PoolStore<T extends PoolBase> {
+    private store$;
+    private updateQueue;
+    private changeset;
+    get pools(): readonly T[];
+    asObservable(): Observable<T[]>;
+    applyChangeset(state: T[]): T[];
+    set(next: T[]): void;
+    /**
+     * Apply a batched mutation to the store.
+     *
+     * Updates are applied one at a time in call order (internally queued).
+     *
+     * @param patch - update callback
+     */
+    update(patch: (state: readonly T[]) => T[] | Promise<T[]>): void;
+    destroy(): void;
+}

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

@@ -1,14 +1,19 @@
-import { Observable } from 'rxjs';
+import { Subscription } 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 getPoolId;
+    private getPoolLimits;
+    loadPools(): Promise<PoolBase[]>;
+    private getPoolDelta;
+    getPoolFees(): Promise<PoolFees>;
     private getReserveH160Id;
+    private parseRouterLog;
+    private parseEvmLog;
+    private subscribeRouterExecuted;
+    private subscribeEvmLog;
+    protected subscribeBalances(): Subscription;
+    protected subscribeUpdates(): Subscription;
 }

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

@@ -0,0 +1,13 @@
+import { HydrationEvents } from '@galacticcouncil/descriptors';
+export type TEvmPayload = HydrationEvents['EVM']['Log'];
+export type TEvmEvent = {
+    eventName: string;
+    reserve: string;
+    key: string;
+};
+export type TRouterExecutedPayload = HydrationEvents['Router']['Executed'];
+export type TRouterEvent = {
+    assetIn: number;
+    assetOut: number;
+    key: string;
+};

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

@@ -1,18 +1,20 @@
-import { type Observable } from 'rxjs';
-import { PoolType, PoolFees } from '../types';
+import { Subscription } from 'rxjs';
+import { PoolType, PoolFees, PoolPair } from '../types';
 import { PoolClient } from '../PoolClient';
 import { LbpPoolBase } from './LbpPool';
 export declare class LbpPoolClient extends PoolClient<LbpPoolBase> {
     private readonly MAX_FINAL_WEIGHT;
     private poolsData;
+    getPoolType(): PoolType;
+    private getPoolLimits;
+    private getPoolWeights;
+    isSupported(): Promise<boolean>;
     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>;
+    getPoolFees(_pair: PoolPair, address: string): Promise<PoolFees>;
+    private subscribeValidationData;
+    protected subscribeUpdates(): Subscription;
 }

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

@@ -9,10 +9,12 @@ export declare class OmniMath {
     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;
+    static recalculateAssetFee(oracleAmountIn: string, oracleAmountOut: string, oracleLiquidity: string, oraclePeriod: string, currentAssetLiquidity: string, previousFee: string, blocDifference: string, minFee: string, maxFee: string, decay: string, amplification: string): string;
+    static recalculateProtocolFee(oracleAmountIn: string, oracleAmountOut: string, oracleLiquidity: string, oraclePeriod: string, currentAssetLiquidity: string, previousFee: string, blocDifference: string, minFee: string, maxFee: string, decay: string, amplification: string): string;
+    static verifyAssetCap(assetReserve: string, assetCap: string, hubAdded: string, totalHubReserve: string): boolean;
 }

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

@@ -1,13 +1,27 @@
-import { type Observable } from 'rxjs';
-import { PoolType, PoolFees } from '../types';
+import { Subscription } from 'rxjs';
 import { PoolClient } from '../PoolClient';
-import { OmniPoolBase } from './OmniPool';
+import { PoolType, PoolPair } from '../types';
+import { OmniPoolBase, OmniPoolFees } from './OmniPool';
 export declare class OmniPoolClient extends PoolClient<OmniPoolBase> {
-    protected loadPools(): Promise<OmniPoolBase[]>;
+    private queryBus;
+    private block;
+    private dynamicFeesConfig;
+    private dynamicFees;
+    private emaOracles;
+    getPoolType(): PoolType;
     private getPoolAddress;
+    private getOraclePair;
     private getPoolLimits;
-    getPoolFees(_pool: OmniPoolBase, feeAsset: number): Promise<PoolFees>;
-    getPoolType(): PoolType;
     isSupported(): Promise<boolean>;
-    subscribePoolChange(pool: OmniPoolBase): Observable<OmniPoolBase>;
+    protected loadPools(): Promise<OmniPoolBase[]>;
+    getPoolFees(pair: PoolPair): Promise<OmniPoolFees>;
+    private getAssetFee;
+    private getProtocolFee;
+    private subscribeEmaOracles;
+    private subscribeDynamicFees;
+    private subscribeDynamicFeesConfig;
+    private subscribeBlock;
+    private subscribeAssets;
+    protected subscribeUpdates(): Subscription;
+    private updateTokenState;
 }

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

@@ -0,0 +1,10 @@
+import { FixedSizeArray } from 'polkadot-api';
+import { HydrationConstants, HydrationQueries } from '@galacticcouncil/descriptors';
+export type TDynamicFees = HydrationQueries['DynamicFees']['AssetFee']['Value'];
+export type TDynamicFeesConfig = HydrationQueries['DynamicFees']['AssetFeeConfiguration']['Value'];
+export type TDynamicFeeRange = [number, number, number];
+export type TAssetFeeParams = HydrationConstants['DynamicFees']['AssetFeeParameters'];
+export type TProtocolFeeParams = HydrationConstants['DynamicFees']['ProtocolFeeParameters'];
+export type TEmaOracle = HydrationQueries['EmaOracle']['Oracles']['Value'];
+export type TEmaPair = FixedSizeArray<2, number>;
+export type TOmnipoolAsset = HydrationQueries['Omnipool']['Assets']['Value'];

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

@@ -1,4 +1,4 @@
-import { BuyCtx, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
+import { BuyCtx, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolPegs, PoolToken, PoolType, SellCtx } from '../types';
 export type StableSwapPair = PoolPair & {
     tradeableIn: number;
     tradeableOut: number;
@@ -8,11 +8,11 @@ export type StableSwapFees = PoolFees & {
 };
 export type StableSwapBase = PoolBase & {
     amplification: bigint;
+    isRampPeriod: boolean;
     id: number;
     fee: PoolFee;
     totalIssuance: bigint;
-    pegs: string[][];
-    pegsFee: PoolFee;
+    pegs: PoolPegs;
 };
 export declare class StableSwap implements Pool {
     type: PoolType;
@@ -22,11 +22,13 @@ export declare class StableSwap implements Pool {
     maxOutRatio: bigint;
     minTradingLimit: bigint;
     amplification: bigint;
+    isRampPeriod: boolean;
     id: number;
     fee: PoolFee;
     totalIssuance: bigint;
+    pegs: string[][];
     static fromPool(pool: StableSwapBase): StableSwap;
-    constructor(address: string, tokens: PoolToken[], maxInRation: bigint, maxOutRatio: bigint, minTradeLimit: bigint, amplification: bigint, id: number, fee: PoolFee, totalIssuance: bigint);
+    constructor(address: string, tokens: PoolToken[], maxInRation: bigint, maxOutRatio: bigint, minTradeLimit: bigint, amplification: bigint, isRampPeriod: boolean, id: number, fee: PoolFee, totalIssuance: bigint, pegs: PoolPegs);
     validatePair(_tokenIn: number, _tokenOut: number): boolean;
     parsePair(tokenIn: number, tokenOut: number): StableSwapPair;
     validateAndBuy(poolPair: StableSwapPair, amountOut: bigint, fees: StableSwapFees): BuyCtx;

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

@@ -1,20 +1,23 @@
-import { type Observable } from 'rxjs';
-import { PoolType, PoolFees } from '../types';
+import { Subscription } from 'rxjs';
+import { PoolType, PoolFees, PoolPair } from '../types';
 import { PoolClient } from '../PoolClient';
 import { StableSwapBase } from './StableSwap';
+import { TStableswap } from './types';
 export declare class StableSwapClient extends PoolClient<StableSwapBase> {
-    private poolsData;
+    protected poolsData: Map<number, TStableswap>;
     getPoolType(): PoolType;
     private getPoolAddress;
     private getPoolLimits;
-    private getPoolDelta;
+    private getPoolAmplification;
     private getPoolTokens;
     isSupported(): Promise<boolean>;
     protected loadPools(): Promise<StableSwapBase[]>;
-    getPoolFees(pool: StableSwapBase): Promise<PoolFees>;
-    private getPoolPegs;
+    getPoolFees(_pair: PoolPair, address: string): Promise<PoolFees>;
     private getDefaultPegs;
     private getRecentPegs;
-    private getLatestPegs;
-    subscribePoolChange(pool: StableSwapBase): Observable<StableSwapBase>;
+    private subscribeIssuance;
+    private subscribePoolPegs;
+    private subscribeBlock;
+    protected subscribeUpdates(): Subscription;
+    private hasOnRamps;
 }

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

@@ -0,0 +1,15 @@
+import { Enum, FixedSizeArray, FixedSizeBinary } from 'polkadot-api';
+import { HydrationQueries } from '@galacticcouncil/descriptors';
+export type TStableswap = HydrationQueries['Stableswap']['Pools']['Value'];
+export type TStableswapPeg = HydrationQueries['Stableswap']['PoolPegs']['Value'];
+export type TEmaOracle = HydrationQueries['EmaOracle']['Oracles']['Value'];
+export type TEmaName = FixedSizeBinary<8>;
+export type TEmaPair = FixedSizeArray<2, number>;
+export type TEmaPeriod = Enum<{
+    LastBlock: undefined;
+    Short: undefined;
+    TenMinutes: undefined;
+    Hour: undefined;
+    Day: undefined;
+    Week: undefined;
+}>;

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

@@ -36,6 +36,7 @@ export type PoolBase = {
     maxOutRatio: bigint;
     minTradingLimit: bigint;
 };
+export type PoolPegs = string[][];
 export interface PoolToken {
     id: number;
     balance: bigint;
@@ -76,8 +77,8 @@ export interface Pool extends PoolBase {
     spotPriceOutGivenIn(poolPair: PoolPair): bigint;
 }
 export interface IPoolCtxProvider {
-    getPools(filter?: PoolFilter): Promise<PoolBase[]>;
-    getPoolFees(pool: PoolBase, feeAsset: number): Promise<PoolFees>;
+    getPools(): Promise<PoolBase[]>;
+    getPoolFees(poolPair: PoolPair, pool: Pool): Promise<PoolFees>;
 }
 export type Hop = {
     pool: PoolType;

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

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

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

@@ -1,12 +1,23 @@
 import { Hop, IPoolCtxProvider, Pool, PoolBase, PoolFilter } from '../pool';
-export type RouterOptions = PoolFilter;
 export declare class Router {
     private readonly routeSuggester;
     private readonly routeProposals;
-    private readonly routerOptions;
     protected readonly ctx: IPoolCtxProvider;
-    constructor(ctx: IPoolCtxProvider, routerOptions?: RouterOptions);
+    private filter;
+    constructor(ctx: IPoolCtxProvider);
+    withFilter(filter?: PoolFilter): Promise<void>;
     protected buildRouteKey(assetIn: number, assetOut: number, pools: PoolBase[]): string;
+    /**
+     * Filter pools given the following contraints:
+     *
+     * 1) Exclusions always win
+     * 2) If useOnly is specified, allow only those types
+     * 3) Otherwise everything not excluded passes
+     *
+     * @param pools - supported & active amms
+     * @returns filtered pools
+     */
+    protected applyPoolFilter(pools: PoolBase[]): PoolBase[];
     /**
      * List trading pools
      */

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

@@ -1,11 +1,11 @@
-import { Router, RouterOptions } from './Router';
+import { Router } from './Router';
 import { Trade } from './types';
 import { Hop, IPoolCtxProvider } from '../pool';
 import { Amount } from '../types';
 export declare class TradeRouter extends Router {
     private readonly mlr;
     private poolsSnapshot?;
-    constructor(ctx: IPoolCtxProvider, routerOptions?: RouterOptions);
+    constructor(ctx: IPoolCtxProvider);
     private buildCtxSync;
     private withCtx;
     /**
@@ -16,10 +16,10 @@ export declare class TradeRouter extends Router {
      */
     private isDirectTrade;
     /**
-     * Find the best sell swap without errors
+     * Find the best sell route
      *
-     * @param {SellSwap[]} swaps - all possible sell routes
-     * @returns best sell swap if exist, otherwise first one found
+     * @param {SellSwap[]} swaps - sell routes
+     * @returns the most beneficial route without errors, if exist
      */
     private findBestSellRoute;
     /**
@@ -48,9 +48,9 @@ export declare class TradeRouter extends Router {
      */
     getBestSell(assetIn: number, assetOut: number, amountIn: bigint | string): Promise<Trade>;
     /**
-     * Calculate and return sell spot price for assetIn>assetOut
+     * Calculate and return sell spot price for assetIn > assetOut
      *
-     * @param route - best possible trade route (sell)
+     * @param route - sell route
      * @returns sell spot price
      */
     private getSellSpot;
@@ -61,9 +61,18 @@ export declare class TradeRouter extends Router {
      * @param {number} assetOut - asset out
      * @param {bigint | string} amountIn - amount of assetIn to sell for assetOut
      * @param {Hop[]} route - explicit route to use for trade
-     * @returns sell trade of given asset pair
+     * @returns sell trade breakdown of given asset pair
      */
     getSell(assetIn: number, assetOut: number, amountIn: bigint | string, route?: Hop[]): Promise<Trade>;
+    /**
+     * Calculate and return all possible sells for assetIn > assetOut
+     *
+     * @param {number} assetIn - asset in
+     * @param {number} assetOut - asset out
+     * @param {bigint | string} amountIn - amount of assetIn to sell for assetOut
+     * @returns possible sell trades of given asset pair
+     */
+    getSells(assetIn: number, assetOut: number, amountIn: bigint | string): Promise<Trade[]>;
     /**
      * Build sell trade
      *
@@ -117,14 +126,14 @@ export declare class TradeRouter extends Router {
      *
      * @param {number} assetIn - asset in
      * @param {number} assetOut - asset out
-     * @return best possible spot price of given asset pair, or undefined if trade not supported
+     * @return spot price of given asset pair, or undefined if trade not supported
      */
-    getSpotPrice(assetIn: number, assetOut: number): Promise<Amount>;
+    getSpotPrice(assetIn: number, assetOut: number): Promise<Amount | undefined>;
     /**
-     * Find best buy route without errors, if there is none return first one found
+     * Find best buy route
      *
      * @param swaps - buy routes
-     * @returns best buy route if exist, otherwise first one found
+     * @returns the most beneficial route without errors, if exist
      */
     private findBestBuyRoute;
     /**
@@ -137,9 +146,9 @@ export declare class TradeRouter extends Router {
      */
     getBestBuy(assetIn: number, assetOut: number, amountOut: bigint | string): Promise<Trade>;
     /**
-     * Calculate and return buy spot price for assetIn>assetOut
+     * Calculate and return buy spot price for assetIn > assetOut
      *
-     * @param route - best possible trade route (buy)
+     * @param route - buy route
      * @returns buy spot price
      */
     private getBuySpot;
@@ -150,9 +159,18 @@ export declare class TradeRouter extends Router {
      * @param {number} assetOut - asset out
      * @param {bigint | string} amountOut - amount of assetOut to buy for assetIn
      * @param {Hop[]} route - explicit route to use for trade
-     * @returns buy trade of given asset pair
+     * @returns buy trade breakdown of given asset pair
      */
     getBuy(assetIn: number, assetOut: number, amountOut: bigint | string, route?: Hop[]): Promise<Trade>;
+    /**
+     * Calculate and return all possible buy trades for assetIn > assetOut
+     *
+     * @param {number} assetIn - asset in
+     * @param {number} assetOut - asset out
+     * @param {bigint | string} amountOut - amount of assetOut to buy for assetIn
+     * @returns possible buy trades of given asset pair
+     */
+    getBuys(assetIn: number, assetOut: number, amountOut: bigint | string): Promise<Trade[]>;
     /**
      * Build buy trade
      *