@galacticcouncil/sdk-next 1.0.0-beta.0

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

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

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

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

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

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

@@ -0,0 +1,24 @@
+import { PolkadotClient } from 'polkadot-api';
+import { HydrationQueries } from '@galacticcouncil/descriptors';
+import { Papi } from '../api';
+import { Asset, ExternalAsset } from '../types';
+type TStableswapPool = HydrationQueries['Stableswap']['Pools']['Value'];
+type TBond = HydrationQueries['Bonds']['Bonds']['Value'];
+type TAssetDetails = HydrationQueries['AssetRegistry']['Assets']['Value'];
+type TAssetLocation = HydrationQueries['AssetRegistry']['AssetLocations']['Value'];
+export declare class AssetClient extends Papi {
+    private SUPPORTED_TYPES;
+    constructor(client: PolkadotClient);
+    queryShares(): Promise<Map<number, TStableswapPool>>;
+    queryBonds(): Promise<Map<number, TBond>>;
+    queryAssets(): Promise<Map<number, TAssetDetails>>;
+    queryAssetLocations(): Promise<Map<number, TAssetLocation>>;
+    private mapToken;
+    private mapBond;
+    private mapShares;
+    private mapExternal;
+    private parseMetadata;
+    getOnChainAssets(includeInvalid?: boolean, external?: ExternalAsset[]): Promise<Asset[]>;
+    private isValidAsset;
+}
+export {};

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

@@ -0,0 +1,17 @@
+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/client/index.d.ts

@@ -0,0 +1,2 @@
+export { AssetClient } from './AssetClient';
+export { BalanceClient } from './BalanceClient';

package/build/types/consts.d.ts

@@ -0,0 +1,8 @@
+export declare const RUNTIME_DECIMALS = 18;
+export declare const SYSTEM_ASSET_ID = 0;
+export declare const SYSTEM_ASSET_DECIMALS = 12;
+export declare const HYDRATION_PARACHAIN_ID = 2034;
+export declare const HYDRATION_SS58_PREFIX = 63;
+export declare const HYDRATION_OMNIPOOL_ADDRESS = "7L53bUTBbfuj14UpdCNPwmgzzHSsrsTWBHX5pys32mVWM3C1";
+export declare const HUB_ASSET_ID = 1;
+export declare const TRADEABLE_DEFAULT = 15;

package/build/types/errors.d.ts

@@ -0,0 +1,10 @@
+import { PoolType } from './pool';
+export declare class AssetNotFound extends Error {
+    constructor(asset: number);
+}
+export declare class PoolNotFound extends Error {
+    constructor(poolType: PoolType);
+}
+export declare class RouteNotFound extends Error {
+    constructor(assetIn: number, assetOut: number);
+}

package/build/types/index.d.ts

@@ -0,0 +1,8 @@
+export * as api from './api';
+export * as client from './client';
+export * as const from './consts';
+export * as error from './errors';
+export * as pool from './pool';
+export * as sor from './sor';
+export * from './types';
+export * from './utils';

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

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

@@ -0,0 +1,26 @@
+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/PoolFactory.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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