@galacticcouncil/sdk 6.2.0 → 7.0.0

package/build/types/evm/abi/Erc20.d.ts

@@ -0,0 +1,150 @@
+export declare const ERC20_ABI: readonly [{
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+    readonly name: "Approval";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+    readonly name: "Transfer";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "spender";
+        readonly type: "address";
+    }];
+    readonly name: "allowance";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "approve";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "balanceOf";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "decimals";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "totalSupply";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "transfer";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "transferFrom";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];

package/build/types/evm/abi/index.d.ts

@@ -0,0 +1 @@
+export * from './Aave';

package/build/types/evm/chain.d.ts

@@ -0,0 +1,2 @@
+import { Chain } from 'viem';
+export declare const evmMainnet: Chain;

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

@@ -0,0 +1,11 @@
+import { Chain, PublicClient, WalletClient } from 'viem';
+export declare class EvmClient {
+    readonly chain: Chain;
+    constructor(chain?: Chain);
+    get chainId(): number;
+    get chainCurrency(): string;
+    get chainDecimals(): number;
+    getProvider(): PublicClient;
+    getWsProvider(): PublicClient;
+    getSigner(address: string): WalletClient;
+}

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

@@ -0,0 +1,4 @@
+export declare const AAVE_PROXY = "0x1b02E051683b5cfaC5929C25E84adb26ECf87B38";
+export declare const AAVE_GAS_LIMIT = 1000000n;
+export declare const AAVE_ROUNDING_THRESHOLD = 5;
+export declare const AAVE_UINT_256_MAX: bigint;

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

@@ -0,0 +1,4 @@
+export * from './abi';
+export * from './const';
+export * from './chain';
+export * from './client';

package/build/types/index.d.ts

@@ -1,9 +1,12 @@
-export { Router, TradeRouter } from './api';
-export * from './pool';
+export * from './consts';
 export * from './client';
-export * from './types';
 export * from './errors';
-export * from './consts';
+export * from './evm';
+export * from './pool';
+export * from './sor';
+export * from './types';
 export * from './utils/bignumber';
+export * from './utils/erc20';
+export * from './utils/h160';
 export * from './utils/math';
 export * from './utils/json';

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

@@ -1,6 +1,6 @@
-import { PoolService } from './PoolService';
-import { Pool, PoolFees, PoolPair } from '../types';
 import { ApiPromise } from '@polkadot/api';
+import { Pool, PoolFees, PoolPair } from './types';
+import { PoolService } from './PoolService';
 export declare class CachingPoolService extends PoolService {
     private feeCache;
     private disconnectSubscribeNewHeads;

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

@@ -1,7 +1,8 @@
 import { ApiPromise } from '@polkadot/api';
 import { UnsubscribePromise } from '@polkadot/api-base/types';
 import { BalanceClient } from '../client';
-import { Asset, PoolBase, PoolFees, PoolPair, PoolType } from '../types';
+import { Asset } from '../types';
+import { PoolBase, PoolFees, PoolPair, PoolType } from './types';
 export declare abstract class PoolClient extends BalanceClient {
     protected pools: PoolBase[];
     protected subs: UnsubscribePromise[];

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

@@ -1,4 +1,4 @@
-import { Pool, PoolBase } from '../types';
+import { Pool, PoolBase } from './types';
 export declare class PoolFactory {
     static get(pool: PoolBase): Pool;
 }

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

@@ -1,12 +1,13 @@
 import { ApiPromise } from '@polkadot/api';
-import { AavePoolClient } from './aave/AavePoolClient';
-import { LbpPoolClient } from './lbp/LbpPoolClient';
-import { OmniPoolClient } from './omni/OmniPoolClient';
-import { XykPoolClient } from './xyk/XykPoolClient';
-import { StableSwapClient } from './stable/StableSwapClient';
-import { AssetClient, PolkadotApiClient } from '../client';
-import { Asset, ExternalAsset, Hop, IPoolService, Pool, PoolBase, PoolFees, PoolPair, PoolType, Transaction } from '../types';
-import { BigNumber } from '../utils/bignumber';
+import { PolkadotApiClient } from '../api';
+import { AssetClient } from '../client';
+import { Asset, ExternalAsset } from '../types';
+import { AavePoolClient } from './aave';
+import { LbpPoolClient } from './lbp';
+import { OmniPoolClient } from './omni';
+import { XykPoolClient } from './xyk';
+import { StableSwapClient } from './stable';
+import { IPoolService, Pool, PoolBase, PoolFees, PoolPair, PoolType } from './types';
 import { PoolClient } from './PoolClient';
 export declare class PoolService extends PolkadotApiClient implements IPoolService {
     protected readonly api: ApiPromise;
@@ -24,11 +25,6 @@ export declare class PoolService extends PolkadotApiClient implements IPoolServi
     get isRegistrySynced(): boolean;
     syncRegistry(external?: ExternalAsset[]): Promise<void>;
     getPools(includeOnly: PoolType[]): Promise<PoolBase[]>;
-    unsubscribe(): void;
+    destroy(): void;
     getPoolFees(poolPair: PoolPair, pool: Pool): Promise<PoolFees>;
-    private isDirectOmnipoolTrade;
-    private dryRun;
-    buildBuyTx(assetIn: string, assetOut: string, amountOut: BigNumber, maxAmountIn: BigNumber, route: Hop[]): Transaction;
-    buildSellTx(assetIn: string, assetOut: string, amountIn: BigNumber, minAmountOut: BigNumber, route: Hop[]): Transaction;
-    buildSellAllTx(assetIn: string, assetOut: string, minAmountOut: BigNumber, route: Hop[]): Transaction;
 }

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

@@ -1,4 +1,4 @@
-import { BuyTransfer, Pool, PoolBase, PoolFees, PoolPair, PoolToken, PoolType, SellTransfer } from '../../types';
+import { BuyCtx, Pool, PoolBase, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
 import { BigNumber } from '../../utils/bignumber';
 export declare class AavePool implements Pool {
     type: PoolType;
@@ -11,8 +11,8 @@ export declare class AavePool implements Pool {
     constructor(address: string, tokens: PoolToken[], maxInRation: number, maxOutRatio: number, minTradeLimit: number);
     validatePair(_tokenIn: string, _tokenOut: string): boolean;
     parsePair(tokenIn: string, tokenOut: string): PoolPair;
-    validateAndBuy(poolPair: PoolPair, amountOut: BigNumber, _fees: PoolFees): BuyTransfer;
-    validateAndSell(poolPair: PoolPair, amountIn: BigNumber, _fees: PoolFees): SellTransfer;
+    validateAndBuy(poolPair: PoolPair, amountOut: BigNumber, _fees: PoolFees): BuyCtx;
+    validateAndSell(poolPair: PoolPair, amountIn: BigNumber, _fees: PoolFees): SellCtx;
     calculateInGivenOut(_poolPair: PoolPair, amountOut: BigNumber): BigNumber;
     calculateOutGivenIn(_poolPair: PoolPair, amountIn: BigNumber): BigNumber;
     spotPriceInGivenOut(poolPair: PoolPair): BigNumber;

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

@@ -1,5 +1,5 @@
 import { UnsubscribePromise } from '@polkadot/api-base/types';
-import { PoolBase, PoolType, PoolFees, PoolPair } from '../../types';
+import { PoolBase, PoolType, PoolFees, PoolPair } from '../types';
 import { PoolClient } from '../PoolClient';
 export declare class AavePoolClient extends PoolClient {
     isSupported(): boolean;

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

@@ -1,9 +1,9 @@
 export { CachingPoolService } from './CachingPoolService';
 export { PoolFactory } from './PoolFactory';
 export { PoolService } from './PoolService';
-export * from './PoolUtils';
 export * from './aave';
 export * from './xyk';
 export * from './omni';
 export * from './lbp';
 export * from './stable';
+export * from './types';

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

@@ -1,4 +1,4 @@
-import { BuyTransfer, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellTransfer } from '../../types';
+import { BuyCtx, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
 import { BigNumber } from '../../utils/bignumber';
 export type WeightedPoolPair = PoolPair & {
     weightIn: BigNumber;
@@ -34,14 +34,14 @@ export declare class LbpPool implements Pool {
      * 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: BigNumber, fees: LbpPoolFees): BuyTransfer;
+    validateAndBuy(poolPair: WeightedPoolPair, amountOut: BigNumber, 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: BigNumber, fees: LbpPoolFees): SellTransfer;
+    validateAndSell(poolPair: WeightedPoolPair, amountIn: BigNumber, fees: LbpPoolFees): SellCtx;
     calculateInGivenOut(poolPair: WeightedPoolPair, amountOut: BigNumber): BigNumber;
     calculateOutGivenIn(poolPair: WeightedPoolPair, amountIn: BigNumber): BigNumber;
     spotPriceInGivenOut(poolPair: WeightedPoolPair): BigNumber;

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

@@ -1,5 +1,5 @@
 import { UnsubscribePromise } from '@polkadot/api-base/types';
-import { PoolBase, PoolFees, PoolPair, PoolType } from '../../types';
+import { PoolBase, PoolFees, PoolPair, PoolType } from '../types';
 import { PoolClient } from '../PoolClient';
 export declare class LbpPoolClient extends PoolClient {
     private readonly MAX_FINAL_WEIGHT;

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

@@ -1,4 +1,4 @@
-import { BuyTransfer, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellTransfer } from '../../types';
+import { BuyCtx, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
 import { BigNumber } from '../../utils/bignumber';
 export type OmniPoolPair = PoolPair & {
     hubReservesIn: BigNumber;
@@ -33,8 +33,8 @@ export declare class OmniPool implements Pool {
     constructor(address: string, tokens: OmniPoolToken[], maxInRation: number, maxOutRatio: number, minTradeLimit: number, hubAssetId: string);
     validatePair(_tokenIn: string, tokenOut: string): boolean;
     parsePair(tokenIn: string, tokenOut: string): OmniPoolPair;
-    validateAndBuy(poolPair: OmniPoolPair, amountOut: BigNumber, fees: OmniPoolFees): BuyTransfer;
-    validateAndSell(poolPair: OmniPoolPair, amountIn: BigNumber, fees: OmniPoolFees): SellTransfer;
+    validateAndBuy(poolPair: OmniPoolPair, amountOut: BigNumber, fees: OmniPoolFees): BuyCtx;
+    validateAndSell(poolPair: OmniPoolPair, amountIn: BigNumber, fees: OmniPoolFees): SellCtx;
     calculateInGivenOut(poolPair: OmniPoolPair, amountOut: BigNumber, fees?: OmniPoolFees): BigNumber;
     calculateLrnaInGivenOut(poolPair: OmniPoolPair, amountOut: BigNumber, fees?: OmniPoolFees): BigNumber;
     calculateOutGivenIn(poolPair: OmniPoolPair, amountIn: BigNumber, fees?: OmniPoolFees): BigNumber;

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

@@ -1,5 +1,5 @@
 import { UnsubscribePromise } from '@polkadot/api-base/types';
-import { PoolBase, PoolType, PoolFees, PoolPair } from '../../types';
+import { PoolBase, PoolType, PoolFees, PoolPair } from '../types';
 import { PoolClient } from '../PoolClient';
 export declare class OmniPoolClient extends PoolClient {
     isSupported(): boolean;

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

@@ -1,4 +1,4 @@
-import { BuyTransfer, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellTransfer } from '../../types';
+import { BuyCtx, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
 import { BigNumber } from '../../utils/bignumber';
 export type StableSwapPair = PoolPair & {
     tradeableIn: number;
@@ -32,8 +32,8 @@ export declare class StableSwap implements Pool {
     constructor(address: string, tokens: PoolToken[], maxInRation: number, maxOutRatio: number, minTradeLimit: number, amplification: string, id: string, fee: PoolFee, totalIssuance: string, pegs: string[][], pegsFee: PoolFee);
     validatePair(_tokenIn: string, _tokenOut: string): boolean;
     parsePair(tokenIn: string, tokenOut: string): StableSwapPair;
-    validateAndBuy(poolPair: StableSwapPair, amountOut: BigNumber, fees: StableSwapFees): BuyTransfer;
-    validateAndSell(poolPair: StableSwapPair, amountIn: BigNumber, fees: StableSwapFees): SellTransfer;
+    validateAndBuy(poolPair: StableSwapPair, amountOut: BigNumber, fees: StableSwapFees): BuyCtx;
+    validateAndSell(poolPair: StableSwapPair, amountIn: BigNumber, fees: StableSwapFees): SellCtx;
     private calculateIn;
     private calculateAddOneAsset;
     private calculateSharesForAmount;

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

@@ -1,5 +1,5 @@
 import { UnsubscribePromise } from '@polkadot/api-base/types';
-import { PoolBase, PoolType, PoolFees, PoolPair } from '../../types';
+import { PoolBase, PoolType, PoolFees, PoolPair } from '../types';
 import { PoolClient } from '../PoolClient';
 export declare const AMOUNT_MAX = 340282366920938463463374607431768211455n;
 export declare class StableSwapClient extends PoolClient {

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

@@ -0,0 +1,81 @@
+import type { Asset } from '../types';
+import type { BigNumber } from '../utils/bignumber';
+export declare enum PoolType {
+    Aave = "Aave",
+    LBP = "Lbp",
+    Omni = "Omnipool",
+    Stable = "Stableswap",
+    XYK = "Xyk"
+}
+export declare enum PoolError {
+    UnknownError = "UnknownError",
+    InsufficientTradingAmount = "InsufficientTradingAmount",
+    MaxInRatioExceeded = "MaxInRatioExceeded",
+    MaxOutRatioExceeded = "MaxOutRatioExceeded",
+    TradeNotAllowed = "TradeNotAllowed"
+}
+export interface PoolPair {
+    assetIn: string;
+    assetOut: string;
+    decimalsIn: number;
+    decimalsOut: number;
+    balanceIn: BigNumber;
+    balanceOut: BigNumber;
+    assetInED: BigNumber;
+    assetOutED: BigNumber;
+}
+export type PoolBase = {
+    address: string;
+    id?: string;
+    type: PoolType;
+    tokens: PoolToken[];
+    maxInRatio: number;
+    maxOutRatio: number;
+    minTradingLimit: number;
+};
+export interface PoolToken extends Asset {
+    id: string;
+    balance: string;
+    tradeable?: number;
+}
+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: BigNumber;
+};
+export type PoolBuy = {
+    calculatedIn: BigNumber;
+};
+export type PoolSwap = {
+    amountIn: BigNumber;
+    amountOut: BigNumber;
+    feePct: number;
+    errors: PoolError[];
+};
+export type SellCtx = PoolSwap & PoolSell;
+export type BuyCtx = PoolSwap & PoolBuy;
+export interface Pool extends PoolBase {
+    validatePair(tokenIn: string, tokenOut: string): boolean;
+    parsePair(tokenIn: string, tokenOut: string): PoolPair;
+    validateAndBuy(poolPair: PoolPair, amountOut: BigNumber, dynamicFees: PoolFees | null): BuyCtx;
+    validateAndSell(poolPair: PoolPair, amountOut: BigNumber, dynamicFees: PoolFees | null): SellCtx;
+    calculateInGivenOut(poolPair: PoolPair, amountOut: BigNumber): BigNumber;
+    calculateOutGivenIn(poolPair: PoolPair, amountIn: BigNumber): BigNumber;
+    spotPriceInGivenOut(poolPair: PoolPair): BigNumber;
+    spotPriceOutGivenIn(poolPair: PoolPair): BigNumber;
+}
+export interface IPoolService {
+    getPools(includeOnly?: PoolType[]): Promise<PoolBase[]>;
+    getPoolFees(poolPair: PoolPair, pool: Pool): Promise<PoolFees>;
+}
+export type Hop = {
+    pool: PoolType;
+    poolAddress: string;
+    poolId?: string;
+    assetIn: string;
+    assetOut: string;
+};

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

@@ -1,4 +1,4 @@
-import { BuyTransfer, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellTransfer } from '../../types';
+import { BuyCtx, Pool, PoolBase, PoolFee, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
 import { BigNumber } from '../../utils/bignumber';
 export type XykPoolFees = PoolFees & {
     exchangeFee: PoolFee;
@@ -14,8 +14,8 @@ export declare class XykPool implements Pool {
     constructor(address: string, tokens: PoolToken[], maxInRation: number, maxOutRatio: number, minTradeLimit: number);
     validatePair(_tokenIn: string, _tokenOut: string): boolean;
     parsePair(tokenIn: string, tokenOut: string): PoolPair;
-    validateAndBuy(poolPair: PoolPair, amountOut: BigNumber, fees: XykPoolFees): BuyTransfer;
-    validateAndSell(poolPair: PoolPair, amountIn: BigNumber, fees: XykPoolFees): SellTransfer;
+    validateAndBuy(poolPair: PoolPair, amountOut: BigNumber, fees: XykPoolFees): BuyCtx;
+    validateAndSell(poolPair: PoolPair, amountIn: BigNumber, fees: XykPoolFees): SellCtx;
     calculateInGivenOut(poolPair: PoolPair, amountOut: BigNumber): BigNumber;
     calculateOutGivenIn(poolPair: PoolPair, amountIn: BigNumber): BigNumber;
     spotPriceInGivenOut(poolPair: PoolPair): BigNumber;

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

@@ -1,5 +1,5 @@
 import { UnsubscribePromise } from '@polkadot/api-base/types';
-import { PoolBase, PoolType, PoolFees, PoolPair } from '../../types';
+import { PoolBase, PoolType, PoolFees, PoolPair } from '../types';
 import { PoolClient } from '../PoolClient';
 export declare class XykPoolClient extends PoolClient {
     isSupported(): boolean;

package/build/types/{api → sor}/Router.d.ts

@@ -1,4 +1,5 @@
-import { Asset, Hop, IPoolService, PoolBase, Pool, PoolType } from '../types';
+import { Hop, IPoolService, Pool, PoolBase, PoolType } from '../pool';
+import { Asset } from '../types';
 export type RouterOptions = {
     includeOnly?: PoolType[];
 };

package/build/types/{api → sor}/TradeRouter.d.ts

@@ -1,6 +1,8 @@
 import { Router } from './Router';
-import { Amount, Hop, Trade } from '../types';
+import { Hop } from '../pool';
+import { Amount } from '../types';
 import { BigNumber } from '../utils/bignumber';
+import { Trade } from './types';
 export declare class TradeRouter extends Router {
     /**
      * Check whether trade is direct or not

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

@@ -0,0 +1,25 @@
+import { ApiPromise } from '@polkadot/api';
+import { PolkadotApiClient, Transaction } from '../api';
+import { PoolType } from '../pool';
+import { Swap, Trade } from './types';
+export declare class TradeUtils extends PolkadotApiClient {
+    private balanceClient;
+    private evmClient;
+    constructor(api: ApiPromise);
+    buildBuyTx(trade: Trade, slippagePct?: number): Transaction;
+    buildSellTx(trade: Trade, slippagePct?: number): Transaction;
+    buildSellAllTx(trade: Trade, slippagePct?: number): Transaction;
+    buildWithdrawAndSellReserveTx(beneficiary: string, trade: Trade, slippagePct?: number): Promise<Transaction>;
+    buildRoute(swaps: Swap[]): ({
+        pool: {
+            Stableswap: string | undefined;
+        };
+        assetIn: string;
+        assetOut: string;
+    } | {
+        pool: PoolType.Aave | PoolType.LBP | PoolType.Omni | PoolType.XYK;
+        assetIn: string;
+        assetOut: string;
+    })[];
+    isDirectOmnipoolTrade(swaps: Swap[]): boolean;
+}

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

@@ -0,0 +1,4 @@
+export { Router } from './Router';
+export { TradeRouter } from './TradeRouter';
+export { TradeUtils } from './TradeUtils';
+export * from './types';

package/build/types/{route → sor/route}/graph.d.ts

@@ -1,4 +1,4 @@
-import { PoolBase } from '../types';
+import { PoolBase } from '../../pool';
 export type Edge = [address: string, from: string, to: string];
 export type NodeEdges = {
     [node: string]: Edge[];

package/build/types/{route → sor/route}/suggester.d.ts

@@ -1,5 +1,5 @@
-import { PoolBase } from '../types';
 import { Edge } from './graph';
+import { PoolBase } from '../../pool';
 export declare class RouteSuggester {
     /**
      * Proposals are ideal paths from

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

@@ -0,0 +1,34 @@
+import type { Hop, PoolBuy, PoolError, PoolSell } from '../pool';
+import type { BigNumber } from '../utils/bignumber';
+export interface Humanizer {
+    toHuman(): any;
+}
+export type Swap = Hop & Humanizer & {
+    assetInDecimals: number;
+    assetOutDecimals: number;
+    amountIn: BigNumber;
+    amountOut: BigNumber;
+    spotPrice: BigNumber;
+    tradeFeePct: number;
+    tradeFeeRange?: [number, number];
+    priceImpactPct: number;
+    errors: PoolError[];
+    isSupply(): boolean;
+    isWithdraw(): boolean;
+};
+export type SellSwap = Swap & PoolSell;
+export type BuySwap = Swap & PoolBuy;
+export declare enum TradeType {
+    Buy = "Buy",
+    Sell = "Sell"
+}
+export interface Trade extends Humanizer {
+    type: TradeType;
+    amountIn: BigNumber;
+    amountOut: BigNumber;
+    spotPrice: BigNumber;
+    tradeFee: BigNumber;
+    tradeFeePct: number;
+    priceImpactPct: number;
+    swaps: Swap[];
+}