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

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

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

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

@@ -99,4 +99,14 @@ export declare class EVMOperatorCalls extends EVMOnChainCalls {
      * @returns EvmOnChainCallResponse
      */
     setDepositAllowList(vaultAddress: string, user: string, status: boolean, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: supply `assets` of idle collateral into the external ERC-4626 strategy. */
+    supplyToStrategy(vaultAddress: string, assets: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: withdraw `assets` of collateral back from the strategy into the vault. */
+    withdrawFromStrategy(vaultAddress: string, assets: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: submit `amount` of collected source `share` for redemption on the source vault. */
+    redeemCollectedEmberShares(vaultAddress: string, share: string, amount: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: release the holdback FIFO for `share` at `unwindingPercentage` (1e18=100%), up to `maxEntries`. */
+    releaseUsersHoldback(vaultAddress: string, share: string, unwindingPercentage: NumStr, maxEntries: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: move `amount` of collateral to a registered sub-account. */
+    supplyToSubAccount(vaultAddress: string, subAccount: string, amount: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
 }

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

@@ -136,4 +136,32 @@ export class EVMOperatorCalls extends EVMOnChainCalls {
         const txCall = this.txBuilder.setVaultDepositAllowList(vaultAddress, user, status);
         return this.execCall(txCall, options);
     }
+    // ============================================
+    // Atomic Liquidity Vault — operator actions (BFE-817/818)
+    // ============================================
+    /** Atomic vault: supply `assets` of idle collateral into the external ERC-4626 strategy. */
+    async supplyToStrategy(vaultAddress, assets, options) {
+        const txCall = this.txBuilder.atomicSupplyToStrategy(vaultAddress, assets);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: withdraw `assets` of collateral back from the strategy into the vault. */
+    async withdrawFromStrategy(vaultAddress, assets, options) {
+        const txCall = this.txBuilder.atomicWithdrawFromStrategy(vaultAddress, assets);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: submit `amount` of collected source `share` for redemption on the source vault. */
+    async redeemCollectedEmberShares(vaultAddress, share, amount, options) {
+        const txCall = this.txBuilder.atomicRedeemCollectedEmberShares(vaultAddress, share, amount);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: release the holdback FIFO for `share` at `unwindingPercentage` (1e18=100%), up to `maxEntries`. */
+    async releaseUsersHoldback(vaultAddress, share, unwindingPercentage, maxEntries, options) {
+        const txCall = this.txBuilder.atomicReleaseUsersHoldback(vaultAddress, share, unwindingPercentage, maxEntries);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: move `amount` of collateral to a registered sub-account. */
+    async supplyToSubAccount(vaultAddress, subAccount, amount, options) {
+        const txCall = this.txBuilder.atomicSupplyToSubAccount(vaultAddress, subAccount, amount);
+        return this.execCall(txCall, options);
+    }
 }

package/dist/src/evm-vaults/on-chain-calls/tx-builder.d.ts

@@ -280,6 +280,27 @@ export declare class EVMTxBuilder {
      * @returns Transaction call object
      */
     collectPlatformFee(vaultAddress: string, isETHVault?: boolean): ITransactionCall;
+    /**
+     * EmberETHVault: claim the caller's own escrowed (deferred) ETH withdrawal — accrued
+     * when a withdrawal couldn't be sent (receiver rejected the transfer). EmberETHVault only.
+     */
+    claimWithdrawal(vaultAddress: string): ITransactionCall;
+    /**
+     * EmberETHVault: deliver `receiver`'s escrowed ETH withdrawal on their behalf
+     * (permissionless — funds can only go to `receiver`). EmberETHVault only.
+     */
+    claimWithdrawalFor(vaultAddress: string, receiver: string): ITransactionCall;
+    /**
+     * EmberETHVault: redirect the CALLER's own escrowed ETH withdrawal to `to`. For a
+     * receiver that can transact but can no longer receive ETH; delivers only the
+     * caller's own escrow. EmberETHVault only.
+     */
+    claimWithdrawalTo(vaultAddress: string, to: string): ITransactionCall;
+    /**
+     * EmberETHVault: owner recovery of `receiver`'s escrowed ETH to `to` (a permanently
+     * unpayable receiver). Owner-only (called directly on the vault). EmberETHVault only.
+     */
+    recoverUnclaimedWithdrawal(vaultAddress: string, receiver: string, to: string): ITransactionCall;
     /**
      * Withdraws assets from the vault without redeeming shares (operator only)
      * Used by operators to move funds to sub-accounts for strategy execution
@@ -501,4 +522,92 @@ export declare class EVMTxBuilder {
      * @returns Transaction call object
      */
     bridgeSend(adapterAddress: string, sendParam: IOFTSendParam, fee: IOFTMessagingFee, refundAddress: string): ITransactionCall;
+    private atomicCall;
+    /** Claim the caller's own escrowed (deferred) holdback collateral. */
+    atomicClaimHoldback(vaultAddress: string): ITransactionCall;
+    /** Deliver `recipient`'s escrowed holdback on their behalf (permissionless). */
+    atomicClaimHoldbackFor(vaultAddress: string, recipient: string): ITransactionCall;
+    /**
+     * Redirect the CALLER's own escrowed holdback to `to`. For a recipient that can
+     * transact but can no longer receive the collateral token (e.g. token blacklist);
+     * moves only the caller's own escrow.
+     */
+    atomicClaimHoldbackTo(vaultAddress: string, to: string): ITransactionCall;
+    /**
+     * Owner recovery of `recipient`'s escrowed holdback to `to` (a permanently unpayable
+     * recipient). Owner-only, called directly on the vault (not via protocol config).
+     */
+    atomicRecoverUnclaimedHoldback(vaultAddress: string, recipient: string, to: string): ITransactionCall;
+    /**
+     * Builds an atomic-vault ADMIN call routed through the vault's protocol config. Atomic admin
+     * setters are `onlyProtocolConfig`, so they must be invoked on the EmberProtocolConfig (which
+     * forwards msg.sender as `caller`) — never on the vault directly. Targets the vault's OWN
+     * protocol config (atomic vaults may use a config distinct from the global one). Each config
+     * forwarder takes the vault address as its first argument and derives `caller` from msg.sender.
+     */
+    private atomicConfigCall;
+    /** Instant (capped, fee'd) withdraw of `shares` to `receiver`; auto-pulls from strategy. */
+    atomicInstantWithdraw(vaultAddress: string, shares: NumStr, receiver: string): ITransactionCall;
+    /** Swap `shareAmount` of a whitelisted source EmberShare into this vault's collateral. */
+    atomicSwapEmberShares(vaultAddress: string, share: string, shareAmount: NumStr, receiver: string): ITransactionCall;
+    /** Supply `assets` of idle collateral into the external ERC-4626 strategy. */
+    atomicSupplyToStrategy(vaultAddress: string, assets: NumStr): ITransactionCall;
+    /** Withdraw `assets` of collateral back from the strategy into the vault. */
+    atomicWithdrawFromStrategy(vaultAddress: string, assets: NumStr): ITransactionCall;
+    /** Submit `amount` of collected source `share` for redemption on the source EmberVault. */
+    atomicRedeemCollectedEmberShares(vaultAddress: string, share: string, amount: NumStr): ITransactionCall;
+    /** Release the holdback FIFO for `share` at `unwindingPercentage` (1e18 = 100%), up to `maxEntries`. */
+    atomicReleaseUsersHoldback(vaultAddress: string, share: string, unwindingPercentage: NumStr, maxEntries: NumStr): ITransactionCall;
+    /** Set the external ERC-4626 strategy (address(0) to disable). Drain the old strategy first. */
+    atomicSetStrategy(vaultAddress: string, _caller: string, newStrategy: string): ITransactionCall;
+    /**
+     * Whitelist (or update) a source EmberShare with fee / capacity / holdback / utilization
+     * percentages, a per-swap minimum gross floor (`minSwapGross`, 0 disables), and a
+     * TVL-independent absolute held-value cap (`maxHeldValueAbsolute`, 0 disables).
+     */
+    atomicSetEmberShareWhitelist(vaultAddress: string, _caller: string, share: string, whitelisted: boolean, feePercentage: NumStr, maxCapacityPercentage: NumStr, holdbackPercentage: NumStr, maxUtilizationPercentage: NumStr, minSwapGross: NumStr, maxHeldValueAbsolute: NumStr): ITransactionCall;
+    /** Set per-account swap waivers (fee and/or holdback); (false,false) removes them. */
+    atomicSetSwapWaiver(vaultAddress: string, _caller: string, account: string, feeWaived: boolean, holdbackWaived: boolean): ITransactionCall;
+    /**
+     * Add/update (remove=false) or remove (remove=true) a fee-multiplier curve
+     * tier for an EmberShare. threshold is a utilization percentage (1e18 = 100%);
+     * multiplier is a fee multiplier (1e18 = 1x, must be >= 1e18 on upsert).
+     */
+    atomicUpdateEmberShareFeeMultiplierTier(vaultAddress: string, _caller: string, share: string, threshold: NumStr, multiplier: NumStr, remove: boolean): ITransactionCall;
+    /** Set the cumulative instant-withdraw cap (in shares). */
+    atomicSetMaxInstantWithdrawShares(vaultAddress: string, _caller: string, newMax: NumStr): ITransactionCall;
+    /** Set the instant-withdraw fee percentage. */
+    atomicSetInstantWithdrawFeePercentage(vaultAddress: string, _caller: string, newFeePercentage: NumStr): ITransactionCall;
+    /** Set the platform fee percentage. */
+    atomicSetFeePercentage(vaultAddress: string, _caller: string, newFeePercentage: NumStr): ITransactionCall;
+    /** Set the maximum TVL. */
+    atomicSetMaxTVL(vaultAddress: string, _caller: string, newMaxTVL: NumStr): ITransactionCall;
+    /** Set the minimum withdrawable shares. */
+    atomicSetMinWithdrawableShares(vaultAddress: string, _caller: string, newMinWithdrawableShares: NumStr): ITransactionCall;
+    /** Set the max rate change per update bound. */
+    atomicSetMaxRateChangePerUpdate(vaultAddress: string, _caller: string, newMaxRateChangePerUpdate: NumStr): ITransactionCall;
+    /** Set the minimum interval between rate updates (ms). */
+    atomicSetRateUpdateInterval(vaultAddress: string, _caller: string, newInterval: NumStr): ITransactionCall;
+    /** Rename the vault. */
+    atomicSetVaultName(vaultAddress: string, _caller: string, newName: string): ITransactionCall;
+    /** Set the vault validator contract. */
+    atomicSetVaultValidator(vaultAddress: string, _caller: string, validator: string): ITransactionCall;
+    /** Add/remove a sub-account. */
+    atomicSetSubAccountStatus(vaultAddress: string, _caller: string, account: string, isSubAccount: boolean): ITransactionCall;
+    /** Pause/unpause one operation ("deposits" | "withdrawals" | "privilegedOperations"). */
+    atomicSetPausedStatus(vaultAddress: string, _caller: string, operation: string, paused: boolean): ITransactionCall;
+    /** Move `amount` of collateral to a registered sub-account (operator). */
+    atomicSupplyToSubAccount(vaultAddress: string, subAccount: string, amount: NumStr): ITransactionCall;
+    /** Rotate the admin role. */
+    atomicSetAdmin(vaultAddress: string, _caller: string, newAdmin: string): ITransactionCall;
+    /** Rotate the operator role. */
+    atomicSetOperator(vaultAddress: string, _caller: string, newOperator: string): ITransactionCall;
+    /** Rotate the rate-manager role. */
+    atomicSetRateManager(vaultAddress: string, _caller: string, newRateManager: string): ITransactionCall;
+    /** Transfer contract ownership (UUPS owner). */
+    atomicTransferOwnership(vaultAddress: string, newOwner: string): ITransactionCall;
+    /** Renounce ownership (irreversible). */
+    atomicRenounceOwnership(vaultAddress: string): ITransactionCall;
+    /** Upgrade the implementation and optionally call init data (UUPS). */
+    atomicUpgradeToAndCall(vaultAddress: string, newImplementation: string, data: string): ITransactionCall;
 }

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

@@ -4,6 +4,7 @@ import EmberETHVaultABI from "../../abis/EmberETHVault.json" with { type: "json"
 import EmberProtocolConfigABI from "../../abis/EmberProtocolConfig.json" with { type: "json" };
 import ERC20TokenABI from "../../abis/ERC20Token.json" with { type: "json" };
 import EmberVaultOFTAdapterABI from "../../abis/EmberVaultMintBurnOFTAdapter.json" with { type: "json" };
+import AtomicLiquidityABI from "../../abis/AtomicLiquidity.json" with { type: "json" };
 import EmberDepositParkingLotABI from "../../abis/EmberDepositParkingLot.json" with { type: "json" };
 import OpenCoverVaultABI from "../../abis/OpenCoverVault.json" with { type: "json" };
 /**
@@ -574,6 +575,63 @@ export class EVMTxBuilder {
             chainId: this.getChainId()
         };
     }
+    /**
+     * EmberETHVault: claim the caller's own escrowed (deferred) ETH withdrawal — accrued
+     * when a withdrawal couldn't be sent (receiver rejected the transfer). EmberETHVault only.
+     */
+    claimWithdrawal(vaultAddress) {
+        return {
+            to: vaultAddress,
+            functionName: "claimWithdrawal",
+            args: [],
+            abi: EmberETHVaultABI.abi,
+            value: 0n,
+            chainId: this.getChainId()
+        };
+    }
+    /**
+     * EmberETHVault: deliver `receiver`'s escrowed ETH withdrawal on their behalf
+     * (permissionless — funds can only go to `receiver`). EmberETHVault only.
+     */
+    claimWithdrawalFor(vaultAddress, receiver) {
+        return {
+            to: vaultAddress,
+            functionName: "claimWithdrawalFor",
+            args: [receiver],
+            abi: EmberETHVaultABI.abi,
+            value: 0n,
+            chainId: this.getChainId()
+        };
+    }
+    /**
+     * EmberETHVault: redirect the CALLER's own escrowed ETH withdrawal to `to`. For a
+     * receiver that can transact but can no longer receive ETH; delivers only the
+     * caller's own escrow. EmberETHVault only.
+     */
+    claimWithdrawalTo(vaultAddress, to) {
+        return {
+            to: vaultAddress,
+            functionName: "claimWithdrawalTo",
+            args: [to],
+            abi: EmberETHVaultABI.abi,
+            value: 0n,
+            chainId: this.getChainId()
+        };
+    }
+    /**
+     * EmberETHVault: owner recovery of `receiver`'s escrowed ETH to `to` (a permanently
+     * unpayable receiver). Owner-only (called directly on the vault). EmberETHVault only.
+     */
+    recoverUnclaimedWithdrawal(vaultAddress, receiver, to) {
+        return {
+            to: vaultAddress,
+            functionName: "recoverUnclaimedWithdrawal",
+            args: [receiver, to],
+            abi: EmberETHVaultABI.abi,
+            value: 0n,
+            chainId: this.getChainId()
+        };
+    }
     /**
      * Withdraws assets from the vault without redeeming shares (operator only)
      * Used by operators to move funds to sub-accounts for strategy execution
@@ -1050,4 +1108,227 @@ export class EVMTxBuilder {
             chainId: this.getChainId()
         };
     }
+    // ============================================
+    // Atomic Liquidity Vault methods (BFE-817/818)
+    //
+    // Atomic vaults are a sibling of EmberVault with instant-withdraw + cross-vault
+    // EmberShare swap, backed by an ERC-4626 strategy. Shares are non-transferable
+    // (no receipt token). These encode against the AtomicLiquidity ABI; admin
+    // setters take `caller` because access is gated via the protocol-config role.
+    // ============================================
+    atomicCall(vaultAddress, functionName, args) {
+        return {
+            to: vaultAddress,
+            functionName,
+            args,
+            abi: AtomicLiquidityABI.abi,
+            value: 0n,
+            chainId: this.getChainId()
+        };
+    }
+    /** Claim the caller's own escrowed (deferred) holdback collateral. */
+    atomicClaimHoldback(vaultAddress) {
+        return this.atomicCall(vaultAddress, "claimHoldback", []);
+    }
+    /** Deliver `recipient`'s escrowed holdback on their behalf (permissionless). */
+    atomicClaimHoldbackFor(vaultAddress, recipient) {
+        return this.atomicCall(vaultAddress, "claimHoldbackFor", [recipient]);
+    }
+    /**
+     * Redirect the CALLER's own escrowed holdback to `to`. For a recipient that can
+     * transact but can no longer receive the collateral token (e.g. token blacklist);
+     * moves only the caller's own escrow.
+     */
+    atomicClaimHoldbackTo(vaultAddress, to) {
+        return this.atomicCall(vaultAddress, "claimHoldbackTo", [to]);
+    }
+    /**
+     * Owner recovery of `recipient`'s escrowed holdback to `to` (a permanently unpayable
+     * recipient). Owner-only, called directly on the vault (not via protocol config).
+     */
+    atomicRecoverUnclaimedHoldback(vaultAddress, recipient, to) {
+        return this.atomicCall(vaultAddress, "recoverUnclaimedHoldback", [recipient, to]);
+    }
+    /**
+     * Builds an atomic-vault ADMIN call routed through the vault's protocol config. Atomic admin
+     * setters are `onlyProtocolConfig`, so they must be invoked on the EmberProtocolConfig (which
+     * forwards msg.sender as `caller`) — never on the vault directly. Targets the vault's OWN
+     * protocol config (atomic vaults may use a config distinct from the global one). Each config
+     * forwarder takes the vault address as its first argument and derives `caller` from msg.sender.
+     */
+    atomicConfigCall(vaultAddress, forwarderName, forwarderArgs) {
+        return {
+            to: this.parser.getProtocolConfigAddressForVault(vaultAddress),
+            functionName: forwarderName,
+            args: [vaultAddress, ...forwarderArgs],
+            abi: EmberProtocolConfigABI.abi,
+            value: 0n,
+            chainId: this.getChainId()
+        };
+    }
+    /** Instant (capped, fee'd) withdraw of `shares` to `receiver`; auto-pulls from strategy. */
+    atomicInstantWithdraw(vaultAddress, shares, receiver) {
+        return this.atomicCall(vaultAddress, "instantWithdraw", [shares, receiver]);
+    }
+    /** Swap `shareAmount` of a whitelisted source EmberShare into this vault's collateral. */
+    atomicSwapEmberShares(vaultAddress, share, shareAmount, receiver) {
+        return this.atomicCall(vaultAddress, "swapEmberShares", [
+            share,
+            shareAmount,
+            receiver
+        ]);
+    }
+    /** Supply `assets` of idle collateral into the external ERC-4626 strategy. */
+    atomicSupplyToStrategy(vaultAddress, assets) {
+        return this.atomicCall(vaultAddress, "supplyToStrategy", [assets]);
+    }
+    /** Withdraw `assets` of collateral back from the strategy into the vault. */
+    atomicWithdrawFromStrategy(vaultAddress, assets) {
+        return this.atomicCall(vaultAddress, "withdrawFromStrategy", [assets]);
+    }
+    /** Submit `amount` of collected source `share` for redemption on the source EmberVault. */
+    atomicRedeemCollectedEmberShares(vaultAddress, share, amount) {
+        return this.atomicCall(vaultAddress, "redeemCollectedEmberShares", [
+            share,
+            amount
+        ]);
+    }
+    /** Release the holdback FIFO for `share` at `unwindingPercentage` (1e18 = 100%), up to `maxEntries`. */
+    atomicReleaseUsersHoldback(vaultAddress, share, unwindingPercentage, maxEntries) {
+        return this.atomicCall(vaultAddress, "releaseUsersHoldback", [
+            share,
+            unwindingPercentage,
+            maxEntries
+        ]);
+    }
+    /** Set the external ERC-4626 strategy (address(0) to disable). Drain the old strategy first. */
+    atomicSetStrategy(vaultAddress, _caller, newStrategy) {
+        return this.atomicConfigCall(vaultAddress, "setVaultStrategy", [newStrategy]);
+    }
+    /**
+     * Whitelist (or update) a source EmberShare with fee / capacity / holdback / utilization
+     * percentages, a per-swap minimum gross floor (`minSwapGross`, 0 disables), and a
+     * TVL-independent absolute held-value cap (`maxHeldValueAbsolute`, 0 disables).
+     */
+    atomicSetEmberShareWhitelist(vaultAddress, _caller, share, whitelisted, feePercentage, maxCapacityPercentage, holdbackPercentage, maxUtilizationPercentage, minSwapGross, maxHeldValueAbsolute) {
+        return this.atomicConfigCall(vaultAddress, "setVaultEmberShareWhitelist", [
+            share,
+            whitelisted,
+            feePercentage,
+            maxCapacityPercentage,
+            holdbackPercentage,
+            maxUtilizationPercentage,
+            minSwapGross,
+            maxHeldValueAbsolute
+        ]);
+    }
+    /** Set per-account swap waivers (fee and/or holdback); (false,false) removes them. */
+    atomicSetSwapWaiver(vaultAddress, _caller, account, feeWaived, holdbackWaived) {
+        return this.atomicConfigCall(vaultAddress, "setVaultSwapWaiver", [
+            account,
+            feeWaived,
+            holdbackWaived
+        ]);
+    }
+    /**
+     * Add/update (remove=false) or remove (remove=true) a fee-multiplier curve
+     * tier for an EmberShare. threshold is a utilization percentage (1e18 = 100%);
+     * multiplier is a fee multiplier (1e18 = 1x, must be >= 1e18 on upsert).
+     */
+    atomicUpdateEmberShareFeeMultiplierTier(vaultAddress, _caller, share, threshold, multiplier, remove) {
+        return this.atomicConfigCall(vaultAddress, "updateVaultEmberShareFeeMultiplierTier", [share, threshold, multiplier, remove]);
+    }
+    /** Set the cumulative instant-withdraw cap (in shares). */
+    atomicSetMaxInstantWithdrawShares(vaultAddress, _caller, newMax) {
+        return this.atomicConfigCall(vaultAddress, "setVaultMaxInstantWithdrawShares", [
+            newMax
+        ]);
+    }
+    /** Set the instant-withdraw fee percentage. */
+    atomicSetInstantWithdrawFeePercentage(vaultAddress, _caller, newFeePercentage) {
+        return this.atomicConfigCall(vaultAddress, "setVaultInstantWithdrawFeePercentage", [newFeePercentage]);
+    }
+    /** Set the platform fee percentage. */
+    atomicSetFeePercentage(vaultAddress, _caller, newFeePercentage) {
+        return this.atomicConfigCall(vaultAddress, "updateVaultFeePercentage", [
+            newFeePercentage
+        ]);
+    }
+    /** Set the maximum TVL. */
+    atomicSetMaxTVL(vaultAddress, _caller, newMaxTVL) {
+        return this.atomicConfigCall(vaultAddress, "updateVaultMaxTVL", [newMaxTVL]);
+    }
+    /** Set the minimum withdrawable shares. */
+    atomicSetMinWithdrawableShares(vaultAddress, _caller, newMinWithdrawableShares) {
+        return this.atomicConfigCall(vaultAddress, "updateVaultMinWithdrawableShares", [
+            newMinWithdrawableShares
+        ]);
+    }
+    /** Set the max rate change per update bound. */
+    atomicSetMaxRateChangePerUpdate(vaultAddress, _caller, newMaxRateChangePerUpdate) {
+        return this.atomicConfigCall(vaultAddress, "updateVaultMaxRateChangePerUpdate", [
+            newMaxRateChangePerUpdate
+        ]);
+    }
+    /** Set the minimum interval between rate updates (ms). */
+    atomicSetRateUpdateInterval(vaultAddress, _caller, newInterval) {
+        return this.atomicConfigCall(vaultAddress, "updateVaultRateUpdateInterval", [
+            newInterval
+        ]);
+    }
+    /** Rename the vault. */
+    atomicSetVaultName(vaultAddress, _caller, newName) {
+        return this.atomicConfigCall(vaultAddress, "updateVaultName", [newName]);
+    }
+    /** Set the vault validator contract. */
+    atomicSetVaultValidator(vaultAddress, _caller, validator) {
+        return this.atomicConfigCall(vaultAddress, "setVaultValidator", [validator]);
+    }
+    /** Add/remove a sub-account. */
+    atomicSetSubAccountStatus(vaultAddress, _caller, account, isSubAccount) {
+        return this.atomicConfigCall(vaultAddress, "setVaultSubAccount", [
+            account,
+            isSubAccount
+        ]);
+    }
+    /** Pause/unpause one operation ("deposits" | "withdrawals" | "privilegedOperations"). */
+    atomicSetPausedStatus(vaultAddress, _caller, operation, paused) {
+        return this.atomicConfigCall(vaultAddress, "setVaultPausedStatus", [
+            operation,
+            paused
+        ]);
+    }
+    /** Move `amount` of collateral to a registered sub-account (operator). */
+    atomicSupplyToSubAccount(vaultAddress, subAccount, amount) {
+        return this.atomicCall(vaultAddress, "supplyToSubAccount", [subAccount, amount]);
+    }
+    /** Rotate the admin role. */
+    atomicSetAdmin(vaultAddress, _caller, newAdmin) {
+        return this.atomicConfigCall(vaultAddress, "updateVaultAdmin", [newAdmin]);
+    }
+    /** Rotate the operator role. */
+    atomicSetOperator(vaultAddress, _caller, newOperator) {
+        return this.atomicConfigCall(vaultAddress, "updateVaultOperator", [newOperator]);
+    }
+    /** Rotate the rate-manager role. */
+    atomicSetRateManager(vaultAddress, _caller, newRateManager) {
+        return this.atomicConfigCall(vaultAddress, "updateVaultRateManager", [
+            newRateManager
+        ]);
+    }
+    /** Transfer contract ownership (UUPS owner). */
+    atomicTransferOwnership(vaultAddress, newOwner) {
+        return this.atomicCall(vaultAddress, "transferOwnership", [newOwner]);
+    }
+    /** Renounce ownership (irreversible). */
+    atomicRenounceOwnership(vaultAddress) {
+        return this.atomicCall(vaultAddress, "renounceOwnership", []);
+    }
+    /** Upgrade the implementation and optionally call init data (UUPS). */
+    atomicUpgradeToAndCall(vaultAddress, newImplementation, data) {
+        return this.atomicCall(vaultAddress, "upgradeToAndCall", [
+            newImplementation,
+            data
+        ]);
+    }
 }

package/dist/src/evm-vaults/on-chain-calls/user.d.ts

@@ -455,4 +455,54 @@ export declare class EVMUserCalls extends EVMOnChainCalls {
      * @returns The allowance as bigint
      */
     getTokenAllowance(tokenAddress: string, spender: string, owner?: string): Promise<bigint>;
+    /**
+     * EmberETHVault: claim your own escrowed (deferred) ETH withdrawal — ETH that couldn't be
+     * sent when your withdrawal was processed (your receiver rejected the transfer) and is now
+     * escrowed. Reverts if nothing is escrowed. Query via the reader's `getUnclaimedWithdrawals`.
+     */
+    claimWithdrawal(vaultAddress: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * EmberETHVault: deliver `receiver`'s escrowed ETH withdrawal on their behalf.
+     * Permissionless — the funds can only ever go to `receiver`.
+     */
+    claimWithdrawalFor(vaultAddress: string, receiver: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * EmberETHVault: redirect YOUR OWN escrowed ETH withdrawal to `to`. Use when you can
+     * transact but can no longer receive ETH at your original address (e.g. a contract
+     * receiver that now reverts). Delivers only the caller's own escrow.
+     */
+    claimWithdrawalTo(vaultAddress: string, to: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * EmberETHVault: owner recovery of `receiver`'s escrowed ETH to `to`, for a receiver
+     * that can neither receive ETH nor call claimWithdrawalTo. Owner-only.
+     */
+    recoverUnclaimedWithdrawal(vaultAddress: string, receiver: string, to: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: instant (capped, fee'd) withdraw of `shares` to `receiver`; auto-pulls from strategy. */
+    instantWithdraw(vaultAddress: string, shares: NumStr, receiver: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: swap `shareAmount` of a whitelisted source EmberShare `share` into collateral. */
+    swapEmberShares(vaultAddress: string, share: string, shareAmount: NumStr, receiver: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Atomic vault: claim your own escrowed holdback — collateral that couldn't be
+     * delivered during `releaseUsersHoldback` (e.g. you were blocklisted on the
+     * collateral token at release time and are now payable again). Reverts if nothing
+     * is escrowed for you. Query the amount via the reader's `unclaimedHoldback`.
+     */
+    claimHoldback(vaultAddress: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Atomic vault: deliver a recipient's escrowed holdback on their behalf. Permissionless
+     * — the funds can only ever go to `recipient` — so anyone (e.g. the operator) may
+     * trigger delivery once the recipient is payable again.
+     */
+    claimHoldbackFor(vaultAddress: string, recipient: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Atomic vault: redirect YOUR OWN escrowed holdback to `to`. Use when you can transact
+     * but can no longer receive the collateral token at your original address (e.g. a
+     * token-level blacklist). Delivers only the caller's own escrow.
+     */
+    claimHoldbackTo(vaultAddress: string, to: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Atomic vault: owner recovery of `recipient`'s escrowed holdback to `to`, for a
+     * recipient that can neither receive the collateral nor call claimHoldbackTo. Owner-only.
+     */
+    recoverUnclaimedHoldback(vaultAddress: string, recipient: string, to: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
 }

package/dist/src/evm-vaults/on-chain-calls/user.js

@@ -702,4 +702,79 @@ export class EVMUserCalls extends EVMOnChainCalls {
         const token = this.getERC20Contract(tokenAddress);
         return token.allowance(ownerAddress, spender);
     }
+    /**
+     * EmberETHVault: claim your own escrowed (deferred) ETH withdrawal — ETH that couldn't be
+     * sent when your withdrawal was processed (your receiver rejected the transfer) and is now
+     * escrowed. Reverts if nothing is escrowed. Query via the reader's `getUnclaimedWithdrawals`.
+     */
+    async claimWithdrawal(vaultAddress, options) {
+        return this.execCall(this.txBuilder.claimWithdrawal(vaultAddress), options);
+    }
+    /**
+     * EmberETHVault: deliver `receiver`'s escrowed ETH withdrawal on their behalf.
+     * Permissionless — the funds can only ever go to `receiver`.
+     */
+    async claimWithdrawalFor(vaultAddress, receiver, options) {
+        return this.execCall(this.txBuilder.claimWithdrawalFor(vaultAddress, receiver), options);
+    }
+    /**
+     * EmberETHVault: redirect YOUR OWN escrowed ETH withdrawal to `to`. Use when you can
+     * transact but can no longer receive ETH at your original address (e.g. a contract
+     * receiver that now reverts). Delivers only the caller's own escrow.
+     */
+    async claimWithdrawalTo(vaultAddress, to, options) {
+        return this.execCall(this.txBuilder.claimWithdrawalTo(vaultAddress, to), options);
+    }
+    /**
+     * EmberETHVault: owner recovery of `receiver`'s escrowed ETH to `to`, for a receiver
+     * that can neither receive ETH nor call claimWithdrawalTo. Owner-only.
+     */
+    async recoverUnclaimedWithdrawal(vaultAddress, receiver, to, options) {
+        return this.execCall(this.txBuilder.recoverUnclaimedWithdrawal(vaultAddress, receiver, to), options);
+    }
+    // ============================================
+    // Atomic Liquidity Vault — user actions (BFE-817/818)
+    // ============================================
+    /** Atomic vault: instant (capped, fee'd) withdraw of `shares` to `receiver`; auto-pulls from strategy. */
+    async instantWithdraw(vaultAddress, shares, receiver, options) {
+        const txCall = this.txBuilder.atomicInstantWithdraw(vaultAddress, shares, receiver);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: swap `shareAmount` of a whitelisted source EmberShare `share` into collateral. */
+    async swapEmberShares(vaultAddress, share, shareAmount, receiver, options) {
+        const txCall = this.txBuilder.atomicSwapEmberShares(vaultAddress, share, shareAmount, receiver);
+        return this.execCall(txCall, options);
+    }
+    /**
+     * Atomic vault: claim your own escrowed holdback — collateral that couldn't be
+     * delivered during `releaseUsersHoldback` (e.g. you were blocklisted on the
+     * collateral token at release time and are now payable again). Reverts if nothing
+     * is escrowed for you. Query the amount via the reader's `unclaimedHoldback`.
+     */
+    async claimHoldback(vaultAddress, options) {
+        return this.execCall(this.txBuilder.atomicClaimHoldback(vaultAddress), options);
+    }
+    /**
+     * Atomic vault: deliver a recipient's escrowed holdback on their behalf. Permissionless
+     * — the funds can only ever go to `recipient` — so anyone (e.g. the operator) may
+     * trigger delivery once the recipient is payable again.
+     */
+    async claimHoldbackFor(vaultAddress, recipient, options) {
+        return this.execCall(this.txBuilder.atomicClaimHoldbackFor(vaultAddress, recipient), options);
+    }
+    /**
+     * Atomic vault: redirect YOUR OWN escrowed holdback to `to`. Use when you can transact
+     * but can no longer receive the collateral token at your original address (e.g. a
+     * token-level blacklist). Delivers only the caller's own escrow.
+     */
+    async claimHoldbackTo(vaultAddress, to, options) {
+        return this.execCall(this.txBuilder.atomicClaimHoldbackTo(vaultAddress, to), options);
+    }
+    /**
+     * Atomic vault: owner recovery of `recipient`'s escrowed holdback to `to`, for a
+     * recipient that can neither receive the collateral nor call claimHoldbackTo. Owner-only.
+     */
+    async recoverUnclaimedHoldback(vaultAddress, recipient, to, options) {
+        return this.execCall(this.txBuilder.atomicRecoverUnclaimedHoldback(vaultAddress, recipient, to), options);
+    }
 }