@upshiftfinance/sdk 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,65 @@
+import type { IAddress, ITokenizedVault } from '../../types';
+/**
+ * Per-vault on-chain reads resolved ahead of the positions fan-out, so
+ * `getVaultPositions` / `getVaultAvailableRedemptions` can skip their own
+ * `balanceOf` / `lagDuration` RPCs. A missing field means the read was not
+ * (or could not be) prefetched — the getter falls back to its own call.
+ * @internal
+ */
+export interface IPrefetchedVaultReads {
+    /** Raw share/receipt-token balance of the wallet (`balanceOf`). */
+    balance?: bigint;
+    /** Vault redemption lag in seconds (`lagDuration`). */
+    lagDuration?: number;
+}
+/**
+ * Minimal shape of a backend tokenized-vault row the prefetch needs. The
+ * full backend response type is looser than this; only these fields are read.
+ * @internal
+ */
+interface IPrefetchableVault {
+    address: string;
+    chain: number;
+    chain_type?: string;
+    /**
+     * Backend vault kind. `getVaultVersionV2` reads this to classify evm-2
+     * (`multiAssetVault`) vaults whose address isn't in the hardcoded
+     * `MULTI_ASSET_VAULTS` list; without it such a vault would be misclassified
+     * as evm-1 and the batch would target the vault itself for `balanceOf`
+     * instead of its receipt token.
+     */
+    internal_type?: ITokenizedVault['internal_type'];
+}
+/**
+ * Batch the two non-cacheable per-vault reads (`balanceOf`, `lagDuration`)
+ * for a vault list via Multicall3, grouped by chain, ahead of the per-vault
+ * positions fan-out.
+ *
+ * Scope and fallback rules (task 52):
+ * - Only EVM vaults on chains with a configured provider AND a verified
+ *   Multicall3 deployment are batched. Solana/Stellar vaults, unverified
+ *   chains (e.g. Citrea 4114), and provider-less chains are skipped — they
+ *   keep today's exact per-vault read path.
+ * - `balanceOf` targets the receipt token for evm-2 vaults (resolved through
+ *   the same cached `getReceiptTokenAddress` the getters use) and the vault
+ *   itself for evm-1. Without an EVM wallet only `lagDuration` is batched.
+ * - Failures never propagate: a reverting vault call is simply absent from
+ *   the result map, and a whole-chain error drops that chain's entries. The
+ *   worst case is always "no prefetch → per-vault fallback", never wrong data.
+ *
+ * RPC cost: per batched chain, `ceil(reads / 10)` `eth_call`s (+1 cold
+ * `lpTokenAddress` per evm-2 vault) instead of ~2 `eth_call`s per vault.
+ *
+ * @param vaults Backend tokenized-vault rows about to be fanned out over.
+ * @param wallet Optional EVM wallet for `balanceOf` reads.
+ * @param providers Chain-id → RPC-url map (the module's `this.providers`).
+ * @returns Map keyed by lowercased vault address; vaults with no batched
+ *   reads have no entry.
+ * @internal
+ */
+export declare function prefetchVaultPositionReads({ vaults, wallet, providers, }: {
+    vaults: IPrefetchableVault[];
+    wallet?: IAddress;
+    providers?: Partial<Record<number, string>>;
+}): Promise<Map<string, IPrefetchedVaultReads>>;
+export {};

package/lib/modules/vaults/prefetch.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prefetchVaultPositionReads = prefetchVaultPositionReads;
+const ethers_1 = require("ethers");
+const abis_1 = require("../../abis");
+const TokenizedVaultV2Receipt_1 = require("../../abis/TokenizedVaultV2Receipt");
+const core_1 = require("../../core");
+/**
+ * Batch the two non-cacheable per-vault reads (`balanceOf`, `lagDuration`)
+ * for a vault list via Multicall3, grouped by chain, ahead of the per-vault
+ * positions fan-out.
+ *
+ * Scope and fallback rules (task 52):
+ * - Only EVM vaults on chains with a configured provider AND a verified
+ *   Multicall3 deployment are batched. Solana/Stellar vaults, unverified
+ *   chains (e.g. Citrea 4114), and provider-less chains are skipped — they
+ *   keep today's exact per-vault read path.
+ * - `balanceOf` targets the receipt token for evm-2 vaults (resolved through
+ *   the same cached `getReceiptTokenAddress` the getters use) and the vault
+ *   itself for evm-1. Without an EVM wallet only `lagDuration` is batched.
+ * - Failures never propagate: a reverting vault call is simply absent from
+ *   the result map, and a whole-chain error drops that chain's entries. The
+ *   worst case is always "no prefetch → per-vault fallback", never wrong data.
+ *
+ * RPC cost: per batched chain, `ceil(reads / 10)` `eth_call`s (+1 cold
+ * `lpTokenAddress` per evm-2 vault) instead of ~2 `eth_call`s per vault.
+ *
+ * @param vaults Backend tokenized-vault rows about to be fanned out over.
+ * @param wallet Optional EVM wallet for `balanceOf` reads.
+ * @param providers Chain-id → RPC-url map (the module's `this.providers`).
+ * @returns Map keyed by lowercased vault address; vaults with no batched
+ *   reads have no entry.
+ * @internal
+ */
+async function prefetchVaultPositionReads({ vaults, wallet, providers, }) {
+    const reads = new Map();
+    const hasWallet = !!(wallet && (0, ethers_1.isAddress)(wallet));
+    const byChain = new Map();
+    for (const v of vaults) {
+        if (!v?.address || !(0, ethers_1.isAddress)(v.address))
+            continue;
+        if (!(0, core_1.isMulticall3Supported)(v.chain))
+            continue;
+        if (!providers?.[v.chain])
+            continue;
+        const group = byChain.get(v.chain) ?? [];
+        group.push(v);
+        byChain.set(v.chain, group);
+    }
+    await Promise.all(Array.from(byChain.entries()).map(async ([chain, chainVaults]) => {
+        try {
+            // Same cache key as the getters (`createProvider(rpcUrl)` without a
+            // chainId) so the receipt-token/decimals caches stay shared.
+            const provider = (0, core_1.createProvider)(providers[chain]);
+            // Resolve each vault's `balanceOf` target — the receipt token for
+            // evm-2 vaults (one `lpTokenAddress` read each on a cold cache),
+            // the vault itself otherwise. Bound the fan-out to
+            // `MULTICALL3_BATCH_SIZE` concurrent reads (CLAUDE.md §4.1): a wallet
+            // with many uncached evm-2 vaults on one chain would otherwise burst
+            // N simultaneous reads before the aggregate3 batch even fires.
+            const balanceTargets = [];
+            for (let i = 0; i < chainVaults.length; i += core_1.MULTICALL3_BATCH_SIZE) {
+                const slice = chainVaults.slice(i, i + core_1.MULTICALL3_BATCH_SIZE);
+                const resolved = await Promise.all(slice.map(async (v) => {
+                    if (!hasWallet)
+                        return undefined;
+                    if ((0, core_1.getVaultVersionV2)(v) === 'evm-2') {
+                        // Cached + in-flight-deduped; a cold miss costs the same
+                        // `lpTokenAddress` read the getter itself would make.
+                        return (0, core_1.getReceiptTokenAddress)(provider, v.address);
+                    }
+                    return v.address;
+                }));
+                balanceTargets.push(...resolved);
+            }
+            const calls = [];
+            const slots = [];
+            chainVaults.forEach((v, i) => {
+                calls.push({
+                    target: v.address,
+                    abi: abis_1.ABI_LENDING_POOL_V2,
+                    functionName: 'lagDuration',
+                });
+                slots.push({ address: v.address, field: 'lagDuration' });
+                const target = balanceTargets[i];
+                if (hasWallet && target && (0, ethers_1.isAddress)(target)) {
+                    calls.push({
+                        target: target,
+                        abi: target === v.address
+                            ? abis_1.ABI_LENDING_POOL_V2
+                            : TokenizedVaultV2Receipt_1.ABI_TOKENIZED_VAULT_V2_RECEIPT,
+                        functionName: 'balanceOf',
+                        args: [wallet],
+                    });
+                    slots.push({ address: v.address, field: 'balance' });
+                }
+            });
+            const results = await (0, core_1.multicall3Aggregate)(provider, chain, calls);
+            results.forEach((r, i) => {
+                if (!r.success)
+                    return;
+                const slot = slots[i];
+                const key = slot.address.toLowerCase();
+                const entry = reads.get(key) ?? {};
+                if (slot.field === 'lagDuration') {
+                    entry.lagDuration = Number(r.value);
+                }
+                else {
+                    entry.balance = BigInt(r.value);
+                }
+                reads.set(key, entry);
+            });
+        }
+        catch (e) {
+            core_1.Logger.log.warn('prefetchVaultPositionReads', `chain ${chain} prefetch failed — falling back to per-vault reads`, e);
+        }
+    }));
+    return reads;
+}
+//# sourceMappingURL=prefetch.js.map

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

@@ -0,0 +1,406 @@
+import type { IAddress, IContractRunner, INormalizedNumber } from '../../types';
+import type { IContractWriteOptions } from './write.actions';
+/**
+ * Function to fetch instant redemption fee
+ * @param signer - signer / provider object
+ * @param options - object including pool contract address, user wallet address
+ * @returns normalized number object of the instant redemption fee
+ */
+export declare function fetchInstantRedemptionFee(signer: IContractRunner, options: IContractWriteOptions): Promise<INormalizedNumber>;
+/**
+ * allowance checks user's current allowance per pool
+ * @param signer - signer / provider object
+ * @param options - object including pool contract address, user wallet address
+ * @returns normalized number object of the user's current allowance
+ */
+export declare function vaultAllowance(signer: IContractRunner, options: IContractWriteOptions): Promise<INormalizedNumber>;
+/**
+ * Fetches the senders whitelist contract address from a whitelisted allocation vault
+ * @param signer - signer / provider object
+ * @param options - object including vault contract address
+ * @returns the senders whitelist contract address
+ */
+export declare function sendersWhitelistAddress(signer: IContractRunner, options: {
+    vault: IAddress;
+}): Promise<IAddress | undefined>;
+/**
+ * Checks if an address is whitelisted on a whitelist contract
+ * @param signer - signer / provider object
+ * @param options - object including whitelist contract address and wallet address to check
+ * @returns boolean indicating if the address is whitelisted
+ */
+export declare function isWhitelisted(signer: IContractRunner, options: {
+    whitelist: IAddress;
+    wallet: IAddress;
+}): Promise<boolean | undefined>;
+/**
+ * Fetches the total amount deposited by an address on a whitelist contract
+ * @param signer - signer / provider object
+ * @param options - object including whitelist contract address, wallet address, and vault address
+ * @returns normalized number of the deposited amount
+ */
+export declare function getDeposited(signer: IContractRunner, options: {
+    whitelist: IAddress;
+    wallet: IAddress;
+    vault: IAddress;
+}): Promise<INormalizedNumber | undefined>;
+/**
+ * Fetches the remaining allocation for an address on a whitelist contract
+ * @param signer - signer / provider object
+ * @param options - object including whitelist contract address, wallet address, vault address, and optional deposit cap amount
+ * @returns the remaining allocation as normalized number
+ */
+export declare function getRemainingAllocations(signer: IContractRunner, options: {
+    whitelist: IAddress;
+    wallet: IAddress;
+    vault: IAddress;
+    depositCapAmount?: bigint;
+}): Promise<INormalizedNumber | undefined>;
+export type IPreviewRwaRedemptionOptions = {
+    /** RwaRedeemSubaccount contract address */
+    target: IAddress;
+    /** Redeemable asset address (e.g. USDC, USDT) */
+    asset: IAddress;
+    /** Amount of vault shares to preview */
+    amount: string | bigint | number;
+    /** Decimals of the vault share token */
+    decimals: number;
+    /** Decimals of the output/redeemable asset */
+    outputDecimals: number;
+};
+/**
+ * Preview the output amount for an RWA instant redemption via the RwaRedeemSubaccount contract.
+ * @param signer - signer / provider object
+ * @param options - object including subaccount address, asset, amount, decimals, and outputDecimals
+ * @returns normalized number of the expected output amount (in output asset decimals)
+ */
+export declare function previewRwaRedemption(signer: IContractRunner, options: IPreviewRwaRedemptionOptions): Promise<INormalizedNumber | undefined>;
+/** Options for {@link previewDeposit}. */
+export type IPreviewDepositOptions = {
+    /** Vault contract address. */
+    vault: IAddress;
+    /** Deposit amount in the deposit asset's smallest unit (raw bigint-shaped). */
+    amount: string | bigint | number;
+    /**
+     * Optional deposit asset. Required for multi-asset vaults (EVM-2); ignored
+     * for single-asset vaults where the underlying is implicit.
+     */
+    asset?: IAddress;
+};
+/** Options for {@link previewRedeem}. */
+export type IPreviewRedeemOptions = {
+    /** Vault contract address. */
+    vault: IAddress;
+    /** Share amount in the vault share token's smallest unit (raw bigint-shaped). */
+    shares: string | bigint | number;
+};
+/** Options for {@link allowance}. */
+export type IAllowanceOptions = {
+    /** Spender contract — usually the vault address. */
+    vault: IAddress;
+    /** Owner whose ERC-20 allowance is being queried. */
+    owner: IAddress;
+    /**
+     * Token whose allowance is queried. Defaults to the vault's underlying
+     * asset, resolved via `IERC4626.asset()`.
+     */
+    asset?: IAddress;
+};
+/** Options for {@link balanceOf}. */
+export type IBalanceOfOptions = {
+    /** ERC-20 token address. */
+    asset: IAddress;
+    /** Owner whose balance is queried. */
+    owner: IAddress;
+};
+/** Options for {@link maxDeposit}. */
+export type IMaxDepositOptions = {
+    /** Vault contract address. */
+    vault: IAddress;
+    /**
+     * Receiver address — passed to ERC-4626 `maxDeposit(address)` on single-
+     * asset vaults. Ignored by EVM-2 multi-asset vaults which expose a vault-
+     * level `maxDepositAmount()` without a receiver argument.
+     */
+    receiver?: IAddress;
+};
+/**
+ * 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
+ * multi-asset vaults using the vault version detected from backend metadata.
+ *
+ * @returns The number of shares (raw on-chain units, share-token decimals).
+ * @throws UpshiftValidationError on invalid vault address or amount.
+ * @throws UpshiftSDKError when the underlying contract call fails.
+ *
+ * @example
+ * ```ts
+ * const shares = await upshiftSdk.evm.previewDeposit({
+ *   vault: '0xE9B725010A9E419412ed67d0fA5f3A5f40159D32',
+ *   amount: 1_000_000n,           // 1 USDC (6 decimals)
+ * });
+ * ```
+ */
+export declare function previewDeposit(signer: IContractRunner, options: IPreviewDepositOptions): Promise<bigint>;
+/**
+ * Preview the number of underlying assets returned by redeeming a given
+ * number of shares, without touching on-chain state. Routes between single-
+ * asset ERC-4626 (`previewRedeem`) and EVM-2 multi-asset
+ * (`previewRedemption(shares, isInstant=false)`) using the vault version.
+ *
+ * @returns The assets that would be redeemed (raw on-chain units, asset
+ *   decimals).
+ * @throws UpshiftValidationError on invalid vault or share input.
+ * @throws UpshiftSDKError when the underlying contract call fails.
+ *
+ * @example
+ * ```ts
+ * const assets = await upshiftSdk.evm.previewRedeem({
+ *   vault: '0xE9B725010A9E419412ed67d0fA5f3A5f40159D32',
+ *   shares: 1_000_000_000_000_000_000n, // 1 share (18 decimals)
+ * });
+ * ```
+ */
+export declare function previewRedeem(signer: IContractRunner, options: IPreviewRedeemOptions): Promise<bigint>;
+/**
+ * Read the ERC-20 allowance an `owner` has granted to a vault (the spender).
+ * If `asset` is omitted, the vault's underlying asset is resolved via
+ * `IERC4626.asset()` and used as the token.
+ *
+ * Returns a raw `bigint` to keep BigInt math precise — call
+ * {@link toNormalizedBn} if you need a UI-shaped {@link INormalizedNumber}.
+ *
+ * @returns Allowance in raw on-chain units of `asset`.
+ * @throws UpshiftValidationError on invalid addresses.
+ * @throws UpshiftSDKError when the underlying contract call fails.
+ *
+ * @example
+ * ```ts
+ * const raw = await upshiftSdk.evm.allowance({
+ *   vault: '0xE9B725010A9E419412ed67d0fA5f3A5f40159D32',
+ *   owner: walletAddress,
+ * });
+ * if (raw < requiredAmount) {
+ *   await upshiftSdk.evm.vaultApprove({
+ *     target: vault,
+ *     wallet: walletAddress,
+ *     amount: requiredAmount.toString(),
+ *   });
+ * }
+ * ```
+ */
+export declare function allowance(signer: IContractRunner, options: IAllowanceOptions): Promise<bigint>;
+/**
+ * Read an ERC-20 balance directly. Returns the raw on-chain value as
+ * `bigint`; call {@link toNormalizedBn} if you need a {@link INormalizedNumber}.
+ *
+ * @returns Balance in raw on-chain units of `asset`.
+ * @throws UpshiftValidationError on invalid asset / owner addresses.
+ * @throws UpshiftSDKError when the underlying contract call fails.
+ *
+ * @example
+ * ```ts
+ * const raw = await upshiftSdk.evm.balanceOf({
+ *   asset: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+ *   owner: walletAddress,
+ * });
+ * ```
+ */
+export declare function balanceOf(signer: IContractRunner, options: IBalanceOfOptions): Promise<bigint>;
+/**
+ * Read the maximum deposit currently accepted by a vault. Routes between
+ * single-asset ERC-4626 (`maxDeposit(receiver)`) and EVM-2 multi-asset
+ * (`maxDepositAmount()`, vault-level cap, no receiver dependence).
+ *
+ * @returns Max deposit in raw on-chain units of the deposit asset.
+ * @throws UpshiftValidationError on invalid vault address.
+ * @throws UpshiftSDKError when the underlying contract call fails.
+ *
+ * @example
+ * ```ts
+ * const cap = await upshiftSdk.evm.maxDeposit({ vault });
+ * if (cap === 0n) showVaultIsFullToast();
+ * ```
+ */
+export declare function maxDeposit(signer: IContractRunner, options: IMaxDepositOptions): Promise<bigint>;
+/** Options for {@link getIdleLiquidity}. */
+export type IGetIdleLiquidityOptions = {
+    /** EVM-2 (Tokenized Vault V2) vault contract address. */
+    vault: IAddress;
+};
+/**
+ * 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 UpshiftValidationError on invalid vault address or a non-EVM-2 vault.
+ * @throws UpshiftSDKError when either underlying contract read fails.
+ *
+ * @worstCaseRpcCalls 3 — vault-version lookup, `getTotalAssets`, `externalAssets`.
+ *
+ * @example
+ * ```ts
+ * const idle = await upshiftSdk.evm.getIdleLiquidity({ vault: vaultAddress });
+ * if (redeemAmount > idle) {
+ *   // fall back to a queued withdrawal instead of an instant one
+ * }
+ * ```
+ */
+export declare function getIdleLiquidity(signer: IContractRunner, options: IGetIdleLiquidityOptions): Promise<bigint>;
+/** Options for {@link lagDuration}. */
+export type ILagDurationOptions = {
+    /** EVM-2 (Tokenized Vault V2) vault contract address. */
+    vault: IAddress;
+};
+/**
+ * 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 UpshiftValidationError on invalid vault address or a non-EVM-2 vault.
+ * @throws UpshiftSDKError when the underlying contract read fails.
+ *
+ * @worstCaseRpcCalls 2 — vault-version lookup, `lagDuration`.
+ *
+ * @example
+ * ```ts
+ * const seconds = await upshiftSdk.evm.lagDuration({ vault: vaultAddress });
+ * ```
+ */
+export declare function lagDuration(signer: IContractRunner, options: ILagDurationOptions): Promise<bigint>;
+/** Options for {@link getWithdrawalEpoch}. */
+export type IGetWithdrawalEpochOptions = {
+    /** EVM-2 (Tokenized Vault V2) vault contract address. */
+    vault: IAddress;
+};
+/** An EVM-2 vault's current withdrawal epoch, as read from `getWithdrawalEpoch()`. */
+export type IWithdrawalEpoch = {
+    year: bigint;
+    month: bigint;
+    day: bigint;
+    /** Unix timestamp at which the current epoch's queued withdrawals become claimable. */
+    claimableEpoch: bigint;
+};
+/**
+ * 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 UpshiftValidationError on invalid vault address or a non-EVM-2 vault.
+ * @throws UpshiftSDKError when the underlying contract read fails.
+ *
+ * @worstCaseRpcCalls 2 — vault-version lookup, `getWithdrawalEpoch`.
+ *
+ * @example
+ * ```ts
+ * const { year, month, day, claimableEpoch } = await upshiftSdk.evm.getWithdrawalEpoch({
+ *   vault: vaultAddress,
+ * });
+ * ```
+ */
+export declare function getWithdrawalEpoch(signer: IContractRunner, options: IGetWithdrawalEpochOptions): Promise<IWithdrawalEpoch>;
+/** Options shared by the EVM-2 queued-withdrawal-date reads. */
+type IWithdrawalDateOptions = {
+    /** EVM-2 (Tokenized Vault V2) vault contract address. */
+    vault: IAddress;
+    /** Withdrawal-epoch year, as returned by `requestRedeem`/`getWithdrawalEpoch`. */
+    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;
+};
+/** Options for {@link getBurnableAmountByReceiver}. */
+export type IGetBurnableAmountByReceiverOptions = IWithdrawalDateOptions & {
+    /** Address whose claimable amount for this date is being queried. */
+    receiver: IAddress;
+};
+/**
+ * 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 UpshiftValidationError on invalid address input or a non-EVM-2 vault.
+ * @throws UpshiftSDKError when the underlying contract read fails.
+ *
+ * @worstCaseRpcCalls 2 — vault-version lookup, `getBurnableAmountByReceiver`.
+ *
+ * @example
+ * ```ts
+ * const claimable = await upshiftSdk.evm.getBurnableAmountByReceiver({
+ *   vault: vaultAddress,
+ *   receiver: walletAddress,
+ *   year, month, day,
+ * });
+ * ```
+ */
+export declare function getBurnableAmountByReceiver(signer: IContractRunner, options: IGetBurnableAmountByReceiverOptions): Promise<bigint>;
+/** Options for {@link getRequirementByDate}. */
+export type IGetRequirementByDateOptions = IWithdrawalDateOptions;
+/**
+ * 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 UpshiftValidationError on invalid vault address or a non-EVM-2 vault.
+ * @throws UpshiftSDKError when the underlying contract read fails.
+ *
+ * @worstCaseRpcCalls 2 — vault-version lookup, `getRequirementByDate`.
+ *
+ * @example
+ * ```ts
+ * const shares = await upshiftSdk.evm.getRequirementByDate({
+ *   vault: vaultAddress,
+ *   year, month, day,
+ * });
+ * ```
+ */
+export declare function getRequirementByDate(signer: IContractRunner, options: IGetRequirementByDateOptions): Promise<bigint>;
+/** Options for {@link getScheduledTransactionsByDate}. */
+export type IGetScheduledTransactionsByDateOptions = IWithdrawalDateOptions;
+/** Scheduled queued-withdrawal volume for a withdrawal-epoch date. */
+export type IScheduledTransactionsByDate = {
+    totalTransactions: bigint;
+    /** Unix timestamp this date's queue is scheduled to execute. */
+    executionEpoch: bigint;
+};
+/**
+ * Read the scheduled queued-withdrawal volume for a withdrawal-epoch date.
+ *
+ * EVM-2 only.
+ *
+ * @returns Total scheduled transactions and their execution epoch.
+ * @throws UpshiftValidationError on invalid vault address or a non-EVM-2 vault.
+ * @throws UpshiftSDKError when the underlying contract read fails.
+ *
+ * @worstCaseRpcCalls 2 — vault-version lookup, `getScheduledTransactionsByDate`.
+ *
+ * @example
+ * ```ts
+ * const { totalTransactions, executionEpoch } =
+ *   await upshiftSdk.evm.getScheduledTransactionsByDate({
+ *     vault: vaultAddress,
+ *     year, month, day,
+ *   });
+ * ```
+ */
+export declare function getScheduledTransactionsByDate(signer: IContractRunner, options: IGetScheduledTransactionsByDateOptions): Promise<IScheduledTransactionsByDate>;
+export {};