@augustdigital/sdk 9.3.0 → 9.4.0

package/lib/modules/vaults/read.actions.js

@@ -12,6 +12,12 @@ exports.previewRedeem = previewRedeem;
 exports.allowance = allowance;
 exports.balanceOf = balanceOf;
 exports.maxDeposit = maxDeposit;
+exports.getIdleLiquidity = getIdleLiquidity;
+exports.lagDuration = lagDuration;
+exports.getWithdrawalEpoch = getWithdrawalEpoch;
+exports.getBurnableAmountByReceiver = getBurnableAmountByReceiver;
+exports.getRequirementByDate = getRequirementByDate;
+exports.getScheduledTransactionsByDate = getScheduledTransactionsByDate;
 const abis_1 = require("../../abis");
 const core_1 = require("../../core");
 /**
@@ -271,40 +277,6 @@ async function previewRwaRedemption(signer, options) {
         throw new Error(`Preview RWA redemption failed: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
-function toRawBigInt(value, label) {
-    if (typeof value === 'bigint')
-        return value;
-    if (typeof value === 'number') {
-        if (!Number.isFinite(value)) {
-            throw new core_1.AugustValidationError('INVALID_INPUT', `${label}: amount must be finite, got ${value}`);
-        }
-        if (value < 0) {
-            throw new core_1.AugustValidationError('INVALID_INPUT', `${label}: amount must be non-negative, got ${value}`);
-        }
-        if (!Number.isSafeInteger(value)) {
-            throw new core_1.AugustValidationError('INVALID_INPUT', `${label}: amount ${value} exceeds Number.MAX_SAFE_INTEGER; pass a string or bigint to preserve precision`);
-        }
-        return BigInt(value);
-    }
-    if (typeof value === 'string') {
-        if (value.trim() === '') {
-            throw new core_1.AugustValidationError('INVALID_INPUT', `${label}: amount string must not be empty`);
-        }
-        try {
-            const parsed = BigInt(value);
-            if (parsed < 0n) {
-                throw new core_1.AugustValidationError('INVALID_INPUT', `${label}: amount must be non-negative, got ${value}`);
-            }
-            return parsed;
-        }
-        catch (e) {
-            if (e instanceof core_1.AugustValidationError)
-                throw e;
-            throw new core_1.AugustValidationError('INVALID_INPUT', `${label}: amount "${value}" is not a valid integer`);
-        }
-    }
-    throw new core_1.AugustValidationError('INVALID_INPUT', `${label}: amount must be a string, bigint, or number`);
-}
 /**
  * Preview the number of shares that would be minted for a deposit, without
  * touching on-chain state. Routes between single-asset ERC-4626 and EVM-2
@@ -327,7 +299,7 @@ async function previewDeposit(signer, options) {
     if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
         throw new core_1.AugustValidationError('INVALID_ADDRESS', `previewDeposit: invalid vault address ${vault}`);
     }
-    const amountRaw = toRawBigInt(amount, 'previewDeposit');
+    const amountRaw = (0, core_1.toRawBigInt)(amount, 'previewDeposit');
     try {
         const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault))?.[0];
         const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
@@ -389,7 +361,7 @@ async function previewRedeem(signer, options) {
     if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
         throw new core_1.AugustValidationError('INVALID_ADDRESS', `previewRedeem: invalid vault address ${vault}`);
     }
-    const sharesRaw = toRawBigInt(shares, 'previewRedeem');
+    const sharesRaw = (0, core_1.toRawBigInt)(shares, 'previewRedeem');
     try {
         const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault))?.[0];
         const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
@@ -593,4 +565,327 @@ async function maxDeposit(signer, options) {
         throw new core_1.AugustSDKError('UNKNOWN', `maxDeposit failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, receiver } });
     }
 }
+/**
+ * Read an EVM-2 vault's idle (uncommitted) liquidity — the balance available
+ * to satisfy an instant redemption without a synchronous recall from the
+ * settlement module, computed as `getTotalAssets() - externalAssets()`.
+ *
+ * EVM-2 only. Two on-chain reads with no caching — call it immediately
+ * before sizing an instant redemption rather than reusing a stale value, and
+ * size the redemption against the result rather than against total assets.
+ *
+ * @returns Idle liquidity, in the vault's reference-asset raw units.
+ * @throws AugustValidationError on invalid vault address or a non-EVM-2 vault.
+ * @throws AugustSDKError when either underlying contract read fails.
+ *
+ * @worstCaseRpcCalls 3 — vault-version lookup, `getTotalAssets`, `externalAssets`.
+ *
+ * @example
+ * ```ts
+ * const idle = await augustSdk.evm.getIdleLiquidity({ vault: vaultAddress });
+ * if (redeemAmount > idle) {
+ *   // fall back to a queued withdrawal instead of an instant one
+ * }
+ * ```
+ */
+async function getIdleLiquidity(signer, options) {
+    const { vault } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `getIdleLiquidity: invalid vault address ${vault}`);
+    }
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        if (vaultVersion !== 'evm-2') {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `getIdleLiquidity: only EVM-2 (Tokenized Vault V2) vaults expose externalAssets() — ${vault} resolved to ${vaultVersion}`);
+        }
+        const contract = (0, core_1.createContract)({
+            address: vault,
+            provider: signer,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+        });
+        const [totalAssets, externalAssets] = await Promise.all([
+            contract.getTotalAssets(),
+            contract.externalAssets(),
+        ]);
+        return BigInt(totalAssets) - BigInt(externalAssets);
+    }
+    catch (e) {
+        if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('getIdleLiquidity', e, (0, core_1.isExpectedRevertError)(e), { vault });
+        throw new core_1.AugustSDKError('UNKNOWN', `getIdleLiquidity failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault } });
+    }
+}
+/**
+ * Read an EVM-2 vault's queued-withdrawal lag — the delay, in seconds,
+ * between `requestRedeem` and the withdrawal epoch becoming claimable.
+ *
+ * EVM-2 only. This value is per-vault (259,200s / 3 days on sentUSD, but
+ * shorter on other deployments) and can change after launch — read it live
+ * rather than hardcoding it.
+ *
+ * @returns Lag duration, in seconds.
+ * @throws AugustValidationError on invalid vault address or a non-EVM-2 vault.
+ * @throws AugustSDKError when the underlying contract read fails.
+ *
+ * @worstCaseRpcCalls 2 — vault-version lookup, `lagDuration`.
+ *
+ * @example
+ * ```ts
+ * const seconds = await augustSdk.evm.lagDuration({ vault: vaultAddress });
+ * ```
+ */
+async function lagDuration(signer, options) {
+    const { vault } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `lagDuration: invalid vault address ${vault}`);
+    }
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        if (vaultVersion !== 'evm-2') {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `lagDuration: only EVM-2 (Tokenized Vault V2) vaults are supported by this wrapper — ${vault} resolved to ${vaultVersion}`);
+        }
+        const contract = (0, core_1.createContract)({
+            address: vault,
+            provider: signer,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+        });
+        const raw = (await contract.lagDuration());
+        return BigInt(raw);
+    }
+    catch (e) {
+        if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('lagDuration', e, (0, core_1.isExpectedRevertError)(e), { vault });
+        throw new core_1.AugustSDKError('UNKNOWN', `lagDuration failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault } });
+    }
+}
+/**
+ * Read an EVM-2 vault's current withdrawal epoch.
+ *
+ * The on-chain return order is `(year, month, day, claimableEpoch)` —
+ * `claimableEpoch` last, not first. This is the opposite order from what
+ * `requestRedeem` returns (`(claimableEpoch, year, month, day)`, epoch
+ * first); treat that call's return value, not this one, as the source of
+ * truth for a specific withdrawal's claim date.
+ *
+ * @returns The vault's current withdrawal epoch, by named field.
+ * @throws AugustValidationError on invalid vault address or a non-EVM-2 vault.
+ * @throws AugustSDKError when the underlying contract read fails.
+ *
+ * @worstCaseRpcCalls 2 — vault-version lookup, `getWithdrawalEpoch`.
+ *
+ * @example
+ * ```ts
+ * const { year, month, day, claimableEpoch } = await augustSdk.evm.getWithdrawalEpoch({
+ *   vault: vaultAddress,
+ * });
+ * ```
+ */
+async function getWithdrawalEpoch(signer, options) {
+    const { vault } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `getWithdrawalEpoch: invalid vault address ${vault}`);
+    }
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        if (vaultVersion !== 'evm-2') {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `getWithdrawalEpoch: only EVM-2 (Tokenized Vault V2) vaults are supported by this wrapper — ${vault} resolved to ${vaultVersion}`);
+        }
+        const contract = (0, core_1.createContract)({
+            address: vault,
+            provider: signer,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+        });
+        const [year, month, day, claimableEpoch] = (await contract.getWithdrawalEpoch());
+        return {
+            year: BigInt(year),
+            month: BigInt(month),
+            day: BigInt(day),
+            claimableEpoch: BigInt(claimableEpoch),
+        };
+    }
+    catch (e) {
+        if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('getWithdrawalEpoch', e, (0, core_1.isExpectedRevertError)(e), {
+            vault,
+        });
+        throw new core_1.AugustSDKError('UNKNOWN', `getWithdrawalEpoch failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault } });
+    }
+}
+/**
+ * Read how much of a withdrawal-epoch date's queue a given receiver can
+ * currently claim via `claim`, before sending the claim transaction.
+ *
+ * EVM-2 only.
+ *
+ * @returns The claimable amount, in share-token raw units.
+ * @throws AugustValidationError on invalid address input or a non-EVM-2 vault.
+ * @throws AugustSDKError when the underlying contract read fails.
+ *
+ * @worstCaseRpcCalls 2 — vault-version lookup, `getBurnableAmountByReceiver`.
+ *
+ * @example
+ * ```ts
+ * const claimable = await augustSdk.evm.getBurnableAmountByReceiver({
+ *   vault: vaultAddress,
+ *   receiver: walletAddress,
+ *   year, month, day,
+ * });
+ * ```
+ */
+async function getBurnableAmountByReceiver(signer, options) {
+    const { vault, year, month, day, receiver } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `getBurnableAmountByReceiver: invalid vault address ${vault}`);
+    }
+    if (!(0, core_1.checkAddress)(receiver, console, 'wallet')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `getBurnableAmountByReceiver: invalid receiver address ${receiver}`);
+    }
+    const yearRaw = (0, core_1.toRawBigInt)(year, 'getBurnableAmountByReceiver', 'year');
+    const monthRaw = (0, core_1.toRawBigInt)(month, 'getBurnableAmountByReceiver', 'month');
+    const dayRaw = (0, core_1.toRawBigInt)(day, 'getBurnableAmountByReceiver', 'day');
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        if (vaultVersion !== 'evm-2') {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `getBurnableAmountByReceiver: only EVM-2 (Tokenized Vault V2) vaults are supported by this wrapper — ${vault} resolved to ${vaultVersion}`);
+        }
+        const contract = (0, core_1.createContract)({
+            address: vault,
+            provider: signer,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+        });
+        const raw = (await contract.getBurnableAmountByReceiver(yearRaw, monthRaw, dayRaw, receiver));
+        return BigInt(raw);
+    }
+    catch (e) {
+        if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('getBurnableAmountByReceiver', e, (0, core_1.isExpectedRevertError)(e), {
+            vault,
+            year,
+            month,
+            day,
+            receiver,
+        });
+        throw new core_1.AugustSDKError('UNKNOWN', `getBurnableAmountByReceiver failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, year, month, day, receiver } });
+    }
+}
+/**
+ * Read the total shares required to settle a withdrawal-epoch date's entire
+ * queue.
+ *
+ * EVM-2 only.
+ *
+ * @returns Required shares, in share-token raw units.
+ * @throws AugustValidationError on invalid vault address or a non-EVM-2 vault.
+ * @throws AugustSDKError when the underlying contract read fails.
+ *
+ * @worstCaseRpcCalls 2 — vault-version lookup, `getRequirementByDate`.
+ *
+ * @example
+ * ```ts
+ * const shares = await augustSdk.evm.getRequirementByDate({
+ *   vault: vaultAddress,
+ *   year, month, day,
+ * });
+ * ```
+ */
+async function getRequirementByDate(signer, options) {
+    const { vault, year, month, day } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `getRequirementByDate: invalid vault address ${vault}`);
+    }
+    const yearRaw = (0, core_1.toRawBigInt)(year, 'getRequirementByDate', 'year');
+    const monthRaw = (0, core_1.toRawBigInt)(month, 'getRequirementByDate', 'month');
+    const dayRaw = (0, core_1.toRawBigInt)(day, 'getRequirementByDate', 'day');
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        if (vaultVersion !== 'evm-2') {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `getRequirementByDate: only EVM-2 (Tokenized Vault V2) vaults are supported by this wrapper — ${vault} resolved to ${vaultVersion}`);
+        }
+        const contract = (0, core_1.createContract)({
+            address: vault,
+            provider: signer,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+        });
+        const raw = (await contract.getRequirementByDate(yearRaw, monthRaw, dayRaw));
+        return BigInt(raw);
+    }
+    catch (e) {
+        if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('getRequirementByDate', e, (0, core_1.isExpectedRevertError)(e), {
+            vault,
+            year,
+            month,
+            day,
+        });
+        throw new core_1.AugustSDKError('UNKNOWN', `getRequirementByDate failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, year, month, day } });
+    }
+}
+/**
+ * Read the scheduled queued-withdrawal volume for a withdrawal-epoch date.
+ *
+ * EVM-2 only.
+ *
+ * @returns Total scheduled transactions and their execution epoch.
+ * @throws AugustValidationError on invalid vault address or a non-EVM-2 vault.
+ * @throws AugustSDKError when the underlying contract read fails.
+ *
+ * @worstCaseRpcCalls 2 — vault-version lookup, `getScheduledTransactionsByDate`.
+ *
+ * @example
+ * ```ts
+ * const { totalTransactions, executionEpoch } =
+ *   await augustSdk.evm.getScheduledTransactionsByDate({
+ *     vault: vaultAddress,
+ *     year, month, day,
+ *   });
+ * ```
+ */
+async function getScheduledTransactionsByDate(signer, options) {
+    const { vault, year, month, day } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `getScheduledTransactionsByDate: invalid vault address ${vault}`);
+    }
+    const yearRaw = (0, core_1.toRawBigInt)(year, 'getScheduledTransactionsByDate', 'year');
+    const monthRaw = (0, core_1.toRawBigInt)(month, 'getScheduledTransactionsByDate', 'month');
+    const dayRaw = (0, core_1.toRawBigInt)(day, 'getScheduledTransactionsByDate', 'day');
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        if (vaultVersion !== 'evm-2') {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `getScheduledTransactionsByDate: only EVM-2 (Tokenized Vault V2) vaults are supported by this wrapper — ${vault} resolved to ${vaultVersion}`);
+        }
+        const contract = (0, core_1.createContract)({
+            address: vault,
+            provider: signer,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+        });
+        const [totalTransactions, executionEpoch] = (await contract.getScheduledTransactionsByDate(yearRaw, monthRaw, dayRaw));
+        return {
+            totalTransactions: BigInt(totalTransactions),
+            executionEpoch: BigInt(executionEpoch),
+        };
+    }
+    catch (e) {
+        if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('getScheduledTransactionsByDate', e, (0, core_1.isExpectedRevertError)(e), { vault, year, month, day });
+        throw new core_1.AugustSDKError('UNKNOWN', `getScheduledTransactionsByDate failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, year, month, day } });
+    }
+}
 //# sourceMappingURL=read.actions.js.map

package/lib/modules/vaults/types.d.ts

@@ -68,6 +68,19 @@ export interface IVaultCustomOptions {
     wallet?: IAddress;
     solanaWallet?: string;
     stellarWallet?: string;
+    /**
+     * Portfolio mode for a SINGLE vault read: when true, a `closed` +
+     * `is_visible: false` vault resolves normally instead of coming back as
+     * null. Needed by any caller reading ONE vault by address on behalf of a
+     * holder — a position in a closed vault must still resolve its metadata, or
+     * the holder is left with no way to act on it.
+     *
+     * The plural counterpart is {@link IGetVaultsOptions.includeClosed}; this is
+     * the same flag on the per-address path.
+     *
+     * @default false
+     */
+    includeClosed?: boolean;
 }
 /**
  * Options accepted by `getVaults` — on both the `AugustSDK` facade and the

package/lib/modules/vaults/utils.js

@@ -524,7 +524,11 @@ async function buildFormattedVault(provider, tokenizedVault, contractCalls) {
         isVisible: tokenizedVault.is_visible,
         reserveTarget: tokenizedVault.reserve_target,
         reserveTolerance: tokenizedVault.reserve_tolerance,
-        isDepositPaused: (0, vaults_1.isBadVault)(tokenizedVault.address),
+        // On-chain pause first, then the hardcoded deny list — a vault can be
+        // withheld from deposits for either reason and the list is not a substitute
+        // for reading the contract.
+        isDepositPaused: contractCalls.depositsPaused === true ||
+            (0, vaults_1.isBadVault)(tokenizedVault.address),
         decimals: contractCalls.decimals,
         isWithdrawalPaused: contractCalls.withdrawalsPaused,
         idleAssets: (0, core_1.toNormalizedBn)(await getIdleAssets(provider, tokenizedVault.address, contractCalls.asset, contractCalls.totalAssets, 

package/lib/modules/vaults/write.actions.d.ts

@@ -275,12 +275,14 @@ export declare function approve(signer: Signer | Wallet, options: IContractWrite
 export declare function vaultDeposit(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
 /**
  * Request to redeem vault shares. For EVM-1 vaults this queues a standard
- * redemption (claimable later via `vaultRedeem`); for EVM-2 vaults this
- * also handles the receipt-token allowance automatically. Pass
- * `isInstantRedeem: true` for vaults that support instant settlement.
+ * redemption (claimable later via `vaultRedeem`). For EVM-2 vaults the queued
+ * `requestRedeem` escrows the shares in the vault via `transferFrom`, so this
+ * also approves the receipt token when its allowance is short; the instant
+ * path (`isInstantRedeem: true`) burns the caller's shares directly and sends
+ * no approval.
  *
- * Approval of the receipt token (EVM-2) is always waited on before the
- * redeem call, regardless of the caller's `wait` flag.
+ * The receipt-token approval (EVM-2 queued path) is always waited on before
+ * the redeem call, regardless of the caller's `wait` flag.
  *
  * @param signer ethers Signer / Wallet (or viem WalletClient via {@link setSigner})
  * @param options Vault address, wallet, amount, optional `isInstantRedeem`,
@@ -311,7 +313,6 @@ export declare function vaultDeposit(signer: Signer | Wallet, options: IContract
  */
 export declare function vaultRequestRedeem(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
 /**
- * @TODO
  * @description withdraw funds from the specified pool including accrued rewards
  * @param signer signer / wallet object
  * @param options object including pool contract address, user wallet address, and more
@@ -323,6 +324,73 @@ export declare function vaultRedeem(signer: Signer | Wallet, options: IContractW
     day: string;
     receiverIndex: string;
 }): Promise<string>;
+/** Options for {@link claimWithdrawal}. */
+export type IClaimWithdrawalOptions = {
+    /** EVM-2 (Tokenized Vault V2) vault contract address. */
+    target: IAddress;
+    /**
+     * Wallet initiating the claim. Not a signer, but it is the default
+     * `receiver` of the withdrawn assets when `receiver` is omitted.
+     */
+    wallet: IAddress;
+    /**
+     * Withdrawal-epoch year to settle, from the `(claimableEpoch, year, month,
+     * day)` tuple `vaultRequestRedeem`/`requestRedeem` returned for this
+     * withdrawal — do not re-derive it from a timestamp.
+     */
+    year: string | bigint | number;
+    /** Withdrawal-epoch month, same source as `year`. */
+    month: string | bigint | number;
+    /** Withdrawal-epoch day, same source as `year`. */
+    day: string | bigint | number;
+    /** Address receiving the withdrawn assets. Defaults to `wallet`. */
+    receiver?: IAddress;
+    /** Wait for transaction confirmation. */
+    wait?: boolean;
+};
+/**
+ * Claim a previously-requested queued withdrawal on an EVM-2 (Tokenized
+ * Vault V2) vault, once its withdrawal epoch has passed.
+ *
+ * EVM-2 only — v1/v0 vaults use a different claim path ({@link vaultRedeem}).
+ * The vault's on-chain `claim(year, month, day, receiverAddr)` reverts if the
+ * epoch has not yet elapsed, or if the vault's idle reserve has not been
+ * refilled from subaccounts to cover the queue for that date; neither
+ * condition is checked client-side before sending.
+ *
+ * @param signer ethers Signer / Wallet.
+ * @param options.target EVM-2 vault contract address.
+ * @param options.wallet Wallet initiating the claim; receives the withdrawn assets unless `receiver` is set.
+ * @param options.year Withdrawal-epoch year from `requestRedeem`.
+ * @param options.month Withdrawal-epoch month from `requestRedeem`.
+ * @param options.day Withdrawal-epoch day from `requestRedeem`.
+ * @param options.receiver Address receiving the withdrawn assets. Defaults to `wallet`.
+ * @param options.wait Wait for transaction confirmation.
+ * @returns Claim transaction hash.
+ * @throws AugustValidationError on invalid address input, missing or non-integer date fields, or a non-EVM-2 vault.
+ * @throws AugustSDKError when the on-chain claim call fails.
+ *
+ * @worstCaseRpcCalls 2 — one vault-version lookup, one claim transaction.
+ *
+ * @example
+ * ```ts
+ * const { year, month, day } = await augustSdk.evm.vaultRequestRedeem({
+ *   target: vaultAddress,
+ *   wallet: walletAddress,
+ *   amount: '10',
+ * });
+ * // ...after the withdrawal epoch has elapsed...
+ * await augustSdk.evm.claimWithdrawal({
+ *   target: vaultAddress,
+ *   wallet: walletAddress,
+ *   year,
+ *   month,
+ *   day,
+ *   wait: true,
+ * });
+ * ```
+ */
+export declare function claimWithdrawal(signer: Signer | Wallet, options: IClaimWithdrawalOptions): Promise<string>;
 /**
  * Deposit a native token (ETH / AVAX / etc.) into a vault via the
  * `MultiAssetNativeDepositWrapper`. The wrapper forwards `msg.value` to