@galacticcouncil/sdk 9.10.0 → 9.12.0

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

@@ -0,0 +1,124 @@
+export declare const GHO_TOKEN_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "facilitator";
+        readonly type: "address";
+    }];
+    readonly name: "getFacilitator";
+    readonly outputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "addr";
+            readonly type: "address";
+        }, {
+            readonly name: "label";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "bucketCapacity";
+            readonly type: "uint128";
+        }, {
+            readonly name: "bucketLevel";
+            readonly type: "uint128";
+        }];
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "facilitator";
+        readonly type: "address";
+    }];
+    readonly name: "getFacilitatorBucket";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getFacilitatorsList";
+    readonly outputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "";
+        readonly type: "address[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "facilitatorAddress";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "label";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "bucketCapacity";
+        readonly type: "uint256";
+    }];
+    readonly name: "FacilitatorAdded";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "facilitatorAddress";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "oldCapacity";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "newCapacity";
+        readonly type: "uint256";
+    }];
+    readonly name: "FacilitatorBucketCapacityUpdated";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "facilitatorAddress";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "oldLevel";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "newLevel";
+        readonly type: "uint256";
+    }];
+    readonly name: "FacilitatorBucketLevelUpdated";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "facilitatorAddress";
+        readonly type: "address";
+    }];
+    readonly name: "FacilitatorRemoved";
+    readonly type: "event";
+}];

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

@@ -0,0 +1,2 @@
+export { GhoTokenClient } from './GhoTokenClient';
+export { GHO_TOKEN_ABI } from './abi';

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

@@ -1,5 +1,7 @@
 import { ApiPromise } from '@polkadot/api';
 import { UnsubscribePromise } from '@polkadot/api-base/types';
+import { Vec } from '@polkadot/types';
+import { FrameSystemEventRecord } from '@polkadot/types/lookup';
 import { BalanceClient } from '../client';
 import { EvmClient } from '../evm';
 import { MmOracleClient } from '../oracle';
@@ -10,11 +12,15 @@ export declare abstract class PoolClient extends BalanceClient {
     protected mmOracle: MmOracleClient;
     protected pools: PoolBase[];
     protected subs: UnsubscribePromise[];
-    private assets;
-    private mem;
+    protected assets: Map<string, Asset>;
+    protected mem: number;
+    readonly onNewBlockHandler: (block: number) => void;
+    readonly onEventsHandler: (events: Vec<FrameSystemEventRecord>) => void;
     private memPoolsCache;
     private memPools;
     constructor(api: ApiPromise, evm: EvmClient);
+    protected onNewBlock(_block: number): void;
+    protected onEvents(_events: Vec<FrameSystemEventRecord>): void;
     abstract isSupported(): boolean;
     abstract getPoolType(): PoolType;
     abstract getPoolFees(block: number, pair: PoolPair, address: string): Promise<PoolFees>;

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

@@ -1,4 +1,6 @@
 import { ApiPromise } from '@polkadot/api';
+import { Vec } from '@polkadot/types';
+import { FrameSystemEventRecord } from '@polkadot/types/lookup';
 import { PolkadotApiClient } from '../api';
 import { AssetClient } from '../client';
 import { EvmClient } from '../evm';
@@ -24,10 +26,14 @@ export declare class PoolService extends PolkadotApiClient implements IPoolServi
     protected readonly clients: PoolClient[];
     protected onChainAssets: Asset[];
     protected block: number;
+    private blockHandlers;
+    private eventHandlers;
     private disconnectSubscribeNewHeads;
+    private disconnectSubscribeEvents;
     private memRegistry;
     constructor(api: ApiPromise, evm: EvmClient);
     protected onNewBlock(block: number): void;
+    protected onEvents(events: Vec<FrameSystemEventRecord>): void;
     get assets(): Asset[];
     get isRegistrySynced(): boolean;
     syncRegistry(external?: ExternalAsset[]): Promise<void>;

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

@@ -1,5 +1,4 @@
 import { BuyCtx, Pool, PoolBase, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
-import { BigNumber } from '../../utils/bignumber';
 export declare class AavePool implements Pool {
     type: PoolType;
     address: string;

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

@@ -1,3 +1,5 @@
+import type { Vec } from '@polkadot/types';
+import type { FrameSystemEventRecord } from '@polkadot/types/lookup';
 import { UnsubscribePromise } from '@polkadot/api-base/types';
 import { PoolBase, PoolType, PoolFees, PoolPair } from '../types';
 import { PoolClient } from '../PoolClient';
@@ -9,6 +11,7 @@ export declare class AavePoolClient extends PoolClient {
     isSupported(): boolean;
     loadPools(): Promise<PoolBase[]>;
     getPoolFees(_block: number, _poolPair: PoolPair, _poolAddress: string): Promise<PoolFees>;
+    protected onEvents(events: Vec<FrameSystemEventRecord>): void;
     protected subscribeBalances(): UnsubscribePromise;
     protected subscribeUpdates(): UnsubscribePromise;
     protected updatePoolState(pool: PoolBase): Promise<void>;

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

@@ -12,10 +12,3 @@ export type RouterExecutedEvent = [
     amountOut: bigint,
     eventId: number
 ];
-export type EvmLogEvent = [
-    log: {
-        address: `0x${string}`;
-        topics: [signature: `0x${string}`, ...args: `0x${string}`[]];
-        data: `0x${string}`;
-    }
-];

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

@@ -1,8 +1,12 @@
 import { BuyCtx, PoolError, PoolFee, PoolPair, SellCtx } from '../types';
 import { StableSwap, StableSwapBase, StableSwapPair } from '../stable';
-import { BigNumber } from '../../utils/bignumber';
 export type HsmPoolBase = StableSwapBase & {
+    hsmAddress: string;
+    hsmMintCapacity: BigNumber;
     hollarId: string;
+    hollarH160: string;
+    collateralId: string;
+    collateralBalance: BigNumber;
     maxBuyPriceCoefficient: BigNumber;
     maxInHolding: BigNumber;
     purchaseFee: PoolFee;
@@ -10,9 +14,14 @@ export type HsmPoolBase = StableSwapBase & {
     buyBackRate: PoolFee;
 };
 export declare class HsmPool extends StableSwap {
+    hsmAddress: string;
+    hsmMintCapacity: BigNumber;
+    hollarId: string;
+    hollarH160: string;
+    collateralId: string;
+    collateralBalance: BigNumber;
     maxBuyPriceCoefficient: BigNumber;
     maxInHolding: BigNumber;
-    hollarId: string;
     purchaseFee: PoolFee;
     buyBackFee: PoolFee;
     buyBackRate: PoolFee;
@@ -20,7 +29,9 @@ export declare class HsmPool extends StableSwap {
     constructor(pool: HsmPoolBase);
     validatePair(_tokenIn: string, _tokenOut: string): boolean;
     parsePair(tokenIn: string, tokenOut: string): StableSwapPair;
-    validateBuyConstraints(poolPair: PoolPair, amountIn: BigNumber, amountOut: BigNumber): PoolError[];
+    validateTradeHollarIn(poolPair: PoolPair, amountIn: BigNumber, amountOut: BigNumber, errors: PoolError[]): PoolError[];
+    validateTradeHollarOut(amountIn: BigNumber, amountOut: BigNumber, errors: PoolError[]): PoolError[];
+    validateTradeConstraints(poolPair: PoolPair, amountIn: BigNumber, amountOut: BigNumber): PoolError[];
     validateAndBuy(poolPair: PoolPair, amountOut: BigNumber): BuyCtx;
     validateAndSell(poolPair: PoolPair, amountIn: BigNumber): SellCtx;
     private calculateHollarInGivenCollateralOut;

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

@@ -1,17 +1,23 @@
-import { ApiPromise } from '@polkadot/api';
+import type { ApiPromise } from '@polkadot/api';
+import type { Vec } from '@polkadot/types';
+import type { FrameSystemEventRecord } from '@polkadot/types/lookup';
 import { UnsubscribePromise } from '@polkadot/api-base/types';
 import { EvmClient } from '../../evm';
-import { PoolType, PoolPair, PoolFees, PoolBase } from '../types';
 import { StableSwapClient } from '../stable';
+import { PoolType, PoolPair, PoolFees, PoolBase } from '../types';
 import { PoolClient } from '../PoolClient';
 export declare class HsmClient extends PoolClient {
     private stableClient;
+    private ghoTokenClient;
     constructor(api: ApiPromise, evm: EvmClient, stableClient: StableSwapClient);
     getPoolType(): PoolType;
     private getPoolId;
+    private getFacilitatorAddress;
+    private getHollarAddress;
     isSupported(): boolean;
     loadPools(): Promise<PoolBase[]>;
     getPoolFees(_block: number, _poolPair: PoolPair, _poolAddress: string): Promise<PoolFees>;
+    protected onEvents(events: Vec<FrameSystemEventRecord>): void;
     protected subscribeBalances(): UnsubscribePromise;
     protected subscribeUpdates(): UnsubscribePromise;
 }

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

@@ -1,5 +1,4 @@
 import { BuyCtx, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
-import { BigNumber } from '../../utils/bignumber';
 export type WeightedPoolPair = PoolPair & {
     weightIn: BigNumber;
     weightOut: BigNumber;

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

@@ -1,5 +1,4 @@
 import { BuyCtx, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
-import { BigNumber } from '../../utils/bignumber';
 export type OmniPoolPair = PoolPair & {
     hubReservesIn: BigNumber;
     hubReservesOut: BigNumber;

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

@@ -1,21 +1,26 @@
 import { UnsubscribePromise } from '@polkadot/api-base/types';
-import { PoolBase, PoolType, PoolFees, PoolPair } from '../types';
+import { PoolBase, PoolType, PoolPair } from '../types';
 import { PoolClient } from '../PoolClient';
+import { OmniPoolFees } from './OmniPool';
 export declare class OmniPoolClient extends PoolClient {
     private dynamicFees;
+    private dynamicFeesConfiguration;
     private oracles;
     private memQueryCache;
     private memOracleQuery;
     private memFeesQuery;
+    private memFeesConfigurationQuery;
     getPoolType(): PoolType;
     private getPoolId;
     private getOracleKey;
     private getPoolLimits;
     private getDynamicFees;
+    private getDynamicFeesConfiguration;
     private getOraclePrice;
     isSupported(): boolean;
+    isAssetConfigSupported(): boolean;
     loadPools(): Promise<PoolBase[]>;
-    getPoolFees(block: number, poolPair: PoolPair, _poolAddress: string): Promise<PoolFees>;
+    getPoolFees(block: number, poolPair: PoolPair, _poolAddress: string): Promise<OmniPoolFees>;
     private getAssetFee;
     private getProtocolFee;
     protected subscribeUpdates(): UnsubscribePromise;

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

@@ -1,5 +1,4 @@
 import { BuyCtx, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
-import { BigNumber } from '../../utils/bignumber';
 export type StableSwapPair = PoolPair & {
     tradeableIn: number;
     tradeableOut: number;

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

@@ -1,5 +1,4 @@
 import type { Asset } from '../types';
-import type { BigNumber } from '../utils/bignumber';
 export type PoolFilter = {
     includeOnly?: PoolType[];
     exclude?: PoolType[];
@@ -14,7 +13,10 @@ export declare enum PoolType {
 }
 export declare enum PoolError {
     UnknownError = "UnknownError",
+    FacilitatorCapacityExceeded = "FacilitatorCapacityExceeded",
     InsufficientTradingAmount = "InsufficientTradingAmount",
+    InsufficientCollateral = "InsufficientCollateral",
+    MaxHoldingExceeded = "MaxHoldingExceeded",
     MaxInRatioExceeded = "MaxInRatioExceeded",
     MaxOutRatioExceeded = "MaxOutRatioExceeded",
     TradeNotAllowed = "TradeNotAllowed",

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

@@ -1,5 +1,4 @@
 import { BuyCtx, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
-import { BigNumber } from '../../utils/bignumber';
 export type XykPoolFees = PoolFees & {
     exchangeFee: PoolFee;
 };

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

@@ -1,28 +1,27 @@
 import { Router } from './Router';
 import { Hop } from '../pool';
 import { Amount } from '../types';
-import { BigNumber } from '../utils/bignumber';
 import { Trade } from './types';
 export declare class TradeRouter extends Router {
     private loadRouteContext;
     /**
      * Check whether trade is direct or not
      *
-     * @param swaps - Trade route
+     * @param swaps - trade route
      * @returns true if direct trade, otherwise false
      */
     private isDirectTrade;
     /**
      * Find best sell swap without errors, if there is none return first one found
      *
-     * @param swaps - All possible sell routes
-     * @returns best sell swap if exist, otherwise first one found
+     * @param swaps - sell routes
+     * @returns best sell route if exist, otherwise first one found
      */
     private findBestSellRoute;
     /**
      * Return route fee range [min,max] in case pool is using dynamic fees
      *
-     * @param swaps - Trade routes
+     * @param swaps - trade route
      * @returns min & max fee range if swap through the pool with dynamic fees support
      */
     private getRouteFeeRange;
@@ -34,107 +33,139 @@ export declare class TradeRouter extends Router {
      */
     private getPoolFeeRange;
     /**
-     * Calculate and return best possible sell trade for assetIn>assetOut
+     * Calculate and return best possible sell trade for assetIn > assetOut pair
      *
-     * @param {string} assetIn - Storage key of assetIn
-     * @param {string} assetOut - Storage key of assetOut
-     * @param {BigNumber} amountIn - Amount of assetIn to sell for assetOut
-     * @returns Best possible sell trade of given token pair
+     * @param {string} assetIn - asset in
+     * @param {string} assetOut - asset out
+     * @param {BigNumber} amountIn - amount of assetIn to sell for assetOut
+     * @returns best possible sell trade of given asset pair
      */
     getBestSell(assetIn: string, assetOut: string, amountIn: BigNumber | string | number): Promise<Trade>;
     /**
-     * Calculate and return sell trade for assetIn>assetOut
+     * Calculate and return sell trade for assetIn > assetOut pair
      *
-     * @param {string} assetIn - Storage key of assetIn
-     * @param {string} assetOut - Storage key of assetOut
-     * @param {BigNumber} amountIn - Amount of assetIn to sell for assetOut
-     * @param {Hop[]} route - Explicit route to use for trade
-     * @returns Sell trade of given token pair
+     * @param {string} assetIn - asset in
+     * @param {string} assetOut - asset out
+     * @param {BigNumber} amountIn - amount of assetIn to sell for assetOut
+     * @param {Hop[]} route - explicit route to use for trade
+     * @returns sell trade of given asset pair
      */
     getSell(assetIn: string, assetOut: string, amountIn: BigNumber | string | number, route?: Hop[]): Promise<Trade>;
     /**
-     * Calculate the amount out for best possible trade if fees are zero
+     * Calculate and return all possible sell trades for assetIn > assetOut
      *
-     * @param amountIn - Amount of assetIn to sell for assetOut
-     * @param bestRoute - Best possible trade route (sell)
-     * @param poolsMap - Pools map
-     * @returns the amount out for best possible trade if fees are zero
+     * @param {string} assetIn - asset in
+     * @param {string} assetOut - asset out
+     * @param {BigNumber} amountIn - amount of assetIn to sell for assetOut
+     * @returns possible sell trades of given asset pair
+     */
+    getSellTrades(assetIn: string, assetOut: string, amountIn: BigNumber | string | number): Promise<Trade[]>;
+    /**
+     * Build sell trade
+     *
+     * @param poolsMap - pools map
+     * @param route - sell route
+     * @returns - sell trade
+     */
+    private buildSell;
+    /**
+     * Calculates the output amount of a trade assuming fees are zero
+     *
+     * @param amountIn - amount of assetIn to sell for assetOut
+     * @param route - trade route
+     * @param poolsMap - pools map
+     * @returns the amount out if fees are zero
      */
     private calculateDelta0Y;
     /**
-     * Calculate and return sell swaps for given path
-     * - final amount of previous swap is entry to next one
+     * Calculate and return sell route for given path
      *
-     * @param amountIn - Amount of assetIn to sell for assetOut
-     * @param path - Current path
-     * @param poolsMap - Pools map
-     * @returns Sell swaps for given path with corresponding pool pairs
+     * @param amountIn - amount of assetIn to sell for assetOut
+     * @param path - current path
+     * @param poolsMap - pools map
+     * @returns sell route for given path with corresponding pool pairs
      */
     private toSellSwaps;
     /**
-     * Calculate and return most liquid route for tokenIn>tokenOut
+     * Calculate and return the most liquid route
      *
      * 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 {string} assetIn - Storage key of tokenIn
-     * @param {string} assetOut - Storage key of tokenOut
-     * @return Most liquid route of given token pair
+     * @param {string} assetIn - asset in
+     * @param {string} assetOut - asset out
+     * @return most liquid route of given asset pair
      */
     getMostLiquidRoute(assetIn: string, assetOut: string): Promise<Hop[]>;
     /**
-     * Calculate and return best possible spot price for tokenIn>tokenOut
+     * Calculate and return best possible spot price for assetIn > assetOut pair
      *
-     * @param {string} assetIn - Storage key of tokenIn
-     * @param {string} assetOut - Storage key of tokenOut
-     * @return Best possible spot price of given token pair, or undefined if given pair trade not supported
+     * @param {string} assetIn - asset in
+     * @param {string} assetOut - asset out
+     * @return best possible spot price of given asset pair, or undefined if trade not supported
      */
     getBestSpotPrice(assetIn: string, assetOut: string): Promise<Amount | undefined>;
     /**
-     * Find best buy swap without errors, if there is none return first one found
+     * Find best buy route without errors, if there is none return first one found
      *
-     * @param swaps - All possible sell routes
-     * @returns best sell swap if exist, otherwise first one found
+     * @param swaps - buy routes
+     * @returns best buy route if exist, otherwise first one found
      */
     private findBestBuyRoute;
     /**
-     * Calculate and return best possible buy trade for assetIn>assetOut
+     * Calculate and return best possible buy trade for assetIn > assetOut pair
      *
-     * @param {string} assetIn - Storage key of assetIn
-     * @param {string} assetOut - Storage key of assetOut
-     * @param {BigNumber} amountOut - Amount of tokenOut to buy for tokenIn
-     * @returns Best possible buy trade of given token pair
+     * @param {string} assetIn - asset in
+     * @param {string} assetOut - asset out
+     * @param {BigNumber} amountOut - amount of assetOut to buy for assetIn
+     * @returns best possible buy trade of given asset pair
      */
     getBestBuy(assetIn: string, assetOut: string, amountOut: BigNumber | string | number): Promise<Trade>;
     /**
-     * Calculate and return buy trade for assetIn>assetOut
+     * Calculate and return buy trade for assetIn > assetOut pair
      *
-     * @param {string} assetIn - Storage key of assetIn
-     * @param {string} assetOut - Storage key of assetOut
-     * @param {BigNumber} amountOut - Amount of tokenOut to buy for tokenIn
-     * @param {Hop[]} route - Explicit route to use for trade
-     * @returns Buy trade of given token pair
+     * @param {string} assetIn - asset in
+     * @param {string} assetOut - asset out
+     * @param {BigNumber} amountOut - amount of assetOut to buy for assetIn
+     * @param {Hop[]} route - explicit route to use for trade
+     * @returns buy trade of given asset pair
      */
     getBuy(assetIn: string, assetOut: string, amountOut: BigNumber | string | number, route?: Hop[]): Promise<Trade>;
     /**
-     * Calculate the amount in for best possible trade if fees are zero
+     * Calculate and return all possible buy trades for assetIn > assetOut
+     *
+     * @param {string} assetIn - asset in
+     * @param {string} assetOut - asset out
+     * @param {BigNumber} amountOut - amount of assetOut to buy for assetIn
+     * @returns possible buy trades of given asset pair
+     */
+    getBuyTrades(assetIn: string, assetOut: string, amountOut: BigNumber | string | number): Promise<Trade[]>;
+    /**
+     * Build buy trade
+     *
+     * @param poolsMap - pools map
+     * @param route - buy route
+     * @returns - buy trade
+     */
+    private buildBuy;
+    /**
+     * Calculates the required input amount for a trade to receive a desired output amount,
+     * assuming 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
+     * @param amountOut - amount of assetOut to buy for assetIn
+     * @param route - trade route
+     * @param poolsMap - pools map
+     * @returns the required input amount for a 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)
+     * Calculate and return buy route for given path
      *
-     * @param amountOut - Amount of assetOut to buy for assetIn
-     * @param path - Current path
-     * @param poolsMap - Pools map
-     * @returns Buy swaps for given path
+     * @param amountOut - amount of assetOut to buy for assetIn
+     * @param path - current path
+     * @param poolsMap - pools map
+     * @returns buy route for given path
      */
     private toBuySwaps;
 }

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

@@ -1,6 +1,5 @@
 import { TradeDcaOrder, TradeOrder } from './types';
 import { TradeRouter } from './TradeRouter';
-import { BigNumber } from '../utils/bignumber';
 export type TradeSchedulerOptions = {
     blockTime?: number;
     minBudgetInNative?: BigNumber;

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

@@ -1,5 +1,5 @@
 export declare const DEFAULT_BLOCK_TIME = 6000;
-export declare const DEFAULT_MIN_BUDGET: import("bignumber.js").BigNumber;
+export declare const DEFAULT_MIN_BUDGET: BigNumber;
 export declare const TWAP_BLOCK_PERIOD = 6;
 export declare const TWAP_MAX_PRICE_IMPACT = -5;
 export declare const TWAP_MAX_DURATION: number;

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

@@ -1,5 +1,4 @@
 import { Hop, PoolBuy, PoolError, PoolSell, PoolType } from '../pool';
-import type { BigNumber } from '../utils/bignumber';
 export interface Humanizer {
     toHuman(): any;
 }

package/build/types/types.d.ts

@@ -1,4 +1,3 @@
-import type { BigNumber } from './utils/bignumber';
 export type Amount = {
     amount: BigNumber;
     decimals: number;

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

@@ -1,4 +1,3 @@
-import { BigNumber } from './bignumber';
 /**
  * Percentage Difference Formula
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacticcouncil/sdk",
-  "version": "9.10.0",
+  "version": "9.12.0",
   "description": "Galactic off-chain routing & optimization of orders across pools for best price execution",
   "author": "GalacticCouncil",
   "repository": {