@galacticcouncil/sdk-next 0.6.0-pr194-1c1c0d6 → 0.6.1-pr196-4dadb83

package/build/types/farm/LiquidityMiningApi.d.ts

@@ -0,0 +1,89 @@
+import { BalanceClient } from '../client/BalanceClient';
+import { LiquidityMiningClient } from './LiquidityMiningClient';
+export declare class LiquidityMiningApi {
+    private readonly client;
+    private readonly balanceClient;
+    protected omnipoolAssetIds: string[];
+    constructor(client: LiquidityMiningClient, balanceClient: BalanceClient);
+    getOraclePrice(rewardCurrency: number, incentivizedAsset: number): Promise<bigint | undefined>;
+    private getFarmAddress;
+    private getGlobalRewardPerPeriod;
+    private getPoolYieldPerPeriod;
+    private farmData;
+    getAllOmnipoolFarms(): Promise<({
+        apr: string;
+        minApr: string | undefined;
+        isDistributed: boolean;
+        estimatedEndPeriod: string;
+        maxRewards: bigint;
+        incentivizedAsset: number;
+        rewardCurrency: number;
+        loyaltyCurve: {
+            initial_reward_percentage: bigint;
+            scale_coef: number;
+        } | undefined;
+        currentPeriod: string;
+        potMaxRewards: bigint;
+        fullness: string;
+        yieldFarmId: number;
+        globalFarmId: number;
+        poolId: string;
+    } | undefined)[][]>;
+    getOmnipoolFarms(id: string): Promise<({
+        apr: string;
+        minApr: string | undefined;
+        isDistributed: boolean;
+        estimatedEndPeriod: string;
+        maxRewards: bigint;
+        incentivizedAsset: number;
+        rewardCurrency: number;
+        loyaltyCurve: {
+            initial_reward_percentage: bigint;
+            scale_coef: number;
+        } | undefined;
+        currentPeriod: string;
+        potMaxRewards: bigint;
+        fullness: string;
+        yieldFarmId: number;
+        globalFarmId: number;
+        poolId: string;
+    } | undefined)[]>;
+    getAllIsolatedFarms(): Promise<({
+        apr: string;
+        minApr: string | undefined;
+        isDistributed: boolean;
+        estimatedEndPeriod: string;
+        maxRewards: bigint;
+        incentivizedAsset: number;
+        rewardCurrency: number;
+        loyaltyCurve: {
+            initial_reward_percentage: bigint;
+            scale_coef: number;
+        } | undefined;
+        currentPeriod: string;
+        potMaxRewards: bigint;
+        fullness: string;
+        yieldFarmId: number;
+        globalFarmId: number;
+        poolId: string;
+    } | undefined)[][]>;
+    getIsolatedFarms(id: string): Promise<({
+        apr: string;
+        minApr: string | undefined;
+        isDistributed: boolean;
+        estimatedEndPeriod: string;
+        maxRewards: bigint;
+        incentivizedAsset: number;
+        rewardCurrency: number;
+        loyaltyCurve: {
+            initial_reward_percentage: bigint;
+            scale_coef: number;
+        } | undefined;
+        currentPeriod: string;
+        potMaxRewards: bigint;
+        fullness: string;
+        yieldFarmId: number;
+        globalFarmId: number;
+        poolId: string;
+    } | undefined)[]>;
+}

package/build/types/farm/LiquidityMiningClient.d.ts

@@ -0,0 +1,130 @@
+import { Papi } from '../api';
+import { Enum } from 'polkadot-api';
+export declare class LiquidityMiningClient extends Papi {
+    protected omnipoolAssetIds: string[];
+    getOraclePrice(orderedAssets: [number, number]): Promise<[{
+        price: {
+            n: bigint;
+            d: bigint;
+        };
+        volume: {
+            a_in: bigint;
+            b_out: bigint;
+            a_out: bigint;
+            b_in: bigint;
+        };
+        liquidity: {
+            a: bigint;
+            b: bigint;
+        };
+        shares_issuance: bigint | undefined;
+        updated_at: number;
+    }, number] | undefined>;
+    getRelayBlockNumber(): Promise<number | undefined>;
+    getAllOmnipooFarms(): Promise<{
+        keyArgs: [number, number];
+        value: number;
+    }[]>;
+    getOmnipooFarms(id: number): Promise<{
+        keyArgs: [number, number];
+        value: number;
+    }[]>;
+    getOmnipoolGlobalFarm(id: number): Promise<{
+        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: Enum<{
+            Active: undefined;
+            Stopped: undefined;
+            Terminated: undefined;
+        }>;
+    } | undefined>;
+    getOmnipoolYieldFarm(id: number, globalFarmId: number, yieldFarmId: number): Promise<{
+        id: number;
+        updated_at: number;
+        accumulated_rpz: bigint;
+        state: 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;
+    } | undefined>;
+    getAllIsolatedFarms(): Promise<{
+        keyArgs: [import("polkadot-api").SS58String, number];
+        value: number;
+    }[]>;
+    getIsolatedFarms(id: string): Promise<{
+        keyArgs: [import("polkadot-api").SS58String, number];
+        value: number;
+    }[]>;
+    getIsolatedGlobalFarm(id: number): Promise<{
+        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: Enum<{
+            Active: undefined;
+            Stopped: undefined;
+            Terminated: undefined;
+        }>;
+    } | undefined>;
+    getIsolatedYieldFarm(id: string, globalFarmId: number, yieldFarmId: number): Promise<{
+        id: number;
+        updated_at: number;
+        accumulated_rpz: bigint;
+        state: 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;
+    } | undefined>;
+}

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

@@ -0,0 +1,2 @@
+export * from './LiquidityMiningApi';
+export * from './LiquidityMiningClient';

package/build/types/oracle/MmOracleClient.d.ts

@@ -0,0 +1,7 @@
+import { EvmClient } from '../evm';
+import { MmOracleEntry } from './types';
+export declare class MmOracleClient {
+    private client;
+    constructor(evm: EvmClient);
+    getData(address: string, blockTimeInSec?: number): Promise<MmOracleEntry>;
+}

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

@@ -0,0 +1,87 @@
+export declare const AGGREGATOR_V3_ABI: readonly [{
+    readonly inputs: readonly [];
+    readonly name: "decimals";
+    readonly outputs: readonly [{
+        readonly internalType: "uint8";
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "description";
+    readonly outputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "version";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint80";
+        readonly name: "_roundId";
+        readonly type: "uint80";
+    }];
+    readonly name: "getRoundData";
+    readonly outputs: readonly [{
+        readonly internalType: "uint80";
+        readonly name: "roundId";
+        readonly type: "uint80";
+    }, {
+        readonly internalType: "int256";
+        readonly name: "answer";
+        readonly type: "int256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "startedAt";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "updatedAt";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint80";
+        readonly name: "answeredInRound";
+        readonly type: "uint80";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "latestRoundData";
+    readonly outputs: readonly [{
+        readonly internalType: "uint80";
+        readonly name: "roundId";
+        readonly type: "uint80";
+    }, {
+        readonly internalType: "int256";
+        readonly name: "answer";
+        readonly type: "int256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "startedAt";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "updatedAt";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint80";
+        readonly name: "answeredInRound";
+        readonly type: "uint80";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];

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

@@ -0,0 +1,2 @@
+export { MmOracleClient } from './MmOracleClient';
+export * from './types';

package/build/types/oracle/types.d.ts

@@ -0,0 +1,5 @@
+export type MmOracleEntry = {
+    price: bigint;
+    decimals: number;
+    updatedAt: number;
+};

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

@@ -1,12 +1,16 @@
 import { PolkadotClient } from 'polkadot-api';
 import { type Observable } from 'rxjs';
 import { BalanceClient } from '../client';
+import { EvmClient } from '../evm';
+import { MmOracleClient } from '../oracle';
 import { PoolBase, PoolFees, PoolTokenOverride, PoolType } from './types';
 export declare abstract class PoolClient<T extends PoolBase> extends BalanceClient {
+    protected evm: EvmClient;
+    protected mmOracle: MmOracleClient;
     private override;
     private mem;
     private memPools;
-    constructor(client: PolkadotClient);
+    constructor(client: PolkadotClient, evm: EvmClient);
     protected abstract loadPools(): Promise<T[]>;
     abstract getPoolFees(pool: T, feeAsset: number): Promise<PoolFees>;
     abstract getPoolType(): PoolType;

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

@@ -1,7 +1,9 @@
 import { PolkadotClient } from 'polkadot-api';
 import { Papi } from '../api';
+import { EvmClient } from '../evm';
 import { IPoolCtxProvider, PoolBase, PoolFees, PoolFilter, PoolTokenOverride } from './types';
 export declare class PoolContextProvider extends Papi implements IPoolCtxProvider {
+    readonly evm: EvmClient;
     private readonly lbpClient;
     private readonly omniClient;
     private readonly stableClient;
@@ -17,7 +19,7 @@ export declare class PoolContextProvider extends Papi implements IPoolCtxProvide
     private aaveSub;
     private isReady;
     private isDestroyed;
-    constructor(client: PolkadotClient);
+    constructor(client: PolkadotClient, evm: EvmClient);
     private subscribe;
     withOmnipool(): this;
     withStableswap(): this;

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

@@ -4,17 +4,17 @@ import { PoolClient } from '../PoolClient';
 import { StableSwapBase } from './StableSwap';
 export declare class StableSwapClient extends PoolClient<StableSwapBase> {
     private poolsData;
-    protected loadPools(): Promise<StableSwapBase[]>;
+    getPoolType(): PoolType;
+    private getPoolAddress;
+    private getPoolLimits;
     private getPoolDelta;
     private getPoolTokens;
+    isSupported(): Promise<boolean>;
+    protected loadPools(): Promise<StableSwapBase[]>;
+    getPoolFees(pool: StableSwapBase): Promise<PoolFees>;
     private getPoolPegs;
     private getDefaultPegs;
     private getRecentPegs;
     private getLatestPegs;
-    private getPoolAddress;
-    private getPoolLimits;
-    getPoolFees(pool: StableSwapBase): Promise<PoolFees>;
-    getPoolType(): PoolType;
-    isSupported(): Promise<boolean>;
     subscribePoolChange(pool: StableSwapBase): Observable<StableSwapBase>;
 }

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

@@ -7,7 +7,7 @@ export declare class StakingApi {
     private readonly client;
     private readonly balanceClient;
     constructor(client: StakingClient, balanceClient: BalanceClient);
-    getTransferablePotBalance(): Promise<bigint>;
+    getFreePotBalance(): Promise<bigint>;
     getStakingPosition(id: bigint): Promise<{
         stake: bigint | undefined;
         rewardPerStake: bigint | undefined;

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

@@ -32,11 +32,6 @@ export declare class StakingClient extends Papi {
             "track": number;
             "origin": import("polkadot-api").Enum<{
                 system: import("@galacticcouncil/descriptors").DispatchRawOrigin;
-                Council: import("polkadot-api").Enum<{
-                    "Members": import("polkadot-api").FixedSizeArray<2, number>;
-                    "Member": import("polkadot-api").SS58String;
-                    "_Phantom": undefined;
-                }>;
                 TechnicalCommittee: import("polkadot-api").Enum<{
                     "Members": import("polkadot-api").FixedSizeArray<2, number>;
                     "Member": import("polkadot-api").SS58String;

package/build/types/tx/TxBuilder.d.ts

@@ -1,4 +1,5 @@
 import { PolkadotClient } from 'polkadot-api';
+import { PublicClient } from 'viem';
 import { AaveUtils } from '../aave';
 import { Papi } from '../api';
 import { BalanceClient } from '../client';
@@ -6,10 +7,11 @@ import { EvmClient } from '../evm';
 import { Swap } from '../sor';
 import { DryRunResult, Transaction, Tx } from './types';
 export declare abstract class TxBuilder extends Papi {
-    protected readonly evmClient: EvmClient;
+    protected readonly evm: EvmClient;
+    protected readonly evmClient: PublicClient;
     protected readonly balanceClient: BalanceClient;
     protected readonly aaveUtils: AaveUtils;
-    constructor(client: PolkadotClient, evmClient?: EvmClient);
+    constructor(client: PolkadotClient, evm: EvmClient);
     protected wrapTx(name: string, tx: Transaction): Tx;
     protected dispatchWithExtraGas(tx: Transaction): Promise<Transaction>;
     protected dryRun(account: string, tx: Transaction): Promise<DryRunResult>;

package/build/types/tx/TxBuilderFactory.d.ts

@@ -6,7 +6,7 @@ import { OrderTxBuilder } from './OrderTxBuilder';
 export declare class TxBuilderFactory {
     private client;
     private evmClient;
-    constructor(client: PolkadotClient, evmClient?: EvmClient);
+    constructor(client: PolkadotClient, evmClient: EvmClient);
     trade(trade: Trade): TradeTxBuilder;
     order(order: TradeOrder): OrderTxBuilder;
 }

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

@@ -1,4 +1,11 @@
 import { PoolFee } from '../pool';
-export declare function toPct(fee: PoolFee): number;
-export declare function toDecimals(fee: PoolFee): number;
-export declare function fromPermill(permill: number): PoolFee;
+export declare class FeeUtils {
+    static toPct(fee: PoolFee): number;
+    static toRaw(fee: PoolFee): number;
+    static fromPermill(permill: number): PoolFee;
+    static fromPerbill(perbill: number): PoolFee;
+    static fromRate(numerator: number, denominator: number): PoolFee;
+    static safeDivide(numerator: number, denominator: number, decimals?: number): number;
+    static safeRound(value: number): number;
+}
+export declare function shiftNeg(amount: string | number | bigint, decimals: number): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacticcouncil/sdk-next",
-  "version": "0.6.0-pr194-1c1c0d6",
+  "version": "0.6.1-pr196-4dadb83",
   "description": "Galactic next gen sdk (papi)",
   "author": "GalacticCouncil",
   "repository": {
@@ -35,11 +35,11 @@
     "@types/big.js": "^6.2.2"
   },
   "dependencies": {
-    "@galacticcouncil/descriptors": "^1.3.0",
+    "@galacticcouncil/descriptors": "^1.4.0",
     "@galacticcouncil/math-lbp": "^1.2.0",
     "@galacticcouncil/math-liquidity-mining": "^1.2.0",
     "@galacticcouncil/math-omnipool": "^1.3.0",
-    "@galacticcouncil/math-stableswap": "^2.2.0",
+    "@galacticcouncil/math-stableswap": "^2.3.0",
     "@galacticcouncil/math-xyk": "^1.2.0",
     "@noble/hashes": "^1.6.1",
     "@thi.ng/cache": "^2.1.35",