@ember-finance/sdk 2.33.0 → 2.34.0

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

@@ -62,6 +62,12 @@ export declare class SuiAtomicLiquidityReader {
     private readTableValue;
     /** Rate value (1e9) of any vault object (ALV or source EmberVault). */
     private rateValue;
+    /**
+     * Platform fee a collection would settle at `atMs` (epoch ms), in collateral base units.
+     * @param vaultId The id of the atomic vault
+     * @param atMs Time to project the fee to
+     */
+    getPlatformFeeDue(vaultId: string, atMs: bigint): Promise<bigint>;
     /** Per-source-share EmberShare config from the `ember_share_configs` table. */
     getEmberShareConfig(vaultId: string, sourceVaultId: string): Promise<{
         whitelisted: boolean;

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

@@ -131,6 +131,27 @@ export class SuiAtomicLiquidityReader {
         const fields = unwrapMoveFields(res.object?.json);
         return toBig(unwrapMoveFields(fields?.rate)?.value);
     }
+    /**
+     * Platform fee a collection would settle at `atMs` (epoch ms), in collateral base units.
+     * @param vaultId The id of the atomic vault
+     * @param atMs Time to project the fee to
+     */
+    async getPlatformFeeDue(vaultId, atMs) {
+        // collect_platform_fee charges the time since last_charged_at before settling:
+        // accrued + tvl' * fee_percentage * elapsed_ms / 31_536_000e12, where tvl' is
+        // TVL (div(total_shares, rate)) net of the already-accrued fee.
+        const fields = await this.vaultFields(vaultId);
+        const fee = unwrapMoveFields(fields.fee) ?? {};
+        const accrued = toBig(fee.accrued);
+        const lastChargedAt = toBig(fee.last_charged_at);
+        const feePercentage = toBig(fields.fee_percentage);
+        if (atMs <= lastChargedAt || feePercentage === 0n)
+            return accrued;
+        const tvl = divFloor(toBig(fields.total_shares), toBig(unwrapMoveFields(fields.rate)?.value));
+        const base = tvl > accrued ? tvl - accrued : 0n;
+        return (accrued +
+            (base * feePercentage * (atMs - lastChargedAt)) / 31536000000000000000n);
+    }
     /** Per-source-share EmberShare config from the `ember_share_configs` table. */
     async getEmberShareConfig(vaultId, sourceVaultId) {
         const fields = await this.vaultFields(vaultId);

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

@@ -139,7 +139,8 @@ export declare class OperatorCalls extends OnChainCalls {
      */
     atomicProcessWithdrawalRequestsUpToTimestamp(vaultId: string, timestamp: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
     /**
-     * Collect the platform fee of an atomic vault
+     * Collect the platform fee of an atomic vault. On a strategy vault, pulls any
+     * shortfall from the strategy first, in the same transaction.
      * @param vaultId The id of the atomic vault
      * @param loss The reported loss amount
      * @param options Optional tx execution params

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

@@ -252,7 +252,8 @@ export class OperatorCalls extends OnChainCalls {
         return this.execCall(txb, options);
     }
     /**
-     * Collect the platform fee of an atomic vault
+     * Collect the platform fee of an atomic vault. On a strategy vault, pulls any
+     * shortfall from the strategy first, in the same transaction.
      * @param vaultId The id of the atomic vault
      * @param loss The reported loss amount
      * @param options Optional tx execution params
@@ -260,6 +261,24 @@ export class OperatorCalls extends OnChainCalls {
      */
     async atomicCollectPlatformFee(vaultId, loss, options) {
         const txb = options?.txBlock || new TransactionBlock();
+        // Unlike EVM's collectPlatformFee, the Sui collection pays from idle balance only
+        // and aborts when it is short, so the strategy is drawn on first. The fee keeps
+        // accruing until the tx lands, so it is projected a few minutes ahead; whatever
+        // is pulled beyond the payout stays idle in the vault.
+        const reader = new SuiAtomicLiquidityReader(this.suiClient);
+        const target = await reader.getStrategyTarget(vaultId);
+        if (target.strategy === "suilend") {
+            const landsBy = BigInt(Date.now() + 10 * 60 * 1000);
+            const due = await reader.getPlatformFeeDue(vaultId, landsBy);
+            const payout = due > BigInt(loss) ? due - BigInt(loss) : 0n;
+            const shortfall = payout - target.idleCollateral;
+            if (shortfall > 0n) {
+                const withdraw = isSuiCoinType(target.collateralType)
+                    ? this.txBuilder.atomicWithdrawFromSuilendStrategySui.bind(this.txBuilder)
+                    : this.txBuilder.atomicWithdrawFromSuilendStrategy.bind(this.txBuilder);
+                withdraw(vaultId, target.suilendPoolType, target.suilendMarketId, shortfall.toString(), { ...options, txBlock: txb });
+            }
+        }
         this.txBuilder.atomicCollectPlatformFee(vaultId, loss, {
             ...options,
             txBlock: txb

package/package.json

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