@oydual31/more-vaults-sdk 0.1.0

package/dist/ethers/index.d.cts

@@ -0,0 +1,671 @@
+import { ContractTransactionReceipt, Signer, Provider } from 'ethers';
+export { ContractTransactionReceipt, Provider, Signer } from 'ethers';
+
+/** Addresses involved in vault operations. */
+interface VaultAddresses {
+    /** Hub vault (diamond proxy) address. */
+    vault: string;
+    /** MoreVaultsEscrow address for cross-chain locking. */
+    escrow?: string;
+    /** OFTAdapter address for share token bridging (cross-chain only). */
+    shareOFT?: string;
+    /** OFT address for USDC bridging (cross-chain only). */
+    usdcOFT?: string;
+}
+/** Result of a synchronous deposit or mint. */
+interface DepositResult {
+    receipt: ContractTransactionReceipt;
+    /** Number of vault shares minted. */
+    shares: bigint;
+}
+/** Result of a synchronous redeem or withdraw. */
+interface RedeemResult {
+    receipt: ContractTransactionReceipt;
+    /** Number of underlying assets returned. */
+    assets: bigint;
+}
+/** Result of an asynchronous cross-chain request. */
+interface AsyncRequestResult {
+    receipt: ContractTransactionReceipt;
+    /** bytes32 request GUID for tracking fulfillment. */
+    guid: string;
+}
+/**
+ * ActionType enum matching MoreVaultsLib.ActionType on-chain values.
+ *
+ * DEPOSIT = 0, MINT = 1, WITHDRAW = 2, REDEEM = 3,
+ * MULTI_ASSETS_DEPOSIT = 4, ACCRUE_FEES = 5
+ */
+declare const ActionType: {
+    readonly DEPOSIT: 0;
+    readonly MINT: 1;
+    readonly WITHDRAW: 2;
+    readonly REDEEM: 3;
+    readonly MULTI_ASSETS_DEPOSIT: 4;
+    readonly ACCRUE_FEES: 5;
+};
+type ActionTypeValue = (typeof ActionType)[keyof typeof ActionType];
+/** Cross-chain request info returned by getRequestInfo. */
+interface CrossChainRequestInfo {
+    initiator: string;
+    timestamp: bigint;
+    actionType: number;
+    actionCallData: string;
+    fulfilled: boolean;
+    finalized: boolean;
+    refunded: boolean;
+    totalAssets: bigint;
+    finalizationResult: bigint;
+    amountLimit: bigint;
+}
+
+/**
+ * Human-readable ABI fragments for MoreVaults diamond facets.
+ * Extracted from compiled artifacts in out/.
+ */
+declare const VAULT_ABI: readonly ["function deposit(uint256 assets, address receiver) returns (uint256 shares)", "function mint(uint256 shares, address receiver) returns (uint256 assets)", "function withdraw(uint256 assets, address receiver, address owner) returns (uint256 shares)", "function redeem(uint256 shares, address receiver, address owner) returns (uint256 assets)", "function deposit(address[] tokens, uint256[] assets, address receiver, uint256 minAmountOut) payable returns (uint256 shares)", "function requestRedeem(uint256 shares, address onBehalfOf)", "function requestWithdraw(uint256 assets, address onBehalfOf)", "function clearRequest()", "function getWithdrawalRequest(address _owner) view returns (uint256 shares, uint256 timelockEndsAt)", "function totalAssets() view returns (uint256)", "function totalSupply() view returns (uint256)", "function balanceOf(address account) view returns (uint256)", "function asset() view returns (address)", "function convertToShares(uint256 assets) view returns (uint256)", "function convertToAssets(uint256 shares) view returns (uint256)", "function previewDeposit(uint256 assets) view returns (uint256)", "function previewRedeem(uint256 shares) view returns (uint256)", "function paused() view returns (bool)", "event Deposit(address indexed sender, address indexed owner, address[] tokens, uint256[] assets, uint256 shares)", "event Transfer(address indexed from, address indexed to, uint256 value)", "event WithdrawRequestCreated(address requester, uint256 sharesAmount, uint256 endsAt)", "event WithdrawRequestFulfilled(address requester, address receiver, uint256 sharesAmount, uint256 assetAmount)"];
+declare const BRIDGE_ABI: readonly ["function initVaultActionRequest(uint8 actionType, bytes actionCallData, uint256 amountLimit, bytes extraOptions) payable returns (bytes32 guid)", "function getRequestInfo(bytes32 guid) view returns (tuple(address initiator, uint64 timestamp, uint8 actionType, bytes actionCallData, bool fulfilled, bool finalized, bool refunded, uint256 totalAssets, uint256 finalizationResult, uint256 amountLimit))", "function getFinalizationResult(bytes32 guid) view returns (uint256 result)", "function oraclesCrossChainAccounting() view returns (bool)", "function quoteAccountingFee(bytes extraOptions) view returns (uint256 nativeFee)", "function accountingBridgeFacet() view returns (uint256 sum, bool isPositive)"];
+declare const CONFIG_ABI: readonly ["function getEscrow() view returns (address escrow)", "function getCrossChainAccountingManager() view returns (address)", "function isHub() view returns (bool)", "function getWithdrawalQueueStatus() view returns (bool)", "function getWithdrawalTimelock() view returns (uint64)", "function getWithdrawalFee() view returns (uint96)", "function getMaxWithdrawalDelay() view returns (uint32)", "function getAvailableAssets() view returns (address[])", "function getDepositableAssets() view returns (address[])", "function depositCapacity() view returns (uint256)", "function fee() view returns (uint96)", "function feeRecipient() view returns (address)", "function paused() view returns (bool)", "function maxDeposit(address receiver) view returns (uint256)"];
+declare const METADATA_ABI: readonly ["function name() view returns (string)", "function symbol() view returns (string)", "function decimals() view returns (uint8)"];
+declare const ERC20_ABI: readonly ["function approve(address spender, uint256 amount) returns (bool)", "function allowance(address owner, address spender) view returns (uint256)", "function balanceOf(address account) view returns (uint256)", "function transfer(address to, uint256 amount) returns (bool)"];
+declare const OFT_ABI: readonly ["function send(tuple(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd) sendParam, tuple(uint256 nativeFee, uint256 lzTokenFee) fee, address refundAddress) payable returns (tuple(bytes32 guid, uint64 nonce, uint256 amountSentLD, uint256 amountReceivedLD) receipt, tuple(uint256 nativeFee, uint256 lzTokenFee) fee)", "function quoteSend(tuple(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd) sendParam, bool payInLzToken) view returns (tuple(uint256 nativeFee, uint256 lzTokenFee))"];
+
+/**
+ * Typed error classes for the MoreVaults SDK.
+ *
+ * Frontend code can use instanceof checks to handle errors programmatically:
+ *   catch (e) {
+ *     if (e instanceof InsufficientLiquidityError) { ... }
+ *   }
+ */
+declare class MoreVaultsError extends Error {
+    constructor(message: string);
+}
+declare class VaultPausedError extends MoreVaultsError {
+    constructor(vault: string);
+}
+declare class CapacityFullError extends MoreVaultsError {
+    constructor(vault: string);
+}
+declare class NotWhitelistedError extends MoreVaultsError {
+    constructor(vault: string, user: string);
+}
+declare class InsufficientLiquidityError extends MoreVaultsError {
+    hubLiquid: bigint;
+    required: bigint;
+    constructor(vault: string, hubLiquid: bigint, required: bigint);
+}
+declare class CCManagerNotConfiguredError extends MoreVaultsError {
+    constructor(vault: string);
+}
+declare class EscrowNotConfiguredError extends MoreVaultsError {
+    constructor(vault: string);
+}
+declare class NotHubVaultError extends MoreVaultsError {
+    constructor(vault: string);
+}
+declare class MissingEscrowAddressError extends MoreVaultsError {
+    constructor();
+}
+
+/**
+ * Deposit `assets` of the vault's underlying token and receive shares.
+ *
+ * TXs: 1 approve (if needed) + 1 deposit.
+ *
+ * @param signer   - Wallet that holds the underlying tokens.
+ * @param addresses - Vault addresses. Only `vault` is used.
+ * @param assets   - Amount of underlying tokens to deposit.
+ * @param receiver - Address that will receive the minted shares.
+ * @returns Shares minted and the transaction receipt.
+ */
+declare function depositSimple(signer: Signer, addresses: VaultAddresses, assets: bigint, receiver: string): Promise<DepositResult>;
+/**
+ * Deposit multiple tokens in a single transaction.
+ *
+ * TXs: N approves (if needed) + 1 deposit.
+ *
+ * @param signer      - Wallet holding the tokens.
+ * @param addresses   - Vault addresses. Only `vault` is used.
+ * @param tokens      - Array of token addresses to deposit.
+ * @param amounts     - Corresponding amounts for each token.
+ * @param receiver    - Address that will receive the minted shares.
+ * @param minShares   - Minimum acceptable shares (slippage protection).
+ * @returns Shares minted and the transaction receipt.
+ */
+declare function depositMultiAsset(signer: Signer, addresses: VaultAddresses, tokens: string[], amounts: bigint[], receiver: string, minShares: bigint): Promise<DepositResult>;
+/**
+ * Deposit when cross-chain oracle accounting is ON.
+ * Behaves identically to a simple deposit because oracle provides
+ * synchronous pricing.
+ *
+ * TXs: 1 approve (if needed) + 1 deposit.
+ */
+declare const depositCrossChainOracleOn: typeof depositSimple;
+/**
+ * Initiate an asynchronous cross-chain deposit request.
+ *
+ * CRITICAL: tokens are approved to the **escrow** address, not the vault.
+ *
+ * TXs: 1 approve to escrow (if needed) + 1 initVaultActionRequest.
+ * After this call, a LayerZero message is sent; the caller must wait for
+ * cross-chain fulfillment before shares are minted.
+ *
+ * @param signer       - Wallet holding the underlying tokens.
+ * @param addresses    - Must include `vault` and `escrow`.
+ * @param assets       - Amount of underlying tokens to deposit.
+ * @param receiver     - Address that will receive shares on fulfillment.
+ * @param lzFee        - Native fee for LayerZero message (use `quoteLzFee`).
+ * @param extraOptions - Optional LZ adapter parameters (bytes).
+ * @returns The request GUID for tracking and the transaction receipt.
+ */
+declare function depositAsync(signer: Signer, addresses: VaultAddresses, assets: bigint, receiver: string, lzFee: bigint, extraOptions?: string): Promise<AsyncRequestResult>;
+/**
+ * Initiate an asynchronous cross-chain mint request (exact shares).
+ *
+ * CRITICAL: tokens are approved to the **escrow** address, not the vault.
+ *
+ * TXs: 1 approve to escrow for maxAssets (if needed) + 1 initVaultActionRequest.
+ *
+ * @param signer       - Wallet holding the underlying tokens.
+ * @param addresses    - Must include `vault` and `escrow`.
+ * @param shares       - Exact number of shares to mint.
+ * @param maxAssets     - Maximum underlying tokens to spend (slippage cap).
+ * @param receiver     - Address that will receive shares on fulfillment.
+ * @param lzFee        - Native fee for LayerZero message.
+ * @param extraOptions - Optional LZ adapter parameters (bytes).
+ * @returns The request GUID for tracking and the transaction receipt.
+ */
+declare function mintAsync(signer: Signer, addresses: VaultAddresses, shares: bigint, maxAssets: bigint, receiver: string, lzFee: bigint, extraOptions?: string): Promise<AsyncRequestResult>;
+/**
+ * Smart deposit — auto-selects the correct flow based on vault configuration.
+ *
+ * Calls getVaultStatus internally to determine the vault mode, then dispatches
+ * to the appropriate flow:
+ * - local / cross-chain-oracle → depositSimple
+ * - cross-chain-async → depositAsync (quotes LZ fee automatically)
+ *
+ * @param signer         Wallet signer with account attached
+ * @param provider       Read-only provider for on-chain reads
+ * @param addresses      Vault address set (`escrow` required for async vaults)
+ * @param assets         Amount of underlying to deposit
+ * @param receiver       Address that will receive shares
+ * @param extraOptions   Optional LZ extra options (only used for async vaults)
+ * @returns              DepositResult or AsyncRequestResult depending on vault mode
+ * @throws               VaultPausedError if vault is paused
+ * @throws               CapacityFullError if vault is full
+ */
+declare function smartDeposit(signer: Signer, provider: Provider, addresses: VaultAddresses, assets: bigint, receiver: string, extraOptions?: string): Promise<DepositResult | AsyncRequestResult>;
+
+/**
+ * D6 / D7 — Deposit from a spoke chain to the hub vault via OFT Compose.
+ *
+ * Bridges tokens from the spoke chain to the hub via LayerZero OFT, attaching a
+ * composeMsg that instructs the hub-side MoreVaultsComposer to deposit into the vault
+ * and send the resulting shares back to the receiver on the spoke chain.
+ *
+ * - **D6 (oracle ON)**: composer calls `_depositAndSend` — shares arrive on spoke in ~1 LZ round-trip.
+ * - **D7 (oracle OFF)**: composer calls `_initDeposit` — requires an additional LZ Read round-trip.
+ *
+ * From the user's perspective, both D6 and D7 have the same interface.
+ *
+ * TXs: 1 approve (if needed) + 1 OFT.send().
+ * Wait: LayerZero cross-chain delivery (typically 1-5 minutes).
+ *
+ * @param signer        - Wallet on the spoke chain.
+ * @param spokeOFT      - OFT/OFTAdapter address on the spoke chain.
+ * @param hubEid        - LayerZero EID for the hub chain (e.g. 30332 for Flow EVM).
+ * @param spokeEid      - LayerZero EID for the spoke chain — where shares are sent back.
+ * @param amount        - Amount of underlying tokens to bridge and deposit.
+ * @param receiver      - Address that will receive shares on the spoke chain.
+ * @param lzFee         - Native fee for the OFT.send() call. Must cover both hub-bound
+ *                        and return (shares back) messages. Quote via OFT.quoteSend().
+ * @param minMsgValue   - Minimum msg.value the hub composer must receive to process
+ *                        the compose and send shares back. Defaults to 0.
+ * @param minSharesOut  - Minimum shares to receive after deposit (slippage protection).
+ *                        Defaults to 0.
+ * @param minAmountLD   - Minimum tokens received on hub after bridge. Defaults to `amount`.
+ * @param extraOptions  - LZ extra options bytes for the hub-bound message.
+ * @returns Transaction receipt.
+ */
+declare function depositFromSpoke(signer: Signer, spokeOFT: string, hubEid: number, spokeEid: number, amount: bigint, receiver: string, lzFee: bigint, minMsgValue?: bigint, minSharesOut?: bigint, minAmountLD?: bigint, extraOptions?: string): Promise<{
+    receipt: ContractTransactionReceipt;
+}>;
+/**
+ * Alias: D7 — Spoke to hub deposit when oracle is OFF (async resolution).
+ * Same interface as D6; the difference is handled server-side by the composer contract.
+ * Shares may take longer to arrive due to the additional LZ Read round-trip.
+ */
+declare const depositFromSpokeAsync: typeof depositFromSpoke;
+/**
+ * Quote the LayerZero fee required for depositFromSpoke / depositFromSpokeAsync.
+ *
+ * @param provider       Read-only provider on the SPOKE chain
+ * @param spokeOFT       OFT contract address on spoke chain
+ * @param hubEid         LayerZero EID for the hub chain
+ * @param spokeEid       LayerZero EID for the spoke chain
+ * @param amount         Amount of tokens to bridge
+ * @param receiver       Address that will receive vault shares on the spoke chain
+ * @param minMsgValue    Same value you plan to pass to depositFromSpoke (default 0n)
+ * @param minSharesOut   Same value you plan to pass to depositFromSpoke (default 0n)
+ * @param minAmountLD    Minimum tokens on hub after bridge (default: amount)
+ * @param extraOptions   LZ extra options (default 0x)
+ * @returns              Native fee in wei to pass as lzFee to depositFromSpoke
+ */
+declare function quoteDepositFromSpokeFee(provider: Provider, spokeOFT: string, hubEid: number, spokeEid: number, amount: bigint, receiver: string, minMsgValue?: bigint, minSharesOut?: bigint, minAmountLD?: bigint, extraOptions?: string): Promise<bigint>;
+
+/**
+ * Redeem `shares` for underlying assets.
+ *
+ * TXs: 1 redeem.
+ * Pre-condition: if withdrawal queue is enabled, `requestRedeem` must have
+ * been called and the timelock must have elapsed.
+ *
+ * @param signer    - Wallet holding the shares.
+ * @param addresses - Vault addresses. Only `vault` is used.
+ * @param shares    - Number of shares to redeem.
+ * @param receiver  - Address that will receive the underlying assets.
+ * @param owner     - Address that owns the shares.
+ * @returns Assets received and the transaction receipt.
+ */
+declare function redeemShares(signer: Signer, addresses: VaultAddresses, shares: bigint, receiver: string, owner: string): Promise<RedeemResult>;
+/**
+ * Withdraw exact `assets` amount of underlying tokens by burning shares.
+ *
+ * TXs: 1 withdraw.
+ *
+ * @param signer    - Wallet holding the shares.
+ * @param addresses - Vault addresses. Only `vault` is used.
+ * @param assets    - Exact amount of underlying tokens to withdraw.
+ * @param receiver  - Address that will receive the tokens.
+ * @param owner     - Address that owns the shares.
+ * @returns Assets received and the transaction receipt.
+ */
+declare function withdrawAssets(signer: Signer, addresses: VaultAddresses, assets: bigint, receiver: string, owner: string): Promise<RedeemResult>;
+/**
+ * Submit a withdrawal queue request for `shares`.
+ *
+ * TXs: 1 requestRedeem.
+ * After this call and once any timelock elapses, call `redeemShares()` to
+ * complete the withdrawal.
+ *
+ * @param signer    - Wallet holding the shares.
+ * @param addresses - Vault addresses. Only `vault` is used.
+ * @param shares    - Number of shares to queue for redemption.
+ * @param owner     - Address on whose behalf to request.
+ * @returns Transaction receipt.
+ */
+declare function requestRedeem(signer: Signer, addresses: VaultAddresses, shares: bigint, owner: string): Promise<{
+    receipt: ContractTransactionReceipt;
+}>;
+/**
+ * Get the current withdrawal request for an owner.
+ * Returns null if no pending request exists.
+ *
+ * @param provider - JSON-RPC provider.
+ * @param vault    - Vault (diamond) address.
+ * @param owner    - Address of the shares owner.
+ * @returns The request details or null.
+ */
+declare function getWithdrawalRequest(provider: Provider, vault: string, owner: string): Promise<{
+    shares: bigint;
+    timelockEndsAt: bigint;
+} | null>;
+/**
+ * Initiate an asynchronous cross-chain redeem request.
+ *
+ * CRITICAL: shares are approved to the **escrow** address (vault share token).
+ * amountLimit MUST be 0 for redeems.
+ *
+ * TXs: 1 approve to escrow for shares (if needed) + 1 initVaultActionRequest.
+ * Wait: LayerZero cross-chain fulfillment.
+ *
+ * @param signer       - Wallet holding the shares.
+ * @param addresses    - Must include `vault` and `escrow`.
+ * @param shares       - Number of shares to redeem.
+ * @param receiver     - Address that will receive the underlying assets.
+ * @param owner        - Address that owns the shares.
+ * @param lzFee        - Native fee for LayerZero message.
+ * @param extraOptions - Optional LZ adapter parameters (bytes).
+ * @returns The request GUID for tracking and the transaction receipt.
+ */
+declare function redeemAsync(signer: Signer, addresses: VaultAddresses, shares: bigint, receiver: string, owner: string, lzFee: bigint, extraOptions?: string): Promise<AsyncRequestResult>;
+/**
+ * Bridge shares from a spoke chain to the hub chain (step 1 of 2).
+ *
+ * After the shares arrive on the hub chain, call `redeemShares()` on the
+ * hub to complete the redemption.
+ *
+ * TXs: 1 approve (if needed) + 1 OFT.send().
+ * Wait: LayerZero delivery (typically 1-5 minutes).
+ *
+ * @param signer      - Wallet on the spoke chain holding shares.
+ * @param shareOFT    - OFTAdapter address for the share token on spoke.
+ * @param hubChainEid - LayerZero endpoint ID for the hub chain (e.g. 30332 for Flow EVM).
+ * @param shares      - Number of shares to bridge.
+ * @param receiver    - Address on hub chain that will receive the shares.
+ * @param lzFee       - Native fee for LayerZero message.
+ * @returns Transaction receipt.
+ */
+declare function bridgeSharesToHub(signer: Signer, shareOFT: string, hubChainEid: number, shares: bigint, receiver: string, lzFee: bigint): Promise<{
+    receipt: ContractTransactionReceipt;
+}>;
+
+/**
+ * Utility helpers for the MoreVaults ethers.js v6 SDK.
+ *
+ * All reads use Provider (read-only). Writes use Signer.
+ */
+
+type VaultMode = "local" | "cross-chain-oracle" | "cross-chain-async" | "paused" | "full";
+interface VaultStatus {
+    /** Vault operating mode — determines which SDK flow to use */
+    mode: VaultMode;
+    /** Which deposit function to call given the current configuration */
+    recommendedDepositFlow: "depositSimple" | "depositAsync" | "mintAsync" | "none";
+    /** Which redeem function to call given the current configuration */
+    recommendedRedeemFlow: "redeemShares" | "redeemAsync" | "none";
+    isHub: boolean;
+    isPaused: boolean;
+    oracleAccountingEnabled: boolean;
+    /** address(0) means CCManager is not set — async flows will fail */
+    ccManager: string;
+    /** address(0) means escrow is not configured in the registry */
+    escrow: string;
+    withdrawalQueueEnabled: boolean;
+    /** Timelock duration in seconds (0 = no timelock) */
+    withdrawalTimelockSeconds: bigint;
+    /**
+     * Remaining deposit capacity in underlying token decimals.
+     * `type(uint256).max` = no cap configured (unlimited).
+     * `0n` = vault is full — no more deposits accepted.
+     * If `depositAccessRestricted = true`, this value is `type(uint256).max` but
+     * deposits are still gated by whitelist or other access control.
+     */
+    remainingDepositCapacity: bigint;
+    /**
+     * True when `maxDeposit(address(0))` reverted, indicating the vault uses
+     * whitelist or other access control to restrict who can deposit.
+     */
+    depositAccessRestricted: boolean;
+    underlying: string;
+    totalAssets: bigint;
+    totalSupply: bigint;
+    /** Vault share token decimals. Use this for display — never hardcode 18. */
+    decimals: number;
+    /**
+     * Price of 1 full share expressed in underlying token units.
+     * = convertToAssets(10^decimals). Grows over time as the vault earns yield.
+     */
+    sharePrice: bigint;
+    /**
+     * Underlying token balance held directly on the hub chain.
+     * This is the only portion that can be paid out to redeeming users immediately.
+     * (= ERC-20.balanceOf(vault) on the hub)
+     */
+    hubLiquidBalance: bigint;
+    /**
+     * Approximate value deployed to spoke chains (totalAssets − hubLiquidBalance).
+     * These funds are NOT immediately redeemable — the vault curator must
+     * call executeBridging to repatriate them before large redeems can succeed.
+     */
+    spokesDeployedBalance: bigint;
+    /**
+     * Maximum assets that can be redeemed right now without curator intervention.
+     * - For hub vaults: equals `hubLiquidBalance`.
+     * - For local/oracle vaults: equals `totalAssets`.
+     */
+    maxImmediateRedeemAssets: bigint;
+    /**
+     * Human-readable list of configuration problems that would cause transactions
+     * to fail. Empty array = vault is ready to use.
+     */
+    issues: string[];
+}
+/**
+ * Ensure the spender has sufficient ERC-20 allowance; approve if not.
+ *
+ * @param signer    Wallet signer with account attached
+ * @param provider  Read-only provider for allowance checks
+ * @param token     ERC-20 token address
+ * @param spender   Address to approve
+ * @param amount    Minimum required allowance
+ */
+declare function ensureAllowance(signer: Signer, provider: Provider, token: string, spender: string, amount: bigint): Promise<void>;
+/**
+ * Quote the LayerZero native fee required for async vault actions.
+ *
+ * @param provider      Read-only provider
+ * @param vault         Vault address (diamond proxy)
+ * @param extraOptions  Optional LZ extra options bytes (default 0x)
+ * @returns             Required native fee in wei
+ */
+declare function quoteLzFee(provider: Provider, vault: string, extraOptions?: string): Promise<bigint>;
+/**
+ * Check if a vault is operating in async mode (cross-chain hub with oracle OFF).
+ *
+ * @param provider  Read-only provider
+ * @param vault     Vault address
+ * @returns         true if the vault requires async cross-chain flows
+ */
+declare function isAsyncMode(provider: Provider, vault: string): Promise<boolean>;
+/**
+ * Poll for async request completion status.
+ *
+ * @param provider  Read-only provider
+ * @param vault     Vault address
+ * @param guid      Request GUID returned by the async flow
+ * @returns         Whether the request is fulfilled, finalized, and the result
+ */
+declare function getAsyncRequestStatus(provider: Provider, vault: string, guid: string): Promise<{
+    fulfilled: boolean;
+    finalized: boolean;
+    result: bigint;
+}>;
+/**
+ * Read the full configuration and operational status of a vault.
+ *
+ * All independent reads are fired in parallel.
+ *
+ * @param provider  Read-only provider
+ * @param vault     Vault address (diamond proxy)
+ * @returns         Full vault status snapshot
+ */
+declare function getVaultStatus(provider: Provider, vault: string): Promise<VaultStatus>;
+
+/**
+ * Pre-flight validation helpers for MoreVaults ethers.js v6 SDK flows.
+ *
+ * Each function reads on-chain state and throws a descriptive error BEFORE
+ * the actual contract call, so developers see a clear, actionable message
+ * instead of a raw VM revert.
+ */
+
+/**
+ * Pre-flight checks for async cross-chain flows (D4 / D5 / R5).
+ *
+ * Validates that:
+ * 1. The CCManager is configured on the vault.
+ * 2. An escrow is registered in the vault's registry.
+ * 3. The vault is a hub (required for async flows).
+ * 4. The vault does NOT have oracle-based cross-chain accounting enabled
+ *    (oracle-on vaults should use depositSimple / depositCrossChainOracleOn).
+ * 5. The vault is not paused.
+ *
+ * All reads that are independent of each other are executed in parallel via
+ * Promise.all to minimise latency.
+ *
+ * @param provider  Read-only provider for contract reads
+ * @param vault     Vault address (diamond proxy)
+ * @param escrow    Escrow address from VaultAddresses
+ */
+declare function preflightAsync(provider: Provider, vault: string, escrow: string): Promise<void>;
+/**
+ * Pre-flight liquidity check for async redeem (R5).
+ *
+ * Reads the hub's liquid balance of the underlying token and compares it
+ * against the assets the user expects to receive. If the hub does not hold
+ * enough liquid assets the redeem will be auto-refunded after the LZ round-trip,
+ * wasting the LayerZero fee.
+ *
+ * @param provider  Read-only provider for contract reads
+ * @param vault     Vault address (diamond proxy)
+ * @param shares    Shares the user intends to redeem
+ */
+declare function preflightRedeemLiquidity(provider: Provider, vault: string, shares: bigint): Promise<void>;
+/**
+ * Pre-flight checks for synchronous deposit flows (D1 / D3).
+ *
+ * Validates that:
+ * 1. The vault is not paused.
+ * 2. The vault still has deposit capacity (maxDeposit > 0).
+ *
+ * Both reads are executed in parallel.
+ *
+ * @param provider  Read-only provider for contract reads
+ * @param vault     Vault address (diamond proxy)
+ */
+declare function preflightSync(provider: Provider, vault: string): Promise<void>;
+
+/**
+ * User-facing helper functions for the MoreVaults ethers.js v6 SDK.
+ *
+ * All functions use Provider (read-only). None send transactions.
+ */
+
+interface UserPosition {
+    /** Vault share balance */
+    shares: bigint;
+    /** convertToAssets(shares) — what they'd get if they redeemed now */
+    estimatedAssets: bigint;
+    /** Price of 1 full share in underlying (convertToAssets(10n ** decimals)) */
+    sharePrice: bigint;
+    /** Vault decimals (for display) */
+    decimals: number;
+    pendingWithdrawal: {
+        shares: bigint;
+        timelockEndsAt: bigint;
+        /** block.timestamp >= timelockEndsAt (or timelockEndsAt === 0n) */
+        canRedeemNow: boolean;
+    } | null;
+}
+/**
+ * Read the user's current position in the vault.
+ *
+ * @param provider  Read-only provider for reads
+ * @param vault     Vault address (diamond proxy)
+ * @param user      User wallet address
+ * @returns         Full user position snapshot
+ */
+declare function getUserPosition(provider: Provider, vault: string, user: string): Promise<UserPosition>;
+/**
+ * Preview how many shares a given asset amount would mint.
+ *
+ * @param provider  Read-only provider
+ * @param vault     Vault address
+ * @param assets    Amount of underlying tokens to deposit
+ * @returns         Estimated shares to be minted
+ */
+declare function previewDeposit(provider: Provider, vault: string, assets: bigint): Promise<bigint>;
+/**
+ * Preview how many underlying assets a given share amount would redeem.
+ *
+ * @param provider  Read-only provider
+ * @param vault     Vault address
+ * @param shares    Amount of vault shares to redeem
+ * @returns         Estimated assets to be returned
+ */
+declare function previewRedeem(provider: Provider, vault: string, shares: bigint): Promise<bigint>;
+type DepositBlockReason = "paused" | "capacity-full" | "not-whitelisted" | "ok";
+interface DepositEligibility {
+    allowed: boolean;
+    reason: DepositBlockReason;
+}
+/**
+ * Check whether a user is eligible to deposit into the vault right now.
+ *
+ * @param provider  Read-only provider
+ * @param vault     Vault address
+ * @param user      User wallet address
+ * @returns         Eligibility result with reason
+ */
+declare function canDeposit(provider: Provider, vault: string, user: string): Promise<DepositEligibility>;
+interface VaultMetadata {
+    name: string;
+    symbol: string;
+    decimals: number;
+    underlying: string;
+    underlyingSymbol: string;
+    underlyingDecimals: number;
+}
+/**
+ * Read display metadata for a vault and its underlying token.
+ *
+ * @param provider  Read-only provider
+ * @param vault     Vault address
+ * @returns         Vault and underlying token metadata
+ */
+declare function getVaultMetadata(provider: Provider, vault: string): Promise<VaultMetadata>;
+type AsyncRequestStatus = "pending" | "ready-to-execute" | "completed" | "refunded";
+interface AsyncRequestStatusInfo {
+    status: AsyncRequestStatus;
+    /** Human-readable description */
+    label: string;
+    /** Shares minted or assets returned (0 if still pending) */
+    result: bigint;
+}
+/**
+ * Get the human-readable status of an async cross-chain request.
+ *
+ * @param provider  Read-only provider
+ * @param vault     Vault address
+ * @param guid      Request GUID returned by depositAsync / mintAsync / redeemAsync
+ * @returns         Status info with label and result
+ */
+declare function getAsyncRequestStatusLabel(provider: Provider, vault: string, guid: string): Promise<AsyncRequestStatusInfo>;
+interface UserBalances {
+    /** Vault shares the user holds */
+    shareBalance: bigint;
+    /** Underlying token balance in wallet (for deposit input) */
+    underlyingBalance: bigint;
+    /** convertToAssets(shareBalance) — vault position value */
+    estimatedAssets: bigint;
+}
+/**
+ * Read the user's token balances relevant to a vault.
+ *
+ * @param provider  Read-only provider
+ * @param vault     Vault address
+ * @param user      User wallet address
+ * @returns         Share balance, underlying wallet balance, and estimated assets
+ */
+declare function getUserBalances(provider: Provider, vault: string, user: string): Promise<UserBalances>;
+interface MaxWithdrawable {
+    /** How many shares can be redeemed right now */
+    shares: bigint;
+    /** How many underlying assets that corresponds to */
+    assets: bigint;
+}
+/**
+ * Calculate the maximum amount a user can withdraw from a vault right now.
+ *
+ * For hub vaults without oracle accounting, this is limited by hub liquidity.
+ * For local and oracle vaults, all assets are immediately redeemable.
+ *
+ * @param provider  Read-only provider
+ * @param vault     Vault address
+ * @param user      User wallet address
+ * @returns         Maximum withdrawable shares and assets
+ */
+declare function getMaxWithdrawable(provider: Provider, vault: string, user: string): Promise<MaxWithdrawable>;
+type VaultSummary = VaultStatus & VaultMetadata;
+/**
+ * Get a combined snapshot of vault status and metadata in one call.
+ *
+ * @param provider  Read-only provider
+ * @param vault     Vault address
+ * @returns         Merged VaultStatus and VaultMetadata
+ */
+declare function getVaultSummary(provider: Provider, vault: string): Promise<VaultSummary>;
+
+export { ActionType, type ActionTypeValue, type AsyncRequestResult, type AsyncRequestStatus, type AsyncRequestStatusInfo, BRIDGE_ABI, CCManagerNotConfiguredError, CONFIG_ABI, CapacityFullError, type CrossChainRequestInfo, type DepositBlockReason, type DepositEligibility, type DepositResult, ERC20_ABI, EscrowNotConfiguredError, InsufficientLiquidityError, METADATA_ABI, type MaxWithdrawable, MissingEscrowAddressError, MoreVaultsError, NotHubVaultError, NotWhitelistedError, OFT_ABI, type RedeemResult, type UserBalances, type UserPosition, VAULT_ABI, type VaultAddresses, type VaultMetadata, type VaultMode, VaultPausedError, type VaultStatus, type VaultSummary, bridgeSharesToHub, canDeposit, depositAsync, depositCrossChainOracleOn, depositFromSpoke, depositFromSpokeAsync, depositMultiAsset, depositSimple, ensureAllowance, getAsyncRequestStatus, getAsyncRequestStatusLabel, getMaxWithdrawable, getUserBalances, getUserPosition, getVaultMetadata, getVaultStatus, getVaultSummary, getWithdrawalRequest, isAsyncMode, mintAsync, preflightAsync, preflightRedeemLiquidity, preflightSync, previewDeposit, previewRedeem, quoteDepositFromSpokeFee, quoteLzFee, redeemAsync, redeemShares, requestRedeem, smartDeposit, withdrawAssets };