@domfi/sdk 0.1.0

package/dist/types-veTDfbhq.d.ts

@@ -0,0 +1,436 @@
+import { R as ReadOptions, e as ResultEnvelope, f as VaultHistoryPageOptions, C as CursorPagination } from './types-7s13ZSql.js';
+import { ReferralCodeIdInput } from './referrals.js';
+import { W as WaitReceiptOptions, T as TransactionReceipt } from './types-DDgJiEFg.js';
+import { Address, Hex, VaultAsset, VaultShare, Ratio, DecimalString, VaultSharePrice } from './units.js';
+
+/** Normalized vault operation type from REST/indexed events. */
+type VaultOperationType = "Deposit" | "DepositLocked" | "DepositUnlocked" | "WithdrawRequested" | "Withdraw" | "WithdrawCanceled" | "LockedDepositTransferIn" | "LockedDepositTransferOut" | "unknown";
+/** Vault event returned by REST read models. */
+type VaultEvent = {
+    time: number;
+    blockNumber: number;
+    txIndex: number;
+    logIndex: number;
+    txHash?: Hex;
+    id?: string;
+    opType: VaultOperationType;
+    rawOpType?: string;
+    assets?: VaultAsset;
+    shares?: VaultShare;
+    currentEpoch?: number;
+    unlockEpoch?: number;
+    lockDurationSeconds?: number;
+};
+/** Current vault aggregate statistics. */
+type VaultStats = {
+    accPnlPerToken: Ratio;
+    currentEpoch: number;
+    currentValueLocked: VaultAsset;
+    epochStart: number;
+    totalShares: VaultShare;
+    apr: DecimalString;
+    sharePrice: VaultSharePrice;
+    collateralizationRatio: DecimalString;
+    overCollateralization: DecimalString;
+};
+/** Vault account summary including locked, unlocked, pending, and historical events. */
+type VaultAccount = {
+    totalAssets: VaultAsset;
+    totalShares: VaultShare;
+    totalLockedShares: VaultShare;
+    lockedDeposits: VaultEvent[];
+    unlockedDeposits: VaultEvent[];
+    pendingWithdraws: VaultEvent[];
+    history: VaultEvent[];
+    historyPagination: CursorPagination;
+};
+/** Paginated vault account history. */
+type VaultAccountHistory = {
+    history: VaultEvent[];
+    pagination: CursorPagination;
+};
+/** Options for vault account summary reads. */
+type VaultAccountOptions = VaultHistoryPageOptions;
+/** Options for vault account history reads. */
+type VaultAccountHistoryOptions = VaultHistoryPageOptions;
+/** Vault events emitted by a specific transaction. */
+type VaultTransactionEvents = {
+    txHash: Hex;
+    events: VaultEvent[];
+};
+/** Onchain vault operation name used by prepared transactions and outcomes. */
+type VaultVerb = "deposit" | "mint" | "makeWithdrawRequest" | "cancelWithdrawRequest" | "withdraw" | "redeem" | "depositWithDiscountAndLock" | "mintWithDiscountAndLock" | "unlockDeposit";
+/** Options for preparing a vault transaction. */
+type VaultPrepareOptions = ReadOptions & {
+    account?: Address;
+    skipApprovalCheck?: boolean;
+};
+/** Options for simulating a prepared vault transaction. */
+type VaultSimulateOptions = ReadOptions & {
+    account?: Address;
+};
+type VaultPreparedSendControls = Pick<ReadOptions, "signal"> & {
+    account?: Address;
+    gas?: bigint;
+    nonce?: number;
+    maxFeePerGas?: bigint;
+};
+/** Send options for a prepared vault transaction. */
+type VaultPreparedSendOptions = VaultPreparedSendControls & {
+    skipApprovalCheck?: never;
+};
+/** Send options for direct vault helper methods. */
+type VaultDirectSendOptions = VaultPreparedSendControls;
+/** Alias for prepared vault send options. */
+type VaultSendOptions = VaultPreparedSendOptions;
+/** Controls for waiting on vault transaction receipts. */
+type VaultWaitReceiptOptions = WaitReceiptOptions;
+/** Controls for tracking vault transactions through REST indexing. */
+type VaultTrackOptions = VaultWaitReceiptOptions & {
+    intervalMs?: number;
+    maxAttempts?: number;
+    maxDurationMs?: number;
+    limit?: number;
+};
+/** Vault deposit parameters. */
+type VaultDepositParams = {
+    assets: VaultAsset;
+    receiver: Address;
+    minShares?: VaultShare;
+    referralCodeId?: ReferralCodeIdInput;
+};
+/** Vault mint parameters. */
+type VaultMintParams = {
+    shares: VaultShare;
+    receiver: Address;
+    maxAssets?: VaultAsset;
+};
+/** Vault withdrawal-request parameters. */
+type VaultMakeWithdrawRequestParams = {
+    shares: VaultShare;
+    owner: Address;
+};
+/** Vault cancel-withdrawal-request parameters. */
+type VaultCancelWithdrawRequestParams = {
+    shares: VaultShare;
+    owner: Address;
+    unlockEpoch: number;
+};
+/** Vault withdraw parameters. */
+type VaultWithdrawParams = {
+    assets: VaultAsset;
+    receiver: Address;
+    owner: Address;
+    maxShares?: VaultShare;
+};
+/** Vault redeem parameters. */
+type VaultRedeemParams = {
+    shares: VaultShare;
+    receiver: Address;
+    owner: Address;
+    minAssets?: VaultAsset;
+};
+/** Discounted locked vault deposit parameters. */
+type VaultDepositWithDiscountAndLockParams = {
+    assets: VaultAsset;
+    lockDurationSeconds: number;
+    receiver: Address;
+    minShares: VaultShare;
+    referralCodeId?: ReferralCodeIdInput;
+};
+/** Discounted locked vault mint parameters. */
+type VaultMintWithDiscountAndLockParams = {
+    shares: VaultShare;
+    lockDurationSeconds: number;
+    receiver: Address;
+    maxAssetsDeposited: VaultAsset;
+};
+/** Vault locked-deposit unlock parameters. */
+type VaultUnlockDepositParams = {
+    depositId: bigint;
+    receiver: Address;
+};
+/** Approval action required before a vault transaction can be sent. */
+type VaultApprovalAction = "none" | "approve";
+/** Asset, share, or NFT approval state needed by a vault transaction. */
+type VaultApprovalNeed = {
+    kind: "asset";
+    token: Address;
+    owner: Address;
+    spender: Address;
+    currentAllowance: VaultAsset;
+    requiredAllowance: VaultAsset;
+    action: VaultApprovalAction;
+} | {
+    kind: "share";
+    token: Address;
+    owner: Address;
+    spender: Address;
+    currentAllowance: VaultShare;
+    requiredAllowance: VaultShare;
+    action: VaultApprovalAction;
+} | {
+    kind: "nft";
+    token: Address;
+    owner: Address;
+    spender: Address;
+    depositId: bigint;
+    currentApproved: Address;
+    operatorApproved: boolean;
+    action: VaultApprovalAction;
+};
+/** Non-fatal preflight warning produced while preparing a vault transaction. */
+type VaultPreflightWarning = {
+    code: string;
+    message: string;
+    severity: "info" | "warning" | "error";
+};
+/** Normalized vault operation parameters used by preflight reports. */
+type VaultNormalizedParams = {
+    kind: "deposit";
+    params: VaultDepositParams;
+} | {
+    kind: "mint";
+    params: VaultMintParams;
+} | {
+    kind: "makeWithdrawRequest";
+    params: VaultMakeWithdrawRequestParams;
+} | {
+    kind: "cancelWithdrawRequest";
+    params: VaultCancelWithdrawRequestParams;
+} | {
+    kind: "withdraw";
+    params: VaultWithdrawParams;
+} | {
+    kind: "redeem";
+    params: VaultRedeemParams;
+} | {
+    kind: "depositWithDiscountAndLock";
+    params: VaultDepositWithDiscountAndLockParams;
+} | {
+    kind: "mintWithDiscountAndLock";
+    params: VaultMintWithDiscountAndLockParams;
+} | {
+    kind: "unlockDeposit";
+    params: VaultUnlockDepositParams;
+};
+/** Summary of a prepared vault transaction before simulation or send. */
+type VaultPreflightReport = {
+    normalizedParams: VaultNormalizedParams;
+    approvals: VaultApprovalNeed[];
+    warnings: VaultPreflightWarning[];
+};
+/** Simulation result for a prepared vault transaction. */
+type VaultSimResult<Verb extends VaultVerb = VaultVerb> = {
+    verb: Verb;
+    request: {
+        to: Address;
+        data: Hex;
+        value?: bigint;
+        account: Address;
+    };
+    result?: unknown;
+    warnings: VaultPreflightWarning[];
+};
+/** Shared receipt-parsed vault outcome fields. */
+type VaultOutcomeBase<Verb extends VaultVerb, EventName extends string> = {
+    eventName: EventName;
+    verb: Verb;
+    owner: Address;
+    txHash: Hex;
+    blockNumber: bigint;
+    txIndex: number;
+    logIndex: number;
+};
+/** Locked deposit data parsed from vault events. */
+type VaultLockedDeposit = {
+    owner: Address;
+    shares: VaultShare;
+    assetsDeposited: VaultAsset;
+    assetsDiscount: VaultAsset;
+    atTimestamp: number;
+    lockDurationSeconds: number;
+};
+/** Receipt outcome parsed from vault deposit or mint events. */
+type VaultDepositOutcome<Verb extends "deposit" | "mint" = "deposit" | "mint"> = VaultOutcomeBase<Verb, "Deposit"> & {
+    sender: Address;
+    assets: VaultAsset;
+    shares: VaultShare;
+};
+/** Receipt outcome parsed from vault withdrawal request events. */
+type VaultWithdrawRequestOutcome = VaultOutcomeBase<"makeWithdrawRequest", "WithdrawRequested"> & {
+    sender: Address;
+    shares: VaultShare;
+    currEpoch: number;
+    unlockEpoch: number;
+};
+/** Receipt outcome parsed from vault withdrawal cancellation events. */
+type VaultWithdrawCancelOutcome = VaultOutcomeBase<"cancelWithdrawRequest", "WithdrawCanceled"> & {
+    sender: Address;
+    shares: VaultShare;
+    currEpoch: number;
+    unlockEpoch: number;
+};
+/** Receipt outcome parsed from vault withdraw or redeem events. */
+type VaultWithdrawOutcome<Verb extends "withdraw" | "redeem" = "withdraw" | "redeem"> = VaultOutcomeBase<Verb, "Withdraw"> & {
+    sender: Address;
+    receiver: Address;
+    assets: VaultAsset;
+    shares: VaultShare;
+};
+/** Receipt outcome parsed from discounted locked deposit events. */
+type VaultLockedDepositOutcome<Verb extends "depositWithDiscountAndLock" | "mintWithDiscountAndLock" = "depositWithDiscountAndLock" | "mintWithDiscountAndLock"> = VaultOutcomeBase<Verb, "DepositLocked"> & {
+    sender: Address;
+    depositId: bigint;
+    lockedDeposit: VaultLockedDeposit;
+};
+/** Receipt outcome parsed from locked deposit unlock events. */
+type VaultUnlockOutcome = VaultOutcomeBase<"unlockDeposit", "DepositUnlocked"> & {
+    sender: Address;
+    receiver: Address;
+    depositId: bigint;
+    lockedDeposit: VaultLockedDeposit;
+};
+/** Any receipt-parsed vault outcome. */
+type VaultReceiptOutcome = VaultDepositOutcome | VaultWithdrawRequestOutcome | VaultWithdrawCancelOutcome | VaultWithdrawOutcome | VaultLockedDepositOutcome | VaultUnlockOutcome;
+/** Receipt outcome mapped to a specific vault verb. */
+type VaultOutcomeForVerb<Verb extends VaultVerb> = Verb extends "deposit" | "mint" ? VaultDepositOutcome<Verb> : Verb extends "makeWithdrawRequest" ? VaultWithdrawRequestOutcome : Verb extends "cancelWithdrawRequest" ? VaultWithdrawCancelOutcome : Verb extends "withdraw" | "redeem" ? VaultWithdrawOutcome<Verb> : Verb extends "depositWithDiscountAndLock" | "mintWithDiscountAndLock" ? VaultLockedDepositOutcome<Verb> : Verb extends "unlockDeposit" ? VaultUnlockOutcome : never;
+/** Vault outcome matched with the REST/indexed event for the same transaction. */
+type VaultIndexedOutcome<Verb extends VaultVerb = VaultVerb> = {
+    outcome: VaultOutcomeForVerb<Verb>;
+    event: VaultEvent;
+};
+/** Indexed vault outcome mapped to a specific vault verb. */
+type VaultIndexedOutcomeForVerb<Verb extends VaultVerb> = VaultIndexedOutcome<Verb>;
+/** Vault outcome with both transaction receipt and indexed REST event. */
+type VaultTrackedOutcome<Verb extends VaultVerb = VaultVerb> = {
+    receipt: TransactionReceipt;
+    outcome: VaultOutcomeForVerb<Verb>;
+    indexed: VaultIndexedOutcome<Verb>;
+};
+/** Tracked vault outcome mapped to a specific vault verb. */
+type VaultTrackedOutcomeForVerb<Verb extends VaultVerb> = VaultTrackedOutcome<Verb>;
+/** Handle returned by direct vault send methods and prepared vault sends. */
+type VaultTxHandle<Verb extends VaultVerb = VaultVerb> = {
+    kind: "vault_tx";
+    verb: Verb;
+    hash: Hex;
+    /**
+     * Waits for the vault transaction receipt.
+     *
+     * @throws TimeoutError, AbortError, or TransportError while waiting for the transaction receipt.
+     */
+    waitReceipt(opts?: VaultWaitReceiptOptions): Promise<TransactionReceipt>;
+    /**
+     * Parses the domain outcome from the vault transaction receipt.
+     *
+     * @throws ContractRevertError for reverted receipts, ValidationError for unexpected receipt logs, or receipt wait errors.
+     */
+    outcome(opts?: VaultWaitReceiptOptions): Promise<VaultOutcomeForVerb<Verb>>;
+    /**
+     * Waits until the vault outcome is visible in REST read models.
+     *
+     * @throws ContractRevertError for reverted receipts, or ReadModelNotReadyError, ValidationError, TimeoutError, AbortError, ApiError, or TransportError.
+     */
+    waitIndexed(opts?: VaultTrackOptions): Promise<VaultIndexedOutcomeForVerb<Verb>>;
+    /**
+     * Waits for receipt parsing and REST indexing, returning both sources.
+     *
+     * @throws ContractRevertError for reverted receipts, or ReadModelNotReadyError, ValidationError, TimeoutError, AbortError, ApiError, or TransportError.
+     */
+    track(opts?: VaultTrackOptions): Promise<VaultTrackedOutcomeForVerb<Verb>>;
+};
+/** Prepared vault transaction that can be summarized, simulated, or sent. */
+type PreparedVaultTx<Verb extends VaultVerb = VaultVerb> = {
+    verb: Verb;
+    to: Address;
+    data: Hex;
+    value?: bigint;
+    preparedAccount?: Address;
+    requiredApprovals: {
+        status: "checked";
+        approvals: VaultApprovalNeed[];
+    } | {
+        status: "unchecked";
+    };
+    /**
+     * Returns the preflight summary for this prepared vault transaction.
+     *
+     * @throws ValidationError for invalid prepared vault parameters.
+     */
+    summary(): Promise<VaultPreflightReport>;
+    /**
+     * Simulates the prepared vault transaction.
+     *
+     * @throws ValidationError, TimeoutError, AbortError, ContractRevertError, TransportError, or provider errors.
+     */
+    simulate(opts?: VaultSimulateOptions): Promise<VaultSimResult<Verb>>;
+    /**
+     * Sends the prepared vault transaction with the SDK-configured wallet client.
+     *
+     * @throws ValidationError, TimeoutError, AbortError, ContractRevertError, wallet errors, or transport SDK errors.
+     */
+    send(opts?: VaultPreparedSendOptions): Promise<VaultTxHandle<Verb>>;
+};
+/**
+ * Vault REST read client.
+ *
+ * @throws ReadModelNotReadyError when strict readiness policy rejects stale or unsafe read models.
+ * @throws ValidationError when SDK input or remote payload validation fails.
+ * @throws TimeoutError when a configured read timeout expires.
+ * @throws AbortError when the caller-provided signal aborts the request.
+ * @throws ApiError or TransportError for REST API and transport failures.
+ */
+type VaultReadClient = {
+    /** Reads current aggregate vault statistics. */
+    stats(opts?: ReadOptions): Promise<ResultEnvelope<VaultStats>>;
+    /** Reads a vault account summary for `wallet`. */
+    account(wallet: Address, opts?: VaultAccountOptions): Promise<ResultEnvelope<VaultAccount>>;
+    /** Reads one page of vault account history for `wallet`. */
+    accountHistory(wallet: Address, opts?: VaultAccountHistoryOptions): Promise<ResultEnvelope<VaultAccountHistory>>;
+    /** Reads vault events indexed for a transaction hash. */
+    transactionEvents(txHash: Hex, opts?: ReadOptions): Promise<ResultEnvelope<VaultTransactionEvents>>;
+    /** Iterates individual vault account history events across pages. */
+    accountHistoryIterator(wallet: Address, opts?: VaultAccountHistoryOptions): AsyncIterable<VaultEvent>;
+};
+/** Full vault client with REST reads, preparation helpers, and direct send helpers. */
+type VaultClient = VaultReadClient & {
+    /** @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or TransportError during vault preflight and approval reads. */
+    prepareDeposit(params: VaultDepositParams, opts?: VaultPrepareOptions): Promise<PreparedVaultTx<"deposit">>;
+    /** @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or TransportError during vault preflight and approval reads. */
+    prepareMint(params: VaultMintParams, opts?: VaultPrepareOptions): Promise<PreparedVaultTx<"mint">>;
+    /** @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or TransportError during vault preflight and approval reads. */
+    prepareMakeWithdrawRequest(params: VaultMakeWithdrawRequestParams, opts?: VaultPrepareOptions): Promise<PreparedVaultTx<"makeWithdrawRequest">>;
+    /** @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or TransportError during vault preflight and approval reads. */
+    prepareCancelWithdrawRequest(params: VaultCancelWithdrawRequestParams, opts?: VaultPrepareOptions): Promise<PreparedVaultTx<"cancelWithdrawRequest">>;
+    /** @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or TransportError during vault preflight and approval reads. */
+    prepareWithdraw(params: VaultWithdrawParams, opts?: VaultPrepareOptions): Promise<PreparedVaultTx<"withdraw">>;
+    /** @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or TransportError during vault preflight and approval reads. */
+    prepareRedeem(params: VaultRedeemParams, opts?: VaultPrepareOptions): Promise<PreparedVaultTx<"redeem">>;
+    /** @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or TransportError during vault preflight and approval reads. */
+    prepareDepositWithDiscountAndLock(params: VaultDepositWithDiscountAndLockParams, opts?: VaultPrepareOptions): Promise<PreparedVaultTx<"depositWithDiscountAndLock">>;
+    /** @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or TransportError during vault preflight and approval reads. */
+    prepareMintWithDiscountAndLock(params: VaultMintWithDiscountAndLockParams, opts?: VaultPrepareOptions): Promise<PreparedVaultTx<"mintWithDiscountAndLock">>;
+    /** @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or TransportError during vault preflight and approval reads. */
+    prepareUnlockDeposit(params: VaultUnlockDepositParams, opts?: VaultPrepareOptions): Promise<PreparedVaultTx<"unlockDeposit">>;
+    /** @throws ValidationError, MissingWalletClientError, MissingPublicClientError, TimeoutError, AbortError, ContractRevertError, or TransportError while preparing and submitting. */
+    deposit(params: VaultDepositParams, opts?: VaultDirectSendOptions): Promise<VaultTxHandle<"deposit">>;
+    /** @throws ValidationError, MissingWalletClientError, MissingPublicClientError, TimeoutError, AbortError, ContractRevertError, or TransportError while preparing and submitting. */
+    mint(params: VaultMintParams, opts?: VaultDirectSendOptions): Promise<VaultTxHandle<"mint">>;
+    /** @throws ValidationError, MissingWalletClientError, MissingPublicClientError, TimeoutError, AbortError, ContractRevertError, or TransportError while preparing and submitting. */
+    makeWithdrawRequest(params: VaultMakeWithdrawRequestParams, opts?: VaultDirectSendOptions): Promise<VaultTxHandle<"makeWithdrawRequest">>;
+    /** @throws ValidationError, MissingWalletClientError, MissingPublicClientError, TimeoutError, AbortError, ContractRevertError, or TransportError while preparing and submitting. */
+    cancelWithdrawRequest(params: VaultCancelWithdrawRequestParams, opts?: VaultDirectSendOptions): Promise<VaultTxHandle<"cancelWithdrawRequest">>;
+    /** @throws ValidationError, MissingWalletClientError, MissingPublicClientError, TimeoutError, AbortError, ContractRevertError, or TransportError while preparing and submitting. */
+    withdraw(params: VaultWithdrawParams, opts?: VaultDirectSendOptions): Promise<VaultTxHandle<"withdraw">>;
+    /** @throws ValidationError, MissingWalletClientError, MissingPublicClientError, TimeoutError, AbortError, ContractRevertError, or TransportError while preparing and submitting. */
+    redeem(params: VaultRedeemParams, opts?: VaultDirectSendOptions): Promise<VaultTxHandle<"redeem">>;
+    /** @throws ValidationError, MissingWalletClientError, MissingPublicClientError, TimeoutError, AbortError, ContractRevertError, or TransportError while preparing and submitting. */
+    depositWithDiscountAndLock(params: VaultDepositWithDiscountAndLockParams, opts?: VaultDirectSendOptions): Promise<VaultTxHandle<"depositWithDiscountAndLock">>;
+    /** @throws ValidationError, MissingWalletClientError, MissingPublicClientError, TimeoutError, AbortError, ContractRevertError, or TransportError while preparing and submitting. */
+    mintWithDiscountAndLock(params: VaultMintWithDiscountAndLockParams, opts?: VaultDirectSendOptions): Promise<VaultTxHandle<"mintWithDiscountAndLock">>;
+    /** @throws ValidationError, MissingWalletClientError, MissingPublicClientError, TimeoutError, AbortError, ContractRevertError, or TransportError while preparing and submitting. */
+    unlockDeposit(params: VaultUnlockDepositParams, opts?: VaultDirectSendOptions): Promise<VaultTxHandle<"unlockDeposit">>;
+};
+
+export type { VaultDirectSendOptions as A, VaultIndexedOutcomeForVerb as B, VaultLockedDeposit as C, VaultLockedDepositOutcome as D, VaultNormalizedParams as E, VaultOperationType as F, VaultOutcomeBase as G, VaultPreflightReport as H, VaultPreflightWarning as I, VaultPrepareOptions as J, VaultPreparedSendOptions as K, VaultReceiptOutcome as L, VaultSendOptions as M, VaultSimResult as N, VaultSimulateOptions as O, PreparedVaultTx as P, VaultTrackedOutcomeForVerb as Q, VaultUnlockOutcome as R, VaultWaitReceiptOptions as S, VaultWithdrawCancelOutcome as T, VaultWithdrawOutcome as U, VaultVerb as V, VaultWithdrawRequestOutcome as W, VaultOutcomeForVerb as a, VaultDepositParams as b, VaultMintParams as c, VaultMakeWithdrawRequestParams as d, VaultCancelWithdrawRequestParams as e, VaultWithdrawParams as f, VaultRedeemParams as g, VaultDepositWithDiscountAndLockParams as h, VaultMintWithDiscountAndLockParams as i, VaultUnlockDepositParams as j, VaultClient as k, VaultReadClient as l, VaultAccount as m, VaultAccountHistory as n, VaultEvent as o, VaultStats as p, VaultTransactionEvents as q, VaultTxHandle as r, VaultTrackOptions as s, VaultTrackedOutcome as t, VaultIndexedOutcome as u, VaultAccountHistoryOptions as v, VaultAccountOptions as w, VaultApprovalAction as x, VaultApprovalNeed as y, VaultDepositOutcome as z };