@upshiftfinance/sdk 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,891 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchInstantRedemptionFee = fetchInstantRedemptionFee;
+exports.vaultAllowance = vaultAllowance;
+exports.sendersWhitelistAddress = sendersWhitelistAddress;
+exports.isWhitelisted = isWhitelisted;
+exports.getDeposited = getDeposited;
+exports.getRemainingAllocations = getRemainingAllocations;
+exports.previewRwaRedemption = previewRwaRedemption;
+exports.previewDeposit = previewDeposit;
+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");
+/**
+ * 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
+ */
+async function fetchInstantRedemptionFee(signer, options) {
+    const { wallet, target } = options;
+    const [goodWallet, goodPool] = [
+        (0, core_1.checkAddress)(wallet, console, 'wallet'),
+        (0, core_1.checkAddress)(target, console),
+    ];
+    if (!goodWallet || !goodPool)
+        return;
+    try {
+        if (signer && target) {
+            const poolContract = (0, core_1.createContract)({
+                address: target,
+                abi: abis_1.ABI_LENDING_POOL_V3,
+                provider: signer,
+            });
+            const instantRedemptionResult = await poolContract.instantRedemptionFee();
+            return (0, core_1.toNormalizedBn)(instantRedemptionResult);
+        }
+    }
+    catch (e) {
+        (0, core_1.logChainError)('failed to fetch instant redeem fee', e, (0, core_1.isExpectedRevertError)(e));
+        throw new Error(`Failed to fetch instant redeem fee for ${target}: ${e instanceof Error ? e.message : 'Unknown error'}`);
+    }
+}
+/**
+ * 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
+ */
+async function vaultAllowance(signer, options) {
+    const { wallet, target } = options;
+    const [goodWallet, goodPool] = [
+        (0, core_1.checkAddress)(wallet, console, 'wallet'),
+        (0, core_1.checkAddress)(target, console),
+    ];
+    if (!goodWallet || !goodPool)
+        return;
+    try {
+        // ERC4626 vault
+        const poolContract = (0, core_1.createContract)({
+            address: target,
+            abi: abis_1.ABI_LENDING_POOLS,
+            provider: signer,
+        });
+        // get vault asset address and decimals
+        const [asset, rawDecimals] = await Promise.all([
+            poolContract.asset(),
+            poolContract.decimals(),
+        ]);
+        const decimals = Number(rawDecimals);
+        // check amount vault approves user for
+        const depositTokenContract = (0, core_1.createContract)({
+            address: asset,
+            abi: abis_1.ABI_ERC20,
+            provider: signer,
+        });
+        const _allowance = (await depositTokenContract.allowance(wallet, target));
+        const normalized = (0, core_1.toNormalizedBn)(_allowance, decimals);
+        core_1.Logger.log.info('allowance', normalized);
+        return normalized;
+    }
+    catch (e) {
+        (0, core_1.logChainError)('allowance', e, (0, core_1.isExpectedRevertError)(e));
+        throw new Error(`Failed to fetch allowance: ${e instanceof Error ? e.message : 'Unknown error'}`);
+    }
+}
+/**
+ * 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
+ */
+async function sendersWhitelistAddress(signer, options) {
+    const { vault } = options;
+    const goodTarget = (0, core_1.checkAddress)(vault, console);
+    if (!goodTarget)
+        return;
+    try {
+        const vaultContract = (0, core_1.createContract)({
+            address: vault,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2_WHITELISTED_ALLOCATION,
+            provider: signer,
+        });
+        const whitelistAddress = await vaultContract.sendersWhitelistAddress();
+        core_1.Logger.log.info('sendersWhitelistAddress', whitelistAddress);
+        return whitelistAddress;
+    }
+    catch (e) {
+        (0, core_1.logChainError)('sendersWhitelistAddress', e, (0, core_1.isExpectedRevertError)(e));
+        throw new Error(`Failed to fetch senders whitelist address: ${e instanceof Error ? e.message : 'Unknown error'}`);
+    }
+}
+/**
+ * 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
+ */
+async function isWhitelisted(signer, options) {
+    const { whitelist, wallet } = options;
+    const [goodWhitelist, goodWallet] = [
+        (0, core_1.checkAddress)(whitelist, console, 'contract'),
+        (0, core_1.checkAddress)(wallet, console, 'wallet'),
+    ];
+    if (!goodWhitelist || !goodWallet)
+        return;
+    try {
+        const whitelistContract = (0, core_1.createContract)({
+            address: whitelist,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2_SENDER_ALLOCATION_WHITELIST,
+            provider: signer,
+        });
+        const result = await whitelistContract.isWhitelisted(wallet);
+        core_1.Logger.log.info('isWhitelisted', result);
+        return result;
+    }
+    catch (e) {
+        (0, core_1.logChainError)('isWhitelisted', e, (0, core_1.isExpectedRevertError)(e));
+        throw new Error(`Failed to check whitelist status: ${e instanceof Error ? e.message : 'Unknown error'}`);
+    }
+}
+/**
+ * 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
+ */
+async function getDeposited(signer, options) {
+    const { whitelist, wallet, vault } = options;
+    const [goodWhitelist, goodWallet, goodVault] = [
+        (0, core_1.checkAddress)(whitelist, console, 'contract'),
+        (0, core_1.checkAddress)(wallet, console, 'wallet'),
+        (0, core_1.checkAddress)(vault, console, 'contract'),
+    ];
+    if (!goodWhitelist || !goodWallet || !goodVault)
+        return;
+    try {
+        const vaultContract = (0, core_1.createContract)({
+            address: vault,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2_WHITELISTED_ALLOCATION,
+            provider: signer,
+        });
+        const whitelistContract = (0, core_1.createContract)({
+            address: whitelist,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2_SENDER_ALLOCATION_WHITELIST,
+            provider: signer,
+        });
+        const [deposited, asset] = await Promise.all([
+            whitelistContract.getDeposited(wallet),
+            vaultContract.asset(),
+        ]);
+        const assetContract = (0, core_1.createContract)({
+            address: asset,
+            abi: abis_1.ABI_ERC20,
+            provider: signer,
+        });
+        const decimals = Number(await assetContract.decimals());
+        const normalized = (0, core_1.toNormalizedBn)(deposited, decimals);
+        core_1.Logger.log.info('getDeposited', normalized);
+        return normalized;
+    }
+    catch (e) {
+        (0, core_1.logChainError)('getDeposited', e, (0, core_1.isExpectedRevertError)(e));
+        throw new Error(`Failed to fetch deposited amount: ${e instanceof Error ? e.message : 'Unknown error'}`);
+    }
+}
+/**
+ * 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
+ */
+async function getRemainingAllocations(signer, options) {
+    const { whitelist, wallet, vault, depositCapAmount } = options;
+    const [goodWhitelist, goodWallet, goodVault] = [
+        (0, core_1.checkAddress)(whitelist, console, 'contract'),
+        (0, core_1.checkAddress)(wallet, console, 'wallet'),
+        (0, core_1.checkAddress)(vault, console, 'contract'),
+    ];
+    if (!goodWhitelist || !goodWallet || !goodVault)
+        return;
+    try {
+        const vaultContract = (0, core_1.createContract)({
+            address: vault,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2_WHITELISTED_ALLOCATION,
+            provider: signer,
+        });
+        const whitelistContract = (0, core_1.createContract)({
+            address: whitelist,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2_SENDER_ALLOCATION_WHITELIST,
+            provider: signer,
+        });
+        // Fetch depositCap if not provided, along with asset address
+        const [capAmount, asset] = await Promise.all([
+            depositCapAmount !== undefined
+                ? Promise.resolve(depositCapAmount)
+                : vaultContract.depositCap(),
+            vaultContract.asset(),
+        ]);
+        const assetContract = (0, core_1.createContract)({
+            address: asset,
+            abi: abis_1.ABI_ERC20,
+            provider: signer,
+        });
+        const decimals = Number(await assetContract.decimals());
+        const remaining = await whitelistContract.getRemainingAllocation(wallet, capAmount);
+        const normalized = (0, core_1.toNormalizedBn)(remaining, decimals);
+        core_1.Logger.log.info('getRemainingAllocations', normalized);
+        return normalized;
+    }
+    catch (e) {
+        (0, core_1.logChainError)('getRemainingAllocations', e, (0, core_1.isExpectedRevertError)(e));
+        throw new Error(`Failed to fetch remaining allocations: ${e instanceof Error ? e.message : 'Unknown error'}`);
+    }
+}
+/**
+ * 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)
+ */
+async function previewRwaRedemption(signer, options) {
+    const { target, asset, amount, decimals, outputDecimals } = options;
+    const goodTarget = (0, core_1.checkAddress)(target, console, 'contract');
+    const goodAsset = (0, core_1.checkAddress)(asset, console, 'contract');
+    if (!goodTarget || !goodAsset)
+        return;
+    try {
+        const subaccountContract = (0, core_1.createContract)({
+            address: target,
+            provider: signer,
+            abi: abis_1.RWA_REDEEM_SUBACCOUNT,
+        });
+        if (!subaccountContract)
+            return;
+        const normalizedAmt = (0, core_1.toNormalizedBn)(amount, decimals);
+        const result = await subaccountContract.previewRedemption(asset, BigInt(normalizedAmt.raw));
+        const normalized = (0, core_1.toNormalizedBn)(result, outputDecimals);
+        core_1.Logger.log.info('previewRwaRedemption', normalized);
+        return normalized;
+    }
+    catch (e) {
+        (0, core_1.logChainError)('previewRwaRedemption', e, (0, core_1.isExpectedRevertError)(e), {
+            target,
+            asset,
+            amount,
+        });
+        throw new Error(`Preview RWA redemption failed: ${e instanceof Error ? e.message : 'Unknown error'}`);
+    }
+}
+/**
+ * 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)
+ * });
+ * ```
+ */
+async function previewDeposit(signer, options) {
+    const { vault, amount, asset } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.UpshiftValidationError('INVALID_ADDRESS', `previewDeposit: invalid vault address ${vault}`);
+    }
+    const amountRaw = (0, core_1.toRawBigInt)(amount, 'previewDeposit');
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault, undefined, false, false))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        const isMultiAsset = vaultVersion === 'evm-2';
+        if (isMultiAsset) {
+            if (!asset || !(0, core_1.checkAddress)(asset, console, 'contract')) {
+                throw new core_1.UpshiftValidationError('INVALID_INPUT', 'previewDeposit: multi-asset vaults require an explicit `asset` parameter');
+            }
+            const contract = (0, core_1.createContract)({
+                address: vault,
+                provider: signer,
+                abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+            });
+            const result = await contract.previewDeposit(asset, amountRaw);
+            // TokenizedVaultV2 previewDeposit returns (shares, _); take shares.
+            const shares = Array.isArray(result) ? result[0] : result;
+            return BigInt(shares);
+        }
+        const contract = (0, core_1.createContract)({
+            address: vault,
+            provider: signer,
+            abi: abis_1.ABI_LENDING_POOLS,
+        });
+        const result = await contract.previewDeposit(amountRaw);
+        return BigInt(result);
+    }
+    catch (e) {
+        if (e instanceof core_1.UpshiftValidationError || e instanceof core_1.UpshiftSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('previewDeposit', e, (0, core_1.isExpectedRevertError)(e), {
+            vault,
+            amount: amount.toString(),
+        });
+        throw new core_1.UpshiftSDKError('UNKNOWN', `previewDeposit failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, amount: amount.toString() } });
+    }
+}
+/**
+ * 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)
+ * });
+ * ```
+ */
+async function previewRedeem(signer, options) {
+    const { vault, shares } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.UpshiftValidationError('INVALID_ADDRESS', `previewRedeem: invalid vault address ${vault}`);
+    }
+    const sharesRaw = (0, core_1.toRawBigInt)(shares, 'previewRedeem');
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault, undefined, false, false))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        const isMultiAsset = vaultVersion === 'evm-2';
+        if (isMultiAsset) {
+            const contract = (0, core_1.createContract)({
+                address: vault,
+                provider: signer,
+                abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+            });
+            const result = await contract.previewRedemption(sharesRaw, false);
+            // EVM-2 previewRedemption returns (assetsAmount, assetsAfterFee); take gross.
+            const assets = Array.isArray(result) ? result[0] : result;
+            return BigInt(assets);
+        }
+        const contract = (0, core_1.createContract)({
+            address: vault,
+            provider: signer,
+            abi: abis_1.ABI_LENDING_POOLS,
+        });
+        const result = await contract.previewRedeem(sharesRaw);
+        return BigInt(result);
+    }
+    catch (e) {
+        if (e instanceof core_1.UpshiftValidationError || e instanceof core_1.UpshiftSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('previewRedeem', e, (0, core_1.isExpectedRevertError)(e), {
+            vault,
+            shares: shares.toString(),
+        });
+        throw new core_1.UpshiftSDKError('UNKNOWN', `previewRedeem failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, shares: shares.toString() } });
+    }
+}
+/**
+ * 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(),
+ *   });
+ * }
+ * ```
+ */
+async function allowance(signer, options) {
+    const { vault, owner, asset } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.UpshiftValidationError('INVALID_ADDRESS', `allowance: invalid vault address ${vault}`);
+    }
+    if (!(0, core_1.checkAddress)(owner, console, 'wallet')) {
+        throw new core_1.UpshiftValidationError('INVALID_ADDRESS', `allowance: invalid owner address ${owner}`);
+    }
+    if (asset && !(0, core_1.checkAddress)(asset, console, 'contract')) {
+        throw new core_1.UpshiftValidationError('INVALID_ADDRESS', `allowance: invalid asset address ${asset}`);
+    }
+    try {
+        let tokenAddress;
+        if (asset) {
+            tokenAddress = asset;
+        }
+        else {
+            const vaultContract = (0, core_1.createContract)({
+                address: vault,
+                provider: signer,
+                abi: abis_1.ABI_LENDING_POOLS,
+            });
+            tokenAddress = (await vaultContract.asset());
+        }
+        const tokenContract = (0, core_1.createContract)({
+            address: tokenAddress,
+            provider: signer,
+            abi: abis_1.ABI_ERC20,
+        });
+        const raw = (await tokenContract.allowance(owner, vault));
+        return BigInt(raw);
+    }
+    catch (e) {
+        if (e instanceof core_1.UpshiftValidationError || e instanceof core_1.UpshiftSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('allowance', e, (0, core_1.isExpectedRevertError)(e), {
+            vault,
+            owner,
+            asset,
+        });
+        throw new core_1.UpshiftSDKError('UNKNOWN', `allowance failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, owner, asset } });
+    }
+}
+/**
+ * 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,
+ * });
+ * ```
+ */
+async function balanceOf(signer, options) {
+    const { asset, owner } = options;
+    if (!(0, core_1.checkAddress)(asset, console, 'contract')) {
+        throw new core_1.UpshiftValidationError('INVALID_ADDRESS', `balanceOf: invalid asset address ${asset}`);
+    }
+    if (!(0, core_1.checkAddress)(owner, console, 'wallet')) {
+        throw new core_1.UpshiftValidationError('INVALID_ADDRESS', `balanceOf: invalid owner address ${owner}`);
+    }
+    try {
+        const tokenContract = (0, core_1.createContract)({
+            address: asset,
+            provider: signer,
+            abi: abis_1.ABI_ERC20,
+        });
+        const raw = (await tokenContract.balanceOf(owner));
+        return BigInt(raw);
+    }
+    catch (e) {
+        if (e instanceof core_1.UpshiftValidationError || e instanceof core_1.UpshiftSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('balanceOf', e, (0, core_1.isExpectedRevertError)(e), { asset, owner });
+        throw new core_1.UpshiftSDKError('UNKNOWN', `balanceOf failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { asset, owner } });
+    }
+}
+/**
+ * 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();
+ * ```
+ */
+async function maxDeposit(signer, options) {
+    const { vault, receiver } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.UpshiftValidationError('INVALID_ADDRESS', `maxDeposit: invalid vault address ${vault}`);
+    }
+    if (receiver && !(0, core_1.checkAddress)(receiver, console, 'wallet')) {
+        throw new core_1.UpshiftValidationError('INVALID_ADDRESS', `maxDeposit: invalid receiver address ${receiver}`);
+    }
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault, undefined, false, false))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        const isMultiAsset = vaultVersion === 'evm-2';
+        if (isMultiAsset) {
+            const contract = (0, core_1.createContract)({
+                address: vault,
+                provider: signer,
+                abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+            });
+            const raw = (await contract.maxDepositAmount());
+            return BigInt(raw);
+        }
+        const contract = (0, core_1.createContract)({
+            address: vault,
+            provider: signer,
+            abi: abis_1.ABI_LENDING_POOLS,
+        });
+        // Zero-address default: vaults that require a receiver arg won't revert.
+        const target = receiver ?? '0x0000000000000000000000000000000000000000';
+        const raw = (await contract.maxDeposit(target));
+        return BigInt(raw);
+    }
+    catch (e) {
+        if (e instanceof core_1.UpshiftValidationError || e instanceof core_1.UpshiftSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('maxDeposit', e, (0, core_1.isExpectedRevertError)(e), {
+            vault,
+            receiver,
+        });
+        throw new core_1.UpshiftSDKError('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 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
+ * }
+ * ```
+ */
+async function getIdleLiquidity(signer, options) {
+    const { vault } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.UpshiftValidationError('INVALID_ADDRESS', `getIdleLiquidity: invalid vault address ${vault}`);
+    }
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault, undefined, false, false))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        if (vaultVersion !== 'evm-2') {
+            throw new core_1.UpshiftValidationError('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.UpshiftValidationError || e instanceof core_1.UpshiftSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('getIdleLiquidity', e, (0, core_1.isExpectedRevertError)(e), { vault });
+        throw new core_1.UpshiftSDKError('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 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 });
+ * ```
+ */
+async function lagDuration(signer, options) {
+    const { vault } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.UpshiftValidationError('INVALID_ADDRESS', `lagDuration: invalid vault address ${vault}`);
+    }
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault, undefined, false, false))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        if (vaultVersion !== 'evm-2') {
+            throw new core_1.UpshiftValidationError('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.UpshiftValidationError || e instanceof core_1.UpshiftSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('lagDuration', e, (0, core_1.isExpectedRevertError)(e), { vault });
+        throw new core_1.UpshiftSDKError('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 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,
+ * });
+ * ```
+ */
+async function getWithdrawalEpoch(signer, options) {
+    const { vault } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.UpshiftValidationError('INVALID_ADDRESS', `getWithdrawalEpoch: invalid vault address ${vault}`);
+    }
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault, undefined, false, false))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        if (vaultVersion !== 'evm-2') {
+            throw new core_1.UpshiftValidationError('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.UpshiftValidationError || e instanceof core_1.UpshiftSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('getWithdrawalEpoch', e, (0, core_1.isExpectedRevertError)(e), {
+            vault,
+        });
+        throw new core_1.UpshiftSDKError('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 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,
+ * });
+ * ```
+ */
+async function getBurnableAmountByReceiver(signer, options) {
+    const { vault, year, month, day, receiver } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.UpshiftValidationError('INVALID_ADDRESS', `getBurnableAmountByReceiver: invalid vault address ${vault}`);
+    }
+    if (!(0, core_1.checkAddress)(receiver, console, 'wallet')) {
+        throw new core_1.UpshiftValidationError('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, undefined, false, false))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        if (vaultVersion !== 'evm-2') {
+            throw new core_1.UpshiftValidationError('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.UpshiftValidationError || e instanceof core_1.UpshiftSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('getBurnableAmountByReceiver', e, (0, core_1.isExpectedRevertError)(e), {
+            vault,
+            year,
+            month,
+            day,
+            receiver,
+        });
+        throw new core_1.UpshiftSDKError('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 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,
+ * });
+ * ```
+ */
+async function getRequirementByDate(signer, options) {
+    const { vault, year, month, day } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.UpshiftValidationError('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, undefined, false, false))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        if (vaultVersion !== 'evm-2') {
+            throw new core_1.UpshiftValidationError('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.UpshiftValidationError || e instanceof core_1.UpshiftSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('getRequirementByDate', e, (0, core_1.isExpectedRevertError)(e), {
+            vault,
+            year,
+            month,
+            day,
+        });
+        throw new core_1.UpshiftSDKError('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 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,
+ *   });
+ * ```
+ */
+async function getScheduledTransactionsByDate(signer, options) {
+    const { vault, year, month, day } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.UpshiftValidationError('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, undefined, false, false))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        if (vaultVersion !== 'evm-2') {
+            throw new core_1.UpshiftValidationError('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.UpshiftValidationError || e instanceof core_1.UpshiftSDKError) {
+            throw e;
+        }
+        (0, core_1.logChainError)('getScheduledTransactionsByDate', e, (0, core_1.isExpectedRevertError)(e), { vault, year, month, day });
+        throw new core_1.UpshiftSDKError('UNKNOWN', `getScheduledTransactionsByDate failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, year, month, day } });
+    }
+}
+//# sourceMappingURL=read.actions.js.map