0xtrails 0.16.2 → 0.17.0

package/dist/useViewManager-BeUH_k1s.d.ts

@@ -0,0 +1,1224 @@
+import { f as Call$1, r as ActionItem } from "./types-BK0WkVnx.js";
+import { t as Token$1 } from "./tokenTypes-D812t5L9.js";
+import { t as QuoteError } from "./quoteError-CmTH5Qm2.js";
+import { c as EDGE_RAIL, d as EdgeRailId, l as EdgeDestinationConfig, r as EdgePlugin, u as EdgeOriginConfig } from "./edge-DmNcuJar.js";
+import { CommitIntentResponse, DepositSignature, EdgeQuoteRequest, ExecuteIntentResponse, FeeOption, FundMethod, GasFeeOptions, Intent, IntentMode, IntentProtocolVersion, IntentReceipt, IntentTransaction, PriceImpactDetails, QuoteIntentRequest, RouteProvider, RouteProvider as RouteProvider$1, TradeType, TradeType as TradeType$1, TrailsApi, TransactionStateInfo } from "@0xtrails/api";
+import { Account, Chain, Log, PublicClient, TransactionReceipt, WalletClient } from "viem";
+import { ReactNode } from "react";
+import { QueryClient } from "@tanstack/react-query";
+import { TrailsWalletClient } from "@0xtrails/wallet";
+import { SequenceIndexer } from "@0xsequence/indexer";
+
+//#region src/decoders.d.ts
+interface CallSucceededEvent {
+  type: "CallSucceeded";
+  opHash: string;
+  index: bigint;
+  log: Log;
+}
+interface CallFailedEvent {
+  type: "CallFailed";
+  opHash: string;
+  index: bigint;
+  returnData: string;
+  log: Log;
+}
+interface CallAbortedEvent {
+  type: "CallAborted";
+  opHash: string;
+  index: bigint;
+  returnData: string;
+  log: Log;
+}
+interface CallSkippedEvent {
+  type: "CallSkipped";
+  deploymentId: string;
+  actionIndex: bigint;
+  log: Log;
+}
+interface RefundEvent {
+  type: "Refund";
+  token: string;
+  recipient: string;
+  amount: bigint;
+  log: Log;
+}
+interface SweepEvent {
+  type: "Sweep";
+  token: string;
+  recipient: string;
+  amount: bigint;
+  log: Log;
+}
+interface RefundAndSweepEvent {
+  type: "RefundAndSweep";
+  token: string;
+  refundRecipient: string;
+  refundAmount: bigint;
+  sweepRecipient: string;
+  actualRefund: bigint;
+  remaining: bigint;
+  log: Log;
+}
+type GuestModuleEvent = CallSucceededEvent | CallFailedEvent | CallAbortedEvent | CallSkippedEvent;
+type TokenSweeperEvent = RefundEvent | SweepEvent | RefundAndSweepEvent;
+//#endregion
+//#region src/transactions.d.ts
+type TransactionStateStatus = "pending" | "failed" | "confirmed" | "aborted";
+type TransactionState = {
+  id?: string;
+  transactionHash: string;
+  explorerUrl: string;
+  blockNumber?: number;
+  chainId: number;
+  state: TransactionStateStatus;
+  label: string;
+  statusReason?: string;
+  decodedTokenSweeperEvents?: TokenSweeperEvent[];
+  decodedGuestModuleEvents?: GuestModuleEvent[];
+  refunded?: boolean;
+  refundTransactionHash?: string;
+  refundTransactionChainId?: number;
+  txnMinedAt?: string;
+};
+type TransactionHistoryItemFromAPI = Awaited<ReturnType<SequenceIndexer["getTransactionHistory"]>>["transactions"][number];
+type TransactionHistoryItem = TransactionHistoryItemFromAPI & {
+  explorerUrl?: string;
+  chainName?: string;
+};
+type TransactionHistoryResponse = {
+  page: {
+    column?: string;
+    pageSize?: number;
+    more?: boolean;
+  };
+  transactions: TransactionHistoryItem[];
+};
+type GetAccountTransactionHistoryParams = {
+  chainId: number;
+  accountAddress: string;
+  pageSize?: number;
+  includeMetadata?: boolean;
+  page?: number;
+  abortSignal?: AbortSignal;
+};
+declare function getTxTimeDiff(firstTx?: TransactionState, lastTx?: TransactionState): Promise<number>;
+declare function getAccountTransactionHistory({
+  chainId,
+  accountAddress,
+  pageSize,
+  page,
+  includeMetadata,
+  abortSignal,
+  apiKey,
+  indexerUrl
+}: GetAccountTransactionHistoryParams & {
+  apiKey: string;
+  indexerUrl: string;
+}): Promise<TransactionHistoryResponse>;
+type IntentTransaction$1 = {
+  originIntentAddress: string;
+  destinationIntentAddress: string;
+  mainSigner: string;
+  mode?: string;
+  intentId?: string;
+  metaTxnId?: string;
+  txnHash?: string;
+  intentStatus?: string;
+  executionStatus?: string;
+  originChainId?: number;
+  destinationChainId?: number;
+  originTokenAddress?: string;
+  originTokenAmount?: string;
+  destinationTokenAddress?: string;
+  destinationTokenAmount?: string;
+  destinationToAddress?: string;
+  createdAt?: string;
+  depositTransactionHash?: string;
+  originTransactionHash?: string;
+  destinationTransactionHash?: string;
+  depositTransactionStatus?: string;
+  originTransactionStatus?: string;
+  destinationTransactionStatus?: string;
+  refundTransactionHash?: string;
+  refundTransactionStatus?: string;
+  refundTransactionChainId?: number;
+  originToken?: {
+    symbol: string;
+    name: string;
+    decimals: number;
+    imageUrl: string;
+    chainId: number;
+  };
+  destinationToken?: {
+    symbol: string;
+    name: string;
+    decimals: number;
+    imageUrl: string;
+    chainId: number;
+  };
+  routeProviders?: string[];
+  swapProviderUsed?: string;
+  bridgeProviderUsed?: string;
+  originIntentTxHash?: string;
+  destinationIntentTxHash?: string;
+  originIntentTxExplorerUrl?: string;
+  destinationIntentTxExplorerUrl?: string;
+  originIntentDepositTxHash?: string;
+  destinationIntentDepositTxHash?: string;
+  originIntentDepositTxExplorerUrl?: string;
+  destinationIntentDepositTxExplorerUrl?: string;
+  balances?: Array<{
+    intentAddress: string;
+    chainId: number;
+    tokens: Array<{
+      contractAddress: string;
+      balance: string;
+      balanceUsd?: string;
+      decimals: number;
+      chainId: number;
+      symbol: string;
+    }>;
+  }>;
+  hasBalance?: boolean;
+  intentProtocol?: string;
+  edge?: {
+    rail: string;
+    mode: string;
+    token?: {
+      symbol: string;
+      name: string;
+      decimals: number;
+      imageUrl: string;
+      chainId: number;
+    };
+    tokenAmount?: string;
+    userAddress?: string;
+    initTransactionHash?: string;
+    fillTransactionHash?: string;
+    refundTransactionHash?: string;
+  };
+};
+type IntentTransactionHistoryResponse = {
+  page?: {
+    page?: number;
+    pageSize?: number;
+    more?: boolean;
+  };
+  transactions: IntentTransaction$1[];
+};
+type UseAccountTransactionHistoryParams = {
+  chainId?: number | null;
+  accountAddress?: string | null;
+  pageSize?: number;
+  page?: number;
+  includeMetadata?: boolean;
+  abortSignal?: AbortSignal;
+  refetchInterval?: number | false;
+};
+type UseAccountTransactionHistoryReturn = {
+  data: TransactionHistoryResponse | undefined;
+  isLoading: boolean;
+  error: Error | null;
+};
+declare function useAccountTransactionHistory({
+  chainId,
+  accountAddress,
+  pageSize,
+  page,
+  includeMetadata,
+  abortSignal,
+  refetchInterval
+}: UseAccountTransactionHistoryParams): UseAccountTransactionHistoryReturn;
+//#endregion
+//#region src/error.d.ts
+declare function getFullErrorMessage(err: any): string;
+type TrailsErrorBoundary = "sdk" | "wallet" | "rpc" | "network" | "trails-api" | "onramp-api";
+type TrailsApiBoundary = Extract<TrailsErrorBoundary, "trails-api" | "onramp-api">;
+type TrailsSdkErrorCode = "balance.insufficient" | "chain.add" | "chain.switch" | "clipboard.copy" | "quote.request" | "quote.timeout" | "receipt-poller.on-deposit-transaction-found" | "receipt-poller.on-destination-transaction-found" | "receipt-poller.on-origin-transaction-found" | "receipt-poller.on-receipt-update" | "receipt-poller.poll" | "receipt-poller.wait" | "send.process" | "send.submit" | "send.transaction-state-change" | "send.wallet-confirm-retry" | "wallet.user-rejected";
+type TrailsErrorCode = TrailsSdkErrorCode | string;
+type TrailsErrorOptions = {
+  boundary?: TrailsErrorBoundary;
+  code?: TrailsErrorCode;
+  cause?: unknown;
+  details?: Record<string, unknown>;
+};
+declare class TrailsError extends Error {
+  boundary?: TrailsErrorBoundary;
+  code?: TrailsErrorCode;
+  details?: Record<string, unknown>;
+  constructor(message: string, options?: TrailsErrorOptions);
+}
+declare function isTrailsError(err: unknown): err is TrailsError;
+type TrailsApiClientErrorOptions = TrailsErrorOptions & {
+  boundary: TrailsApiBoundary;
+  code: TrailsErrorCode;
+  apiName: string;
+  apiCode: number;
+  apiStatus: number;
+};
+declare class TrailsApiClientError extends TrailsError {
+  boundary: TrailsApiBoundary;
+  apiName: string;
+  apiCode: number;
+  apiStatus: number;
+  constructor(message: string, options: TrailsApiClientErrorOptions);
+}
+declare function isTrailsApiClientError(err: unknown): err is TrailsApiClientError;
+declare function getErrorBoundary(err: unknown): TrailsErrorBoundary | null;
+declare function getErrorCode(err: unknown): TrailsErrorCode | null;
+declare function getIsUserRejectionError(err: unknown): err is UserRejectionError;
+declare function getIsBalanceTooLowError(err: unknown): boolean;
+type SpecializedTrailsErrorOptions = Pick<TrailsErrorOptions, "boundary" | "cause" | "code" | "details">;
+declare class InsufficientBalanceError extends TrailsError {
+  constructor(message: string, options?: SpecializedTrailsErrorOptions);
+}
+declare class UserRejectionError extends TrailsError {
+  constructor(message: string, options?: SpecializedTrailsErrorOptions);
+}
+declare function getIsApiError(err: unknown): boolean;
+declare function getIsRateLimitedError(err: unknown): boolean;
+declare function getIsRequiredAmountNotMetError(err: unknown): boolean;
+declare function getIsNoAvailableQuoteError(err: unknown): boolean;
+declare function getIsQuoteFailedError(err: unknown): boolean;
+declare function getIsQuoteTokenError(err: unknown): boolean;
+declare function getIsQuoteInputError(err: unknown): boolean;
+declare function getIsInsufficientLiquidityError(err: unknown): boolean;
+declare function getIsWalletAlreadyConnectedError(err: unknown): boolean;
+declare function getPrettifiedErrorMessage(err: unknown, defaultMessage?: string): string;
+//#endregion
+//#region src/hooks/useCheckout.d.ts
+type CheckoutOnHandlers = {
+  /** Triggered when the intent transaction process starts. */triggerCheckoutStart: () => void; /** Triggered when a quote is received. */
+  triggerCheckoutQuote: (quote: PrepareSendQuote) => void; /** Triggered when a signature is requested. */
+  triggerCheckoutSignatureRequest: () => void; /** Triggered when a signature is confirmed. */
+  triggerCheckoutSignatureConfirmed: () => void; /** Triggered when a signature is rejected. */
+  triggerCheckoutSignatureRejected: (error: unknown) => void; /** Triggered when a token approval is requested. */
+  triggerCheckoutApprovalRequest: () => void; /** Triggered when a token approval is confirmed. */
+  triggerCheckoutApprovalConfirmed: (transactionHash: `0x${string}`) => void; /** Triggered when a token approval is rejected. */
+  triggerCheckoutApprovalRejected: (error: unknown) => void; /** Triggered when the intent transaction process completes. */
+  triggerCheckoutComplete: (txStatus: "success" | "fail", accountAddress?: string) => void; /** Triggered when an error occurs. */
+  triggerCheckoutError: (error: string) => void; /** Triggered when the intent transaction states change. */
+  triggerCheckoutStatusUpdate: (transactionStates: TransactionState[]) => void;
+};
+//#endregion
+//#region src/chainRegistry.d.ts
+interface Chain$1 extends Chain {
+  imageUrl?: string;
+}
+declare function getAllChains(): readonly [Chain$1, ...Chain$1[]];
+//#endregion
+//#region src/chainRpcClient.d.ts
+declare const getRpcUrl: (chainId: number, sequenceProjectAccessKey: string, sequenceNodeGatewayUrl: string) => string | null;
+//#endregion
+//#region src/chains.d.ts
+/**
+ * Create a public RPC client for a chain using Sequence RPC URLs
+ * This is a temporary solution to use global config for RPC URLs
+ * @param chainId - The chain ID to create the public client for
+ * @param retryCount - The number of retry attempts for the RPC client
+ * @returns Viem PublicClient configured with Sequence RPC URL if available
+ */
+declare function getPublicClient(chainId: number, retryCount?: number): PublicClient;
+declare function getChainInfo(chainId?: number, options?: {
+  usePublicRpc?: boolean;
+  sequenceProjectAccessKey?: string;
+  sequenceNodeGatewayUrl?: string;
+}): Chain$1 | null;
+declare function getSupportedChains(config?: {
+  trailsApiUrl?: string;
+  trailsApiKey?: string;
+}): Promise<Chain$1[]>;
+//#endregion
+//#region src/fees.d.ts
+interface FeeItem {
+  amount: string;
+  tokenSymbol: string;
+  tokenAddress: string;
+  chainId: number;
+  usdValue: string;
+  usdValueLocale?: string;
+}
+interface ProviderFeeItem {
+  id: string;
+  name: string;
+  url: string;
+  feeUsd: number;
+  usdValue: string;
+  usdValueLocale?: string;
+  isBridge: boolean;
+}
+interface TrailsFeeBreakdown {
+  originRelayFee?: FeeItem;
+  destinationRelayFee?: FeeItem;
+  providerFee?: FeeItem;
+  providerFees?: ProviderFeeItem[];
+  trailsFee?: FeeItem;
+  totalUsdValue?: string;
+  originChainId?: number;
+  destinationChainId?: number;
+}
+//#endregion
+//#region src/widget/types/analytics.d.ts
+interface OnrampTrackingData {
+  sessionId?: string;
+  provider: string;
+  sourceAmount: string;
+  sourceCurrencyCode: string;
+  destinationAmount: string;
+  destinationCurrencyCode: string;
+  exchangeRate: string;
+  networkFees?: string;
+  transactionFee?: string;
+  totalFees?: string;
+  countryCode: string;
+  paymentMethod?: string;
+  quoteId?: string;
+  walletAddress: string;
+  timestamp: string;
+}
+//#endregion
+//#region src/chainResolution.d.ts
+type SupportedChainName = "ethereum" | "mainnet" | "base" | "arbitrum" | "arbitrum-nova" | "optimism" | "gnosis" | "polygon" | "avalanche" | "avalanche-c" | "bsc" | "binance" | "bnb" | "sonic" | "soneium" | "somnia" | "apechain" | "b3" | "katana" | "etherlink" | "monad" | "berachain" | "hyperevm" | "solana";
+type ChainIdentifier = SupportedChainName | (string & {}) | number | Chain;
+declare function resolveChainName(chainId: number): string;
+declare function resolveChainId(chain: ChainIdentifier): number;
+//#endregion
+//#region src/hooks/useQuote.d.ts
+/**
+ * Configuration options for the `useQuote` hook.
+ *
+ * All parameters are optional, but the hook will not fetch a quote until all required
+ * parameters are provided (connected wallet account or walletAddress, `from.token`,
+ * `from.chain`, `to.token`, `to.chain`, exactly one of
+ * `from.amount`/`from.amountRaw`/`to.amount`/`to.amountRaw`, and a
+ * destination recipient or owner address).
+ */
+type QuoteFrom = {
+  /** Token address or symbol (e.g. "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913" or "USDC"). Use zero address or native symbol (e.g. "ETH") for native tokens. Symbols are resolved against the supported token list for the specified chain. */token: string; /** Chain ID, name (e.g. "base"), or viem Chain object. */
+  chain: ChainIdentifier;
+  /**
+   * Amount to spend, as a human-readable decimal string (e.g. `"1.5"`).
+   * Scaled to the source token's decimals internally via `parseUnits`.
+   *
+   * If provided, this is an EXACT_INPUT quote. Mutually exclusive with `to.amount`,
+   * `to.amountRaw`, and `from.amountRaw`.
+   *
+   * Precision matches the token's decimals exactly — for an 18-decimal token
+   * you can pass values down to `"0.000000000000000001"` (1 wei) without loss.
+   * If you already have a raw wei value, prefer `amountRaw` to skip the
+   * `formatUnits` → `parseUnits` round-trip and the decimals lookup.
+   */
+  amount?: string;
+  /**
+   * Raw amount in the source token's smallest unit (wei) as a `bigint` or
+   * integer-only numeric string (e.g. `1000000n` or `"1000000"` for 1 USDC).
+   *
+   * If provided, this is an EXACT_INPUT quote. Mutually exclusive with
+   * `from.amount`, `to.amount`, and `to.amountRaw`.
+   *
+   * Pass this when you already have a raw on-chain value (e.g. from a balance
+   * query, contract event, or another bigint source) — it skips the internal
+   * `parseUnits` step and avoids the supported-tokens registry / on-chain
+   * `decimals()` lookup that exists solely to scale `amount`. Pair with
+   * `decimals` if you also want to bypass decimals resolution downstream.
+   */
+  amountRaw?: bigint | string;
+  /**
+   * Optional decimals override for the source token.
+   *
+   * Use this to skip the cold-path RPC for tokens not in the registry, or
+   * as a fallback when the RPC is unreliable.
+   */
+  decimals?: number;
+};
+type QuoteTo = {
+  /** Token address or symbol (e.g. "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913" or "USDC"). Use zero address or native symbol (e.g. "ETH") for native tokens. Symbols are resolved against the supported token list for the specified chain. */token: string; /** Chain ID, name (e.g. "arbitrum"), or viem Chain object. */
+  chain: ChainIdentifier;
+  /**
+   * Recipient address for the destination token. Defaults to the connected
+   * wallet address or walletAddress when omitted.
+   *
+   * Not supported with composable destination execution (`actions` or
+   * `to.calls`). In those modes, use per-action recipient fields instead.
+   */
+  recipient?: string | null; /** Address to approve the destination token to. */
+  approve?: string | null;
+  /**
+   * @deprecated Use `to.calls` for raw custom calls or the top-level `actions` prop for pre-built DeFi actions (swap, lend, deposit, …).
+   *
+   * A single ABI-encoded calldata blob to execute on the destination chain after the funds land. Retained for backwards compatibility and will be removed in a future major release.
+   */
+  calldata?: string | null;
+  /**
+   * Amount to receive, as a human-readable decimal string (e.g. `"1.5"`).
+   * Scaled to the destination token's decimals internally via `parseUnits`.
+   *
+   * If provided, this is an EXACT_OUTPUT quote. Mutually exclusive with
+   * `from.amount`, `from.amountRaw`, and `to.amountRaw`.
+   *
+   * Precision matches the token's decimals exactly — for an 18-decimal token
+   * you can pass values down to `"0.000000000000000001"` (1 wei) without loss.
+   * If you already have a raw wei value, prefer `amountRaw` to skip the
+   * `formatUnits` → `parseUnits` round-trip and the decimals lookup.
+   */
+  amount?: string;
+  /**
+   * Raw amount in the destination token's smallest unit (wei) as a `bigint`
+   * or integer-only numeric string (e.g. `1000000n` or `"1000000"` for 1
+   * USDC).
+   *
+   * If provided, this is an EXACT_OUTPUT quote. Mutually exclusive with
+   * `to.amount`, `from.amount`, and `from.amountRaw`.
+   *
+   * Pass this when you already have a raw on-chain value (e.g. from a
+   * balance query, contract event, or another bigint source) — it skips the
+   * internal `parseUnits` step and avoids the supported-tokens registry /
+   * on-chain `decimals()` lookup that exists solely to scale `amount`. Pair
+   * with `decimals` if you also want to bypass decimals resolution
+   * downstream.
+   */
+  amountRaw?: bigint | string;
+  /**
+   * Optional decimals override for the destination token.
+   *
+   * Resolution order: this field → supported-tokens registry → on-chain
+   * `decimals()` read → throw.
+   *
+   * Use this to skip the cold-path RPC for tokens not in the registry, or
+   * as a fallback when the RPC is unreliable. **You are responsible for
+   * passing the correct value** — a mismatch will silently produce
+   * wrong-magnitude amounts.
+   */
+  decimals?: number;
+  /**
+   * Raw destination calls to execute on the destination chain after the funds land.
+   *
+   * Prefer the top-level `actions` prop for high-level DeFi primitives (swap, lend, deposit, …), reach for `calls` when you need to hand-roll ABI-encoded calls.
+   */
+  calls?: (Call$1 | Call$1[])[] | null;
+};
+type UseQuoteProps = {
+  /** Optional connected viem wallet client override. If present, `walletClient.account.address` is the quote owner and takes priority over `walletAddress`. If omitted, the hook reads from the Trails wallet runtime when available. Required for executing swaps via `send()`. */walletClient?: WalletClient | null; /** Explicit wallet address. Used as the quote owner only when `walletClient.account.address` is unavailable. Pass this to show quote previews before or without a wallet connection. */
+  walletAddress?: string | null; /** Source token and chain configuration. */
+  from: QuoteFrom; /** Destination token and chain configuration. */
+  to: QuoteTo;
+  slippageTolerance?: string | number | null;
+  onStatusUpdate?: ((transactionStates: TransactionState[]) => void) | null; /** Swap provider (e.g. "LIFI", "CCTP", "RELAY"). */
+  swapProvider?: RouteProvider | null; /** Bridge provider (e.g. "LIFI", "CCTP", "RELAY"). */
+  bridgeProvider?: RouteProvider | null;
+  swapProviderFallback?: boolean;
+  bridgeProviderFallback?: boolean;
+  checkoutOnHandlers?: Partial<CheckoutOnHandlers>; /** Optional fee option selection (e.g., user selects USDC as the fee token instead of ETH) */
+  selectedFeeOption?: FeeOption | null;
+  abortSignal?: AbortSignal;
+  apiKey?: string | null;
+  nodeGatewayEnv?: "prod" | "dev" | "local" | "cors-anywhere";
+  isSmartWallet?: boolean | null;
+  fundMethod?: FundMethod$1 | null;
+  onramp?: OnrampTrackingData | null;
+  mode?: "pay" | "fund" | "earn" | "swap" | "withdraw" | null;
+  intentProtocolVersion?: IntentProtocolVersion | null;
+  /**
+   * Composable destination actions (`swap`, `lend`, `deposit`, `custom`,
+   * `assertCondition`). Resolved into destination calls internally.
+   *
+   * Mutually exclusive with `to.calls` and the deprecated `to.calldata`.
+   *
+   * @example
+   * ```ts
+   * import { swap, lend } from "0xtrails"
+   *
+   * const actions = [
+   *   swap({
+   *     tokenIn: "WETH",
+   *     tokenOut: "USDC",
+   *     amountOut: "1000",
+   *     fee: "0.3"
+   *   }),
+   *   lend({ marketId: "base-usdc-aave-v3-lending", amount: "1000" }),
+   * ]
+   * ```
+   */
+  actions?: ActionItem[];
+  /**
+   * When true, suppresses quote fetching regardless of other conditions.
+   * Use to block quotes during error states (e.g. edge→edge, recipient chain mismatch).
+   */
+  disabled?: boolean;
+};
+/**
+ * Result returned by the `send` function from {@link useQuote}.
+ *
+ * Contains information about both the origin and destination transactions,
+ * including transaction hashes, explorer URLs, and receipts.
+ */
+type SwapReturn = {
+  originTransaction: {
+    transactionHash?: string | null;
+    explorerUrl?: string | null;
+    receipt: TransactionReceipt | IntentTransaction | null;
+  };
+  destinationTransaction: {
+    transactionHash?: string | null;
+    explorerUrl?: string | null;
+    receipt: IntentTransaction | null;
+  };
+  totalCompletionSeconds?: number;
+};
+/**
+ * Information about a quote provider (LiFi, CCTP, Relay, etc.) used for routing the swap.
+ */
+type RouteProviderInfo = {
+  id: string;
+  name: string;
+  url: string;
+};
+/**
+ * A quote object containing all the details about a Trails intent transaction.
+ *
+ * Includes token amounts, fees, price impact, estimated completion time,
+ * and other relevant information for displaying to the user.
+ */
+type Quote = {
+  /** Raw origin amount in smallest unit (wei). */originAmount: string; /** Minimum origin amount after slippage. */
+  originAmountMin: string; /** Raw destination amount in smallest unit (wei). */
+  destinationAmount: string; /** Minimum destination amount after slippage. */
+  destinationAmountMin: string; /** Origin amount formatted as USD string (e.g. "$1.23"). */
+  originAmountUsdDisplay: string; /** Destination amount formatted as USD string. */
+  destinationAmountUsdDisplay: string; /** Human-readable origin amount (e.g. "1.5"). */
+  originAmountDisplay: string; /** Human-readable destination amount. */
+  destinationAmountDisplay: string;
+  originAmountMinDisplay: string;
+  originAmountMinUsdFormatted: string;
+  originAmountMinUsdDisplay: string;
+  destinationAmountMinDisplay: string;
+  destinationAmountMinUsdFormatted: string;
+  destinationAmountMinUsdDisplay: string;
+  originAmountUsdFormatted: string;
+  destinationAmountUsdFormatted: string; /** Human-readable origin amount formatted with user locale. */
+  originAmountFormattedLocale?: string; /** Origin amount in USD formatted with user locale. */
+  originAmountUsdLocaleDisplay?: string; /** Human-readable destination amount formatted with user locale. */
+  destinationAmountFormattedLocale?: string; /** Destination amount in USD formatted with user locale. */
+  destinationAmountUsdLocaleDisplay?: string; /** Origin amount as a numeric USD value for calculations. */
+  originAmountUsd?: number; /** Human-readable origin amount (e.g. "1.5 USDC"). */
+  originAmountFormatted: string; /** Human-readable destination amount (e.g. "0.001 ETH"). */
+  destinationAmountFormatted: string; /** Intent protocol used for this quote. */
+  intentProtocol: string;
+  originToken: Token$1;
+  destinationToken: Token$1;
+  originChain: Chain$1;
+  destinationChain: Chain$1;
+  fees: PrepareSendFees;
+  slippageTolerance: string;
+  priceImpact: string;
+  priceImpactUsd: string | null;
+  priceImpactUsdDisplay: string;
+  priceImpactUsdLocaleDisplay?: string;
+  completionEstimateSeconds: number;
+  completionEstimateDisplay: string;
+  transactionStates: TransactionState[];
+  originTokenRate: string;
+  routeProviders: RouteProviderInfo[];
+  destinationTokenRate: string;
+  originTokenPriceUsd: number;
+  destinationTokenPriceUsd: number;
+  gasCostUsd: number | null;
+  gasCostUsdDisplay: string;
+  gasCost: string;
+  gasCostFormatted: string;
+  totalFeesUsd: number | null;
+  totalFeesUsdDisplay: string;
+  totalGasUsd: number | null;
+  totalGasUsdDisplay: string;
+  intentId: string | null;
+  edgeId: string | null;
+  originDepositAddress: string;
+  destinationDepositAddress: string;
+  destinationAddress: string;
+  destinationApproveAddress: string;
+  destinationCalldata: string;
+  trailsFeeBreakdown: TrailsFeeBreakdown | null;
+  originGasUsd: number | null;
+  originGasUsdDisplay: string;
+  destinationGasUsd: number | null;
+  destinationGasUsdDisplay: string;
+  providerFeeUsd: number | null;
+  providerFeeUsdDisplay: string;
+  trailsFeeUsd: number | null;
+  trailsFeeUsdDisplay: string;
+  totalProviderFeesUsd: number | null;
+  totalProviderFeesUsdDisplay: string;
+  totalGasUsdLocaleDisplay?: string;
+  originGasUsdLocaleDisplay?: string;
+  destinationGasUsdLocaleDisplay?: string;
+  totalProviderFeesUsdLocaleDisplay?: string;
+  providerFeeUsdLocaleDisplay?: string;
+  trailsFeeUsdLocaleDisplay?: string;
+  noSufficientBalance: boolean;
+  expiresAt: string | null;
+  priceImpactDetails: PriceImpactDetails | null;
+  passthroughEligible?: boolean;
+  passthroughTransactionStates?: TransactionState[];
+};
+/**
+ * Return type for the {@link useQuote} hook.
+ *
+ * Provides the quote data, send function, loading state, error information,
+ * and utility functions for managing the quote lifecycle.
+ */
+type SendOptions = {
+  /** Override the fee option for this transaction (e.g., pay gas in USDC instead of ETH). */selectedFeeOption?: FeeOption | null; /** Callback called when the wallet signature is confirmed and transaction is submitted. */
+  onOriginSend?: () => void; /** For onramp-meld flow, provide the deposit transaction hash directly. */
+  depositTransactionHash?: string; /** Skip committing the intent (used when intent is already committed). */
+  skipCommit?: boolean;
+};
+type UseQuoteReturn = {
+  /** The quote object with transaction details, or `null` if not available. */quote: Quote | null; /** A function to execute the transaction, or `null` if not available. Returns a Promise that resolves to transaction result with receipts. Accepts optional SendOptions to override fee option. */
+  send: ((options?: SendOptions) => Promise<SwapReturn | null>) | null; /** Boolean indicating if a quote is currently being fetched. */
+  isLoadingQuote: boolean; /** Typed error with a `code` property for programmatic handling, or `null`. */
+  quoteError: QuoteError | null; /** A user-friendly error message string (empty string when no error). */
+  quoteErrorPrettified: string; /** Function to manually refetch the quote (useful for refreshing stale quotes). */
+  refetchQuote: () => Promise<void>; /** Function to abort any in-flight quote requests. */
+  abort: () => void; /** Fee options available for this quote (e.g., pay gas in different tokens). */
+  feeOptions: FeeOption[]; /** Whether the recipient address is a contract (null if not yet checked). */
+  isRecipientContract: boolean | null; /** Whether the sender address is a contract on the origin chain (null if not yet checked). */
+  isSenderContractOnOrigin: boolean | null; /** Whether the sender address is a contract on the destination chain (null if not yet checked). */
+  isSenderContractOnDestination: boolean | null; /** True when destination is an edge rail but calldata is also present (incompatible — quote disabled). */
+  isEdgeDestinationWithCalldata: boolean;
+};
+/**
+ * React hook for fetching quotes and executing cross-chain or same-chain intent transactions.
+ *
+ * This hook provides a simple interface to get quotes for intent transactions and execute them.
+ * It handles both cross-chain and same-chain intent transactions, automatically fetching token balances,
+ * calculating fees, and providing transaction state updates.
+ *
+ * ## Required providers
+ *
+ * This hook **must** be rendered inside the following providers:
+ *
+ * 1. **`QueryClientProvider`** (@tanstack/react-query) — supplies the React Query cache
+ * 2. **`TrailsProvider`** — supplies the API key, SDK configuration, and wallet integration
+ *
+ * `TrailsProvider` mounts the built-in wallet runtime by default, so
+ * address-driven reads work without extra setup and execution can light up
+ * once a wallet connects. Add `config.adapters` only when this hook should
+ * share a host-owned wallet runtime instead.
+ *
+ * ```tsx
+ * import { TrailsProvider } from '0xtrails'
+ *
+ * <QueryClientProvider client={queryClient}>
+ *   <TrailsProvider config={{ trailsApiKey: 'YOUR_KEY' }}>
+ *     <YourComponent />
+ *   </TrailsProvider>
+ * </QueryClientProvider>
+ * ```
+ *
+ * Optional host-runtime integration:
+ *
+ * ```tsx
+ * import { TrailsProvider } from '0xtrails'
+ * import { wagmiAdapter } from '@0xtrails/adapter-wagmi'
+ *
+ * <QueryClientProvider client={queryClient}>
+ *   <TrailsProvider
+ *     config={{
+ *       trailsApiKey: 'YOUR_KEY',
+ *       adapters: [wagmiAdapter({ wagmiConfig })],
+ *     }}
+ *   >
+ *     <YourComponent />
+ *   </TrailsProvider>
+ * </QueryClientProvider>
+ * ```
+ *
+ * ## Destination execution modes
+ *
+ * Three mutually-exclusive ways to execute logic on the destination chain after the funds land:
+ *
+ * 1. **`actions`** (recommended, composable) — high-level DeFi primitives
+ *    (`swap`, `lend`, `deposit`, `custom`, `assertCondition`). Resolved into destination calls internally.
+ * 2. **`to.calls`** — array of raw `{ to, data, value }` calls when you need hand-rolled
+ *    ABI-encoded transactions. Use for bespoke integrations not covered by the action factories.
+ * 3. **`to.calldata`** — ⚠️ **deprecated**. A single ABI-encoded calldata blob. Retained for
+ *    backwards compatibility; migrate to `calls` (or `actions`) in new code.
+ *
+ * Specifying more than one of these at a time throws a configuration error.
+ *
+ * ## Error handling
+ *
+ * The `quoteError` field is a {@link QuoteError} instance with a typed `code` property.
+ * Use `quoteError.code` to programmatically distinguish failure modes:
+ *
+ * ```ts
+ * if (quoteError?.code === 'INSUFFICIENT_LIQUIDITY') { ... }
+ * if (quoteError?.code === 'NO_ROUTE') { ... }
+ * ```
+ *
+ * @example
+ * Exact input (spend 1 USDC from Base) — human-readable string:
+ * ```tsx
+ * const { quote, send } = useQuote({
+ *   from: {
+ *     token: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913', // USDC
+ *     chain: 8453, // Base
+ *     amount: '1', // 1 USDC — EXACT_INPUT
+ *   },
+ *   to: {
+ *     token: '0x0000000000000000000000000000000000000000', // ETH
+ *     chain: 42161, // Arbitrum
+ *     recipient: address,
+ *   },
+ *   slippageTolerance: '0.005',
+ *   onStatusUpdate: (states) => console.log(states),
+ * })
+ * ```
+ *
+ * @example
+ * Exact output (receive 0.001 ETH on Arbitrum):
+ * ```tsx
+ * const { quote, send } = useQuote({
+ *   from: {
+ *     token: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+ *     chain: 8453,
+ *   },
+ *   to: {
+ *     token: '0x0000000000000000000000000000000000000000',
+ *     chain: 42161,
+ *     recipient: address,
+ *     amount: '0.001', // 0.001 ETH — EXACT_OUTPUT
+ *   },
+ * })
+ * ```
+ *
+ * @example
+ * Using token symbols instead of addresses:
+ * ```tsx
+ * const { quote, send } = useQuote({
+ *   from: {
+ *     token: 'USDC',
+ *     chain: 'base',
+ *     amount: '1', // 1 USDC
+ *   },
+ *   to: {
+ *     token: 'ETH',
+ *     chain: 'arbitrum',
+ *     recipient: address,
+ *   },
+ * })
+ * ```
+ *
+ * @example
+ * Raw bigint amounts — skips `parseUnits` and the decimals registry/RPC
+ * lookup when paired with `from.decimals`. Pass this when you already have
+ * a raw on-chain value (e.g. from a balance query or contract event):
+ * ```tsx
+ * const { quote, send } = useQuote({
+ *   from: {
+ *     token: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913', // USDC
+ *     chain: 8453,
+ *     amountRaw: 1_000_000n, // 1 USDC (6 decimals) — EXACT_INPUT
+ *     decimals: 6,
+ *   },
+ *   to: {
+ *     token: '0x0000000000000000000000000000000000000000',
+ *     chain: 42161,
+ *     recipient: address,
+ *   },
+ * })
+ * ```
+ *
+ * @example
+ * Composable actions on the destination chain (swap + lend):
+ * ```tsx
+ * import { swap, lend } from '0xtrails'
+ *
+ * const { quote, send } = useQuote({
+ *   from: { token: 'USDC', chain: 'base' },
+ *   to: {
+ *     token: 'USDC',
+ *     chain: 'arbitrum',
+ *     amount: '50', // 50 USDC
+ *   },
+ *   actions: [
+ *     swap({
+ *       tokenIn: 'USDC',
+ *       tokenOut: 'WETH',
+ *       amountIn: '25', // EXACT_INPUT (inferred)
+ *     }),
+ *     lend({
+ *       marketId: 'arbitrum-usdc-aave-v3-lending',
+ *       amount: '25',
+ *     }),
+ *   ],
+ * })
+ * ```
+ *
+ * @param props - Configuration options for the quote
+ * @param props.walletClient - Optional viem `WalletClient` override. If provided, its account address is the quote owner. If omitted, uses the connected wallet client from the Trails wallet runtime when available.
+ * @param props.walletAddress - Optional owner address for quote previews before or without a wallet connection. Ignored when a wallet client account address is available.
+ * @param props.from - Source token, chain, and optional `amount` (human-readable decimal string) or `amountRaw` (bigint | integer-only string in wei) for EXACT_INPUT
+ * @param props.to - Destination token, chain, recipient, and optional `amount` or `amountRaw` for EXACT_OUTPUT
+ * @param props.actions - Optional composable destination actions built with the `swap`/`lend`/`deposit`/`custom`/`assertCondition` factories (mutually exclusive with `to.calls` and the deprecated `to.calldata`)
+ * @param props.slippageTolerance - Slippage tolerance as a decimal string or number (e.g., '0.005' for 0.5%)
+ * @param props.onStatusUpdate - Optional callback for transaction state updates
+ * @param props.swapProvider - Optional swap provider ID
+ * @param props.bridgeProvider - Optional bridge provider ID
+ * @param props.abortSignal - Optional AbortSignal to cancel the quote request
+ *
+ * @returns An object containing:
+ * - `quote` — The quote object with transaction details, or `null` if not available
+ * - `send` — A function to execute the transaction, or `null` if not available
+ * - `isLoadingQuote` — Boolean indicating if a quote is currently being fetched
+ * - `quoteError` — A {@link QuoteError} with a typed `code`, or `null`
+ * - `quoteErrorPrettified` — A user-friendly error message string
+ * - `refetchQuote` — Function to manually refetch the quote
+ * - `abort` — Function to abort any in-flight quote requests
+ * - `feeOptions` — Fee options available for this quote
+ *
+ * @remarks
+ * - The hook uses React Query internally, so quotes are cached and automatically refetched based on query key changes
+ * - The hook will not fetch a quote until all required parameters are provided (connected wallet account or walletAddress, source/destination tokens and chains, one amount side, and a destination recipient or owner address). Missing parameters are logged as a console warning.
+ * - `walletAddress` supports quote previews without a wallet connection. `send` remains unavailable until a real wallet client is connected.
+ * - For native tokens (ETH, MATIC, etc.), use the zero address (`0x0000000000000000000000000000000000000000`) or the native currency symbol (e.g. `"ETH"`)
+ * - Token symbols are resolved against the supported token list for the specified chain. If a symbol is not found, the quote will not fire. Prefer addresses in production for deterministic asset selection
+ *
+ * @throws {QuoteError} When the quote request fails. The error `code` discriminates the failure mode.
+ *
+ * @see {@link QuoteError} for the error class
+ * @see {@link QuoteErrorCode} for available error codes
+ * @see {@link Quote} for the quote object structure
+ * @see {@link SwapReturn} for the swap result structure
+ *
+ * For more information go to {@link https://docs.trails.build/sdk/hooks#usequote-hook}
+ */
+declare function useQuote({
+  walletClient,
+  walletAddress,
+  from,
+  to,
+  actions,
+  slippageTolerance,
+  onStatusUpdate,
+  checkoutOnHandlers,
+  swapProvider,
+  bridgeProvider,
+  swapProviderFallback,
+  bridgeProviderFallback,
+  selectedFeeOption,
+  nodeGatewayEnv,
+  abortSignal: externalAbortSignal,
+  apiKey,
+  isSmartWallet,
+  fundMethod,
+  onramp,
+  mode,
+  intentProtocolVersion,
+  disabled
+}: UseQuoteProps): UseQuoteReturn;
+//#endregion
+//#region src/plugins/edgeWallet.d.ts
+/** Per-rail origin wallet configs passed into intent execution. */
+type EdgeWalletConfigs = {
+  [EDGE_RAIL.SOLANA]?: Extract<EdgeOriginConfig, {
+    rail: typeof EDGE_RAIL.SOLANA;
+  }>;
+};
+declare function toEdgeWalletConfigs(origin: EdgeOriginConfig | null | undefined): EdgeWalletConfigs | undefined;
+declare function getEdgeOriginConfig(wallets: EdgeWalletConfigs | undefined, rail: EdgeRailId): EdgeOriginConfig | undefined;
+declare function buildEdgeQuoteRequestFromOriginConfig(origin: EdgeOriginConfig, input: {
+  originTokenMint: string;
+  edgeTradeType?: TradeType;
+  originTokenAmount?: bigint;
+  refundAddress?: string;
+  providerRelayOnly?: boolean;
+}): EdgeQuoteRequest;
+declare function buildEdgeQuoteRequestFromDestinationConfig(destination: EdgeDestinationConfig, input: {
+  destinationTokenAddress: string;
+  edgeTradeType?: TradeType;
+  originTokenAmount?: bigint;
+}): EdgeQuoteRequest;
+//#endregion
+//#region src/transactionIntent/types.d.ts
+type FundMethod$1 = "wallet" | "direct-transfer" | "onramp-mesh" | "onramp-bluvo" | "onramp-meld";
+type IntentMode$1 = "pay" | "fund" | "earn" | "swap" | "withdraw";
+type PrepareSendOptions = {
+  account: Account;
+  originTokenAddress: string;
+  originChainId: number;
+  originTokenBalance: string;
+  destinationChainId: number;
+  recipient: string;
+  destinationTokenAddress: string;
+  swapAmount: string;
+  tradeType?: TradeType$1;
+  originTokenSymbol: string;
+  destinationTokenSymbol: string;
+  sequenceProjectAccessKey?: string;
+  sequenceIndexerUrl?: string;
+  client?: TrailsWalletClient;
+  trailsClient: TrailsApi;
+  destinationApproveAddress?: string;
+  destinationCalldata?: string;
+  onTransactionStateChange: (transactionStates: TransactionState[]) => void;
+  sourceTokenPriceUsd?: number | null;
+  destinationTokenPriceUsd?: number | null;
+  sourceTokenDecimals: number;
+  destinationTokenDecimals: number;
+  slippageTolerance?: string;
+  originNativeTokenPriceUsd?: number | null;
+  swapProvider?: RouteProvider | null;
+  bridgeProvider?: RouteProvider | null;
+  swapProviderFallback?: boolean;
+  bridgeProviderFallback?: boolean;
+  intentProtocolVersion?: IntentProtocolVersion;
+  fundMethod?: FundMethod$1;
+  mode?: IntentMode$1;
+  originPublicClient?: PublicClient;
+  destinationPublicClient?: PublicClient;
+  checkoutOnHandlers?: Partial<CheckoutOnHandlers>;
+  refundAddress?: string;
+  selectedFeeOption?: FeeOption | null;
+  walletId?: string;
+  abortSignal?: AbortSignal;
+  isSmartWallet?: boolean;
+  isSenderContractOnOrigin?: boolean | null;
+  trailsApiKey?: string;
+  trailsApiUrl?: string;
+  sequenceMetadataUrl?: string;
+  onramp?: OnrampTrackingData | null;
+  isMultiCallEncoding?: boolean;
+  queryClient?: QueryClient;
+  commitIntentFn?: (intent: Intent) => Promise<CommitIntentResponse>;
+  executeIntentFn?: (params: {
+    intentId: string;
+    depositTransactionHash?: string;
+    depositSignature?: DepositSignature;
+  }) => Promise<ExecuteIntentResponse>;
+  /**
+   * Per-rail wallet/RPC config for edge quotes (e.g. `edge.solana` for Solana origin).
+   */
+  edge?: EdgeWalletConfigs; /** Plugin that executes edge deposits. Provided by @0xtrails/svm via SvmPluginProvider. */
+  edgePlugin?: EdgePlugin; /** Plugin for edge DESTINATION mode (EVM → Solana). Provided by @0xtrails/svm via SvmPluginProvider. */
+  destinationEdgePlugin?: EdgePlugin;
+};
+type PrepareSendFees = {
+  feeTokenAddress: string | null;
+  totalFeeAmount: string | null;
+  totalFeeAmountUsd: string | null;
+  totalFeeAmountUsdDisplay: string | null;
+  totalFeeAmountUsdLocaleDisplay?: string | null;
+};
+type PrepareSendQuote = {
+  intentProtocol: IntentProtocolVersion;
+  originDepositAddress: string;
+  destinationDepositAddress: string;
+  destinationAddress: string;
+  destinationApproveAddress?: string;
+  destinationCalldata: string;
+  intentId?: string | null;
+  edgeId?: string | null;
+  expiresAt?: string | null;
+  originChain: Chain;
+  destinationChain: Chain;
+  originAmount: string;
+  originAmountDisplay: string;
+  originAmountMin: string;
+  originAmountMinDisplay: string;
+  originAmountMinUsdFormatted: string;
+  originAmountMinUsdDisplay: string;
+  destinationAmount: string;
+  destinationAmountDisplay: string;
+  destinationAmountMin: string;
+  destinationAmountMinDisplay: string;
+  destinationAmountMinUsdFormatted: string;
+  destinationAmountMinUsdDisplay: string;
+  originAmountFormatted: string;
+  originAmountFormattedLocale?: string;
+  originAmountUsd?: number;
+  fromAmountUsd?: number;
+  originAmountUsdFormatted: string;
+  originAmountUsdDisplay: string;
+  originAmountUsdLocaleDisplay?: string;
+  destinationAmountFormatted: string;
+  destinationAmountFormattedLocale?: string;
+  destinationAmountUsd?: number;
+  toAmountUsd?: number;
+  destinationAmountUsdFormatted: string;
+  destinationAmountUsdDisplay: string;
+  destinationAmountUsdLocaleDisplay?: string;
+  originToken: Token$1;
+  destinationToken: Token$1;
+  fees: PrepareSendFees;
+  slippageTolerance: string;
+  maxSlippage?: number | null;
+  priceImpact: string;
+  priceImpactUsd?: string;
+  priceImpactUsdDisplay: string;
+  completionEstimateSeconds: number;
+  completionEstimateDisplay: string;
+  transactionStates: TransactionState[];
+  passthroughTransactionStates?: TransactionState[];
+  passthroughEligible?: boolean;
+  gasCostUsd: number;
+  gasCostUsdDisplay: string;
+  gasCost: string;
+  gasCostFormatted: string;
+  originTokenRate: string;
+  destinationTokenRate: string;
+  originTokenPriceUsd: number;
+  destinationTokenPriceUsd: number;
+  routeProviders?: RouteProviderInfo[];
+  noSufficientBalance: boolean;
+  trailsFeeBreakdown?: TrailsFeeBreakdown | null;
+  totalFeesUsd?: number;
+  totalFeesUsdDisplay?: string;
+  originGasUsd?: number;
+  destinationGasUsd?: number;
+  totalGasUsd?: number;
+  providerFeeUsd?: number;
+  trailsFeeUsd?: number;
+  originGasUsdDisplay?: string;
+  destinationGasUsdDisplay?: string;
+  totalGasUsdDisplay?: string;
+  providerFeeUsdDisplay?: string;
+  trailsFeeUsdDisplay?: string;
+  totalProviderFeesUsd?: number;
+  totalProviderFeesUsdDisplay?: string;
+  originGasUsdLocaleDisplay?: string;
+  destinationGasUsdLocaleDisplay?: string;
+  totalGasUsdLocaleDisplay?: string;
+  providerFeeUsdLocaleDisplay?: string;
+  trailsFeeUsdLocaleDisplay?: string;
+  totalProviderFeesUsdLocaleDisplay?: string;
+  priceImpactUsdLocaleDisplay?: string;
+  priceImpactDetails?: PriceImpactDetails | null;
+};
+type PrepareSendReturn = {
+  quote: PrepareSendQuote;
+  feeOptions?: GasFeeOptions;
+  send: ({
+    onOriginSend,
+    selectedFeeOption,
+    depositTransactionHash,
+    skipCommit
+  }: {
+    onOriginSend?: () => void;
+    selectedFeeOption?: FeeOption | null;
+    depositTransactionHash?: string;
+    skipCommit?: boolean;
+  }) => Promise<SendReturn>;
+};
+type SendReturn = {
+  depositUserTxnReceipt: TransactionReceipt | null;
+  originIntentTransaction: IntentTransaction | null;
+  destinationIntentTransaction: IntentTransaction | null;
+  totalCompletionSeconds?: number;
+};
+//#endregion
+//#region src/prepareSend.d.ts
+declare function prepareSend(options: PrepareSendOptions): Promise<PrepareSendReturn>;
+//#endregion
+//#region src/types/chain.d.ts
+/**
+ * Supported chain families for chain-agnostic SDK types.
+ */
+declare const CHAIN_TYPE: {
+  readonly EVM: "EVM";
+  readonly SOLANA: "SOLANA";
+};
+type ChainType = (typeof CHAIN_TYPE)[keyof typeof CHAIN_TYPE];
+declare const SOLANA_MAINNET_CHAIN_ID = 101;
+declare function isSolanaChainId(chainId: number): boolean;
+/**
+ * Chain-agnostic chain descriptor.
+ * Every supported chain can be represented as a TrailsChain.
+ */
+interface TrailsChain {
+  /** Unique numeric chain ID. Solana mainnet = 101, EVM chains use standard chain IDs. */
+  chainId: number;
+  /** Human-readable chain name. */
+  name: string;
+  /** Chain family. */
+  chainType: ChainType;
+  /** Native currency metadata. */
+  nativeCurrency: {
+    name: string;
+    symbol: string;
+    decimals: number;
+  };
+  /** Chain icon URL. */
+  imageUrl?: string;
+  /** Block explorer base URL. */
+  explorerUrl?: string;
+}
+//#endregion
+//#region src/widget/providers/UnifiedWalletProvider.d.ts
+/**
+ * Solana (SVM) signing + RPC surface passed as `solanaWallet` on `TrailsWidget`.
+ * Transactions are signed as serialized Solana wire bytes, matching Wallet Standard.
+ */
+interface SolanaWalletContextValue {
+  connected: boolean;
+  connecting?: boolean;
+  publicKey?: {
+    toBase58(): string;
+  } | null;
+  signSerializedTransaction?: (transactionBytes: Uint8Array) => Promise<Uint8Array>;
+  connection?: {
+    rpcEndpoint?: string; /** Ordered list of fallback RPC endpoints to try if the primary fails. */
+    rpcUrls?: string[];
+    getLatestBlockhash?: (commitment?: string) => Promise<{
+      blockhash: string;
+      lastValidBlockHeight: number;
+    }>;
+    sendRawTransaction: (serializedTransaction: unknown, options?: unknown) => Promise<string>;
+  } | null;
+  walletId?: string;
+  walletName?: string;
+  walletIcon?: string;
+  availableWallets?: Array<{
+    walletId: string;
+    walletName: string;
+    walletIcon?: string;
+    installUrl?: string;
+    connected?: boolean;
+    discovered?: boolean;
+  }>;
+  activeChain?: TrailsChain;
+  connect?: ((walletId?: string) => Promise<{
+    publicKey?: {
+      toBase58(): string;
+    } | null;
+  } | undefined> | {
+    publicKey?: {
+      toBase58(): string;
+    } | null;
+  } | undefined) | null;
+  disconnect?: (() => Promise<void> | void) | null;
+}
+/** Alias for {@link SolanaWalletContextValue} — SVM adapter shape for `solanaWallet`. */
+type SvmWalletAdapter = SolanaWalletContextValue;
+interface UnifiedWalletProviderProps {
+  children: ReactNode;
+  solanaWallet?: SolanaWalletContextValue | null;
+}
+/**
+ * Optional provider for **SVM (Solana)** wallet context that does not come from wagmi.
+ * Supply the same object you pass as `TrailsWidget` `solanaWallet`.
+ */
+declare function UnifiedWalletProvider({
+  children,
+  solanaWallet
+}: UnifiedWalletProviderProps): import("react").JSX.Element;
+declare function useOptionalSolanaWalletContext(): SolanaWalletContextValue | null;
+/** Preferred name: SVM (Solana) adapter from context — same as {@link useOptionalSolanaWalletContext}. */
+declare function useOptionalSvmWalletContext(): SolanaWalletContextValue | null;
+//#endregion
+//#region src/hooks/useViewManager.d.ts
+type Mode = "pay" | "fund" | "earn" | "swap" | "withdraw";
+type Screen = "connect" | "tokens" | "select-origin-token" | "select-origin-amount" | "send-form" | "fund-form" | "fund-methods" | "mesh-exchanges" | "mesh-exchange-confirmation" | "mesh-session-options" | "payment-methods" | "select-funding-wallet" | "onramp-payment-methods" | "recipients" | "earn-pools" | "earn" | "swap" | "withdraw" | "wallet-confirmation" | "qr-code-wallet-select" | "direct-transfer-screen" | "onramp-meld" | "pending" | "receipt" | "onramp-mesh" | "onramp-bluvo" | "wallet-connect" | "wallet-list" | "wallet-connection-pending" | "connect-all-wallets" | "connect-wallet-variants" | "connect-error" | "account-history" | "account-settings" | "user-preferences" | "chain-list" | "disconnect" | "qrcode-options" | "meld-history" | "recover" | "onramp-confirmation";
+//#endregion
+export { getIsRateLimitedError as $, resolveChainName as A, TrailsErrorBoundary as B, SwapReturn as C, ChainIdentifier as D, useQuote as E, Chain$1 as F, getFullErrorMessage as G, UserRejectionError as H, getAllChains as I, getIsInsufficientLiquidityError as J, getIsApiError as K, InsufficientBalanceError as L, getPublicClient as M, getSupportedChains as N, SupportedChainName as O, getRpcUrl as P, getIsQuoteTokenError as Q, TrailsApiClientError as R, QuoteTo as S, UseQuoteReturn as T, getErrorBoundary as U, TrailsErrorCode as V, getErrorCode as W, getIsQuoteFailedError as X, getIsNoAvailableQuoteError as Y, getIsQuoteInputError as Z, buildEdgeQuoteRequestFromOriginConfig as _, UnifiedWalletProvider as a, isTrailsError as at, Quote as b, SOLANA_MAINNET_CHAIN_ID as c, IntentTransactionHistoryResponse as ct, prepareSend as d, UseAccountTransactionHistoryParams as dt, getIsRequiredAmountNotMetError as et, FundMethod$1 as f, UseAccountTransactionHistoryReturn as ft, buildEdgeQuoteRequestFromDestinationConfig as g, EdgeWalletConfigs as h, useAccountTransactionHistory as ht, SvmWalletAdapter as i, isTrailsApiClientError as it, getChainInfo as j, resolveChainId as k, isSolanaChainId as l, TransactionHistoryResponse as lt, TradeType$1 as m, getTxTimeDiff as mt, Screen as n, getIsWalletAlreadyConnectedError as nt, useOptionalSolanaWalletContext as o, GetAccountTransactionHistoryParams as ot, PrepareSendQuote as p, getAccountTransactionHistory as pt, getIsBalanceTooLowError as q, SolanaWalletContextValue as r, getPrettifiedErrorMessage as rt, useOptionalSvmWalletContext as s, IntentTransaction$1 as st, Mode as t, getIsUserRejectionError as tt, RouteProvider$1 as u, TransactionState as ut, getEdgeOriginConfig as v, UseQuoteProps as w, QuoteFrom as x, toEdgeWalletConfigs as y, TrailsError as z };