@galacticcouncil/sdk-next 0.10.0-pr206-70b5b04 → 0.10.0

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

@@ -1,4 +1,4 @@
-import { FarmDepositReward, OmnipoolWarehouseLMDepositYieldFarmEntry, GlobalFarm, YieldFarm } from './types';
+import { FarmDepositReward, YieldFarmEntry, GlobalFarm, YieldFarm } from './types';
 import { MultiCurrencyContainer } from './MultiCurrencyContainer';
 export declare class RewardClaimSimulator {
     protected getAccount: (sub: number) => string;
@@ -12,5 +12,5 @@ export declare class RewardClaimSimulator {
     syncGlobalFarm(globalFarm: GlobalFarm, currentPeriod: number, oraclePrice: bigint): Promise<GlobalFarm | null>;
     syncYieldFarm(yieldFarm: YieldFarm, globalFarm: GlobalFarm, currentPeriod: number): YieldFarm | null;
     getLoyaltyMultiplier(periods: number, loyaltyCurve: YieldFarm['loyalty_curve']): string;
-    claimRewards(globalFarm: GlobalFarm, yieldFarm: YieldFarm, farmEntry: OmnipoolWarehouseLMDepositYieldFarmEntry, relaychainBlockNumber: number, oraclePrice: bigint): Promise<FarmDepositReward | null>;
+    claimRewards(globalFarm: GlobalFarm, yieldFarm: YieldFarm, farmEntry: YieldFarmEntry, relaychainBlockNumber: number, oraclePrice: bigint): Promise<FarmDepositReward | null>;
 }

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

@@ -5,7 +5,7 @@ export type ISolatedYieldFarm = HydrationQueries['XYKWarehouseLM']['YieldFarm'][
 export type OmnipoolGlobalFarm = HydrationQueries['OmnipoolWarehouseLM']['GlobalFarm']['Value'];
 export type OmnipoolYieldFarm = HydrationQueries['OmnipoolWarehouseLM']['YieldFarm']['Value'];
 export type OmnipoolWarehouseLMDeposit = HydrationQueries['OmnipoolWarehouseLM']['Deposit']['Value'];
-export type OmnipoolWarehouseLMDepositYieldFarmEntry = OmnipoolWarehouseLMDeposit['yield_farm_entries'][number];
+export type YieldFarmEntry = OmnipoolWarehouseLMDeposit['yield_farm_entries'][number] | HydrationQueries['XYKWarehouseLM']['Deposit']['Value']['yield_farm_entries'][number];
 export type OmnipoolFarm = {
     id: string;
     globalFarm: OmnipoolGlobalFarm;
@@ -20,6 +20,8 @@ export type FarmDepositReward = {
     readonly reward: bigint;
     readonly maxReward: bigint;
     readonly assetId: number;
+    readonly yieldFarmId: number;
+    readonly isActiveFarm: boolean;
 };
 export type Farm = {
     apr: string;

package/build/types/gho/GhoTokenClient.d.ts

@@ -0,0 +1,6 @@
+import { EvmClient } from '../evm';
+export declare class GhoTokenClient {
+    private client;
+    constructor(evm: EvmClient);
+    getFacilitatorCapacity(address: string, facilitator: string): Promise<bigint>;
+}

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

@@ -0,0 +1,124 @@
+export declare const GHO_TOKEN_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "facilitator";
+        readonly type: "address";
+    }];
+    readonly name: "getFacilitator";
+    readonly outputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "addr";
+            readonly type: "address";
+        }, {
+            readonly name: "label";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "bucketCapacity";
+            readonly type: "uint128";
+        }, {
+            readonly name: "bucketLevel";
+            readonly type: "uint128";
+        }];
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "facilitator";
+        readonly type: "address";
+    }];
+    readonly name: "getFacilitatorBucket";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getFacilitatorsList";
+    readonly outputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "";
+        readonly type: "address[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "facilitatorAddress";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "label";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "bucketCapacity";
+        readonly type: "uint256";
+    }];
+    readonly name: "FacilitatorAdded";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "facilitatorAddress";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "oldCapacity";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "newCapacity";
+        readonly type: "uint256";
+    }];
+    readonly name: "FacilitatorBucketCapacityUpdated";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "facilitatorAddress";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "oldLevel";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "newLevel";
+        readonly type: "uint256";
+    }];
+    readonly name: "FacilitatorBucketLevelUpdated";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "facilitatorAddress";
+        readonly type: "address";
+    }];
+    readonly name: "FacilitatorRemoved";
+    readonly type: "event";
+}];

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

@@ -0,0 +1,2 @@
+export { GhoTokenClient } from './GhoTokenClient';
+export { GHO_TOKEN_ABI } from './abi';

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

@@ -22,8 +22,8 @@ export declare abstract class PoolClient<T extends PoolBase> extends BalanceClie
     getSubscriber(): Observable<T[]>;
     private subscribeStore;
     protected subscribeBalances(): Subscription;
-    private hasSystemAsset;
-    private hasErc20Asset;
+    protected hasSystemAsset(pool: T): boolean;
+    protected hasErc20Asset(pool: PoolBase): boolean;
     private hasValidAssets;
     private updateBalances;
 }

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

@@ -2,6 +2,7 @@ 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';
@@ -12,6 +13,7 @@ export declare class PoolContextProvider extends Papi implements IPoolCtxProvide
     readonly aave: AavePoolClient;
     readonly omnipool: OmniPoolClient;
     readonly stableswap: StableSwapClient;
+    readonly hsm: HsmPoolClient;
     readonly xyk: XykPoolClient;
     readonly lbp: LbpPoolClient;
     private readonly active;
@@ -20,17 +22,19 @@ export declare class PoolContextProvider extends Papi implements IPoolCtxProvide
     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;
-    withLbp(): this;
-    withAave(): this;
+    withHsm(): this;
     withXyk(override?: PoolTokenOverride[]): this;
+    withLbp(): this;
     destroy(): void;
     getPools(): Promise<PoolBase[]>;
     getPoolFees(poolPair: PoolPair, pool: Pool): Promise<PoolFees>;

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

@@ -11,7 +11,7 @@ export declare class AavePool implements Pool {
     maxOutRatio: bigint;
     minTradingLimit: bigint;
     static fromPool(pool: PoolBase): AavePool;
-    constructor(address: string, tokens: AavePoolToken[], maxInRation: bigint, maxOutRatio: bigint, minTradeLimit: bigint);
+    constructor(pool: PoolBase);
     validatePair(_tokenIn: number, _tokenOut: number): boolean;
     parsePair(tokenIn: number, tokenOut: number): PoolPair;
     validateAndBuy(poolPair: PoolPair, amountOut: bigint, _fees: PoolFees): BuyCtx;

package/build/types/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/types/pool/hsm/HsmPool.d.ts

@@ -0,0 +1,51 @@
+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, amountOut: 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;
+}

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

@@ -0,0 +1,24 @@
+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;
+    protected subscribeBalances(): Subscription;
+    protected subscribeUpdates(): Subscription;
+}

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

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

package/build/types/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;
+};

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

@@ -1,8 +1,9 @@
 export { PoolFactory } from './PoolFactory';
 export { PoolContextProvider } from './PoolContextProvider';
 export * as aave from './aave';
-export * as xyk from './xyk';
 export * as omni from './omni';
-export * as lbp from './lbp';
 export * as stable from './stable';
+export * as hsm from './hsm';
+export * as xyk from './xyk';
+export * as lbp from './lbp';
 export * from './types';

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

@@ -24,7 +24,7 @@ export declare class LbpPool implements Pool {
     fee: PoolFee;
     repayFeeApply: boolean;
     static fromPool(pool: LbpPoolBase): LbpPool;
-    constructor(address: string, tokens: WeightedPoolToken[], maxInRatio: bigint, maxOutRatio: bigint, minTradingLimit: bigint, fee: PoolFee, repayFeeApply: boolean);
+    constructor(pool: LbpPoolBase);
     validatePair(_tokenIn: number, _tokenOut: number): boolean;
     parsePair(tokenIn: number, tokenOut: number): WeightedPoolPair;
     /**

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

@@ -29,7 +29,7 @@ export declare class OmniPool implements Pool {
     minTradingLimit: bigint;
     hubAssetId: number;
     static fromPool(pool: OmniPoolBase): OmniPool;
-    constructor(address: string, tokens: OmniPoolToken[], maxInRation: bigint, maxOutRatio: bigint, minTradeLimit: bigint, hubAssetId: number);
+    constructor(pool: OmniPoolBase);
     validatePair(_tokenIn: number, tokenOut: number): boolean;
     parsePair(tokenIn: number, tokenOut: number): OmniPoolPair;
     validateAndBuy(poolPair: OmniPoolPair, amountOut: bigint, fees: OmniPoolFees): BuyCtx;

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

@@ -28,7 +28,7 @@ export declare class StableSwap implements Pool {
     totalIssuance: bigint;
     pegs: string[][];
     static fromPool(pool: StableSwapBase): StableSwap;
-    constructor(address: string, tokens: PoolToken[], maxInRation: bigint, maxOutRatio: bigint, minTradeLimit: bigint, amplification: bigint, isRampPeriod: boolean, id: number, fee: PoolFee, totalIssuance: bigint, pegs: PoolPegs);
+    constructor(pool: StableSwapBase);
     validatePair(_tokenIn: number, _tokenOut: number): boolean;
     parsePair(tokenIn: number, tokenOut: number): StableSwapPair;
     validateAndBuy(poolPair: StableSwapPair, amountOut: bigint, fees: StableSwapFees): BuyCtx;

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

@@ -8,14 +8,20 @@ export declare enum PoolType {
     LBP = "LBP",
     Omni = "Omnipool",
     Stable = "Stableswap",
-    XYK = "XYK"
+    XYK = "XYK",
+    HSM = "HSM"
 }
 export declare enum PoolError {
+    UnknownError = "UnknownError",
+    FacilitatorCapacityExceeded = "FacilitatorCapacityExceeded",
     InsufficientTradingAmount = "InsufficientTradingAmount",
+    InsufficientCollateral = "InsufficientCollateral",
+    MaxHoldingExceeded = "MaxHoldingExceeded",
     MaxInRatioExceeded = "MaxInRatioExceeded",
     MaxOutRatioExceeded = "MaxOutRatioExceeded",
     TradeNotAllowed = "TradeNotAllowed",
-    UnknownError = "UnknownError"
+    MaxBuyBackExceeded = "MaxBuyBackExceeded",
+    MaxBuyPriceExceeded = "MaxBuyPriceExceeded"
 }
 export interface PoolPair {
     assetIn: number;

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

@@ -10,7 +10,7 @@ export declare class XykPool implements Pool {
     maxOutRatio: bigint;
     minTradingLimit: bigint;
     static fromPool(pool: PoolBase): XykPool;
-    constructor(address: string, tokens: PoolToken[], maxInRation: bigint, maxOutRatio: bigint, minTradeLimit: bigint);
+    constructor(pool: PoolBase);
     validatePair(_tokenIn: number, _tokenOut: number): boolean;
     parsePair(tokenIn: number, tokenOut: number): PoolPair;
     validateAndBuy(poolPair: PoolPair, amountOut: bigint, fees: XykPoolFees): BuyCtx;

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

@@ -6,6 +6,7 @@ export declare class Router {
     private filter;
     constructor(ctx: IPoolCtxProvider);
     withFilter(filter?: PoolFilter): Promise<void>;
+    protected onFilterChanged(): void;
     protected buildRouteKey(assetIn: number, assetOut: number, pools: PoolBase[]): string;
     /**
      * Filter pools given the following contraints:

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

@@ -4,8 +4,8 @@ import { Hop, IPoolCtxProvider } from '../pool';
 import { Amount } from '../types';
 export declare class TradeRouter extends Router {
     private readonly mlr;
-    private poolsSnapshot?;
     constructor(ctx: IPoolCtxProvider);
+    protected onFilterChanged(): void;
     private buildCtxSync;
     private withCtx;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacticcouncil/sdk-next",
-  "version": "0.10.0-pr206-70b5b04",
+  "version": "0.10.0",
   "description": "Galactic next gen sdk (papi)",
   "author": "GalacticCouncil",
   "repository": {
@@ -36,6 +36,7 @@
   },
   "dependencies": {
     "@galacticcouncil/descriptors": "^1.4.0",
+    "@galacticcouncil/math-hsm": "^1.1.0",
     "@galacticcouncil/math-lbp": "^1.2.0",
     "@galacticcouncil/math-liquidity-mining": "^1.2.0",
     "@galacticcouncil/math-omnipool": "^1.3.0",