@ember-finance/sdk 2.25.0 → 2.26.0

package/dist/src/sui-vaults/on-chain-calls/atomic-liquidity.d.ts

@@ -2,6 +2,18 @@ import { BaseClient as SuiClient } from "@mysten/sui/client";
 import { FeeMultiplierTier, InstantWithdrawQuote } from "../../atomic/instant-withdraw.js";
 /** Strategy an atomic vault's idle collateral can be supplied to. */
 export type SuiAtomicStrategy = "none" | "suilend";
+/** An atomic vault's strategy and, for Suilend, the market it supplies to. */
+export interface SuiAtomicStrategyTarget {
+    strategy: SuiAtomicStrategy;
+    /** The vault's collateral coin type (`T`). */
+    collateralType: string;
+    /** Collateral held in the vault, in base units. */
+    idleCollateral: bigint;
+    /** Suilend only: the LendingMarket object id. */
+    suilendMarketId?: string;
+    /** Suilend only: the market's pool type (`P`). */
+    suilendPoolType?: string;
+}
 /**
  * Read-only views + instant-withdraw quotes for the Sui Atomic Liquidity Vault (BET-4111).
  *
@@ -42,6 +54,15 @@ export declare class SuiAtomicLiquidityReader {
     } | null>;
     /** Caller's ALV (non-transferable) share balance from the `shares` table. */
     shareOf(vaultId: string, account: string): Promise<bigint>;
+    /**
+     * The strategy an atomic vault is on, and for Suilend the market it supplies to.
+     * Plain object reads, no simulation.
+     * @param vaultId Object id of the atomic vault
+     * @returns The strategy, the vault's collateral coin type and idle collateral, and
+     * for Suilend the market id and its pool type (`P`)
+     */
+    getStrategyTarget(vaultId: string): Promise<SuiAtomicStrategyTarget>;
+    private readStrategyTarget;
     /**
      * Where an atomic vault's collateral sits: idle in the vault, or supplied to its
      * strategy.

package/dist/src/sui-vaults/on-chain-calls/atomic-liquidity.js

@@ -112,14 +112,18 @@ export class SuiAtomicLiquidityReader {
         return toBig(await this.readTableValue(tableId, "address", account));
     }
     /**
-     * Where an atomic vault's collateral sits: idle in the vault, or supplied to its
-     * strategy.
+     * The strategy an atomic vault is on, and for Suilend the market it supplies to.
+     * Plain object reads, no simulation.
      * @param vaultId Object id of the atomic vault
-     * @returns The active strategy, idle collateral and strategy assets, in collateral
-     * base units. `suilendMarketId` and `suilendPoolType` (the market's `P`) are set when
-     * the strategy is Suilend.
+     * @returns The strategy, the vault's collateral coin type and idle collateral, and
+     * for Suilend the market id and its pool type (`P`)
      */
-    async getStrategyState(vaultId) {
+    async getStrategyTarget(vaultId) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { packageId, ...target } = await this.readStrategyTarget(vaultId);
+        return target;
+    }
+    async readStrategyTarget(vaultId) {
         const res = await this.suiClient.core.getObject({
             objectId: vaultId,
             include: { json: true }
@@ -131,16 +135,14 @@ export class SuiAtomicLiquidityReader {
         if (!strategy) {
             throw new Error(`Unknown strategy kind ${fields.strategy_kind} on ${vaultId}`);
         }
+        const vaultType = res.object.type;
+        // The package that defines the vault type is the one with the views.
+        const packageId = vaultType.split("::")[0];
+        const collateralType = vaultType.slice(vaultType.indexOf("<") + 1, -1);
         const idleCollateral = toBig(fields.balance);
         if (strategy === "none") {
-            return { strategy, idleCollateral, strategyAssets: 0n };
+            return { strategy, collateralType, idleCollateral, packageId };
         }
-        // The vault's type names the package that defines it, which is the one with
-        // the views. The position is valued by Suilend against the reserve's current
-        // interest, so it is simulated rather than read from fields.
-        const vaultType = res.object.type;
-        const collateralType = vaultType.slice(vaultType.indexOf("<") + 1, -1);
-        const packageId = vaultType.split("::")[0];
         const marketField = await this.suiClient.core.getDynamicField({
             parentId: vaultId,
             name: {
@@ -154,13 +156,41 @@ export class SuiAtomicLiquidityReader {
         const suilendMarketId = bcs.Address.parse(marketField.dynamicField.value.bcs);
         const market = await this.suiClient.core.getObject({ objectId: suilendMarketId });
         const marketType = market.object.type;
-        const poolType = marketType.slice(marketType.indexOf("<") + 1, -1);
+        return {
+            strategy,
+            collateralType,
+            idleCollateral,
+            packageId,
+            suilendMarketId,
+            suilendPoolType: marketType.slice(marketType.indexOf("<") + 1, -1)
+        };
+    }
+    /**
+     * Where an atomic vault's collateral sits: idle in the vault, or supplied to its
+     * strategy.
+     * @param vaultId Object id of the atomic vault
+     * @returns The active strategy, idle collateral and strategy assets, in collateral
+     * base units. `suilendMarketId` and `suilendPoolType` (the market's `P`) are set when
+     * the strategy is Suilend.
+     */
+    async getStrategyState(vaultId) {
+        const target = await this.readStrategyTarget(vaultId);
+        const { strategy, idleCollateral, suilendMarketId, suilendPoolType, packageId } = target;
+        if (strategy === "none") {
+            return { strategy, idleCollateral, strategyAssets: 0n };
+        }
+        // Suilend values the position against the reserve's current interest, so it is
+        // simulated rather than read from fields.
         const tx = new Transaction();
         tx.setSender(SUI_ZERO_ADDRESS);
         tx.moveCall({
             target: `${packageId}::atomic_liquidity_vault::get_suilend_strategy_assets`,
-            typeArguments: [collateralType, poolType],
-            arguments: [tx.object(vaultId), tx.object(suilendMarketId), tx.object.clock()]
+            typeArguments: [target.collateralType, suilendPoolType],
+            arguments: [
+                tx.object(vaultId),
+                tx.object(suilendMarketId),
+                tx.object.clock()
+            ]
         });
         const sim = await this.suiClient.core.simulateTransaction({
             transaction: tx,
@@ -176,7 +206,7 @@ export class SuiAtomicLiquidityReader {
             idleCollateral,
             strategyAssets: BigInt(bcs.u64().parse(returned)),
             suilendMarketId,
-            suilendPoolType: poolType
+            suilendPoolType
         };
     }
     /**

package/dist/src/sui-vaults/on-chain-calls/user.d.ts

@@ -87,7 +87,8 @@ export declare class UserCalls extends OnChainCalls {
      */
     atomicCancelPendingWithdrawalRequest(vaultId: string, sequenceNumber: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
     /**
-     * Instantly withdraw collateral from an atomic liquidity vault (no strategy)
+     * Instantly withdraw collateral from an atomic liquidity vault. Routes to the
+     * entry point for the vault's current strategy.
      * @param vaultId The id of the atomic vault
      * @param shares The number of shares to withdraw
      * @param options Optional tx execution params
@@ -109,7 +110,8 @@ export declare class UserCalls extends OnChainCalls {
         receiver?: SuiAddress;
     } & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
     /**
-     * Swap ember shares (source vault receipt coin) into an atomic vault
+     * Swap ember shares (source vault receipt coin) into an atomic vault. Routes to the
+     * entry point for the vault's current strategy.
      * @param vaultId The id of the atomic vault
      * @param sourceReceiptType The receipt coin type of the source vault (R)
      * @param sourceVaultId Object id of the source Vault<T, R>

package/dist/src/sui-vaults/on-chain-calls/user.js

@@ -1,6 +1,11 @@
 import { OnChainCalls } from "./onchain-calls.js";
 import { TransactionBlock, bigNumber, CoinUtils, SUI_NATIVE_BASE } from "@firefly-exchange/library-sui";
 import { Vault } from "./vault.js";
+import { SuiAtomicLiquidityReader } from "./atomic-liquidity.js";
+const isSuiCoinType = (coinType) => {
+    const [address, module, name] = coinType.split("::");
+    return module === "sui" && name === "SUI" && /^0x0*2$/.test(address);
+};
 export class UserCalls extends OnChainCalls {
     constructor(_network, _suiClient, _deployment, _signer, _walletAddress, _isUIWallet) {
         super(_network, _suiClient, _deployment, _signer, _walletAddress, _isUIWallet);
@@ -186,7 +191,8 @@ export class UserCalls extends OnChainCalls {
         return this.execCall(txb, options);
     }
     /**
-     * Instantly withdraw collateral from an atomic liquidity vault (no strategy)
+     * Instantly withdraw collateral from an atomic liquidity vault. Routes to the
+     * entry point for the vault's current strategy.
      * @param vaultId The id of the atomic vault
      * @param shares The number of shares to withdraw
      * @param options Optional tx execution params
@@ -194,10 +200,20 @@ export class UserCalls extends OnChainCalls {
      */
     async atomicInstantWithdraw(vaultId, shares, options) {
         const txb = options?.txBlock || new TransactionBlock();
-        this.txBuilder.atomicInstantWithdraw(vaultId, shares, options?.receiver ?? null, {
-            ...options,
-            txBlock: txb
-        });
+        const target = await new SuiAtomicLiquidityReader(this.suiClient).getStrategyTarget(vaultId);
+        // The plain entry point asserts the vault has no strategy (EStrategyMismatch);
+        // a strategy vault must be called with its market so liquidity can be pulled.
+        if (target.strategy === "suilend") {
+            if (isSuiCoinType(target.collateralType)) {
+                this.txBuilder.atomicInstantWithdrawWithSuilendSui(vaultId, target.suilendPoolType, target.suilendMarketId, shares, options?.receiver ?? this.walletAddress, { ...options, txBlock: txb });
+            }
+            else {
+                this.txBuilder.atomicInstantWithdrawWithSuilend(vaultId, target.suilendPoolType, target.suilendMarketId, shares, options?.receiver ?? null, { ...options, txBlock: txb });
+            }
+        }
+        else {
+            this.txBuilder.atomicInstantWithdraw(vaultId, shares, options?.receiver ?? null, { ...options, txBlock: txb });
+        }
         return this.execCall(txb, options);
     }
     /**
@@ -215,7 +231,8 @@ export class UserCalls extends OnChainCalls {
         return this.execCall(txb, options);
     }
     /**
-     * Swap ember shares (source vault receipt coin) into an atomic vault
+     * Swap ember shares (source vault receipt coin) into an atomic vault. Routes to the
+     * entry point for the vault's current strategy.
      * @param vaultId The id of the atomic vault
      * @param sourceReceiptType The receipt coin type of the source vault (R)
      * @param sourceVaultId Object id of the source Vault<T, R>
@@ -242,7 +259,20 @@ export class UserCalls extends OnChainCalls {
             [split, merged] = await CoinUtils.validateCoinBalance(this.suiClient, txb, bigNumber(amount).toFixed(0), coinId);
             coinId = split;
         }
-        this.txBuilder.atomicSwapEmberShares(vaultId, sourceReceiptType, sourceVaultId, coinId, options?.receiver ?? null, minNetOut, { ...options, txBlock: txb });
+        const target = await new SuiAtomicLiquidityReader(this.suiClient).getStrategyTarget(vaultId);
+        // The plain entry point asserts the vault has no strategy (EStrategyMismatch);
+        // a strategy vault must be called with its market so liquidity can be pulled.
+        if (target.strategy === "suilend") {
+            if (isSuiCoinType(target.collateralType)) {
+                this.txBuilder.atomicSwapEmberSharesWithSuilendSui(vaultId, sourceReceiptType, target.suilendPoolType, sourceVaultId, target.suilendMarketId, coinId, options?.receiver ?? this.walletAddress, minNetOut, { ...options, txBlock: txb });
+            }
+            else {
+                this.txBuilder.atomicSwapEmberSharesWithSuilend(vaultId, sourceReceiptType, target.suilendPoolType, sourceVaultId, target.suilendMarketId, coinId, options?.receiver ?? null, minNetOut, { ...options, txBlock: txb });
+            }
+        }
+        else {
+            this.txBuilder.atomicSwapEmberShares(vaultId, sourceReceiptType, sourceVaultId, coinId, options?.receiver ?? null, minNetOut, { ...options, txBlock: txb });
+        }
         if (merged) {
             txb.transferObjects([merged], this.walletAddress);
         }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@ember-finance/sdk",
     "description": "Ember Protocol SDK",
-    "version": "2.25.0",
+    "version": "2.26.0",
     "type": "module",
     "module": "./dist/index.js",
     "main": "./dist/index.js",