@ember-finance/sdk 2.12.0 → 2.14.0

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

@@ -1,6 +1,6 @@
 import { SuiDeploymentParser } from "../utils/index.js";
 import { TransactionBlock } from "@firefly-exchange/library-sui";
-import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
+import { SUI_CLOCK_OBJECT_ID, SUI_SYSTEM_STATE_OBJECT_ID } from "@mysten/sui/utils";
 export class TxBuilder {
     constructor(_deployment) {
         this.parser = new SuiDeploymentParser(_deployment);
@@ -1734,21 +1734,30 @@ export class TxBuilder {
         return txb;
     }
     /**
-     * Sets the Suilend strategy for an atomic vault
+     * Step 1 of 2 for Suilend activation: commits the reserve index, the market
+     * object and the collateral type. Step 2 is `atomicOpenSuilendObligation`,
+     * without which every supply aborts `ESuilendObligationMissing`.
+     *
+     * The market object and `poolCoinType` became required in the I-11 fix —
+     * previously only the reserve index was committed, so a wrong market was
+     * undetectable on chain.
      * @param vaultId Id of the atomic vault
+     * @param poolCoinType The Suilend pool coin type (P)
+     * @param lendingMarketId Object id of the Suilend LendingMarket<P>
      * @param reserveArrayIndex Suilend reserve array index
      * @param options Optional tx building params
      * @returns TransactionBlock
      */
-    atomicSetStrategySuilend(vaultId, reserveArrayIndex, options) {
+    atomicSetStrategySuilend(vaultId, poolCoinType, lendingMarketId, reserveArrayIndex, options) {
         const txb = options?.txBlock || new TransactionBlock();
         txb.moveCall({
             arguments: [
                 txb.object(vaultId),
                 txb.object(this.parser.getProtocolConfig()),
+                txb.object(lendingMarketId),
                 txb.pure.u64(reserveArrayIndex)
             ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
+            typeArguments: [this.parser.getAtomicCollateralType(vaultId), poolCoinType],
             target: `${this.parser.getPackageId()}::gateway::atomic_set_strategy_suilend`
         });
         if (options?.gasBudget)
@@ -1757,6 +1766,209 @@ export class TxBuilder {
             txb.setSenderIfNotSet(options.sender);
         return txb;
     }
+    /**
+     * Step 2 of 2 for Suilend activation: opens the obligation the vault's
+     * supply is held in. Must run after `atomicSetStrategySuilend` and before
+     * the first supply.
+     *
+     * Not optional. Suilend accounts liquidity-mining rewards against an
+     * obligation, so cTokens held outside one earn base interest and no
+     * rewards; supplying before this aborts rather than silently falling back.
+     * Callable by either the vault admin or the operator.
+     * @param vaultId Id of the atomic vault
+     * @param poolCoinType The Suilend pool coin type (P)
+     * @param lendingMarketId Object id of the Suilend LendingMarket<P>
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    atomicOpenSuilendObligation(vaultId, poolCoinType, lendingMarketId, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(lendingMarketId)
+            ],
+            typeArguments: [this.parser.getAtomicCollateralType(vaultId), poolCoinType],
+            target: `${this.parser.getPackageId()}::gateway::atomic_open_suilend_obligation`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Claims one accrued Suilend pool reward and forwards it to `subAccount`,
+     * which must be on the vault's sub-account allowlist (`EInvalidAccount`).
+     *
+     * Suilend accounts rewards per (reserve, reward slot, deposit-or-borrow)
+     * triple, so call once per triple and batch them in one PTB. Sweep EVERY
+     * occupied slot, not just the live campaign — ended campaigns keep
+     * claimable `earned_rewards`.
+     *
+     * `rewardIndex` must be resolved off chain per claim and never cached:
+     * `add_pool_reward` fills the first vacant slot, so indices are reused, and
+     * a stale (index, rewardType) pair aborts on Suilend's `EInvalidType`.
+     * @param vaultId Id of the atomic vault
+     * @param poolCoinType The Suilend pool coin type (P)
+     * @param lendingMarketId Object id of the Suilend LendingMarket<P>
+     * @param rewardSourceType Coin type identifying the reserve the reward
+     *   accrues on. The vault's collateral for the strategy position itself,
+     *   but the foreign type's own reserve for rewards earned by secondary
+     *   collateral sitting in the obligation — those accrue separately and are
+     *   lost at exit if not claimed.
+     * @param rewardType Coin type of the reward being claimed
+     * @param subAccount Allowlisted sub-account to receive the reward
+     * @param rewardIndex Slot index in the reserve's pool_rewards vector
+     * @param isDepositReward True for the deposit-side reward manager
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    atomicClaimSuilendStrategyReward(vaultId, poolCoinType, lendingMarketId, rewardSourceType, rewardType, subAccount, rewardIndex, isDepositReward, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(lendingMarketId),
+                txb.pure.address(subAccount),
+                txb.pure.u64(rewardIndex),
+                txb.pure.bool(isDepositReward),
+                txb.object(SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [
+                this.parser.getAtomicCollateralType(vaultId),
+                poolCoinType,
+                rewardSourceType,
+                rewardType
+            ],
+            target: `${this.parser.getPackageId()}::gateway::atomic_claim_suilend_strategy_reward`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Drains a foreign collateral position from the vault's Suilend obligation
+     * to an allowlisted sub-account.
+     *
+     * Needed because Suilend's `claim_rewards_and_deposit` takes an obligation
+     * id rather than the owner cap, so anyone can deposit this vault's claimed
+     * rewards into its obligation as collateral in a type the vault never
+     * chose. Teardown refuses to discard the obligation cap while any deposit
+     * remains, so this is what stops a third party blocking the exit. Read the
+     * foreign types off the obligation's `deposits` vector; one call per type.
+     *
+     * Aborts if `rewardType` is the vault's collateral — that position exits
+     * through `atomicWithdrawFromSuilendStrategy`.
+     * @param vaultId Id of the atomic vault
+     * @param poolCoinType The Suilend pool coin type (P)
+     * @param lendingMarketId Object id of the Suilend LendingMarket<P>
+     * @param rewardType Coin type of the foreign collateral position
+     * @param subAccount Allowlisted sub-account to receive the proceeds
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    atomicWithdrawSuilendSecondaryCollateral(vaultId, poolCoinType, lendingMarketId, rewardType, subAccount, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(lendingMarketId),
+                txb.pure.address(subAccount),
+                txb.object(SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [
+                this.parser.getAtomicCollateralType(vaultId),
+                poolCoinType,
+                rewardType
+            ],
+            target: `${this.parser.getPackageId()}::gateway::atomic_withdraw_suilend_secondary_collateral`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * SUI variant of `atomicWithdrawSuilendSecondaryCollateral`. Threads the Sui
+     * system state for Suilend's request -> unstake -> fulfill path.
+     *
+     * Use this whenever the foreign position is SUI, regardless of the vault's
+     * own collateral type. The generic call rejects SUI, because Suilend stakes
+     * idle SUI reserve balance and the combined redemption helper has no
+     * unstake step — it pays from a liquid balance that may be empty. A SUI
+     * position here is likely rather than exotic: SUI and sSUI are what these
+     * reserves pay out.
+     * @param vaultId Id of the atomic vault
+     * @param poolCoinType The Suilend pool coin type (P)
+     * @param lendingMarketId Object id of the Suilend LendingMarket<P>
+     * @param subAccount Allowlisted sub-account to receive the proceeds
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    atomicWithdrawSuilendSecondaryCollateralSui(vaultId, poolCoinType, lendingMarketId, subAccount, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(lendingMarketId),
+                txb.object(SUI_SYSTEM_STATE_OBJECT_ID),
+                txb.pure.address(subAccount),
+                txb.object(SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [this.parser.getAtomicCollateralType(vaultId), poolCoinType],
+            target: `${this.parser.getPackageId()}::gateway::atomic_withdraw_suilend_secondary_collateral_sui`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Collects accrued AlphaLend rewards of coin type `rewardType` and forwards
+     * them to an allowlisted sub-account.
+     *
+     * Call once per reward type BEFORE exiting the strategy — the exit burns
+     * the `PositionCap` and strands anything uncollected. `rewardType` must not
+     * be SUI; AlphaLend settles SUI through the staking system and needs the
+     * monomorphic variant, which this SDK does not yet expose.
+     *
+     * PTB REQUIREMENT: refresh AlphaLend Pyth prices for the active market
+     * earlier in the same transaction.
+     * @param vaultId Id of the atomic vault
+     * @param lendingProtocolId Object id of the AlphaLend LendingProtocol
+     * @param rewardType Coin type of the reward being collected
+     * @param subAccount Allowlisted sub-account to receive the reward
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    atomicCollectAlphalendStrategyReward(vaultId, lendingProtocolId, rewardType, subAccount, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(lendingProtocolId),
+                txb.pure.address(subAccount),
+                txb.object(SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [this.parser.getAtomicCollateralType(vaultId), rewardType],
+            target: `${this.parser.getPackageId()}::gateway::atomic_collect_alphalend_strategy_reward`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
     /**
      * Sets the AlphaLend strategy for an atomic vault
      * @param vaultId Id of the atomic vault
@@ -2384,10 +2596,16 @@ export class TxBuilder {
      * @param sourceVaultId Object id of the source Vault<T, R>
      * @param shareCoinId Object id of the Coin<R> to swap
      * @param receiver Optional receiver address (defaults on-chain to the sender)
+     * @param minNetOut Minimum collateral to receive, in base units. The swap
+     *   aborts below it. This is the A-9 slippage guard: the payout is
+     *   gross - fee - holdback, and both the fee multiplier (which moves with
+     *   utilization) and the source rate can change between quoting and
+     *   landing. Pass the value from `previewSwapInstantWithdraw`; 0 disables
+     *   the guard entirely.
      * @param options Optional tx building params
      * @returns TransactionBlock
      */
-    atomicSwapEmberShares(vaultId, sourceReceiptType, sourceVaultId, shareCoinId, receiver, options) {
+    atomicSwapEmberShares(vaultId, sourceReceiptType, sourceVaultId, shareCoinId, receiver, minNetOut, options) {
         const txb = options?.txBlock || new TransactionBlock();
         txb.moveCall({
             arguments: [
@@ -2396,6 +2614,7 @@ export class TxBuilder {
                 txb.object(sourceVaultId),
                 txb.object(shareCoinId),
                 txb.pure.option("address", receiver ?? null),
+                txb.pure.u64(minNetOut),
                 txb.object(SUI_CLOCK_OBJECT_ID)
             ],
             typeArguments: [
@@ -2420,10 +2639,16 @@ export class TxBuilder {
      * @param lendingMarketId Object id of the Suilend LendingMarket<P>
      * @param shareCoinId Object id of the Coin<R> to swap
      * @param receiver Optional receiver address (defaults on-chain to the sender)
+     * @param minNetOut Minimum collateral to receive, in base units. The swap
+     *   aborts below it. This is the A-9 slippage guard: the payout is
+     *   gross - fee - holdback, and both the fee multiplier (which moves with
+     *   utilization) and the source rate can change between quoting and
+     *   landing. Pass the value from `previewSwapInstantWithdraw`; 0 disables
+     *   the guard entirely.
      * @param options Optional tx building params
      * @returns TransactionBlock
      */
-    atomicSwapEmberSharesWithSuilend(vaultId, sourceReceiptType, poolCoinType, sourceVaultId, lendingMarketId, shareCoinId, receiver, options) {
+    atomicSwapEmberSharesWithSuilend(vaultId, sourceReceiptType, poolCoinType, sourceVaultId, lendingMarketId, shareCoinId, receiver, minNetOut, options) {
         const txb = options?.txBlock || new TransactionBlock();
         txb.moveCall({
             arguments: [
@@ -2433,6 +2658,7 @@ export class TxBuilder {
                 txb.object(lendingMarketId),
                 txb.object(shareCoinId),
                 txb.pure.option("address", receiver ?? null),
+                txb.pure.u64(minNetOut),
                 txb.object(SUI_CLOCK_OBJECT_ID)
             ],
             typeArguments: [
@@ -2457,10 +2683,16 @@ export class TxBuilder {
      * @param lendingProtocolId Object id of the AlphaLend LendingProtocol
      * @param shareCoinId Object id of the Coin<R> to swap
      * @param receiver Optional receiver address (defaults on-chain to the sender)
+     * @param minNetOut Minimum collateral to receive, in base units. The swap
+     *   aborts below it. This is the A-9 slippage guard: the payout is
+     *   gross - fee - holdback, and both the fee multiplier (which moves with
+     *   utilization) and the source rate can change between quoting and
+     *   landing. Pass the value from `previewSwapInstantWithdraw`; 0 disables
+     *   the guard entirely.
      * @param options Optional tx building params
      * @returns TransactionBlock
      */
-    atomicSwapEmberSharesWithAlphalend(vaultId, sourceReceiptType, sourceVaultId, lendingProtocolId, shareCoinId, receiver, options) {
+    atomicSwapEmberSharesWithAlphalend(vaultId, sourceReceiptType, sourceVaultId, lendingProtocolId, shareCoinId, receiver, minNetOut, options) {
         const txb = options?.txBlock || new TransactionBlock();
         txb.moveCall({
             arguments: [
@@ -2470,6 +2702,7 @@ export class TxBuilder {
                 txb.object(lendingProtocolId),
                 txb.object(shareCoinId),
                 txb.pure.option("address", receiver ?? null),
+                txb.pure.u64(minNetOut),
                 txb.object(SUI_CLOCK_OBJECT_ID)
             ],
             typeArguments: [
@@ -2484,4 +2717,257 @@ export class TxBuilder {
             txb.setSenderIfNotSet(options.sender);
         return txb;
     }
+    // === Vault<SUI> variants ===
+    //
+    // A SUI-collateral atomic vault cannot use the generic builders above. The
+    // lending protocols need to unwrap/rewrap SUI through the system state, so
+    // these entry functions are monomorphic in `T = SUI` and take
+    // `&mut SuiSystemState` as an extra argument. `T` therefore drops out of
+    // typeArguments — passing it is the easy mistake here.
+    //
+    // Note the receiver asymmetry, which is in the contract rather than here:
+    // the SUILEND variants take a bare `address`, the ALPHALEND ones take
+    // `Option<address>`. The Suilend builders below therefore require an
+    // explicit receiver — there is no on-chain "default to sender" for them.
+    /**
+     * Swaps ember shares into a SUI-collateral atomic vault, sourcing payout
+     * liquidity from Suilend.
+     * @param vaultId Id of the atomic vault (collateral must be SUI)
+     * @param sourceReceiptType Receipt coin type of the source vault (R)
+     * @param poolCoinType Suilend pool coin type (P)
+     * @param sourceVaultId Object id of the source Vault<SUI, R>
+     * @param lendingMarketId Object id of the Suilend LendingMarket<P>
+     * @param shareCoinId Object id of the Coin<R> to swap
+     * @param receiver Payout recipient. REQUIRED — this entry function takes a
+     *   bare address, so unlike the generic variant there is no on-chain
+     *   fallback to the sender.
+     * @param minNetOut Minimum collateral to receive, in base units (A-9 guard)
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    atomicSwapEmberSharesWithSuilendSui(vaultId, sourceReceiptType, poolCoinType, sourceVaultId, lendingMarketId, shareCoinId, receiver, minNetOut, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(sourceVaultId),
+                txb.object(lendingMarketId),
+                txb.object(SUI_SYSTEM_STATE_OBJECT_ID),
+                txb.object(shareCoinId),
+                txb.pure.address(receiver),
+                txb.pure.u64(minNetOut),
+                txb.object(SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [sourceReceiptType, poolCoinType],
+            target: `${this.parser.getPackageId()}::gateway::atomic_swap_ember_shares_with_suilend_sui`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Swaps ember shares into a SUI-collateral atomic vault, sourcing payout
+     * liquidity from AlphaLend.
+     * @param vaultId Id of the atomic vault (collateral must be SUI)
+     * @param sourceReceiptType Receipt coin type of the source vault (R)
+     * @param sourceVaultId Object id of the source Vault<SUI, R>
+     * @param lendingProtocolId Object id of the AlphaLend LendingProtocol
+     * @param shareCoinId Object id of the Coin<R> to swap
+     * @param receiver Optional receiver address (defaults on-chain to the sender)
+     * @param minNetOut Minimum collateral to receive, in base units (A-9 guard)
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    atomicSwapEmberSharesWithAlphalendSui(vaultId, sourceReceiptType, sourceVaultId, lendingProtocolId, shareCoinId, receiver, minNetOut, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(sourceVaultId),
+                txb.object(lendingProtocolId),
+                txb.object(SUI_SYSTEM_STATE_OBJECT_ID),
+                txb.object(shareCoinId),
+                txb.pure.option("address", receiver ?? null),
+                txb.pure.u64(minNetOut),
+                txb.object(SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [sourceReceiptType],
+            target: `${this.parser.getPackageId()}::gateway::atomic_swap_ember_shares_with_alphalend_sui`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Instant withdraw from a SUI-collateral atomic vault, pulling liquidity
+     * from Suilend.
+     * @param receiver Payout recipient. REQUIRED — bare address on chain.
+     */
+    atomicInstantWithdrawWithSuilendSui(vaultId, poolCoinType, lendingMarketId, shares, receiver, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(lendingMarketId),
+                txb.object(SUI_SYSTEM_STATE_OBJECT_ID),
+                txb.pure.u64(shares),
+                txb.pure.address(receiver),
+                txb.object(SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [poolCoinType],
+            target: `${this.parser.getPackageId()}::gateway::atomic_instant_withdraw_with_suilend_sui`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Instant withdraw from a SUI-collateral atomic vault, pulling liquidity
+     * from AlphaLend.
+     * @param receiver Optional receiver address (defaults on-chain to the sender)
+     */
+    atomicInstantWithdrawWithAlphalendSui(vaultId, lendingProtocolId, shares, receiver, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(lendingProtocolId),
+                txb.object(SUI_SYSTEM_STATE_OBJECT_ID),
+                txb.pure.u64(shares),
+                txb.pure.option("address", receiver ?? null),
+                txb.object(SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [],
+            target: `${this.parser.getPackageId()}::gateway::atomic_instant_withdraw_with_alphalend_sui`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /** Exits the Suilend strategy on a SUI-collateral vault (operator). */
+    atomicSetStrategyNoneFromSuilendSui(vaultId, poolCoinType, lendingMarketId, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(lendingMarketId),
+                txb.object(SUI_SYSTEM_STATE_OBJECT_ID),
+                txb.object(SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [poolCoinType],
+            target: `${this.parser.getPackageId()}::gateway::atomic_set_strategy_none_from_suilend_sui`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Exits the AlphaLend strategy on a SUI-collateral vault (operator).
+     * @param acceptResidual Abandon a dust residual rather than aborting the exit
+     */
+    atomicSetStrategyNoneFromAlphalendSui(vaultId, lendingProtocolId, acceptResidual, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(lendingProtocolId),
+                txb.object(SUI_SYSTEM_STATE_OBJECT_ID),
+                txb.pure.bool(acceptResidual),
+                txb.object(SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [],
+            target: `${this.parser.getPackageId()}::gateway::atomic_set_strategy_none_from_alphalend_sui`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /** Withdraws from the Suilend strategy on a SUI-collateral vault (operator). */
+    atomicWithdrawFromSuilendStrategySui(vaultId, poolCoinType, lendingMarketId, amount, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(lendingMarketId),
+                txb.object(SUI_SYSTEM_STATE_OBJECT_ID),
+                txb.pure.u64(amount),
+                txb.object(SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [poolCoinType],
+            target: `${this.parser.getPackageId()}::gateway::atomic_withdraw_from_suilend_strategy_sui`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /** Withdraws from the AlphaLend strategy on a SUI-collateral vault (operator). */
+    atomicWithdrawFromAlphalendStrategySui(vaultId, lendingProtocolId, amount, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(lendingProtocolId),
+                txb.object(SUI_SYSTEM_STATE_OBJECT_ID),
+                txb.pure.u64(amount),
+                txb.object(SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [],
+            target: `${this.parser.getPackageId()}::gateway::atomic_withdraw_from_alphalend_strategy_sui`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Collects AlphaLend rewards through the SUI system state and forwards them
+     * to an allowlisted sub-account (operator).
+     *
+     * Unlike the other `_sui` entrypoints this one is still generic in `T` — it
+     * is the reward path, not the collateral path, so the vault's own collateral
+     * type is still a type argument.
+     */
+    atomicCollectAlphalendStrategyRewardSui(vaultId, lendingProtocolId, subAccount, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(lendingProtocolId),
+                txb.object(SUI_SYSTEM_STATE_OBJECT_ID),
+                txb.pure.address(subAccount),
+                txb.object(SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
+            target: `${this.parser.getPackageId()}::gateway::atomic_collect_alphalend_strategy_reward_sui`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
 }