@galacticcouncil/sdk-next 0.6.0-pr192-1d1a581 → 0.6.0-pr193-4adb9c7

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

@@ -0,0 +1,196 @@
+import { TypedApi } from 'polkadot-api';
+import { MultiCurrencyContainer, OmnipoolWarehouseLMDepositYieldFarmEntry } from './LiquidityMiningClient';
+import { hydration } from '@galacticcouncil/descriptors';
+import Big from 'big.js';
+type Api = TypedApi<typeof hydration>;
+type NotUndefined<T> = T extends undefined ? never : T;
+type GlobalFarm = NotUndefined<Awaited<ReturnType<Api['query']['XYKWarehouseLM']['GlobalFarm']['getValue'] | Api['query']['OmnipoolWarehouseLM']['GlobalFarm']['getValue']>>>;
+type YieldFarm = NotUndefined<Awaited<ReturnType<Api['query']['XYKWarehouseLM']['YieldFarm']['getValue'] | Api['query']['OmnipoolWarehouseLM']['YieldFarm']['getValue']>>>;
+export declare class OmnipoolLiquidityMiningClaimSim {
+    protected get_account: (sub: number) => string;
+    protected multiCurrency: MultiCurrencyContainer;
+    protected getAsset: (id: number) => Promise<{
+        existential_deposit: bigint;
+    } | undefined>;
+    constructor(get_account: (sub: number) => string, multiCurrency: MultiCurrencyContainer, getAsset: (id: number) => Promise<{
+        existential_deposit: bigint;
+    } | undefined>);
+    calculate_rewards_from_pot(global_farm: GlobalFarm, yield_farm: YieldFarm, stake_in_global_farm: Big): {
+        reward: Big.Big;
+        mutatedYieldFarm: {
+            id: number;
+            updated_at: number;
+            accumulated_rpz: bigint;
+            state: import("polkadot-api").Enum<{
+                Active: undefined;
+                Stopped: undefined;
+                Terminated: undefined;
+            }>;
+            total_shares: bigint;
+            total_valued_shares: bigint;
+            accumulated_rpvs: bigint;
+            loyalty_curve: {
+                initial_reward_percentage: bigint;
+                scale_coef: number;
+            } | undefined;
+            multiplier: bigint;
+            entries_count: bigint;
+            left_to_distribute: bigint;
+            total_stopped: number;
+        };
+        mutatedGlobalFarm: {
+            id: number;
+            owner: import("polkadot-api").SS58String;
+            updated_at: number;
+            total_shares_z: bigint;
+            accumulated_rpz: bigint;
+            reward_currency: number;
+            pending_rewards: bigint;
+            accumulated_paid_rewards: bigint;
+            yield_per_period: bigint;
+            planned_yielding_periods: number;
+            blocks_per_period: number;
+            incentivized_asset: number;
+            max_reward_per_period: bigint;
+            min_deposit: bigint;
+            live_yield_farms_count: number;
+            total_yield_farms_count: number;
+            price_adjustment: bigint;
+            state: import("polkadot-api").Enum<{
+                Active: undefined;
+                Stopped: undefined;
+                Terminated: undefined;
+            }>;
+        };
+    };
+    sync_global_farm(global_farm: GlobalFarm, current_period: number, oraclePrice: bigint): Promise<{
+        global_farm: {
+            updated_at: number;
+            id: number;
+            owner: import("polkadot-api").SS58String;
+            total_shares_z: bigint;
+            accumulated_rpz: bigint;
+            reward_currency: number;
+            pending_rewards: bigint;
+            accumulated_paid_rewards: bigint;
+            yield_per_period: bigint;
+            planned_yielding_periods: number;
+            blocks_per_period: number;
+            incentivized_asset: number;
+            max_reward_per_period: bigint;
+            min_deposit: bigint;
+            live_yield_farms_count: number;
+            total_yield_farms_count: number;
+            price_adjustment: bigint;
+            state: import("polkadot-api").Enum<{
+                Active: undefined;
+                Stopped: undefined;
+                Terminated: undefined;
+            }>;
+        };
+        reward?: undefined;
+    } | {
+        reward: Big.Big;
+        global_farm: {
+            id: number;
+            owner: import("polkadot-api").SS58String;
+            updated_at: number;
+            total_shares_z: bigint;
+            accumulated_rpz: bigint;
+            reward_currency: number;
+            pending_rewards: bigint;
+            accumulated_paid_rewards: bigint;
+            yield_per_period: bigint;
+            planned_yielding_periods: number;
+            blocks_per_period: number;
+            incentivized_asset: number;
+            max_reward_per_period: bigint;
+            min_deposit: bigint;
+            live_yield_farms_count: number;
+            total_yield_farms_count: number;
+            price_adjustment: bigint;
+            state: import("polkadot-api").Enum<{
+                Active: undefined;
+                Stopped: undefined;
+                Terminated: undefined;
+            }>;
+        };
+    } | undefined>;
+    sync_yield_farm(yield_farm: YieldFarm, global_farm: GlobalFarm, current_period: number): {
+        yield_farm: {
+            accumulated_rpz: bigint;
+            updated_at: number;
+            id: number;
+            state: import("polkadot-api").Enum<{
+                Active: undefined;
+                Stopped: undefined;
+                Terminated: undefined;
+            }>;
+            total_shares: bigint;
+            total_valued_shares: bigint;
+            accumulated_rpvs: bigint;
+            loyalty_curve: {
+                initial_reward_percentage: bigint;
+                scale_coef: number;
+            } | undefined;
+            multiplier: bigint;
+            entries_count: bigint;
+            left_to_distribute: bigint;
+            total_stopped: number;
+        };
+        global_farm?: undefined;
+    } | {
+        yield_farm: {
+            id: number;
+            updated_at: number;
+            accumulated_rpz: bigint;
+            state: import("polkadot-api").Enum<{
+                Active: undefined;
+                Stopped: undefined;
+                Terminated: undefined;
+            }>;
+            total_shares: bigint;
+            total_valued_shares: bigint;
+            accumulated_rpvs: bigint;
+            loyalty_curve: {
+                initial_reward_percentage: bigint;
+                scale_coef: number;
+            } | undefined;
+            multiplier: bigint;
+            entries_count: bigint;
+            left_to_distribute: bigint;
+            total_stopped: number;
+        };
+        global_farm: {
+            id: number;
+            owner: import("polkadot-api").SS58String;
+            updated_at: number;
+            total_shares_z: bigint;
+            accumulated_rpz: bigint;
+            reward_currency: number;
+            pending_rewards: bigint;
+            accumulated_paid_rewards: bigint;
+            yield_per_period: bigint;
+            planned_yielding_periods: number;
+            blocks_per_period: number;
+            incentivized_asset: number;
+            max_reward_per_period: bigint;
+            min_deposit: bigint;
+            live_yield_farms_count: number;
+            total_yield_farms_count: number;
+            price_adjustment: bigint;
+            state: import("polkadot-api").Enum<{
+                Active: undefined;
+                Stopped: undefined;
+                Terminated: undefined;
+            }>;
+        };
+    } | undefined;
+    get_loyalty_multiplier(periods: Big, loyaltyCurve: YieldFarm['loyalty_curve']): string;
+    claim_rewards(global_farm: GlobalFarm, yield_farm: YieldFarm, farmEntry: OmnipoolWarehouseLMDepositYieldFarmEntry, relaychainBlockNumber: number, oraclePrice: bigint): Promise<{
+        reward: Big.Big;
+        maxReward: Big.Big;
+        assetId: number;
+    } | null>;
+}
+export {};

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

@@ -1,3 +1,4 @@
 export { AssetClient } from './AssetClient';
 export { BalanceClient } from './BalanceClient';
 export { ChainParams } from './ChainParams';
+export { LiquidityMining } from './LiquidityMiningClient';

package/build/types/factory.d.ts

@@ -1,20 +1,23 @@
 import { PolkadotClient } from 'polkadot-api';
 import { AaveUtils } from './aave';
-import { AssetClient, BalanceClient } from './client';
+import { AssetClient, BalanceClient, LiquidityMining } from './client';
 import { EvmClient } from './evm';
 import { PoolContextProvider } from './pool';
 import { TradeRouter, TradeScheduler } from './sor';
 import { TxBuilderFactory } from './tx';
+import { StakingApi } from './staking';
 export type SdkCtx = {
     api: {
         aave: AaveUtils;
         router: TradeRouter;
         scheduler: TradeScheduler;
+        staking: StakingApi;
     };
     client: {
         asset: AssetClient;
         balance: BalanceClient;
         evm: EvmClient;
+        mining: LiquidityMining;
     };
     ctx: {
         pool: PoolContextProvider;

package/build/types/index.d.ts

@@ -6,6 +6,7 @@ export * as error from './errors';
 export * as evm from './evm';
 export * as pool from './pool';
 export * as sor from './sor';
+export * as staking from './staking';
 export * as tx from './tx';
 export * from './factory';
 export * from './types';

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

@@ -1,6 +1,6 @@
 import { PolkadotClient } from 'polkadot-api';
 import { Papi } from '../api';
-import { IPoolCtxProvider, PoolBase, PoolFees, PoolTokenOverride } from './types';
+import { IPoolCtxProvider, PoolBase, PoolFees, PoolFilter, PoolTokenOverride } from './types';
 export declare class PoolContextProvider extends Papi implements IPoolCtxProvider {
     private readonly lbpClient;
     private readonly omniClient;
@@ -25,6 +25,7 @@ export declare class PoolContextProvider extends Papi implements IPoolCtxProvide
     withAave(): this;
     withXyk(override?: PoolTokenOverride[]): this;
     destroy(): void;
-    getPools(): Promise<PoolBase[]>;
+    getPools(filter?: PoolFilter): Promise<PoolBase[]>;
+    private getFilteredPools;
     getPoolFees(pool: PoolBase, feeAsset: number): Promise<PoolFees>;
 }

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

@@ -1,4 +1,8 @@
 import type { AssetType } from '../types';
+export type PoolFilter = {
+    useOnly?: PoolType[];
+    exclude?: PoolType[];
+};
 export declare enum PoolType {
     Aave = "Aave",
     LBP = "LBP",
@@ -72,7 +76,7 @@ export interface Pool extends PoolBase {
     spotPriceOutGivenIn(poolPair: PoolPair): bigint;
 }
 export interface IPoolCtxProvider {
-    getPools(): Promise<PoolBase[]>;
+    getPools(filter?: PoolFilter): Promise<PoolBase[]>;
     getPoolFees(pool: PoolBase, feeAsset: number): Promise<PoolFees>;
 }
 export type Hop = {

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

@@ -1,13 +1,12 @@
-import { Hop, IPoolCtxProvider, Pool, PoolBase, PoolType } from '../pool';
-export type RouterOptions = {
-    useOnly: PoolType[];
-};
+import { Hop, IPoolCtxProvider, Pool, PoolBase, PoolFilter } from '../pool';
+export type RouterOptions = PoolFilter;
 export declare class Router {
     private readonly routeSuggester;
+    private readonly routeProposals;
     private readonly routerOptions;
     protected readonly ctx: IPoolCtxProvider;
-    private readonly defaultRouterOptions;
     constructor(ctx: IPoolCtxProvider, routerOptions?: RouterOptions);
+    protected buildRouteKey(assetIn: number, assetOut: number, pools: PoolBase[]): string;
     /**
      * List trading pools
      */
@@ -23,6 +22,12 @@ export declare class Router {
      * List tradeable assets
      */
     getTradeableAssets(): Promise<number[]>;
+    /**
+     * Return list of all routeble assets from substrate based pools
+     *
+     * @returns {number[]} List of all routeable asset ids
+     */
+    getRouteableAssets(toAsset: number): Promise<number[]>;
     /**
      * Ckeck if asset pair is valid
      *
@@ -44,7 +49,8 @@ export declare class Router {
      * @param {number} assetOut - assetOut id
      * @param {PoolBase[]} pools - trading pools
      */
-    protected getPaths(assetIn: number, assetOut: number | null, pools: PoolBase[]): Hop[][];
+    protected getPaths(assetIn: number, assetOut: number, pools: PoolBase[]): Hop[][];
+    private getProposals;
     /**
      * Check if path is valid -> all edges are valid asset pairs
      *

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

@@ -1,8 +1,13 @@
-import { Router } from './Router';
+import { Router, RouterOptions } from './Router';
 import { Trade } from './types';
-import { Hop } from '../pool';
+import { Hop, IPoolCtxProvider } from '../pool';
 import { Amount } from '../types';
 export declare class TradeRouter extends Router {
+    private readonly mlr;
+    private poolsSnapshot?;
+    constructor(ctx: IPoolCtxProvider, routerOptions?: RouterOptions);
+    private buildCtxSync;
+    private withCtx;
     /**
      * Check whether trade is direct or not
      *
@@ -50,15 +55,23 @@ export declare class TradeRouter extends Router {
      */
     private getSellSpot;
     /**
-     * Calculate and return sell trade for assetIn>assetOut
+     * Calculate and return sell trade for assetIn > assetOut pair
      *
-     * @param {number} assetIn - assetIn id
-     * @param {number} assetOut - assetOut id
-     * @param {bigint} amountIn - amount of assetIn to sell for assetOut
+     * @param {number} assetIn - asset in
+     * @param {number} assetOut - asset out
+     * @param {bigint | string} amountIn - amount of assetIn to sell for assetOut
      * @param {Hop[]} route - explicit route to use for trade
-     * @returns sell trade of given token pair
+     * @returns sell trade of given asset pair
      */
     getSell(assetIn: number, assetOut: number, amountIn: bigint | string, route?: Hop[]): Promise<Trade>;
+    /**
+     * Build sell trade
+     *
+     * @param poolsMap - pools map
+     * @param route - sell route
+     * @returns - sell trade
+     */
+    private buildSell;
     /**
      * Calculate the amount out for best possible trade if fees are zero
      *
@@ -68,6 +81,19 @@ export declare class TradeRouter extends Router {
      * @returns the amount out for best possible trade if fees are zero
      */
     private calculateDelta0Y;
+    /**
+     * Calculate and cache 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 {number} assetIn - asset in
+     * @param {number} assetOut - asset out
+     * @param {Ctx} ctx - route ctx
+     * @return most liquid route of given asset pair
+     */
+    private calculateMostLiquidRoute;
     /**
      * Calculate and return sell swaps for given path
      * - final amount of previous swap is entry to next one
@@ -79,40 +105,35 @@ export declare class TradeRouter extends Router {
      */
     private toSellSwaps;
     /**
-     * Calculate and return most liquid route for tokenIn>tokenOut
+     * Returns 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 {number} assetIn - assetIn id
-     * @param {number} assetOut - assetout id
-     * @return Most liquid route of given token pair
+     * @param {number} assetIn - asset in
+     * @param {number} assetOut - asset out
+     * @return most liquid route of given asset pair
      */
     getMostLiquidRoute(assetIn: number, assetOut: number): Promise<Hop[]>;
     /**
-     * Calculate and return best spot price for tokenIn>tokenOut
+     * Calculate and return best possible spot price for assetIn > assetOut pair
      *
-     * @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
+     * @param {number} assetIn - asset in
+     * @param {number} assetOut - asset out
+     * @return best possible spot price of given asset pair, or undefined if trade not supported
      */
     getSpotPrice(assetIn: number, assetOut: number): Promise<Amount>;
     /**
-     * Find the 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 {BuySwap[]} swaps - all possible buy routes
-     * @returns best buy 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 {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
+     * @param {number} assetIn - asset in
+     * @param {number} assetOut - asset out
+     * @param {bigint | string} amountOut - amount of assetOut to buy for assetIn
+     * @returns best possible buy trade of given asset pair
      */
     getBestBuy(assetIn: number, assetOut: number, amountOut: bigint | string): Promise<Trade>;
     /**
@@ -123,15 +144,23 @@ export declare class TradeRouter extends Router {
      */
     private getBuySpot;
     /**
-     * Calculate and return buy trade for assetIn>assetOut
+     * Calculate and return buy trade for assetIn > assetOut pair
      *
-     * @param {number} assetIn - assetIn id
-     * @param {number} assetOut - assetOut id
-     * @param {bigint} amountOut - amount of assetOut to buy for assetIn
+     * @param {number} assetIn - asset in
+     * @param {number} assetOut - asset out
+     * @param {bigint | string} amountOut - amount of assetOut to buy for assetIn
      * @param {Hop[]} route - explicit route to use for trade
-     * @returns buy trade of given token pair
+     * @returns buy trade of given asset pair
      */
     getBuy(assetIn: number, assetOut: number, amountOut: bigint | string, route?: Hop[]): Promise<Trade>;
+    /**
+     * Build buy trade
+     *
+     * @param poolsMap - pools map
+     * @param route - buy route
+     * @returns - buy trade
+     */
+    private buildBuy;
     /**
      * Calculate the amount in for best possible trade if fees are zero
      *

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

@@ -1,5 +1,5 @@
-export type Path = Node[];
 export type Node = [id: number, from: string];
+export type Path = Node[];
 /**
  * Breadth First Search.
  *
@@ -25,7 +25,16 @@ export declare class Bfs {
      * @param dst - destination node or null if requesting all posible paths from src
      * @returns paths
      */
-    findPaths(g: Map<number, Path>, src: number, dst: number | null): Path[];
+    findPaths(g: Map<number, Path>, src: number, dst: number): Path[];
+    /**
+     * Finding shortest paths in graph from given source to destination
+     *
+     * @param g - routes graph containing nodes & corresponding edges
+     * @param src - source node
+     * @param dst - destination node or null if requesting all posible paths from src
+     * @returns shortest paths
+     */
+    findShortestPaths(g: Map<number, Path>, src: number, dst: number | null): Path[];
     /**
      * Build and populate graph
      *

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

@@ -1,3 +1,3 @@
 export { Bfs, Path } from './bfs';
 export { Edge, getNodesAndEdges } from './graph';
-export { RouteSuggester } from './suggester';
+export { RouteSuggester, RouteProposal } from './suggester';

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

@@ -1,24 +1,33 @@
 import { Edge } from './graph';
 import { PoolBase } from '../../pool';
+export type RouteProposal = Edge[];
 export declare class RouteSuggester {
     /**
-     * Proposals are ideal paths from
-     * 1) tokenIn to tokenOut
-     * 2) tokenIn to *(all possible paths are requested)
+     * Returns ideal path proposals from `tokenIn` to `tokenOut`
+     * based on BFS over trusted, isolated or both pools.
      *
-     * calculated from all permutations of tokens of given pools.
+     * - Trusted pools = all pools except XYK (isolated)
      *
-     * E.g. permutation of pool A={1,3} is 2, such as {1,3}, {3,1} where 1 are 3
-     * are pool assets(tokens)
+     * The routing strategy is:
+     * - If neither `tokenIn` and `tokenOut` is in a trusted pool:
+     *   → Run BFS over isolated pools only, searching for all paths.
+     * - If both `tokenIn` and `tokenOut` are in trusted pools:
+     *   → Run BFS over trusted pools only, searching for shortest paths.
+     * - Otherwise:
+     *   → Run BFS over all relevant pools (trusted + isolated).
      *
-     * Filtering of valid paths and corresponding asset pairs is done by router itself!!!
+     * This strategy minimizes search scope while ensuring all viable
+     * paths are discovered.
      *
-     * @param tokenIn - tokenIn
-     * @param tokenOut - tokenOut or null if all possible paths from tokenIn are requested
-     * @param pools - substrate based pools
-     * @returns all possible path proposals
+     * NOTE: Filtering of valid swaps and pair execution is handled by the router,
+     * not in this step.
+     *
+     * @param tokenIn - The starting token (asset ID as string)
+     * @param tokenOut - The destination token (asset ID as string)
+     * @param pools - The list of available pools
+     * @returns Array of path proposals (each path is a list of edges)
      */
-    getProposals(tokenIn: number, tokenOut: number | null, pools: PoolBase[]): Edge[][];
+    getProposals(tokenIn: number, tokenOut: number, pools: PoolBase[]): RouteProposal[];
     private parsePaths;
     private toEdge;
 }

package/build/types/staking/StakingApi.d.ts

@@ -0,0 +1,46 @@
+import Big from 'big.js';
+import { StakingClient } from './StakingClient';
+import { BalanceClient } from 'client';
+export declare const BIG_10: Big.Big;
+export declare const BIG_BILL: Big.Big;
+export declare class StakingApi {
+    private readonly client;
+    private readonly balanceClient;
+    constructor(client: StakingClient, balanceClient: BalanceClient);
+    getTransferablePotBalance(): Promise<bigint>;
+    getStakingPosition(id: bigint): Promise<{
+        stake: bigint | undefined;
+        rewardPerStake: bigint | undefined;
+        createdAt: number | undefined;
+        actionPoints: bigint | undefined;
+        accumulatedUnpaidRewards: bigint | undefined;
+        accumulatedSlashPoints: bigint | undefined;
+        accumulatedLockedRewards: bigint | undefined;
+        votes: {
+            id: number;
+            amount: bigint;
+            conviction: string;
+        }[];
+    }>;
+    getStake(address: string): Promise<{
+        totalStake: bigint;
+        accumulatedRewardPerStake: bigint;
+        potReservedBalance: bigint;
+        positionId: bigint | undefined;
+        stakePosition: {
+            stake: bigint | undefined;
+            rewardPerStake: bigint | undefined;
+            createdAt: number | undefined;
+            actionPoints: bigint | undefined;
+            accumulatedUnpaidRewards: bigint | undefined;
+            accumulatedSlashPoints: bigint | undefined;
+            accumulatedLockedRewards: bigint | undefined;
+            votes: {
+                id: number;
+                amount: bigint;
+                conviction: string;
+            }[];
+        } | undefined;
+    }>;
+    getRewards(account: string, blockNumber: string): Promise<string | undefined>;
+}