@galacticcouncil/sdk-next 1.0.0-beta.0 → 1.0.0

package/build/oracle/abi.d.ts

@@ -0,0 +1,196 @@
+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";
+}];
+export declare const DIA_ORACLE_ABI: readonly [{
+    readonly inputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "string";
+        readonly name: "key";
+        readonly type: "string";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint128";
+        readonly name: "value";
+        readonly type: "uint128";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint128";
+        readonly name: "timestamp";
+        readonly type: "uint128";
+    }];
+    readonly name: "OracleUpdate";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "address";
+        readonly name: "newUpdater";
+        readonly type: "address";
+    }];
+    readonly name: "UpdaterAddressChange";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "key";
+        readonly type: "string";
+    }];
+    readonly name: "getValue";
+    readonly outputs: readonly [{
+        readonly internalType: "uint128";
+        readonly name: "";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "";
+        readonly type: "uint128";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string[]";
+        readonly name: "keys";
+        readonly type: "string[]";
+    }, {
+        readonly internalType: "uint256[]";
+        readonly name: "compressedValues";
+        readonly type: "uint256[]";
+    }];
+    readonly name: "setMultipleValues";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "key";
+        readonly type: "string";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "value";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "timestamp";
+        readonly type: "uint128";
+    }];
+    readonly name: "setValue";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "newOracleUpdaterAddress";
+        readonly type: "address";
+    }];
+    readonly name: "updateOracleUpdaterAddress";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly name: "values";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];

package/build/oracle/index.d.ts

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

package/build/oracle/types.d.ts

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

package/build/pool/PoolClient.d.ts

@@ -0,0 +1,75 @@
+import { PolkadotClient } from 'polkadot-api';
+import { Observable, OperatorFunction, Subscription } from 'rxjs';
+import { Papi } from '../api';
+import { BalanceClient } from '../client';
+import { EvmClient } from '../evm';
+import { PoolBase, PoolFees, PoolPair, PoolType } from './types';
+import { PoolStore } from './PoolStore';
+import { PoolLog } from './PoolLog';
+export declare abstract class PoolClient<T extends PoolBase> extends Papi {
+    protected evm: EvmClient;
+    protected balance: BalanceClient;
+    protected store: PoolStore<T>;
+    protected log: PoolLog;
+    private shared$?;
+    private resync$;
+    private resyncAt;
+    private resyncPending;
+    private mem;
+    private memPoolsCache;
+    private memPools;
+    constructor(client: PolkadotClient, evm: EvmClient);
+    abstract isSupported(): Promise<boolean>;
+    abstract getPoolFees(pair: PoolPair, address: string): Promise<PoolFees>;
+    abstract getPoolType(): PoolType;
+    protected abstract loadPools(): Promise<T[]>;
+    protected abstract subscribeUpdates(): Subscription;
+    private getMemPools;
+    getPools(): Promise<T[]>;
+    getSubscriber(): Observable<T[]>;
+    private subscribeStore;
+    protected subscribeBalances(): Subscription;
+    protected hasSystemAsset(pool: T): boolean;
+    protected hasErc20Asset(pool: PoolBase): boolean;
+    private hasValidAssets;
+    private updateBalances;
+    /**
+     * Invalidates the current seed, tears down all active writers,
+     * and rebuilds the store from scratch.
+     *
+     * - Increments `mem` to bust memoized seeds
+     * - Emits on `resync$` to restart the active cycle
+     * - Rate-limited by default to avoid resync storms
+     * - Use `force` for fatal, state-corrupting errors
+     *
+     * @param force - bypass the resync throttle
+     */
+    private resync;
+    /**
+     * Schedules a resync on the next tick.
+     *
+     * - Ensures the current cycle tears down before resync
+     * - Dedup multiple requests occurring in the same tick
+     *
+     * @param force - forward the force flag to `resync`
+     */
+    private requestResync;
+    /**
+     * Starts the connection and block watchdog.
+     *
+     * - Triggers a resync on offline → online recovery
+     * - Triggers a resync on block gap
+     * - Errors are swallowed and the watchdog re-subscribes (`repeat`)
+     */
+    private startWatchdog;
+    /**
+     * Guards a watcher stream.
+     *
+     * - Logs any error and treats it as fatal
+     * - Schedules a forced resync
+     * - Outer re-sync cycle handles recovery
+     *
+     * @param tag - log prefix of the watcher
+     */
+    protected watchGuard<T>(tag: string): OperatorFunction<T, T>;
+}

package/build/pool/PoolContextProvider.d.ts

@@ -0,0 +1,41 @@
+import { PolkadotClient } from 'polkadot-api';
+import { Papi } from '../api';
+import { EvmClient } from '../evm';
+import { AavePoolClient } from './aave';
+import { HsmPoolClient } from './hsm';
+import { LbpPoolClient } from './lbp';
+import { OmniPoolClient } from './omni';
+import { XykPoolClient } from './xyk';
+import { StableSwapClient } from './stable';
+import { IPoolCtxProvider, Pool, PoolBase, PoolFees, PoolPair, PoolTokenOverride } from './types';
+export declare class PoolContextProvider extends Papi implements IPoolCtxProvider {
+    readonly evm: EvmClient;
+    readonly aave: AavePoolClient;
+    readonly omnipool: OmniPoolClient;
+    readonly stableswap: StableSwapClient;
+    readonly hsm: HsmPoolClient;
+    readonly xyk: XykPoolClient;
+    readonly lbp: LbpPoolClient;
+    private readonly active;
+    private readonly pools;
+    private readonly clients;
+    private aaveSub;
+    private omniSub;
+    private stableSub;
+    private hsmSub;
+    private xykSub;
+    private lbpSub;
+    private isReady;
+    private isDestroyed;
+    constructor(client: PolkadotClient, evm: EvmClient);
+    private subscribe;
+    withAave(): this;
+    withOmnipool(): this;
+    withStableswap(): this;
+    withHsm(): this;
+    withXyk(override?: PoolTokenOverride[]): this;
+    withLbp(): this;
+    destroy(): void;
+    getPools(): Promise<PoolBase[]>;
+    getPoolFees(poolPair: PoolPair, pool: Pool): Promise<PoolFees>;
+}

package/build/pool/PoolLog.d.ts

@@ -0,0 +1,11 @@
+import { PoolType } from './types';
+export declare class PoolLog {
+    private readonly type;
+    constructor(type: PoolType);
+    private prefix;
+    trace(label: string, ...args: any[]): void;
+    debug(label: string, ...args: any[]): void;
+    info(label: string, ...args: any[]): void;
+    error(label: string, ...args: any[]): void;
+    private pad;
+}

package/build/pool/PoolStore.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+import { PoolBase } from './types';
+export declare class PoolStore<T extends PoolBase> {
+    private store$;
+    private updateQueue;
+    private changeset;
+    get pools(): readonly T[];
+    asObservable(): Observable<T[]>;
+    applyChangeset(state: T[]): T[];
+    set(next: T[]): void;
+    /**
+     * Apply a batched mutation to the store.
+     *
+     * Updates are applied one at a time in call order (internally queued).
+     *
+     * @param patch - update callback
+     */
+    update(patch: (state: readonly T[]) => T[] | Promise<T[]>): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,126 @@
+export declare const AAVE_ABI: readonly [{
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "reserve";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "onBehalfOf";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint16";
+        readonly name: "referralCode";
+        readonly type: "uint16";
+    }];
+    readonly name: "Supply";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "reserve";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "Withdraw";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "reserve";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "onBehalfOf";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "enum DataTypes.InterestRateMode";
+        readonly name: "interestRateMode";
+        readonly type: "uint8";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "borrowRate";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint16";
+        readonly name: "referralCode";
+        readonly type: "uint16";
+    }];
+    readonly name: "Borrow";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "reserve";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "repayer";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bool";
+        readonly name: "useATokens";
+        readonly type: "bool";
+    }];
+    readonly name: "Repay";
+    readonly type: "event";
+}];

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

@@ -0,0 +1,24 @@
+import { BuyCtx, Pool, PoolBase, PoolFees, PoolPair, PoolToken, PoolType, SellCtx } from '../types';
+import { XcmV3Multilocation } from '../../types';
+export type AavePoolToken = PoolToken & {
+    location: XcmV3Multilocation;
+};
+export declare class AavePool implements Pool {
+    type: PoolType;
+    address: string;
+    tokens: AavePoolToken[];
+    maxInRatio: bigint;
+    maxOutRatio: bigint;
+    minTradingLimit: bigint;
+    static fromPool(pool: PoolBase): AavePool;
+    constructor(pool: PoolBase);
+    validatePair(_tokenIn: number, _tokenOut: number): boolean;
+    parsePair(tokenIn: number, tokenOut: number): PoolPair;
+    validateAndBuy(poolPair: PoolPair, amountOut: bigint, _fees: PoolFees): BuyCtx;
+    validateAndSell(poolPair: PoolPair, amountIn: bigint, _fees: PoolFees): SellCtx;
+    calculateInGivenOut(_poolPair: PoolPair, amountOut: bigint): bigint;
+    calculateOutGivenIn(_poolPair: PoolPair, amountIn: bigint): bigint;
+    spotPriceInGivenOut(_poolPair: PoolPair): bigint;
+    spotPriceOutGivenIn(_poolPair: PoolPair): bigint;
+    calculateTradeFee(_amount: bigint, _fees: PoolFees): bigint;
+}

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

@@ -0,0 +1,19 @@
+import { Subscription } from 'rxjs';
+import { PoolBase, PoolFees, PoolType } from '../types';
+import { PoolClient } from '../PoolClient';
+export declare class AavePoolClient extends PoolClient<PoolBase> {
+    getPoolType(): PoolType;
+    isSupported(): Promise<boolean>;
+    private getPoolId;
+    private getPoolLimits;
+    loadPools(): Promise<PoolBase[]>;
+    private getPoolDelta;
+    getPoolFees(): Promise<PoolFees>;
+    private getReserveH160Id;
+    private parseRouterLog;
+    private parseEvmLog;
+    private subscribeRouterExecuted;
+    private subscribeEvmLog;
+    protected subscribeBalances(): Subscription;
+    protected subscribeUpdates(): Subscription;
+}

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

@@ -0,0 +1,2 @@
+export * from './AavePool';
+export * from './AavePoolClient';

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

@@ -0,0 +1,13 @@
+import { HydrationEvents } from '@galacticcouncil/descriptors';
+export type TEvmPayload = HydrationEvents['EVM']['Log'];
+export type TEvmEvent = {
+    eventName: string;
+    reserve: string;
+    key: string;
+};
+export type TRouterExecutedPayload = HydrationEvents['Router']['Executed'];
+export type TRouterEvent = {
+    assetIn: number;
+    assetOut: number;
+    key: string;
+};

package/build/pool/hsm/HsmMath.d.ts

@@ -0,0 +1,21 @@
+export declare class HsmMath {
+    static calculateCollateralInGivenHollarOut(amountOut: string, collateralPeg: string, purchaseFee: string): string;
+    static calculateCollateralOutGivenHollarIn(amountIn: string, executionPrice: string, buybackFee: string): string;
+    static calculateHollarOutGivenCollateralIn(amountIn: string, collateralPeg: string, purchaseFee: string): string;
+    static calculateHollarInGivenCollateralOut(amountOut: string, executionPrice: string, buybackFee: string): string;
+    /**
+     * I_i = (H_i - peg_i * R_i) / 2
+     *
+     * If hollar reserve is less than pegged collateral, we're considering zero imbalance
+     * as we only care about positive imbalance (excess Hollar in the pool
+     *
+     * @param hollarReserve
+     * @param collateralPeg
+     * @param collateralReserve
+     * @returns pool imbalance or 0 if hollar reserve is less than pegged collateral
+     */
+    static calculateImbalance(hollarReserve: string, collateralPeg: string, collateralReserve: string): string;
+    static calculateBuybackLimit(imbalance: string, buybackRate: string): string;
+    static calculateBuybackPriceWithFee(executionPriceNum: string, executionPriceDen: string, buyBackFee: string): string;
+    static calculateMaxPrice(collateralPeg: string, coeficient: string): string;
+}

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

@@ -0,0 +1,63 @@
+import { BuyCtx, PoolError, PoolFee, PoolPair, SellCtx } from '../types';
+import { StableSwap, StableSwapBase, StableSwapPair } from '../stable';
+export type HsmPoolBase = StableSwapBase & {
+    hsmAddress: string;
+    hsmMintCapacity: bigint;
+    hollarId: number;
+    hollarH160: string;
+    collateralId: number;
+    collateralBalance: bigint;
+    maxBuyPriceCoefficient: bigint;
+    maxInHolding: bigint;
+    purchaseFee: PoolFee;
+    buyBackFee: PoolFee;
+    buyBackRate: PoolFee;
+};
+export declare class HsmPool extends StableSwap {
+    hsmAddress: string;
+    hsmMintCapacity: bigint;
+    hollarId: number;
+    hollarH160: string;
+    collateralId: number;
+    collateralBalance: bigint;
+    maxBuyPriceCoefficient: bigint;
+    maxInHolding: bigint;
+    purchaseFee: PoolFee;
+    buyBackFee: PoolFee;
+    buyBackRate: PoolFee;
+    static fromPool(pool: HsmPoolBase): HsmPool;
+    constructor(pool: HsmPoolBase);
+    validatePair(_tokenIn: number, _tokenOut: number): boolean;
+    parsePair(tokenIn: number, tokenOut: number): StableSwapPair;
+    validateTradeHollarIn(poolPair: PoolPair, amountIn: bigint, errors: PoolError[]): PoolError[];
+    validateTradeHollarOut(amountIn: bigint, amountOut: bigint, errors: PoolError[]): PoolError[];
+    validateTradeConstraints(poolPair: PoolPair, amountIn: bigint, amountOut: bigint): PoolError[];
+    validateAndBuy(poolPair: PoolPair, amountOut: bigint): BuyCtx;
+    validateAndSell(poolPair: PoolPair, amountIn: bigint): SellCtx;
+    private calculateHollarInGivenCollateralOut;
+    private calculateCollateralInGivenHollarOut;
+    calculateInGivenOut(poolPair: PoolPair, amountOut: bigint): bigint;
+    private calculateCollateralOutGivenHollarIn;
+    private calculateHollarOutGivenCollateralIn;
+    calculateOutGivenIn(poolPair: PoolPair, amountIn: bigint): bigint;
+    private calculateImbalance;
+    private calculateBuybackLimit;
+    private calculateBuyPrice;
+    private calculateMaxPrice;
+    spotPriceInGivenOut(poolPair: PoolPair): bigint;
+    spotPriceOutGivenIn(poolPair: PoolPair): bigint;
+    private getCollateralPeg;
+    private isDefaultPeg;
+    /**
+     * Normalize spot to runtime decimals.
+     *
+     * - if `decimalsIn === decimalsOut`: spot already 18dp
+     * - if `decimalsIn > decimalsOut`: spot in 18 - (decimalsIn - decimalsOut)
+     * - if `decimalsIn < decimalsOut`: spot in 18 + (decimalsOut - decimalsIn)
+     *
+     * @param spotRaw - raw spot
+     * @param decimalsIn - asset in decimals
+     * @param decimalsOut - asset out decimals
+     */
+    private normalizeSpotPrice;
+}

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

@@ -0,0 +1,26 @@
+import { PolkadotClient } from 'polkadot-api';
+import { Subscription } from 'rxjs';
+import { PoolClient } from '../PoolClient';
+import { StableSwapClient } from '../stable';
+import { PoolFees, PoolType } from '../types';
+import { EvmClient } from '../../evm';
+import { HsmPoolBase } from './HsmPool';
+export declare class HsmPoolClient extends PoolClient<HsmPoolBase> {
+    private ghoClient;
+    private stableClient;
+    constructor(client: PolkadotClient, evm: EvmClient, stableClient: StableSwapClient);
+    getPoolType(): PoolType;
+    private getPoolId;
+    private getFacilitatorAddress;
+    private getHollarAddress;
+    private getPoolAddress;
+    isSupported(): Promise<boolean>;
+    loadPools(): Promise<HsmPoolBase[]>;
+    getPoolFees(): Promise<PoolFees>;
+    private parseEvmLog;
+    private subscribeEvmLog;
+    private subscribeCollateralBalance;
+    private subscribeStableswapUpdates;
+    protected subscribeBalances(): Subscription;
+    protected subscribeUpdates(): Subscription;
+}

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

@@ -0,0 +1,3 @@
+export * from './HsmMath';
+export * from './HsmPool';
+export * from './HsmPoolClient';

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

@@ -0,0 +1,7 @@
+import { HydrationEvents } from '@galacticcouncil/descriptors';
+export type TEvmPayload = HydrationEvents['EVM']['Log'];
+export type TEvmEvent = {
+    eventName: string;
+    facilitator: string;
+    key: string;
+};