@ember-finance/sdk 2.5.0-pre.8 → 2.5.0

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

@@ -1018,1434 +1018,4 @@ export class TxBuilder {
             txb.setSenderIfNotSet(options.sender);
         return txb;
     }
-    // ============================================================================
-    // Atomic Liquidity Vault (BFE-818)
-    //
-    // All entrypoints below target `gateway::atomic_*` (+ `create_atomic_vault`).
-    // The atomic vault type is `AtomicLiquidityVault<T>` where `T` is the
-    // collateral coin type and there is NO receipt token. `T` is resolved from
-    // the deployment via `parser.getAtomicCollateralType(vaultId)` rather than
-    // being passed explicitly. Functions that also need `R` (the source ember
-    // vault receipt) or `P` (the Suilend pool coin type) take those type strings
-    // as explicit method params. External objects (Suilend `LendingMarket<P>`,
-    // AlphaLend `LendingProtocol`, source `Vault<T, R>`, and `Receiving<Coin>`
-    // payment objects) are passed as object id strings.
-    //
-    // JUDGMENT CALLS NEEDING SUI-NODE VALIDATION:
-    //  - `Coin<T>` / `Coin<R>` arguments (atomicDeposit, atomicSwapEmberShares*,
-    //    atomicDepositFromSubAccount payments) are passed via `txb.object(coinId)`.
-    //    Callers are expected to pre-split/merge to an exact coin, mirroring the
-    //    existing receipt-vault `deposit`/`redeemShares` flow which does the
-    //    split in the role class before calling the builder.
-    //  - `Receiving<Coin<T>>` / `Receiving<Coin<R>>` arguments
-    //    (atomicDepositFromSubAccount, atomicClaimReceivedCollateral,
-    //    atomicClaimReturnedEmberShares) are passed via `txb.object(receivingId)`.
-    //    The Sui PTB builder resolves an owned/received object reference from a
-    //    plain object id; this should be validated against a live node.
-    //  - `Option<address>` receiver args use `txb.pure.option("address", x ?? null)`.
-    // ============================================================================
-    /**
-     * Creates a new atomic liquidity vault
-     * @param collateralCoinType Type of the collateral coin (T)
-     * @param name Name of the vault
-     * @param admin Admin of the vault
-     * @param operator Operator of the vault
-     * @param rateManager Rate manager of the vault
-     * @param maxRateChangePerUpdate Max rate change per update
-     * @param feePercentage Fee percentage
-     * @param minWithdrawalShares Min withdrawal shares
-     * @param rateUpdateInterval Rate update interval
-     * @param maxTVL Max TVL
-     * @param subAccounts Sub accounts
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    createAtomicVault(collateralCoinType, name, admin, operator, rateManager, maxRateChangePerUpdate, feePercentage, minWithdrawalShares, rateUpdateInterval, maxTVL, subAccounts, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(this.parser.getProtocolConfig()),
-                txb.object(this.parser.getAdminCap()),
-                txb.pure.string(name),
-                txb.pure.address(admin),
-                txb.pure.address(operator),
-                txb.pure.address(rateManager),
-                txb.pure.u64(maxRateChangePerUpdate),
-                txb.pure.u64(feePercentage),
-                txb.pure.u64(minWithdrawalShares),
-                txb.pure.u64(rateUpdateInterval),
-                txb.pure.u64(maxTVL),
-                txb.pure.vector("address", subAccounts)
-            ],
-            typeArguments: [collateralCoinType],
-            target: `${this.parser.getPackageId()}::gateway::create_atomic_vault`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Changes the admin of an atomic vault (protocol admin)
-     * @param vaultId Id of the atomic vault
-     * @param newAdmin New admin address
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicChangeVaultAdmin(vaultId, newAdmin, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.object(this.parser.getAdminCap()),
-                txb.pure.address(newAdmin)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_change_vault_admin`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Updates the name of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param name New vault name
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicUpdateVaultName(vaultId, name, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.string(name)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_update_vault_name`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Updates the max TVL of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param maxTVL Max TVL
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicUpdateVaultMaxTvl(vaultId, maxTVL, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(maxTVL)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_update_vault_max_tvl`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Updates the max rate change per update of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param maxRateChangePerUpdate Max rate change per update
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicUpdateVaultMaxRateChangePerUpdate(vaultId, maxRateChangePerUpdate, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(maxRateChangePerUpdate)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_update_vault_max_rate_change_per_update`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Changes the rate update interval of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param interval Rate update interval in ms
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicChangeVaultRateUpdateInterval(vaultId, interval, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(interval)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_change_vault_rate_update_interval`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Changes the operator of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param newOperator New operator address
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicChangeVaultOperator(vaultId, newOperator, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.address(newOperator)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_change_vault_operator`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Updates the rate manager of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param newRateManager New rate manager address
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicUpdateVaultRateManager(vaultId, newRateManager, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.address(newRateManager)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_update_vault_rate_manager`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Updates the fee percentage of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param feePercentage Fee percentage
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicUpdateVaultFeePercentage(vaultId, feePercentage, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(feePercentage),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_update_vault_fee_percentage`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Sets the min withdrawal shares of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param minWithdrawalShares Min withdrawal shares
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetMinWithdrawalShares(vaultId, minWithdrawalShares, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(minWithdrawalShares)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_min_withdrawal_shares`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Sets / unsets a sub account on an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param account Sub account address
-     * @param status Status of the sub account
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetSubAccount(vaultId, account, status, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.address(account),
-                txb.pure.bool(status)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_sub_account`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Sets the pause status of an operation on an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param operation Operation identifier bytes (vector<u8>)
-     * @param paused Paused status
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetPauseStatus(vaultId, operation, paused, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.vector("u8", operation),
-                txb.pure.bool(paused)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_pause_status`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Sets the max instant withdraw shares of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param newMax New max instant withdraw shares
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetMaxInstantWithdrawShares(vaultId, newMax, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(newMax)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_max_instant_withdraw_shares`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Sets the instant withdraw fee percentage of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param newFeePercentage New instant withdraw fee percentage
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetInstantWithdrawFeePercentage(vaultId, newFeePercentage, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(newFeePercentage)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_instant_withdraw_fee_percentage`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Whitelists (or updates) an ember share source vault for an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param shareVaultId Id of the source ember share vault
-     * @param whitelisted Whitelist status
-     * @param feePercentage Fee percentage
-     * @param maxCapacityPercentage Max capacity percentage
-     * @param holdbackPercentage Holdback percentage
-     * @param maxUtilizationPercentage Max utilization percentage
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetEmberShareWhitelist(vaultId, shareVaultId, whitelisted, feePercentage, maxCapacityPercentage, holdbackPercentage, maxUtilizationPercentage, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.id(shareVaultId),
-                txb.pure.bool(whitelisted),
-                txb.pure.u64(feePercentage),
-                txb.pure.u64(maxCapacityPercentage),
-                txb.pure.u64(holdbackPercentage),
-                txb.pure.u64(maxUtilizationPercentage)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_ember_share_whitelist`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Sets the max utilization percentage of an ember share source vault
-     * @param vaultId Id of the atomic vault
-     * @param shareVaultId Id of the source ember share vault
-     * @param maxUtilizationPercentage Max utilization percentage
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetEmberShareMaxUtilization(vaultId, shareVaultId, maxUtilizationPercentage, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.id(shareVaultId),
-                txb.pure.u64(maxUtilizationPercentage)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_ember_share_max_utilization`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Sets a fee multiplier tier for an ember share source vault
-     * @param vaultId Id of the atomic vault
-     * @param shareVaultId Id of the source ember share vault
-     * @param threshold Tier threshold
-     * @param multiplier Tier multiplier
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetEmberShareFeeMultiplierTier(vaultId, shareVaultId, threshold, multiplier, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.id(shareVaultId),
-                txb.pure.u64(threshold),
-                txb.pure.u64(multiplier)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_ember_share_fee_multiplier_tier`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Removes a fee multiplier tier for an ember share source vault
-     * @param vaultId Id of the atomic vault
-     * @param shareVaultId Id of the source ember share vault
-     * @param threshold Tier threshold to remove
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicRemoveEmberShareFeeMultiplierTier(vaultId, shareVaultId, threshold, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.id(shareVaultId),
-                txb.pure.u64(threshold)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_remove_ember_share_fee_multiplier_tier`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Sets a swap waiver for an account on an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param account Account address
-     * @param feeWaived Whether the swap fee is waived
-     * @param holdbackWaived Whether the holdback is waived
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetSwapWaiver(vaultId, account, feeWaived, holdbackWaived, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.address(account),
-                txb.pure.bool(feeWaived),
-                txb.pure.bool(holdbackWaived)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_swap_waiver`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Sets the permanent withdrawal fee percentage of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param permanentFeePercentage Permanent fee percentage
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetPermanentFeePercentage(vaultId, permanentFeePercentage, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(permanentFeePercentage)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_permanent_fee_percentage`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Sets the time based withdrawal fee percentage of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param timeBasedFeePercentage Time based fee percentage
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetTimeBasedFeePercentage(vaultId, timeBasedFeePercentage, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(timeBasedFeePercentage)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_time_based_fee_percentage`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Sets the time based withdrawal fee threshold of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param timeBasedFeeThreshold Time based fee threshold
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetTimeBasedFeeThreshold(vaultId, timeBasedFeeThreshold, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(timeBasedFeeThreshold)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_time_based_fee_threshold`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Sets / unsets a user on the fee exemption list of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param user User address
-     * @param status Status of the user in the fee exemption list
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetFeeExemptionList(vaultId, user, status, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.address(user),
-                txb.pure.bool(status)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_fee_exemption_list`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Switches an atomic vault from the Suilend strategy to STRATEGY_NONE,
-     * draining cTokens back into the vault balance.
-     * @param vaultId Id of the atomic vault
-     * @param poolCoinType Suilend pool coin type (P)
-     * @param lendingMarketId Object id of the Suilend LendingMarket<P>
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetStrategyNoneFromSuilend(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_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId), poolCoinType],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_strategy_none_from_suilend`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Switches an atomic vault from the AlphaLend strategy to STRATEGY_NONE,
-     * draining the full position collateral back into the vault balance.
-     * @param vaultId Id of the atomic vault
-     * @param lendingProtocolId Object id of the AlphaLend LendingProtocol
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetStrategyNoneFromAlphalend(vaultId, lendingProtocolId, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.object(lendingProtocolId),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_strategy_none_from_alphalend`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Sets the Suilend strategy for an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param reserveArrayIndex Suilend reserve array index
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetStrategySuilend(vaultId, reserveArrayIndex, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(reserveArrayIndex)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_strategy_suilend`
-        });
-        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
-     * @param lendingProtocolId Object id of the AlphaLend LendingProtocol
-     * @param marketId AlphaLend market id
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetStrategyAlphalend(vaultId, lendingProtocolId, marketId, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.object(lendingProtocolId),
-                txb.pure.u64(marketId)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_strategy_alphalend`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Sets / unsets a blacklisted account on an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param account Account address
-     * @param status Blacklist status
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetBlacklistedAccount(vaultId, account, status, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.address(account),
-                txb.pure.bool(status)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_blacklisted_account`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Sets / unsets a user on the deposit user list of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param user User address
-     * @param status Status of the user in the deposit list
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSetDepositUserList(vaultId, user, status, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.address(user),
-                txb.pure.bool(status)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_set_deposit_user_list`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Supplies collateral from an atomic vault to one of its sub accounts
-     * @param vaultId Id of the atomic vault
-     * @param subAccount Sub account address
-     * @param amount Amount to supply
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSupplyToSubAccount(vaultId, subAccount, amount, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.address(subAccount),
-                txb.pure.u64(amount)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_supply_to_sub_account`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Deposits collateral back into an atomic vault from a sub account
-     * @param vaultId Id of the atomic vault
-     * @param tokenId Object id of the Receiving<Coin<T>> payment to claim
-     * @param subAccount Sub account address
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicDepositFromSubAccount(vaultId, tokenId, subAccount, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.object(tokenId),
-                txb.pure.address(subAccount)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_deposit_from_sub_account`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Collects the platform fee of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param loss Reported loss amount
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicCollectPlatformFee(vaultId, loss, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(loss),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_collect_platform_fee`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Processes pending withdrawal requests of an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param maxRequests Max number of requests to process
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicProcessWithdrawalRequests(vaultId, maxRequests, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(maxRequests),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_process_withdrawal_requests`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Processes pending withdrawal requests of an atomic vault up to a timestamp
-     * @param vaultId Id of the atomic vault
-     * @param timestamp Timestamp to process up to
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicProcessWithdrawalRequestsUpToTimestamp(vaultId, timestamp, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(timestamp),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_process_withdrawal_requests_up_to_timestamp`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Supplies collateral from an atomic vault into the Suilend strategy
-     * @param vaultId Id of the atomic vault
-     * @param poolCoinType Suilend pool coin type (P)
-     * @param lendingMarketId Object id of the Suilend LendingMarket<P>
-     * @param amount Amount to supply
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSupplyToSuilendStrategy(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.pure.u64(amount),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId), poolCoinType],
-            target: `${this.parser.getPackageId()}::gateway::atomic_supply_to_suilend_strategy`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Supplies collateral from an atomic vault into the AlphaLend strategy
-     * @param vaultId Id of the atomic vault
-     * @param lendingProtocolId Object id of the AlphaLend LendingProtocol
-     * @param amount Amount to supply
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSupplyToAlphalendStrategy(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.pure.u64(amount),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_supply_to_alphalend_strategy`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Withdraws collateral from the Suilend strategy back into an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param poolCoinType Suilend pool coin type (P)
-     * @param lendingMarketId Object id of the Suilend LendingMarket<P>
-     * @param amount Amount to withdraw
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicWithdrawFromSuilendStrategy(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.pure.u64(amount),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId), poolCoinType],
-            target: `${this.parser.getPackageId()}::gateway::atomic_withdraw_from_suilend_strategy`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Withdraws collateral from the AlphaLend strategy back into an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param lendingProtocolId Object id of the AlphaLend LendingProtocol
-     * @param amount Amount to withdraw
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicWithdrawFromAlphalendStrategy(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.pure.u64(amount),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_withdraw_from_alphalend_strategy`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Releases users' holdback for an ember share source vault
-     * @param vaultId Id of the atomic vault
-     * @param shareVaultId Id of the source ember share vault
-     * @param unwindingPercentage Unwinding percentage
-     * @param maxEntries Max entries to process
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicReleaseUsersHoldback(vaultId, shareVaultId, unwindingPercentage, maxEntries, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.id(shareVaultId),
-                txb.pure.u64(unwindingPercentage),
-                txb.pure.u64(maxEntries),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_release_users_holdback`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Redeems collected ember shares from an atomic vault against a source vault
-     * @param vaultId Id of the atomic vault
-     * @param sourceReceiptType Receipt coin type of the source vault (R)
-     * @param sourceVaultId Object id of the source Vault<T, R>
-     * @param amount Amount of shares to redeem
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicRedeemCollectedEmberShares(vaultId, sourceReceiptType, sourceVaultId, amount, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.object(sourceVaultId),
-                txb.pure.u64(amount),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [
-                this.parser.getAtomicCollateralType(vaultId),
-                sourceReceiptType
-            ],
-            target: `${this.parser.getPackageId()}::gateway::atomic_redeem_collected_ember_shares`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Claims received collateral (a Receiving<Coin<T>>) for an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param tokenId Object id of the Receiving<Coin<T>> payment to claim
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicClaimReceivedCollateral(vaultId, tokenId, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.object(tokenId)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_claim_received_collateral`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Claims returned ember shares (a Receiving<Coin<R>>) for an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param sourceReceiptType Receipt coin type of the source vault (R)
-     * @param sourceVaultId Id of the source vault the shares belong to
-     * @param tokenId Object id of the Receiving<Coin<R>> payment to claim
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicClaimReturnedEmberShares(vaultId, sourceReceiptType, sourceVaultId, tokenId, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.id(sourceVaultId),
-                txb.object(tokenId)
-            ],
-            typeArguments: [
-                this.parser.getAtomicCollateralType(vaultId),
-                sourceReceiptType
-            ],
-            target: `${this.parser.getPackageId()}::gateway::atomic_claim_returned_ember_shares`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Updates the rate of an atomic vault (rate manager)
-     * @param vaultId Id of the atomic vault
-     * @param newRate New rate
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicUpdateVaultRate(vaultId, newRate, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(newRate),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_update_vault_rate`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Deposits collateral into an atomic vault, minting shares
-     * @param vaultId Id of the atomic vault
-     * @param coinId Object id of the Coin<T> to deposit
-     * @param minShares Minimum number of shares to mint
-     * @param receiver Optional receiver address (defaults on-chain to the sender)
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicDeposit(vaultId, coinId, minShares, receiver, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.object(coinId),
-                txb.pure.u64(minShares),
-                txb.pure.option("address", receiver ?? null),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_deposit`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Redeems shares from an atomic vault (queued withdrawal)
-     * @param vaultId Id of the atomic vault
-     * @param shares Number of shares to redeem
-     * @param receiver Optional receiver address (defaults on-chain to the sender)
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicRedeemShares(vaultId, shares, receiver, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(shares),
-                txb.pure.option("address", receiver ?? null),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_redeem_shares`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Cancels a pending withdrawal request on an atomic vault
-     * @param vaultId Id of the atomic vault
-     * @param sequenceNumber Sequence number of the request
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicCancelPendingWithdrawalRequest(vaultId, sequenceNumber, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u128(sequenceNumber)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_cancel_pending_withdrawal_request`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Performs an instant withdraw from an atomic vault (no strategy)
-     * @param vaultId Id of the atomic vault
-     * @param shares Number of shares to withdraw
-     * @param receiver Optional receiver address (defaults on-chain to the sender)
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicInstantWithdraw(vaultId, shares, receiver, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.pure.u64(shares),
-                txb.pure.option("address", receiver ?? null),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_instant_withdraw`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Performs an instant withdraw from an atomic vault routed through Suilend
-     * @param vaultId Id of the atomic vault
-     * @param poolCoinType Suilend pool coin type (P)
-     * @param lendingMarketId Object id of the Suilend LendingMarket<P>
-     * @param shares Number of shares to withdraw
-     * @param receiver Optional receiver address (defaults on-chain to the sender)
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicInstantWithdrawWithSuilend(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.pure.u64(shares),
-                txb.pure.option("address", receiver ?? null),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId), poolCoinType],
-            target: `${this.parser.getPackageId()}::gateway::atomic_instant_withdraw_with_suilend`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Performs an instant withdraw from an atomic vault routed through AlphaLend
-     * @param vaultId Id of the atomic vault
-     * @param lendingProtocolId Object id of the AlphaLend LendingProtocol
-     * @param shares Number of shares to withdraw
-     * @param receiver Optional receiver address (defaults on-chain to the sender)
-     * @param options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicInstantWithdrawWithAlphalend(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.pure.u64(shares),
-                txb.pure.option("address", receiver ?? null),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
-            target: `${this.parser.getPackageId()}::gateway::atomic_instant_withdraw_with_alphalend`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Swaps ember shares (Coin<R>) into an atomic vault, minting atomic shares
-     * @param vaultId Id of the atomic vault
-     * @param sourceReceiptType Receipt coin type of the source vault (R)
-     * @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 options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSwapEmberShares(vaultId, sourceReceiptType, sourceVaultId, shareCoinId, receiver, options) {
-        const txb = options?.txBlock || new TransactionBlock();
-        txb.moveCall({
-            arguments: [
-                txb.object(vaultId),
-                txb.object(this.parser.getProtocolConfig()),
-                txb.object(sourceVaultId),
-                txb.object(shareCoinId),
-                txb.pure.option("address", receiver ?? null),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [
-                this.parser.getAtomicCollateralType(vaultId),
-                sourceReceiptType
-            ],
-            target: `${this.parser.getPackageId()}::gateway::atomic_swap_ember_shares`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Swaps ember shares (Coin<R>) into an atomic vault, routing collateral
-     * through the Suilend strategy
-     * @param vaultId Id of the atomic vault
-     * @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<T, R>
-     * @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 options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSwapEmberSharesWithSuilend(vaultId, sourceReceiptType, poolCoinType, sourceVaultId, lendingMarketId, shareCoinId, receiver, 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(shareCoinId),
-                txb.pure.option("address", receiver ?? null),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [
-                this.parser.getAtomicCollateralType(vaultId),
-                sourceReceiptType,
-                poolCoinType
-            ],
-            target: `${this.parser.getPackageId()}::gateway::atomic_swap_ember_shares_with_suilend`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
-    /**
-     * Swaps ember shares (Coin<R>) into an atomic vault, routing collateral
-     * through the AlphaLend strategy
-     * @param vaultId Id of the atomic vault
-     * @param sourceReceiptType Receipt coin type of the source vault (R)
-     * @param sourceVaultId Object id of the source Vault<T, 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 options Optional tx building params
-     * @returns TransactionBlock
-     */
-    atomicSwapEmberSharesWithAlphalend(vaultId, sourceReceiptType, sourceVaultId, lendingProtocolId, shareCoinId, receiver, 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(shareCoinId),
-                txb.pure.option("address", receiver ?? null),
-                txb.object(SUI_CLOCK_OBJECT_ID)
-            ],
-            typeArguments: [
-                this.parser.getAtomicCollateralType(vaultId),
-                sourceReceiptType
-            ],
-            target: `${this.parser.getPackageId()}::gateway::atomic_swap_ember_shares_with_alphalend`
-        });
-        if (options?.gasBudget)
-            txb.setGasBudget(options.gasBudget);
-        if (options?.sender)
-            txb.setSenderIfNotSet(options.sender);
-        return txb;
-    }
 }