@ember-finance/sdk 2.25.0 → 2.27.0

package/dist/src/atomic/instant-withdraw.d.ts

@@ -39,13 +39,12 @@ export interface EmberShareSwapConfig {
     /**
      * Minimum gross collateral value per swap (collateral units). A swap with
      * `gross < minSwapGross` reverts `SwapAmountTooSmall`. 0/undefined disables the floor.
-     * EVM-only (no Sui equivalent yet) — omit on Sui.
      */
     minSwapGross?: bigint;
     /**
      * TVL-independent absolute ceiling on this source share's post-swap held value
      * (collateral units). A swap pushing `currentHeldValue + gross` above it reverts
-     * `EmberShareHeldValueCapExceeded`. 0/undefined disables it. EVM-only — omit on Sui.
+     * `EmberShareHeldValueCapExceeded`. 0/undefined disables it.
      */
     maxHeldValueAbsolute?: bigint;
 }

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).
  *
@@ -39,9 +51,20 @@ export declare class SuiAtomicLiquidityReader {
         epochStartedAt: bigint;
         epochUsedAmount: bigint;
         feeMultiplierCurve: FeeMultiplierTier[];
+        minSwapGross: bigint;
+        maxHeldValueAbsolute: bigint;
     } | 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

@@ -99,7 +99,9 @@ export class SuiAtomicLiquidityReader {
                 maxUtilizationPercentage: toBig(cfg.max_utilization_percentage),
                 epochStartedAt: toBig(cfg.epoch_started_at),
                 epochUsedAmount: toBig(cfg.epoch_used_amount),
-                feeMultiplierCurve: curve
+                feeMultiplierCurve: curve,
+                minSwapGross: toBig(cfg.min_swap_gross),
+                maxHeldValueAbsolute: toBig(cfg.max_held_value_absolute)
             };
         }
     }
@@ -112,14 +114,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 +137,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 +158,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 +208,7 @@ export class SuiAtomicLiquidityReader {
             idleCollateral,
             strategyAssets: BigInt(bcs.u64().parse(returned)),
             suilendMarketId,
-            suilendPoolType: poolType
+            suilendPoolType
         };
     }
     /**
@@ -218,7 +250,9 @@ export class SuiAtomicLiquidityReader {
                 feePercentage: config.feePercentage,
                 holdbackPercentage: config.holdbackPercentage,
                 maxUtilizationPercentage: config.maxUtilizationPercentage,
-                feeMultiplierCurve: config.feeMultiplierCurve
+                feeMultiplierCurve: config.feeMultiplierCurve,
+                minSwapGross: config.minSwapGross,
+                maxHeldValueAbsolute: config.maxHeldValueAbsolute
             },
             feeWaived: feeWaived.includes(owner),
             holdbackWaived: holdbackWaived.includes(owner)

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.27.0",
     "type": "module",
     "module": "./dist/index.js",
     "main": "./dist/index.js",