@ember-finance/sdk 2.23.0 → 2.24.0

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

@@ -1,5 +1,7 @@
 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";
 /**
  * Read-only views + instant-withdraw quotes for the Sui Atomic Liquidity Vault (BET-4111).
  *
@@ -40,6 +42,19 @@ export declare class SuiAtomicLiquidityReader {
     } | null>;
     /** Caller's ALV (non-transferable) share balance from the `shares` table. */
     shareOf(vaultId: string, account: string): Promise<bigint>;
+    /**
+     * 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` is set when the strategy is Suilend.
+     */
+    getStrategyState(vaultId: string): Promise<{
+        strategy: SuiAtomicStrategy;
+        idleCollateral: bigint;
+        strategyAssets: bigint;
+        suilendMarketId?: string;
+    }>;
     /**
      * Live quote for the EmberShare swap-with-holdback "instant withdraw" on Sui.
      * Reads ALV + source vault fields and replicates `swap_ember_shares` math.

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

@@ -1,6 +1,10 @@
 import { bcs } from "@mysten/sui/bcs";
+import { Transaction } from "@mysten/sui/transactions";
+import { SUI_ZERO_ADDRESS } from "./protocol-config-reader.js";
 import { tableIdOf, unwrapMoveFields } from "../utils/common.js";
 import { computeSwapQuote, computePlainInstantQuote } from "../../atomic/instant-withdraw.js";
+// Indexed by the Move `strategy_kind` u8.
+const SUI_ATOMIC_STRATEGIES = ["none", "suilend"];
 /** Sui fixed-point scale (1e9) used by the Atomic Liquidity Vault Move math. */
 const SUI_SCALE = 1000000000n;
 const toBig = (v) => v === undefined || v === null ? 0n : BigInt(v);
@@ -107,6 +111,72 @@ export class SuiAtomicLiquidityReader {
             return 0n;
         return toBig(await this.readTableValue(tableId, "address", account));
     }
+    /**
+     * 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` is set when the strategy is Suilend.
+     */
+    async getStrategyState(vaultId) {
+        const res = await this.suiClient.core.getObject({
+            objectId: vaultId,
+            include: { json: true }
+        });
+        const fields = unwrapMoveFields(res.object?.json);
+        if (!fields)
+            throw new Error(`Atomic vault ${vaultId} not found`);
+        const strategy = SUI_ATOMIC_STRATEGIES[Number(fields.strategy_kind)];
+        if (!strategy) {
+            throw new Error(`Unknown strategy kind ${fields.strategy_kind} on ${vaultId}`);
+        }
+        const idleCollateral = toBig(fields.balance);
+        if (strategy === "none") {
+            return { strategy, idleCollateral, strategyAssets: 0n };
+        }
+        // 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: {
+                type: "vector<u8>",
+                bcs: bcs
+                    .vector(bcs.u8())
+                    .serialize(new TextEncoder().encode("al_strategy_suilend_market_id"))
+                    .toBytes()
+            }
+        });
+        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);
+        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()]
+        });
+        const sim = await this.suiClient.core.simulateTransaction({
+            transaction: tx,
+            checksEnabled: false,
+            include: { commandResults: true }
+        });
+        const returned = sim.commandResults?.[0]?.returnValues?.[0]?.bcs;
+        if (sim.$kind !== "Transaction" || !returned) {
+            throw new Error(`get_suilend_strategy_assets failed for ${vaultId}: ${sim.FailedTransaction?.status?.error?.message ?? "no return value"}`);
+        }
+        return {
+            strategy,
+            idleCollateral,
+            strategyAssets: BigInt(bcs.u64().parse(returned)),
+            suilendMarketId
+        };
+    }
     /**
      * Live quote for the EmberShare swap-with-holdback "instant withdraw" on Sui.
      * Reads ALV + source vault fields and replicates `swap_ember_shares` math.

package/package.json

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