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

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,219 @@ 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
+        ]);
+    }
+    /** 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);
+    }
 }

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

@@ -162,4 +162,52 @@ export declare class EVMVaultAdminCalls extends EVMOnChainCalls {
      * @returns EvmOnChainCallResponse
      */
     updateVaultName(vaultAddress: string, newName: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: set the external ERC-4626 strategy (address(0) to disable). Drain the old strategy first. */
+    setStrategy(vaultAddress: string, caller: string, newStrategy: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Atomic vault: whitelist (or update) a source EmberShare with fee / capacity / holdback /
+     * utilization percentages, a per-swap minimum gross floor, and an absolute held-value cap.
+     *
+     * @param minSwapGross Minimum gross collateral value per swap (collateral units); 0 disables
+     *        the dust floor that would otherwise allow holdback-queue bloat.
+     * @param maxHeldValueAbsolute TVL-independent ceiling on this source share's post-swap held
+     *        value (collateral units); 0 disables it.
+     */
+    setEmberShareWhitelist(vaultAddress: string, caller: string, share: string, whitelisted: boolean, feePercentage: NumStr, maxCapacityPercentage: NumStr, holdbackPercentage: NumStr, maxUtilizationPercentage: NumStr, minSwapGross: NumStr, maxHeldValueAbsolute: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: set per-account swap waivers (fee and/or holdback); (false,false) removes them. */
+    setSwapWaiver(vaultAddress: string, caller: string, account: string, feeWaived: boolean, holdbackWaived: boolean, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: set the cumulative instant-withdraw cap (in shares). */
+    setMaxInstantWithdrawShares(vaultAddress: string, caller: string, newMax: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: set the instant-withdraw fee percentage. */
+    setInstantWithdrawFeePercentage(vaultAddress: string, caller: string, newFeePercentage: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: set the platform fee percentage. */
+    setFeePercentage(vaultAddress: string, caller: string, newFeePercentage: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: set the maximum TVL. */
+    setMaxTVL(vaultAddress: string, caller: string, newMaxTVL: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: set the minimum withdrawable shares. */
+    setMinWithdrawableShares(vaultAddress: string, caller: string, newMinWithdrawableShares: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: set the max rate change per update bound. */
+    setMaxRateChangePerUpdate(vaultAddress: string, caller: string, newMaxRateChangePerUpdate: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: set the minimum interval between rate updates (ms). */
+    setRateUpdateInterval(vaultAddress: string, caller: string, newInterval: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: rename the vault. */
+    setVaultName(vaultAddress: string, caller: string, newName: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: set the vault validator contract. */
+    setVaultValidator(vaultAddress: string, caller: string, validator: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: add/remove a sub-account. */
+    setSubAccountStatus(vaultAddress: string, caller: string, account: string, isSubAccount: boolean, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: pause/unpause an operation ("deposits" | "withdrawals" | "privilegedOperations"). */
+    setPausedStatus(vaultAddress: string, caller: string, operation: string, paused: boolean, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: rotate the admin role. */
+    setAdmin(vaultAddress: string, caller: string, newAdmin: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: rotate the operator role. */
+    setOperator(vaultAddress: string, caller: string, newOperator: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: rotate the rate-manager role. */
+    setRateManager(vaultAddress: string, caller: string, newRateManager: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: transfer contract ownership (UUPS owner). */
+    transferOwnership(vaultAddress: string, newOwner: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: renounce ownership (irreversible). */
+    renounceOwnership(vaultAddress: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /** Atomic vault: upgrade the implementation and optionally call init data (UUPS). */
+    upgradeToAndCall(vaultAddress: string, newImplementation: string, data: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
 }

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

@@ -220,4 +220,116 @@ export class EVMVaultAdminCalls extends EVMOnChainCalls {
         const txCall = this.txBuilder.updateVaultName(vaultAddress, newName);
         return this.execCall(txCall, options);
     }
+    // ============================================
+    // Atomic Liquidity Vault — vault admin actions (BFE-817/818)
+    // Gated via protocol-config; pass the admin as `caller`.
+    // ============================================
+    /** Atomic vault: set the external ERC-4626 strategy (address(0) to disable). Drain the old strategy first. */
+    async setStrategy(vaultAddress, caller, newStrategy, options) {
+        const txCall = this.txBuilder.atomicSetStrategy(vaultAddress, caller, newStrategy);
+        return this.execCall(txCall, options);
+    }
+    /**
+     * Atomic vault: whitelist (or update) a source EmberShare with fee / capacity / holdback /
+     * utilization percentages, a per-swap minimum gross floor, and an absolute held-value cap.
+     *
+     * @param minSwapGross Minimum gross collateral value per swap (collateral units); 0 disables
+     *        the dust floor that would otherwise allow holdback-queue bloat.
+     * @param maxHeldValueAbsolute TVL-independent ceiling on this source share's post-swap held
+     *        value (collateral units); 0 disables it.
+     */
+    async setEmberShareWhitelist(vaultAddress, caller, share, whitelisted, feePercentage, maxCapacityPercentage, holdbackPercentage, maxUtilizationPercentage, minSwapGross, maxHeldValueAbsolute, options) {
+        const txCall = this.txBuilder.atomicSetEmberShareWhitelist(vaultAddress, caller, share, whitelisted, feePercentage, maxCapacityPercentage, holdbackPercentage, maxUtilizationPercentage, minSwapGross, maxHeldValueAbsolute);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: set per-account swap waivers (fee and/or holdback); (false,false) removes them. */
+    async setSwapWaiver(vaultAddress, caller, account, feeWaived, holdbackWaived, options) {
+        const txCall = this.txBuilder.atomicSetSwapWaiver(vaultAddress, caller, account, feeWaived, holdbackWaived);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: set the cumulative instant-withdraw cap (in shares). */
+    async setMaxInstantWithdrawShares(vaultAddress, caller, newMax, options) {
+        const txCall = this.txBuilder.atomicSetMaxInstantWithdrawShares(vaultAddress, caller, newMax);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: set the instant-withdraw fee percentage. */
+    async setInstantWithdrawFeePercentage(vaultAddress, caller, newFeePercentage, options) {
+        const txCall = this.txBuilder.atomicSetInstantWithdrawFeePercentage(vaultAddress, caller, newFeePercentage);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: set the platform fee percentage. */
+    async setFeePercentage(vaultAddress, caller, newFeePercentage, options) {
+        const txCall = this.txBuilder.atomicSetFeePercentage(vaultAddress, caller, newFeePercentage);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: set the maximum TVL. */
+    async setMaxTVL(vaultAddress, caller, newMaxTVL, options) {
+        const txCall = this.txBuilder.atomicSetMaxTVL(vaultAddress, caller, newMaxTVL);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: set the minimum withdrawable shares. */
+    async setMinWithdrawableShares(vaultAddress, caller, newMinWithdrawableShares, options) {
+        const txCall = this.txBuilder.atomicSetMinWithdrawableShares(vaultAddress, caller, newMinWithdrawableShares);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: set the max rate change per update bound. */
+    async setMaxRateChangePerUpdate(vaultAddress, caller, newMaxRateChangePerUpdate, options) {
+        const txCall = this.txBuilder.atomicSetMaxRateChangePerUpdate(vaultAddress, caller, newMaxRateChangePerUpdate);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: set the minimum interval between rate updates (ms). */
+    async setRateUpdateInterval(vaultAddress, caller, newInterval, options) {
+        const txCall = this.txBuilder.atomicSetRateUpdateInterval(vaultAddress, caller, newInterval);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: rename the vault. */
+    async setVaultName(vaultAddress, caller, newName, options) {
+        const txCall = this.txBuilder.atomicSetVaultName(vaultAddress, caller, newName);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: set the vault validator contract. */
+    async setVaultValidator(vaultAddress, caller, validator, options) {
+        const txCall = this.txBuilder.atomicSetVaultValidator(vaultAddress, caller, validator);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: add/remove a sub-account. */
+    async setSubAccountStatus(vaultAddress, caller, account, isSubAccount, options) {
+        const txCall = this.txBuilder.atomicSetSubAccountStatus(vaultAddress, caller, account, isSubAccount);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: pause/unpause an operation ("deposits" | "withdrawals" | "privilegedOperations"). */
+    async setPausedStatus(vaultAddress, caller, operation, paused, options) {
+        const txCall = this.txBuilder.atomicSetPausedStatus(vaultAddress, caller, operation, paused);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: rotate the admin role. */
+    async setAdmin(vaultAddress, caller, newAdmin, options) {
+        const txCall = this.txBuilder.atomicSetAdmin(vaultAddress, caller, newAdmin);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: rotate the operator role. */
+    async setOperator(vaultAddress, caller, newOperator, options) {
+        const txCall = this.txBuilder.atomicSetOperator(vaultAddress, caller, newOperator);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: rotate the rate-manager role. */
+    async setRateManager(vaultAddress, caller, newRateManager, options) {
+        const txCall = this.txBuilder.atomicSetRateManager(vaultAddress, caller, newRateManager);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: transfer contract ownership (UUPS owner). */
+    async transferOwnership(vaultAddress, newOwner, options) {
+        const txCall = this.txBuilder.atomicTransferOwnership(vaultAddress, newOwner);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: renounce ownership (irreversible). */
+    async renounceOwnership(vaultAddress, options) {
+        const txCall = this.txBuilder.atomicRenounceOwnership(vaultAddress);
+        return this.execCall(txCall, options);
+    }
+    /** Atomic vault: upgrade the implementation and optionally call init data (UUPS). */
+    async upgradeToAndCall(vaultAddress, newImplementation, data, options) {
+        const txCall = this.txBuilder.atomicUpgradeToAndCall(vaultAddress, newImplementation, data);
+        return this.execCall(txCall, options);
+    }
 }

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

@@ -275,6 +275,12 @@ export declare class EVMVaultReader {
      * @returns Total supply
      */
     getTotalSupply(vaultAddress: string, isETHVault?: boolean): Promise<bigint>;
+    /**
+     * Escrowed (deferred) ETH withdrawal claimable by `account` on an EmberETHVault —
+     * accrued when a withdrawal couldn't be sent (the receiver rejected the ETH transfer).
+     * Claim via `claimWithdrawal` / `claimWithdrawalFor`. Returns 0 if none. EmberETHVault only.
+     */
+    getUnclaimedWithdrawals(vaultAddress: string, account: string): Promise<bigint>;
     /**
      * Converts assets to shares
      * @param vaultAddress The vault address

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

@@ -275,6 +275,15 @@ export class EVMVaultReader {
         const vault = this.getVaultContract(vaultAddress, isETHVault);
         return vault.totalSupply();
     }
+    /**
+     * Escrowed (deferred) ETH withdrawal claimable by `account` on an EmberETHVault —
+     * accrued when a withdrawal couldn't be sent (the receiver rejected the ETH transfer).
+     * Claim via `claimWithdrawal` / `claimWithdrawalFor`. Returns 0 if none. EmberETHVault only.
+     */
+    async getUnclaimedWithdrawals(vaultAddress, account) {
+        const vault = this.getVaultContract(vaultAddress, true);
+        return vault.unclaimedWithdrawals(account);
+    }
     /**
      * Converts assets to shares
      * @param vaultAddress The vault address

package/dist/src/evm-vaults/utils/deployment-parser.d.ts

@@ -20,6 +20,14 @@ export declare class EVMDeploymentParser {
      * Gets the protocol config proxy address
      */
     getProtocolConfigAddress(): string | undefined;
+    /**
+     * 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: string): string | undefined;
     /**
      * Gets the protocol config implementation address
      */