@galacticcouncil/sdk-next 1.0.0-beta.0 → 1.0.0

package/build/types/api/Papi.d.ts

@@ -1,375 +0,0 @@
-import { PolkadotClient } from 'polkadot-api';
-export declare abstract class Papi {
-    readonly client: PolkadotClient;
-    constructor(client: PolkadotClient);
-    get api(): import("polkadot-api").TypedApi<{
-        descriptors: {
-            pallets: {
-                __storage: {
-                    System: {
-                        Account: import("polkadot-api").StorageDescriptor<[Key: import("polkadot-api").SS58String], {
-                            nonce: number;
-                            consumers: number;
-                            providers: number;
-                            sufficients: number;
-                            data: {
-                                free: bigint;
-                                reserved: bigint;
-                                frozen: bigint;
-                                flags: bigint;
-                            };
-                        }, false, never>;
-                        Number: import("polkadot-api").StorageDescriptor<[], number, false, never>;
-                    };
-                    AssetRegistry: {
-                        Assets: import("polkadot-api").StorageDescriptor<[Key: number], {
-                            symbol: import("polkadot-api").Binary | undefined;
-                            decimals: number | undefined;
-                            name: import("polkadot-api").Binary | undefined;
-                            asset_type: import("polkadot-api").Enum<{
-                                Token: undefined;
-                                XYK: undefined;
-                                StableSwap: undefined;
-                                Bond: undefined;
-                                External: undefined;
-                                Erc20: undefined;
-                            }>;
-                            existential_deposit: bigint;
-                            xcm_rate_limit: bigint | undefined;
-                            is_sufficient: boolean;
-                        }, true, never>;
-                        AssetLocations: import("polkadot-api").StorageDescriptor<[Key: number], {
-                            parents: number;
-                            interior: import("@galacticcouncil/descriptors").XcmV3Junctions;
-                        }, true, never>;
-                    };
-                    Omnipool: {
-                        Assets: import("polkadot-api").StorageDescriptor<[Key: number], {
-                            shares: bigint;
-                            hub_reserve: bigint;
-                            protocol_shares: bigint;
-                            cap: bigint;
-                            tradable: number;
-                        }, true, never>;
-                        HubAssetTradability: import("polkadot-api").StorageDescriptor<[], number, false, never>;
-                    };
-                    DynamicFees: {
-                        AssetFee: import("polkadot-api").StorageDescriptor<[Key: number], {
-                            asset_fee: number;
-                            protocol_fee: number;
-                            timestamp: number;
-                        }, true, never>;
-                    };
-                    Stableswap: {
-                        Pools: import("polkadot-api").StorageDescriptor<[Key: number], {
-                            assets: number[];
-                            initial_amplification: number;
-                            final_amplification: number;
-                            initial_block: number;
-                            final_block: number;
-                            fee: number;
-                        }, true, never>;
-                        AssetTradability: import("polkadot-api").StorageDescriptor<import("polkadot-api").FixedSizeArray<2, number>, number, false, never>;
-                    };
-                    Bonds: {
-                        Bonds: import("polkadot-api").StorageDescriptor<[Key: number], [number, bigint], true, never>;
-                    };
-                    LBP: {
-                        PoolData: import("polkadot-api").StorageDescriptor<[Key: import("polkadot-api").SS58String], {
-                            assets: import("polkadot-api").FixedSizeArray<2, number>;
-                            fee: import("polkadot-api").FixedSizeArray<2, number>;
-                            owner: import("polkadot-api").SS58String;
-                            start: number | undefined;
-                            end: number | undefined;
-                            initial_weight: number;
-                            final_weight: number;
-                            weight_curve: {
-                                type: "Linear";
-                                value: undefined;
-                            };
-                            fee_collector: import("polkadot-api").SS58String;
-                            repay_target: bigint;
-                        }, true, never>;
-                    };
-                    XYK: {
-                        PoolAssets: import("polkadot-api").StorageDescriptor<[Key: import("polkadot-api").SS58String], import("polkadot-api").FixedSizeArray<2, number>, true, never>;
-                    };
-                    Tokens: {
-                        TotalIssuance: import("polkadot-api").StorageDescriptor<[Key: number], bigint, false, never>;
-                        Accounts: import("polkadot-api").StorageDescriptor<[import("polkadot-api").SS58String, number], {
-                            free: bigint;
-                            frozen: bigint;
-                            reserved: bigint;
-                        }, false, never>;
-                    };
-                    ParachainSystem: {
-                        ValidationData: import("polkadot-api").StorageDescriptor<[], {
-                            parent_head: import("polkadot-api").Binary;
-                            relay_parent_number: number;
-                            relay_parent_storage_root: import("polkadot-api").FixedSizeBinary<32>;
-                            max_pov_size: number;
-                        }, true, never>;
-                    };
-                };
-                __tx: {
-                    Omnipool: {
-                        sell: import("polkadot-api").TxDescriptor<{
-                            amount: bigint;
-                            asset_out: number;
-                            asset_in: number;
-                            min_buy_amount: bigint;
-                        }>;
-                        buy: import("polkadot-api").TxDescriptor<{
-                            amount: bigint;
-                            asset_out: number;
-                            asset_in: number;
-                            max_sell_amount: bigint;
-                        }>;
-                    };
-                    Router: {
-                        sell: import("polkadot-api").TxDescriptor<{
-                            asset_out: number;
-                            asset_in: number;
-                            route: {
-                                pool: import("polkadot-api").Enum<{
-                                    "XYK": undefined;
-                                    "LBP": undefined;
-                                    "Stableswap": number;
-                                    "Omnipool": undefined;
-                                    "Aave": undefined;
-                                }>;
-                                asset_in: number;
-                                asset_out: number;
-                            }[];
-                            amount_in: bigint;
-                            min_amount_out: bigint;
-                        }>;
-                        buy: import("polkadot-api").TxDescriptor<{
-                            asset_out: number;
-                            asset_in: number;
-                            amount_out: bigint;
-                            max_amount_in: bigint;
-                            route: {
-                                pool: import("polkadot-api").Enum<{
-                                    "XYK": undefined;
-                                    "LBP": undefined;
-                                    "Stableswap": number;
-                                    "Omnipool": undefined;
-                                    "Aave": undefined;
-                                }>;
-                                asset_in: number;
-                                asset_out: number;
-                            }[];
-                        }>;
-                        sell_all: import("polkadot-api").TxDescriptor<{
-                            asset_out: number;
-                            asset_in: number;
-                            route: {
-                                pool: import("polkadot-api").Enum<{
-                                    "XYK": undefined;
-                                    "LBP": undefined;
-                                    "Stableswap": number;
-                                    "Omnipool": undefined;
-                                    "Aave": undefined;
-                                }>;
-                                asset_in: number;
-                                asset_out: number;
-                            }[];
-                            min_amount_out: bigint;
-                        }>;
-                    };
-                };
-                __event: {
-                    EVM: {
-                        Log: import("polkadot-api").PlainDescriptor<{
-                            log: {
-                                address: import("polkadot-api").FixedSizeBinary<20>;
-                                topics: import("polkadot-api").FixedSizeBinary<32>[];
-                                data: import("polkadot-api").Binary;
-                            };
-                        }>;
-                    };
-                };
-                __error: {};
-                __const: {
-                    System: {
-                        BlockWeights: import("polkadot-api").PlainDescriptor<{
-                            base_block: {
-                                ref_time: bigint;
-                                proof_size: bigint;
-                            };
-                            max_block: {
-                                ref_time: bigint;
-                                proof_size: bigint;
-                            };
-                            per_class: {
-                                normal: {
-                                    "base_extrinsic": {
-                                        ref_time: bigint;
-                                        proof_size: bigint;
-                                    };
-                                    "max_extrinsic"?: ({
-                                        ref_time: bigint;
-                                        proof_size: bigint;
-                                    }) | undefined;
-                                    "max_total"?: ({
-                                        ref_time: bigint;
-                                        proof_size: bigint;
-                                    }) | undefined;
-                                    "reserved"?: ({
-                                        ref_time: bigint;
-                                        proof_size: bigint;
-                                    }) | undefined;
-                                };
-                                operational: {
-                                    "base_extrinsic": {
-                                        ref_time: bigint;
-                                        proof_size: bigint;
-                                    };
-                                    "max_extrinsic"?: ({
-                                        ref_time: bigint;
-                                        proof_size: bigint;
-                                    }) | undefined;
-                                    "max_total"?: ({
-                                        ref_time: bigint;
-                                        proof_size: bigint;
-                                    }) | undefined;
-                                    "reserved"?: ({
-                                        ref_time: bigint;
-                                        proof_size: bigint;
-                                    }) | undefined;
-                                };
-                                mandatory: {
-                                    "base_extrinsic": {
-                                        ref_time: bigint;
-                                        proof_size: bigint;
-                                    };
-                                    "max_extrinsic"?: ({
-                                        ref_time: bigint;
-                                        proof_size: bigint;
-                                    }) | undefined;
-                                    "max_total"?: ({
-                                        ref_time: bigint;
-                                        proof_size: bigint;
-                                    }) | undefined;
-                                    "reserved"?: ({
-                                        ref_time: bigint;
-                                        proof_size: bigint;
-                                    }) | undefined;
-                                };
-                            };
-                        }>;
-                        BlockLength: import("polkadot-api").PlainDescriptor<{
-                            normal: number;
-                            operational: number;
-                            mandatory: number;
-                        }>;
-                        BlockHashCount: import("polkadot-api").PlainDescriptor<number>;
-                        DbWeight: import("polkadot-api").PlainDescriptor<{
-                            read: bigint;
-                            write: bigint;
-                        }>;
-                        Version: import("polkadot-api").PlainDescriptor<{
-                            apis: [import("polkadot-api").FixedSizeBinary<8>, number][];
-                            spec_name: string;
-                            impl_name: string;
-                            authoring_version: number;
-                            spec_version: number;
-                            impl_version: number;
-                            transaction_version: number;
-                            state_version: number;
-                        }>;
-                        SS58Prefix: import("polkadot-api").PlainDescriptor<number>;
-                    };
-                    Omnipool: {
-                        HdxAssetId: import("polkadot-api").PlainDescriptor<number>;
-                        HubAssetId: import("polkadot-api").PlainDescriptor<number>;
-                        MinWithdrawalFee: import("polkadot-api").PlainDescriptor<number>;
-                        MinimumTradingLimit: import("polkadot-api").PlainDescriptor<bigint>;
-                        MinimumPoolLiquidity: import("polkadot-api").PlainDescriptor<bigint>;
-                        MaxInRatio: import("polkadot-api").PlainDescriptor<bigint>;
-                        MaxOutRatio: import("polkadot-api").PlainDescriptor<bigint>;
-                        NFTCollectionId: import("polkadot-api").PlainDescriptor<bigint>;
-                        BurnProtocolFee: import("polkadot-api").PlainDescriptor<number>;
-                    };
-                    DynamicFees: {
-                        AssetFeeParameters: import("polkadot-api").PlainDescriptor<{
-                            min_fee: number;
-                            max_fee: number;
-                            decay: bigint;
-                            amplification: bigint;
-                        }>;
-                        ProtocolFeeParameters: import("polkadot-api").PlainDescriptor<{
-                            min_fee: number;
-                            max_fee: number;
-                            decay: bigint;
-                            amplification: bigint;
-                        }>;
-                    };
-                    Stableswap: {
-                        MinPoolLiquidity: import("polkadot-api").PlainDescriptor<bigint>;
-                        MinTradingLimit: import("polkadot-api").PlainDescriptor<bigint>;
-                        AmplificationRange: import("polkadot-api").PlainDescriptor<{
-                            start: number;
-                            end: number;
-                        }>;
-                    };
-                    LBP: {
-                        MinTradingLimit: import("polkadot-api").PlainDescriptor<bigint>;
-                        MinPoolLiquidity: import("polkadot-api").PlainDescriptor<bigint>;
-                        MaxInRatio: import("polkadot-api").PlainDescriptor<bigint>;
-                        MaxOutRatio: import("polkadot-api").PlainDescriptor<bigint>;
-                        repay_fee: import("polkadot-api").PlainDescriptor<import("polkadot-api").FixedSizeArray<2, number>>;
-                    };
-                    XYK: {
-                        NativeAssetId: import("polkadot-api").PlainDescriptor<number>;
-                        GetExchangeFee: import("polkadot-api").PlainDescriptor<import("polkadot-api").FixedSizeArray<2, number>>;
-                        MinTradingLimit: import("polkadot-api").PlainDescriptor<bigint>;
-                        MinPoolLiquidity: import("polkadot-api").PlainDescriptor<bigint>;
-                        MaxInRatio: import("polkadot-api").PlainDescriptor<bigint>;
-                        MaxOutRatio: import("polkadot-api").PlainDescriptor<bigint>;
-                        OracleSource: import("polkadot-api").PlainDescriptor<import("polkadot-api").FixedSizeBinary<8>>;
-                    };
-                };
-            };
-            apis: {
-                CurrenciesApi: {
-                    account: import("polkadot-api").RuntimeDescriptor<[asset_id: number, who: import("polkadot-api").SS58String], {
-                        free: bigint;
-                        frozen: bigint;
-                        reserved: bigint;
-                    }>;
-                    accounts: import("polkadot-api").RuntimeDescriptor<[who: import("polkadot-api").SS58String], [number, {
-                        free: bigint;
-                        frozen: bigint;
-                        reserved: bigint;
-                    }][]>;
-                    free_balance: import("polkadot-api").RuntimeDescriptor<[asset_id: number, who: import("polkadot-api").SS58String], bigint>;
-                };
-                AaveTradeExecutor: {
-                    pairs: import("polkadot-api").RuntimeDescriptor<[], import("polkadot-api").FixedSizeArray<2, number>[]>;
-                    liquidity_depth: import("polkadot-api").RuntimeDescriptor<[asset_in: number, asset_out: number], bigint | undefined>;
-                    pool: import("polkadot-api").RuntimeDescriptor<[reserve: number, atoken: number], {
-                        reserve: number;
-                        atoken: number;
-                        liqudity_in: bigint;
-                        liqudity_out: bigint;
-                    }>;
-                    pools: import("polkadot-api").RuntimeDescriptor<[], {
-                        reserve: number;
-                        atoken: number;
-                        liqudity_in: bigint;
-                        liqudity_out: bigint;
-                    }[]>;
-                };
-            };
-        } & Promise<any>;
-        metadataTypes: Promise<Uint8Array>;
-        asset: {
-            _type?: void | undefined;
-        };
-        getMetadata: () => Promise<Uint8Array>;
-        genesis: string | undefined;
-    }>;
-    logSync(who: string, action: string, payload: any): void;
-}

package/build/types/api/client.d.ts

@@ -1,2 +0,0 @@
-import { PolkadotClient } from 'polkadot-api';
-export declare const getWs: (wsUrl: string | string[]) => Promise<PolkadotClient>;

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

@@ -1,2 +0,0 @@
-export * from './client';
-export * from './Papi';

package/build/types/client/BalanceClient.d.ts

@@ -1,17 +0,0 @@
-import { PolkadotClient } from 'polkadot-api';
-import { type Observable } from 'rxjs';
-import { Papi } from '../api';
-import { AssetAmount } from '../types';
-export declare class BalanceClient extends Papi {
-    constructor(client: PolkadotClient);
-    getBalance(account: string, assetId: number): Promise<bigint>;
-    getSystemBalance(account: string): Promise<bigint>;
-    getTokenBalance(account: string, assetId: number): Promise<bigint>;
-    getErc20Balance(account: string, assetId: number): Promise<bigint>;
-    subscribeBalance(address: string): Observable<AssetAmount[]>;
-    subscribeSystemBalance(address: string): Observable<AssetAmount>;
-    subscribeTokenBalance(address: string, assetId: number): Observable<AssetAmount>;
-    subscribeTokensBalance(address: string): Observable<AssetAmount[]>;
-    subscribeErc20Balance(address: string, includeOnly?: number[]): Observable<AssetAmount[]>;
-    private getTokenBalanceData;
-}

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

@@ -1,25 +0,0 @@
-import { PolkadotClient } from 'polkadot-api';
-import { type Observable } from 'rxjs';
-import { BalanceClient } from '../client';
-import { PoolBase, PoolFees, PoolTokenOverride, PoolType } from './types';
-export declare abstract class PoolClient<T extends PoolBase> extends BalanceClient {
-    private override;
-    private mem;
-    private memPools;
-    constructor(client: PolkadotClient);
-    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[]>;
-    getPools(): Promise<T[]>;
-    getSubscriber(): Observable<T>;
-    private subscribe;
-    private subscribePoolBalance;
-    private hasSystemAsset;
-    private hasErc20Asset;
-    private hasValidAssets;
-    private updatePool;
-}

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

@@ -1,26 +0,0 @@
-import { PolkadotClient } from 'polkadot-api';
-import { Papi } from '../api';
-import { IPoolCtxProvider, PoolBase, PoolFees, PoolTokenOverride } from './types';
-export declare class PoolContextProvider extends Papi implements IPoolCtxProvider {
-    private readonly lbpClient;
-    private readonly omniClient;
-    private readonly stableClient;
-    private readonly xykClient;
-    private readonly active;
-    private readonly clients;
-    private readonly pools;
-    private lbpSub;
-    private omniSub;
-    private stableSub;
-    private xykSub;
-    private isReady;
-    private isDestroyed;
-    constructor(client: PolkadotClient);
-    withOmnipool(): this;
-    withStableswap(): this;
-    withLbp(): this;
-    withXyk(override?: PoolTokenOverride[]): this;
-    destroy(): void;
-    getPools(): Promise<PoolBase[]>;
-    getPoolFees(pool: PoolBase, feeAsset: number): Promise<PoolFees>;
-}

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

@@ -1,13 +0,0 @@
-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/stable/StableSwapClient.d.ts

@@ -1,16 +0,0 @@
-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/xyk/XykPoolClient.d.ts

@@ -1,12 +0,0 @@
-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/sor/TradeRouter.d.ts

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

@@ -1,12 +0,0 @@
-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;
-}