@ember-finance/sdk 2.3.1 → 2.5.0-pre.0

package/dist/src/evm-vaults/utils/deployment-parser.js

@@ -27,6 +27,17 @@ export class EVMDeploymentParser {
     getProtocolConfigAddress() {
         return this.deployment.contracts?.protocolConfig.proxyAddress;
     }
+    /**
+     * Resolves the protocol config that governs a specific vault. Atomic Liquidity vaults can be
+     * deployed against their own protocol config (carried per-vault in the deployment), which may
+     * differ from the global one; admin ops for an atomic vault MUST route through that config.
+     * Falls back to the global protocol config for non-atomic vaults (and atomic vaults that don't
+     * specify one).
+     */
+    getProtocolConfigAddressForVault(vaultAddress) {
+        const atomic = Object.values(this.deployment.contracts?.atomicLiquidityVaults ?? {}).find(v => v.proxyAddress?.toLowerCase() === vaultAddress.toLowerCase());
+        return atomic?.protocolConfig ?? this.getProtocolConfigAddress();
+    }
     /**
      * Gets the protocol config implementation address
      */

package/dist/src/sui-vaults/interfaces/index.d.ts

@@ -29,6 +29,21 @@ export interface ISuiDeployment {
             DepositCoinDecimals: number;
         };
     };
+    AtomicVaults?: {
+        [key: string]: {
+            Admin?: Address;
+            Operator?: Address;
+            RateManager?: Address;
+            Name: string;
+            MaxRateChangePerUpdate?: string;
+            FeePercentage?: string;
+            MinWithdrawalShares?: string;
+            SubAccounts?: Address[];
+            ObjectId: Address;
+            CollateralCoinType: Address;
+            CollateralCoinDecimals: number;
+        };
+    };
 }
 export interface IDeploymentConfig {
     rpc: string;

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

@@ -85,4 +85,39 @@ export declare class AdminCalls extends OnChainCalls {
      * @returns OnChainCallResponse
      */
     updateMaxRateInterval(maxRateInterval: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Create and execute a create-atomic-vault transaction. Allows admin to
+     * create a new atomic liquidity vault on the protocol.
+     * @param collateralCoinType The type of the collateral coin (T)
+     * @param vaultName Name of the vault
+     * @param adminAddress The admin address of the vault
+     * @param operatorAddress The operator address of the vault
+     * @param rateManagerAddress The rate manager address of the vault
+     * @param maxRateChangePerUpdate The maximum rate change per update
+     * @param feePercentage The fee percentage
+     * @param minWithdrawalShares The minimum withdrawal shares
+     * @param rateUpdateInterval The rate update interval
+     * @param maxTVL The maximum TVL of the vault
+     * @param subAccounts The sub accounts of the vault
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    createAtomicVault(collateralCoinType: string, vaultName: string, adminAddress: SuiAddress, operatorAddress: SuiAddress, rateManagerAddress: SuiAddress, maxRateChangePerUpdate: NumStr, feePercentage: NumStr, minWithdrawalShares: NumStr, rateUpdateInterval: NumStr, maxTVL: NumStr, subAccounts: SuiAddress[], options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Change the admin address of an atomic vault
+     * @param vaultId The id of the atomic vault
+     * @param adminAddress The new admin address
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    atomicChangeVaultAdmin(vaultId: string, adminAddress: SuiAddress, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Set / unset a blacklisted account on an atomic vault
+     * @param vaultId The id of the atomic vault
+     * @param account The account to set the blacklist status for
+     * @param status Whether the account should be blacklisted
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    atomicSetBlacklistedAccount(vaultId: string, account: SuiAddress, status: boolean, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
 }

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

@@ -137,4 +137,60 @@ export class AdminCalls extends OnChainCalls {
         });
         return this.execCall(txb, options);
     }
+    // ============================================================================
+    // Atomic Liquidity Vault (BFE-818) — protocol admin methods
+    // ============================================================================
+    /**
+     * Create and execute a create-atomic-vault transaction. Allows admin to
+     * create a new atomic liquidity vault on the protocol.
+     * @param collateralCoinType The type of the collateral coin (T)
+     * @param vaultName Name of the vault
+     * @param adminAddress The admin address of the vault
+     * @param operatorAddress The operator address of the vault
+     * @param rateManagerAddress The rate manager address of the vault
+     * @param maxRateChangePerUpdate The maximum rate change per update
+     * @param feePercentage The fee percentage
+     * @param minWithdrawalShares The minimum withdrawal shares
+     * @param rateUpdateInterval The rate update interval
+     * @param maxTVL The maximum TVL of the vault
+     * @param subAccounts The sub accounts of the vault
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async createAtomicVault(collateralCoinType, vaultName, adminAddress, operatorAddress, rateManagerAddress, maxRateChangePerUpdate, feePercentage, minWithdrawalShares, rateUpdateInterval, maxTVL, subAccounts, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        this.txBuilder.createAtomicVault(collateralCoinType, vaultName, adminAddress, operatorAddress, rateManagerAddress, maxRateChangePerUpdate, feePercentage, minWithdrawalShares, rateUpdateInterval, maxTVL, subAccounts, { ...options, txBlock: txb });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Change the admin address of an atomic vault
+     * @param vaultId The id of the atomic vault
+     * @param adminAddress The new admin address
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async atomicChangeVaultAdmin(vaultId, adminAddress, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        this.txBuilder.atomicChangeVaultAdmin(vaultId, adminAddress, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Set / unset a blacklisted account on an atomic vault
+     * @param vaultId The id of the atomic vault
+     * @param account The account to set the blacklist status for
+     * @param status Whether the account should be blacklisted
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async atomicSetBlacklistedAccount(vaultId, account, status, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        this.txBuilder.atomicSetBlacklistedAccount(vaultId, account, status, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
 }

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

@@ -0,0 +1,62 @@
+import { SuiClient } from "@firefly-exchange/library-sui";
+import { FeeMultiplierTier, InstantWithdrawQuote } from "../../atomic/instant-withdraw.js";
+/**
+ * Read-only views + instant-withdraw quotes for the Sui Atomic Liquidity Vault (BET-4111).
+ *
+ * There is no on-chain preview function and no off-chain view calls on Sui, so this reads
+ * the ALV (and source vault) object fields directly and replicates the Move math
+ * (`calculate_amount_from_shares`, `get_vault_tvl`, `swap_ember_shares`,
+ * `do_instant_withdraw_core`) via the shared chain-agnostic quote core at scale 1e9.
+ *
+ * @example
+ * ```ts
+ * const reader = new SuiAtomicLiquidityReader(suiClient);
+ * const q = await reader.previewSwapInstantWithdraw(vaultId, sourceVaultId, 100_000000n, owner);
+ * ```
+ */
+export declare class SuiAtomicLiquidityReader {
+    suiClient: SuiClient;
+    constructor(suiClient: SuiClient);
+    /** Raw Move fields of the AtomicLiquidityVault object. */
+    private vaultFields;
+    /**
+     * Read a `Table<K, V>` entry value. Table entries are plain dynamic fields, so we
+     * resolve the `Field<K,V>` object id via `getDynamicField`, then fetch its json
+     * (`{ name, value }`). Returns the unwrapped `value`, or null if absent.
+     */
+    private readTableValue;
+    /** Rate value (1e9) of any vault object (ALV or source EmberVault). */
+    private rateValue;
+    /** Per-source-share EmberShare config from the `ember_share_configs` table. */
+    getEmberShareConfig(vaultId: string, sourceVaultId: string): Promise<{
+        whitelisted: boolean;
+        feePercentage: bigint;
+        holdbackPercentage: bigint;
+        maxCapacityPercentage: bigint;
+        maxUtilizationPercentage: bigint;
+        epochStartedAt: bigint;
+        epochUsedAmount: bigint;
+        feeMultiplierCurve: FeeMultiplierTier[];
+    } | null>;
+    /** Caller's ALV (non-transferable) share balance from the `shares` table. */
+    shareOf(vaultId: string, account: string): Promise<bigint>;
+    /**
+     * Live quote for the EmberShare swap-with-holdback "instant withdraw" on Sui.
+     * Reads ALV + source vault fields and replicates `swap_ember_shares` math.
+     *
+     * `currentHeldValue` defaults to 0 (the common case before any swap); pass it when the
+     * ALV already custodies source shares. `availableCapacity` (remaining 24h epoch capacity,
+     * collateral units) is bfvs-sourced when precise epoch accounting is required — when
+     * omitted, only the utilization cap gates `withinCapacity`.
+     */
+    previewSwapInstantWithdraw(vaultId: string, sourceVaultId: string, shareAmount: bigint, owner: string, opts?: {
+        availableCapacity?: bigint;
+        currentHeldValue?: bigint;
+        userShareBalance?: bigint;
+    }): Promise<InstantWithdrawQuote>;
+    /**
+     * Live quote for the ALV's own plain `instant_withdraw` on Sui (atomic-share holders).
+     * `net = gross - fee`, no holdback, capped by `max_instant_withdraw_shares`.
+     */
+    previewPlainInstantWithdraw(vaultId: string, shareAmount: bigint, owner: string): Promise<InstantWithdrawQuote>;
+}

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

@@ -0,0 +1,174 @@
+import { bcs } from "@mysten/sui/bcs";
+import { computeSwapQuote, computePlainInstantQuote } from "../../atomic/instant-withdraw.js";
+/** Sui fixed-point scale (1e9) used by the Atomic Liquidity Vault Move math. */
+const SUI_SCALE = 1000000000n;
+const unwrapMoveFields = (value) => value?.fields ?? value;
+const toBig = (v) => v === undefined || v === null ? 0n : BigInt(v);
+/** `math::div(a, b)` = floor(a * scale / b). */
+const divFloor = (a, b) => (b === 0n ? 0n : (a * SUI_SCALE) / b);
+/** `math::div_ceil(a, b)` = ceil(a * scale / b) — used by `calculate_amount_from_shares`. */
+const divCeil = (a, b) => b === 0n ? 0n : (a * SUI_SCALE + (b - 1n)) / b;
+/**
+ * Read-only views + instant-withdraw quotes for the Sui Atomic Liquidity Vault (BET-4111).
+ *
+ * There is no on-chain preview function and no off-chain view calls on Sui, so this reads
+ * the ALV (and source vault) object fields directly and replicates the Move math
+ * (`calculate_amount_from_shares`, `get_vault_tvl`, `swap_ember_shares`,
+ * `do_instant_withdraw_core`) via the shared chain-agnostic quote core at scale 1e9.
+ *
+ * @example
+ * ```ts
+ * const reader = new SuiAtomicLiquidityReader(suiClient);
+ * const q = await reader.previewSwapInstantWithdraw(vaultId, sourceVaultId, 100_000000n, owner);
+ * ```
+ */
+export class SuiAtomicLiquidityReader {
+    constructor(suiClient) {
+        this.suiClient = suiClient;
+    }
+    /** Raw Move fields of the AtomicLiquidityVault object. */
+    async vaultFields(vaultId) {
+        const res = await this.suiClient.core.getObject({
+            objectId: vaultId,
+            include: { json: true }
+        });
+        const fields = unwrapMoveFields(res.object?.json);
+        if (!fields)
+            throw new Error(`Atomic vault ${vaultId} not found`);
+        return fields;
+    }
+    /**
+     * Read a `Table<K, V>` entry value. Table entries are plain dynamic fields, so we
+     * resolve the `Field<K,V>` object id via `getDynamicField`, then fetch its json
+     * (`{ name, value }`). Returns the unwrapped `value`, or null if absent.
+     */
+    async readTableValue(parentId, nameType, keyAddress) {
+        try {
+            const df = await this.suiClient.core.getDynamicField({
+                parentId,
+                name: { type: nameType, bcs: bcs.Address.serialize(keyAddress).toBytes() }
+            });
+            const fieldId = df?.dynamicField?.fieldId;
+            if (!fieldId)
+                return null;
+            const obj = await this.suiClient.core.getObject({
+                objectId: fieldId,
+                include: { json: true }
+            });
+            return unwrapMoveFields(obj.object?.json)?.value;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Rate value (1e9) of any vault object (ALV or source EmberVault). */
+    async rateValue(vaultId) {
+        const res = await this.suiClient.core.getObject({
+            objectId: vaultId,
+            include: { json: true }
+        });
+        const fields = unwrapMoveFields(res.object?.json);
+        return toBig(unwrapMoveFields(fields?.rate)?.value);
+    }
+    /** Per-source-share EmberShare config from the `ember_share_configs` table. */
+    async getEmberShareConfig(vaultId, sourceVaultId) {
+        const fields = await this.vaultFields(vaultId);
+        const tableId = unwrapMoveFields(fields.ember_share_configs)?.id?.id;
+        if (!tableId)
+            return null;
+        {
+            const cfg = unwrapMoveFields(await this.readTableValue(tableId, "0x2::object::ID", sourceVaultId));
+            if (!cfg)
+                return null;
+            const curve = (cfg.fee_multiplier_curve || []).map((t) => {
+                const tf = unwrapMoveFields(t);
+                return {
+                    threshold: toBig(tf.threshold),
+                    multiplier: toBig(tf.multiplier)
+                };
+            });
+            return {
+                whitelisted: !!cfg.whitelisted,
+                feePercentage: toBig(cfg.fee_percentage),
+                holdbackPercentage: toBig(cfg.holdback_percentage),
+                maxCapacityPercentage: toBig(cfg.max_capacity_percentage),
+                maxUtilizationPercentage: toBig(cfg.max_utilization_percentage),
+                epochStartedAt: toBig(cfg.epoch_started_at),
+                epochUsedAmount: toBig(cfg.epoch_used_amount),
+                feeMultiplierCurve: curve
+            };
+        }
+    }
+    /** Caller's ALV (non-transferable) share balance from the `shares` table. */
+    async shareOf(vaultId, account) {
+        const fields = await this.vaultFields(vaultId);
+        const tableId = unwrapMoveFields(fields.shares)?.id?.id;
+        if (!tableId)
+            return 0n;
+        return toBig(await this.readTableValue(tableId, "address", account));
+    }
+    /**
+     * Live quote for the EmberShare swap-with-holdback "instant withdraw" on Sui.
+     * Reads ALV + source vault fields and replicates `swap_ember_shares` math.
+     *
+     * `currentHeldValue` defaults to 0 (the common case before any swap); pass it when the
+     * ALV already custodies source shares. `availableCapacity` (remaining 24h epoch capacity,
+     * collateral units) is bfvs-sourced when precise epoch accounting is required — when
+     * omitted, only the utilization cap gates `withinCapacity`.
+     */
+    async previewSwapInstantWithdraw(vaultId, sourceVaultId, shareAmount, owner, opts = {}) {
+        const fields = await this.vaultFields(vaultId);
+        const atomicRate = toBig(unwrapMoveFields(fields.rate)?.value);
+        const totalShares = toBig(fields.total_shares);
+        const feeWaived = fields.fee_waived_addresses || [];
+        const holdbackWaived = fields.holdback_waived_addresses || [];
+        const [config, sourceRate] = await Promise.all([
+            this.getEmberShareConfig(vaultId, sourceVaultId),
+            this.rateValue(sourceVaultId)
+        ]);
+        if (!config)
+            throw new Error(`source vault ${sourceVaultId} not whitelisted`);
+        // gross = calculate_amount_from_shares(source, shareAmount) = div_ceil(shares, sourceRate)
+        const grossAmount = divCeil(shareAmount, sourceRate);
+        // tvl = get_vault_tvl(atomic) = div(total_shares, atomicRate)
+        const vaultTotalAssets = divFloor(totalShares, atomicRate);
+        return computeSwapQuote({
+            scale: SUI_SCALE,
+            grossAmount,
+            shareAmount,
+            userShareBalance: opts.userShareBalance ?? 0n,
+            currentHeldValue: opts.currentHeldValue ?? 0n,
+            vaultTotalAssets,
+            // Default to "epoch capacity not binding" when not supplied; the on-chain
+            // swap still enforces it. Pass from bfvs for an exact pre-check.
+            availableCapacity: opts.availableCapacity ?? grossAmount,
+            config: {
+                feePercentage: config.feePercentage,
+                holdbackPercentage: config.holdbackPercentage,
+                maxUtilizationPercentage: config.maxUtilizationPercentage,
+                feeMultiplierCurve: config.feeMultiplierCurve
+            },
+            feeWaived: feeWaived.includes(owner),
+            holdbackWaived: holdbackWaived.includes(owner)
+        });
+    }
+    /**
+     * Live quote for the ALV's own plain `instant_withdraw` on Sui (atomic-share holders).
+     * `net = gross - fee`, no holdback, capped by `max_instant_withdraw_shares`.
+     */
+    async previewPlainInstantWithdraw(vaultId, shareAmount, owner) {
+        const fields = await this.vaultFields(vaultId);
+        const atomicRate = toBig(unwrapMoveFields(fields.rate)?.value);
+        const grossAmount = divCeil(shareAmount, atomicRate);
+        const userShareBalance = await this.shareOf(vaultId, owner);
+        return computePlainInstantQuote({
+            scale: SUI_SCALE,
+            grossAmount,
+            shareAmount,
+            userShareBalance,
+            instantWithdrawFeePercentage: toBig(fields.instant_withdraw_fee_percentage),
+            cumulativeInstantWithdrawShares: toBig(fields.cumulative_instant_withdraw_shares),
+            maxInstantWithdrawShares: toBig(fields.max_instant_withdraw_shares)
+        });
+    }
+}

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

@@ -4,3 +4,4 @@ export * from "./user.js";
 export * from "./vault-admin.js";
 export * from "./operator.js";
 export * from "./vault.js";
+export * from "./atomic-liquidity.js";

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

@@ -4,3 +4,4 @@ export * from "./user.js";
 export * from "./vault-admin.js";
 export * from "./operator.js";
 export * from "./vault.js";
+export * from "./atomic-liquidity.js";

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

@@ -100,4 +100,131 @@ export declare class OperatorCalls extends OnChainCalls {
      * @returns OnChainCallResponse
      */
     setFeeExemptionList(vaultId: string, user: SuiAddress, status: boolean, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Process pending withdrawal requests of an atomic vault
+     * @param vaultId The id of the atomic vault
+     * @param maxRequests The maximum number of withdrawal requests to process
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    atomicProcessWithdrawalRequests(vaultId: string, maxRequests: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Process pending withdrawal requests of an atomic vault up to a timestamp
+     * @param vaultId The id of the atomic vault
+     * @param timestamp The timestamp to process withdrawal requests up to
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    atomicProcessWithdrawalRequestsUpToTimestamp(vaultId: string, timestamp: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Collect the platform fee of an atomic vault
+     * @param vaultId The id of the atomic vault
+     * @param loss The reported loss amount
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    atomicCollectPlatformFee(vaultId: string, loss: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Supply collateral from an atomic vault into the Suilend strategy
+     * @param vaultId The id of the atomic vault
+     * @param poolCoinType The Suilend pool coin type (P)
+     * @param lendingMarketId Object id of the Suilend LendingMarket<P>
+     * @param amount The amount to supply
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    atomicSupplyToSuilendStrategy(vaultId: string, poolCoinType: string, lendingMarketId: string, amount: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Supply collateral from an atomic vault into the AlphaLend strategy
+     * @param vaultId The id of the atomic vault
+     * @param lendingProtocolId Object id of the AlphaLend LendingProtocol
+     * @param amount The amount to supply
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    atomicSupplyToAlphalendStrategy(vaultId: string, lendingProtocolId: string, amount: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Withdraw collateral from the Suilend strategy back into an atomic vault
+     * @param vaultId The id of the atomic vault
+     * @param poolCoinType The Suilend pool coin type (P)
+     * @param lendingMarketId Object id of the Suilend LendingMarket<P>
+     * @param amount The amount to withdraw
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    atomicWithdrawFromSuilendStrategy(vaultId: string, poolCoinType: string, lendingMarketId: string, amount: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Withdraw collateral from the AlphaLend strategy back into an atomic vault
+     * @param vaultId The id of the atomic vault
+     * @param lendingProtocolId Object id of the AlphaLend LendingProtocol
+     * @param amount The amount to withdraw
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    atomicWithdrawFromAlphalendStrategy(vaultId: string, lendingProtocolId: string, amount: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Supply collateral from an atomic vault to one of its sub accounts
+     * @param vaultId The id of the atomic vault
+     * @param subAccount The sub account address
+     * @param amount The amount to supply
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    atomicSupplyToSubAccount(vaultId: string, subAccount: string, amount: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Deposit collateral back into an atomic vault from a sub account
+     * @param vaultId The id of the atomic vault
+     * @param tokenId Object id of the Receiving<Coin<T>> payment to claim
+     * @param subAccount The sub account address
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    atomicDepositFromSubAccount(vaultId: string, tokenId: string, subAccount: string, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Redeem collected ember shares from an atomic vault against a source vault
+     * @param vaultId The id of the atomic vault
+     * @param sourceReceiptType The receipt coin type of the source vault (R)
+     * @param sourceVaultId Object id of the source Vault<T, R>
+     * @param amount The amount of shares to redeem
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    atomicRedeemCollectedEmberShares(vaultId: string, sourceReceiptType: string, sourceVaultId: string, amount: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Release users' holdback for an ember share source vault
+     * @param vaultId The id of the atomic vault
+     * @param shareVaultId Id of the source ember share vault
+     * @param unwindingPercentage The unwinding percentage
+     * @param maxEntries The max entries to process
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    atomicReleaseUsersHoldback(vaultId: string, shareVaultId: string, unwindingPercentage: NumStr, maxEntries: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Claim received collateral (a Receiving<Coin<T>>) for an atomic vault
+     * @param vaultId The id of the atomic vault
+     * @param tokenId Object id of the Receiving<Coin<T>> payment to claim
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    atomicClaimReceivedCollateral(vaultId: string, tokenId: string, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Claim returned ember shares (a Receiving<Coin<R>>) for an atomic vault
+     * @param vaultId The id of the atomic vault
+     * @param sourceReceiptType The 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 execution params
+     * @returns OnChainCallResponse
+     */
+    atomicClaimReturnedEmberShares(vaultId: string, sourceReceiptType: string, sourceVaultId: string, tokenId: string, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Update the rate of an atomic vault (rate manager role; uses operator class
+     * to mirror the receipt-vault `updateVaultRate` placement)
+     * @param vaultId The id of the atomic vault
+     * @param newRate The new rate to set for the vault
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    atomicUpdateVaultRate(vaultId: string, newRate: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
 }