0xtrails 0.16.2 → 0.17.0

package/dist/index-CMdwQmYL.d.ts

@@ -0,0 +1,1044 @@
+import { t as Token$1 } from "./tokenTypes-D812t5L9.js";
+import { D as ChainIdentifier, n as Screen, p as PrepareSendQuote, r as SolanaWalletContextValue, t as Mode, ut as TransactionState } from "./useViewManager-BeUH_k1s.js";
+import { FeeOption, GasFeeOptions, IntentProtocolVersion } from "@0xtrails/api";
+import React$1, { ComponentType, ReactElement, ReactNode } from "react";
+import { EvmAdapterRuntime, EvmChainConfig, EvmWalletDescriptor, TrailsUnifiedWalletConnectOption, TrailsWalletConnection, useWalletSession as useWalletSession$1 } from "@0xtrails/wallet";
+import { TrailsWalletNamespace } from "@0xtrails/wallet/core";
+
+//#region src/widget/providers/TrailsModalProvider.d.ts
+interface PendingFeeConfirmation {
+  resolve: (selectedFeeOption: FeeOption | null) => void;
+  reject: (error: Error) => void;
+}
+interface ModalSelectionParams {
+  fromTokenAddress: string;
+  fromChainId: number;
+  fromAmount?: string;
+  originToken?: Token$1;
+}
+type HostTransactionStatus = "idle" | "awaiting-origin" | "awaiting-amount" | "quoting" | "confirmation" | "pending" | "success" | "error";
+interface HostTransactionDetails {
+  to?: string;
+  tokenAddress?: string;
+  tokenAmount?: string;
+  toChainId?: number;
+  data?: string;
+  targetAmountUsd?: number | null;
+  targetAmountUsdFormatted?: string | null;
+  originToken?: Token$1;
+}
+interface HostTransactionResultLinks {
+  originTxHash?: string;
+  originExplorerUrl?: string;
+  destinationTxHash?: string;
+  destinationExplorerUrl?: string;
+}
+interface HostTransactionState {
+  status: HostTransactionStatus;
+  details?: HostTransactionDetails;
+  error?: string;
+  result?: HostTransactionResultLinks;
+  retryEnabled?: boolean;
+}
+interface LastOriginSelection {
+  tokenAddress: string;
+  chainId: number;
+  amount?: string;
+}
+interface TrailsModalContextType {
+  isModalOpen: boolean;
+  openModal: () => void;
+  closeModal: () => void;
+  getHandleCloseModal: () => (() => void) | null;
+  setHandleCloseModal: (handler: (() => void) | null) => void;
+  pendingSelection?: {
+    resolve: (selection: ModalSelectionParams) => void;
+    reject: (error: Error) => void;
+    requireAmountInput?: boolean;
+  };
+  setPendingSelection: (pending: {
+    resolve: (selection: ModalSelectionParams) => void;
+    reject: (error: Error) => void;
+    requireAmountInput?: boolean;
+  } | undefined) => void;
+  hostTransactionState: HostTransactionState;
+  setHostTransactionState: (next: HostTransactionState | ((prev: HostTransactionState) => HostTransactionState)) => void;
+  resetHostTransactionState: () => void;
+  resetForNewTransaction: () => void;
+  hostTransactionQuote: PrepareSendQuote | null;
+  setHostTransactionQuote: (quote: PrepareSendQuote | null | ((prev: PrepareSendQuote | null) => PrepareSendQuote | null)) => void;
+  hostTransactionStates: TransactionState[];
+  setHostTransactionStates: (states: TransactionState[] | ((prev: TransactionState[]) => TransactionState[])) => void;
+  hostTransactionTimestamp: number | null;
+  setHostTransactionTimestamp: (value: number | null | ((prev: number | null) => number | null)) => void;
+  /** Gas fee options surfaced by the latest quote, for in-modal fee-token selection. */
+  feeOptions: GasFeeOptions | null;
+  setFeeOptions: (feeOptions: GasFeeOptions | null) => void;
+  /**
+   * Pending fee-confirmation handshake: set by `useTrailsSendTransaction` after a
+   * quote with selectable fee tokens, resolved by the modal once the user confirms
+   * their chosen fee token (or `null` for native gas).
+   */
+  pendingFeeConfirmation?: PendingFeeConfirmation;
+  setPendingFeeConfirmation: (pending: PendingFeeConfirmation | undefined) => void;
+  receiptActionButtonText: string | null;
+  setReceiptActionButtonText: (text: string | null) => void;
+  onReceiptAction: (() => void) | null;
+  setOnReceiptAction: (callback: (() => void) | null) => void;
+  retryTransactionRef: {
+    current: (() => void) | null;
+  };
+  repeatTransactionRef: {
+    current: (() => void) | null;
+  };
+  /**
+   * Re-arms origin selection after the user navigates back to the token list
+   * from a post-selection screen (quoting/confirmation/fee). The one-shot
+   * pendingSelection promise is consumed on first pick, so without this a
+   * second selection would never quote. Set by useTrailsSendTransaction.
+   */
+  restartOriginSelectionRef: {
+    current: (() => void) | null;
+  };
+  lastOriginSelection: LastOriginSelection | null;
+  setLastOriginSelection: (selection: LastOriginSelection | null) => void;
+}
+interface TrailsModalProviderProps {
+  children: React.ReactNode;
+}
+declare const TrailsModalProvider: ({
+  children
+}: TrailsModalProviderProps) => import("react").JSX.Element;
+declare function useTrailsModal(): TrailsModalContextType;
+//#endregion
+//#region src/widget/providers/sequenceSupport.d.ts
+interface TrailsSequenceSupportConfig {
+  trailsApiKey: string;
+  sequenceApiUrl: string;
+  sequenceIndexerUrl: string;
+  sequenceMetadataUrl: string;
+}
+interface TrailsSequenceFeeToken {
+  contractAddress?: string | null;
+  decimals?: number;
+  logoURL?: string;
+  symbol?: string;
+}
+interface TrailsSequenceFeeOption {
+  balance?: string;
+  hasEnoughBalanceForFee?: boolean;
+  token: TrailsSequenceFeeToken;
+  value?: string;
+}
+interface TrailsWaasFeeOptionConfirmation {
+  chainId: number;
+  id: string;
+  options: TrailsSequenceFeeOption[];
+}
+interface TrailsWaasFeeOptionsControllerValue {
+  confirmPendingFeeOption: (id: string, feeTokenAddress: string | null) => void;
+  pendingFeeOptionConfirmation: TrailsWaasFeeOptionConfirmation | undefined;
+  rejectPendingFeeOption: (id: string) => void;
+}
+interface TrailsWaasFeeOptionsControllerProps {
+  chainId?: number;
+  children: (value: TrailsWaasFeeOptionsControllerValue) => ReactNode;
+}
+interface TrailsSequenceSupportProviderProps {
+  children: ReactNode;
+  config: TrailsSequenceSupportConfig;
+}
+interface TrailsSequenceSupport {
+  Provider?: ComponentType<TrailsSequenceSupportProviderProps>;
+  WaasFeeOptionsController?: ComponentType<TrailsWaasFeeOptionsControllerProps>;
+}
+//#endregion
+//#region src/widget/providers/TrailsProvider.d.ts
+type SequenceEnv = "prod" | "dev" | "local" | "cors-anywhere";
+interface TrailsAdapterProviderProps {
+  children: ReactNode;
+}
+/**
+ * Runtime-neutral wallet adapter shape consumed by `0xtrails`.
+ *
+ * Adapter packages such as `@0xtrails/adapter-wagmi` return this shape.
+ */
+interface TrailsAdapterConfig {
+  Provider?: ComponentType<TrailsAdapterProviderProps & Record<string, unknown>>;
+  providerProps?: Record<string, unknown>;
+  namespaces?: readonly TrailsWalletNamespace[];
+  sequenceSupport?: TrailsSequenceSupport;
+}
+/**
+ * Optional adapter entry mode used for advanced composition.
+ *
+ * Most integrations should use the default `shared` mode.
+ */
+type TrailsAdapterManagedBy = "host" | "trails";
+/**
+ * Wrap an adapter entry when you need to supply an explicit key or declare
+ * wallet lifecycle ownership. `managedBy` does not decide whether an adapter
+ * bridges to a parent provider; that is determined by the adapter itself, e.g.
+ * the wagmi adapter bridges only when it receives the same wagmi config
+ * instance as the ambient `WagmiProvider`.
+ */
+interface WrappedTrailsAdapterEntry {
+  adapter: TrailsAdapterConfig;
+  key?: string;
+  managedBy?: TrailsAdapterManagedBy;
+}
+type TrailsAdapterEntry = TrailsAdapterConfig | WrappedTrailsAdapterEntry;
+interface TrailsConfig {
+  trailsApiKey: string;
+  trailsApiUrl: string;
+  trailsAppUrl: string;
+  sequenceIndexerUrl: string;
+  sequenceNodeGatewayUrl: string;
+  sequenceMetadataUrl: string;
+  sequenceApiUrl: string;
+  keyMachineUrl: string;
+  /** Solana mainnet JSON-RPC for SDK-initiated reads. Env vars are the fallback. */
+  solanaRpcUrl?: string;
+  walletConnectProjectId: string;
+  slippageTolerance: string | number;
+  debug: boolean;
+  commitHash: string | undefined;
+  hasAdapters: boolean;
+  intentProtocol?: IntentProtocolVersion;
+  sequenceSupport?: TrailsSequenceSupport;
+}
+interface TrailsProviderConfig {
+  trailsApiKey: string;
+  trailsApiUrl?: string;
+  trailsAppUrl?: string;
+  sequenceIndexerUrl?: string;
+  sequenceNodeGatewayUrl?: string;
+  sequenceMetadataUrl?: string;
+  sequenceApiUrl?: string;
+  keyMachineUrl?: string;
+  /** Solana mainnet JSON-RPC for SDK-initiated reads (balances, SPL scans). */
+  solanaRpcUrl?: string;
+  walletConnectProjectId?: string;
+  slippageTolerance?: string | number;
+  debug?: boolean;
+  intentProtocol?: IntentProtocolVersion;
+  /**
+   * Optional wallet adapters for connecting Trails to explicit wallet runtimes.
+   *
+   * When omitted, `TrailsProvider` mounts the built-in native EVM wallet
+   * runtime by default. Provide adapters here when widgets and hooks should
+   * share the same configured wallet runtime. For composite adapter lists,
+   * wrap host-owned entries with `managedBy: "host"` so Trails does not own
+   * their lifecycle.
+   */
+  adapters?: readonly TrailsAdapterEntry[];
+}
+interface TrailsProviderProps {
+  children: ReactNode;
+  config: TrailsProviderConfig;
+}
+/**
+ * Supplies Trails configuration to hooks and mounts either the built-in wallet
+ * runtime or provider-owned adapters.
+ *
+ * `TrailsWidget` can self-bootstrap without this provider for the standalone
+ * built-in runtime path. Use `TrailsProvider` when you want app-level config,
+ * direct hook usage, or shared adapter ownership across hooks and widgets.
+ */
+declare const TrailsProvider: ({
+  children,
+  config
+}: TrailsProviderProps) => import("react").JSX.Element;
+declare function useTrails(): Readonly<TrailsConfig>;
+//#endregion
+//#region src/adapters/evmAdapter.d.ts
+interface EvmAdapterOptions {
+  wallets: EvmWalletDescriptor | readonly EvmWalletDescriptor[];
+  chains?: readonly [EvmChainConfig, ...EvmChainConfig[]];
+  runtime?: EvmAdapterRuntime;
+  supportsWalletSelection?: boolean;
+}
+declare function evmAdapter(options: EvmAdapterOptions): TrailsAdapterConfig;
+//#endregion
+//#region src/theme.d.ts
+type Theme = "light" | "dark" | "auto";
+//#endregion
+//#region src/onramp/TrailsOnRampProvider.d.ts
+interface MeshConfig {
+  exchanges?: string[];
+  clientId?: string;
+  environment?: "sandbox" | "production";
+  sandbox?: boolean;
+  sandboxEnabled?: boolean;
+  productionEnabled?: boolean;
+  mode?: "sandbox" | "production";
+}
+interface BluvoConfig {
+  enabled?: boolean;
+  environment?: "sandbox" | "production";
+  allowedExchanges?: string[];
+}
+interface TrailsOnRampConfig {
+  mesh?: MeshConfig;
+  bluvo?: BluvoConfig;
+  environment?: "sandbox" | "production";
+  apiKey?: string;
+  jwt?: string;
+  hostname?: string;
+  clientId?: string;
+}
+interface TrailsOnRampContextValue {
+  config: TrailsOnRampConfig;
+}
+interface TrailsOnRampProviderProps {
+  config?: TrailsOnRampConfig;
+  children: React$1.ReactNode;
+}
+declare function TrailsOnRampProvider({
+  config,
+  children
+}: TrailsOnRampProviderProps): React$1.JSX.Element;
+declare function useTrailsOnRamp(): TrailsOnRampContextValue | null;
+declare function isMeshEnabled(config?: TrailsOnRampConfig | null): boolean;
+declare function getActiveMeshMode(config?: TrailsOnRampConfig | null): "sandbox" | "production";
+//#endregion
+//#region src/widget/shared/destinationSupport.d.ts
+type SupportedTokensByChainConfig = {
+  chain: ChainIdentifier;
+  tokens: string[];
+};
+//#endregion
+//#region src/widget/props.d.ts
+/** Transfer result data returned by an onramp provider on completion.
+ * Shape based on @meshconnect/web-link-sdk TransferFinishedPayload. */
+interface OnrampTransferResult {
+  status: string;
+  txId: string;
+  fromAddress: string;
+  toAddress: string;
+  symbol: string;
+  amount: number;
+  networkId: string;
+  amountInFiat?: number;
+  totalAmountInFiat?: number;
+  networkName?: string;
+  txHash?: string;
+  transferId?: string;
+}
+type FundMethodListOption = "connected-wallet" | "crypto-transfer" | "cc-onramp" | "exchange" | "exchange-onramp";
+declare const WidgetFundMethod: {
+  readonly Wallet: "wallet";
+  readonly CryptoTransfer: "crypto-transfer";
+  readonly Onramp: "onramp";
+  readonly OnrampExchange: "onramp-exchange";
+};
+type WidgetFundMethod = (typeof WidgetFundMethod)[keyof typeof WidgetFundMethod];
+type ExchangeProvider = "mesh" | "bluvo";
+type TrailsWidgetProps = {
+  /** Required when the widget is mounted without a parent `TrailsProvider`. */apiKey?: string;
+  sequenceIndexerUrl?: string;
+  trailsApiUrl?: string;
+  trailsAppUrl?: string;
+  sequenceNodeGatewayUrl?: string;
+  sequenceMetadataUrl?: string;
+  sequenceApiUrl?: string; /** Solana mainnet JSON-RPC for SDK-initiated reads (balances, SPL scans). */
+  solanaRpcUrl?: string;
+  toAddress?: string | null;
+  toAmount?: string | null; /** Controlled destination chain, user cannot change selection */
+  toChainId?: number | string | null; /** Controlled destination token, user cannot change selection */
+  toToken?: string | null; /** Default destination chain, user can change selection */
+  defaultToChainId?: number | string | null; /** Default destination token, user can change selection */
+  defaultToToken?: string | null; /** Destination chains visible/selectable in the widget. Accepts chain IDs, clear chain names, or viem Chain objects. */
+  supportedChains?: ChainIdentifier[] | null; /** Destination token allowlist grouped by chain. Tokens can be symbols or contract addresses. */
+  supportedTokensByChain?: SupportedTokensByChainConfig[] | null; /** Origin chains visible/selectable in withdraw source selection. */
+  originSupportedChains?: ChainIdentifier[] | null; /** Origin token allowlist grouped by chain for withdraw source selection. */
+  originSupportedTokensByChain?: SupportedTokensByChainConfig[] | null; /** Default input mode for fund/withdraw modes: "fiat" starts with USD input, "token" starts with token input */
+  defaultInputMode?: "fiat" | "token";
+  toCalldata?: string | null;
+  fromChainId?: number | string | null;
+  fromToken?: string | null; /** Pre-populate the source input amount (in human-readable token units, e.g. "1.5"). */
+  fromAmount?: string | null;
+  fromAccount?: string | null;
+  children?: ReactNode;
+  renderInline?: boolean;
+  theme?: Theme;
+  mode?: Mode;
+  /**
+   * Pre-select funding method used by the widget.
+   *
+   * This applies across modes (fund/pay/swap/earn) wherever funding method is used.
+   * In fund mode it also controls the initial destination flow:
+   * - "wallet" -> Funding with wallet flow
+   * - "crypto-transfer" --> Funding with QR Code or deposit to address flow
+   * - "onramp" --> Funding with onramp flow
+   * - "onramp-exchange" --> Funding with exchange flow
+   */
+  fundMethod?: WidgetFundMethod;
+  fundTradeType?: "EXACT_INPUT" | "EXACT_OUTPUT"; /** Preferred provider for the exchange funding flow. Defaults to "mesh". */
+  exchangeProvider?: ExchangeProvider;
+  onOriginConfirmation?: (data: {
+    txHash: string;
+    chainId: number;
+    sessionId: string;
+  }) => void;
+  onDestinationConfirmation?: (data: {
+    txHash: string;
+    chainId: number;
+    sessionId: string;
+  }) => void;
+  onStart?: (data: {
+    sessionId: string;
+  }) => void;
+  onQuote?: (data: {
+    sessionId: string;
+    quote: PrepareSendQuote;
+  }) => void;
+  onSignRequest?: (data: {
+    sessionId: string;
+  }) => void;
+  onSign?: (data: {
+    sessionId: string;
+  }) => void;
+  onSignReject?: (data: {
+    sessionId: string;
+    error: unknown;
+  }) => void;
+  onSuccess?: (data: {
+    sessionId: string;
+  }) => void;
+  onError?: (data: {
+    sessionId: string;
+    error: unknown;
+  }) => void;
+  onStatus?: (data: {
+    sessionId: string;
+    transactionStates: TransactionState[];
+  }) => void;
+  onApproveRequest?: (data: {
+    sessionId: string;
+  }) => void;
+  onApprove?: (data: {
+    sessionId: string;
+    transactionHash: `0x${string}`;
+  }) => void;
+  onApproveReject?: (data: {
+    sessionId: string;
+    error: unknown;
+  }) => void;
+  onOpen?: () => void;
+  onClose?: () => void;
+  walletConnectProjectId?: string;
+  /**
+   * Optional wallet adapters for this widget instance.
+   *
+   * Use this when a widget should use explicit wallet runtime adapters instead
+   * of a parent `TrailsProvider` or the built-in EVM runtime.
+   *
+   * Do not provide adapters both here and in a parent `TrailsProvider`. This
+   * prop also cannot be used inside an existing parent wallet context. When
+   * omitted and no parent wallet context exists, `TrailsWidget` falls back to
+   * its built-in EVM runtime.
+   *
+   * Supports multiple adapters. Wrap entries with `managedBy: "host"` when
+   * Trails can use a host-owned wallet but must not own its lifecycle.
+   */
+  adapters?: readonly TrailsAdapterEntry[];
+  paymasterUrls?: Array<{
+    chainId: number;
+    url: string;
+  }>;
+  buttonText?: string;
+  customCss?: string | Record<string, string>;
+  disableCss?: boolean;
+  swapProvider?: string;
+  bridgeProvider?: string;
+  swapProviderFallback?: boolean;
+  bridgeProviderFallback?: boolean; /** Force intent protocol version for quoting/execution instead of API default selection. */
+  intentProtocolVersion?: IntentProtocolVersion;
+  slippageTolerance?: number | string;
+  priceImpactWarningThresholdBps?: number;
+  priceImpactWarningMessage?: string;
+  priceImpactFallbackBridgeUrl?: string;
+  debug?: boolean;
+  hideAddWallet?: boolean; /** Options for customizing fund mode behavior */
+  fundOptions?: {
+    /** Hide the Swap button in the fund screen header. Default: false */hideSwap?: boolean; /** Array of wallet addresses to hide from the funding wallet selection. */
+    hideWallets?: string[];
+    /**
+     * Ordered list of funding methods to display.
+     *
+     * Supported readable values (mapped internally):
+     * - "connected-wallet"
+     * - "crypto-transfer"
+     * - "cc-onramp"
+     * - "exchange"
+     *
+     * Preferred values: "connected-wallet", "crypto-transfer", "exchange", "cc-onramp".
+     * Legacy alias "exchange-onramp" is still accepted.
+     *
+     * @example ["connected-wallet", "crypto-transfer"]
+     */
+    fundMethodsList?: FundMethodListOption[];
+    /**
+     * If true, methods not in fundMethodsList are hidden.
+     *
+     * If false (default), unlisted methods are shown but disabled.
+     *
+     * Default: false.
+     */
+    hideUnlistedFundMethods?: boolean; /** ISO 4217 currency code to pre-select in onramp mode (e.g. "EUR", "GBP") */
+    fiatCurrency?: string; /** Fiat amount to pre-populate in onramp mode */
+    fiatAmount?: string; /** Meld payment method type to pre-select (e.g. "CREDIT_DEBIT_CARD", "APPLE_PAY", "GOOGLE_PAY", "SEPA", "PAYPAL") */
+    paymentMethodType?: string; /** Mesh exchange key to pre-select (e.g. "coinbase", "robinhoodDirect"). Skips exchange selection screen. */
+    meshExchangeKey?: string;
+  };
+  toast?: boolean;
+  appName?: string;
+  appUrl?: string;
+  appImageUrl?: string;
+  appDescription?: string;
+  payMessage?: string;
+  /**
+   * Optional SVM signing adapter for Solana-origin edge quotes.
+   * This is separate from the EVM wallet runtime used by the rest of the widget.
+   */
+  solanaWallet?: SolanaWalletContextValue | null;
+  isSmartWallet?: boolean;
+  /**
+   * Optional onramp configuration or factory.
+   * If provided, enables exchange funding options in the widget.
+   *
+   * @example
+   * ```tsx
+   * <TrailsWidget
+   *   onramp={{
+   *     mesh: {
+   *       environment: "production",
+   *     },
+   *   }}
+   * />
+   * ```
+   */
+  onramp?: TrailsOnRampConfig | ((handlers: {
+    setCurrentScreen: (screen: Screen) => void;
+    onComplete?: (transferData: OnrampTransferResult) => void;
+    onError?: (error: unknown) => void;
+    onBack?: () => void;
+    toTokenSymbol?: string;
+    toTokenAmount?: string;
+    toChainId?: number;
+    toRecipientAddress?: string;
+    toAmountUsd?: number;
+    selectedExchange?: {
+      integrationId: string;
+      exchangeKey: string;
+      exchangeName: string;
+    };
+    apiKey?: string;
+    hostname?: string;
+  }) => ReactElement);
+};
+//#endregion
+//#region src/widget/widget.d.ts
+interface TrailsWidgetRef {
+  openModal: () => void;
+  closeModal: () => void;
+  isModalOpen: boolean;
+}
+declare const TrailsWidget: React$1.ForwardRefExoticComponent<TrailsWidgetProps & React$1.RefAttributes<TrailsWidgetRef>>;
+declare const createModalController: (ref: React$1.RefObject<TrailsWidgetRef>) => {
+  openModal: () => void;
+  closeModal: () => void;
+  isModalOpen: boolean;
+};
+//#endregion
+//#region src/widget/components/TrailsHookModal.d.ts
+/**
+ * TrailsHookModal is the modal component used by useTrailsSendTransaction.
+ * It consumes a parent wallet runtime when one exists and otherwise falls back
+ * to a widget-owned runtime when available.
+ *
+ * The modal content is wrapped with WidgetProviders to ensure all widget-level
+ * context providers are available, making shared components like ScreenHeader work.
+ */
+declare function TrailsHookModal(): import("react").JSX.Element;
+//#endregion
+//#region src/widget/connect/error/types.d.ts
+type ConnectFailureKind = "user-rejected" | "wallet-not-detected" | "connector-unavailable" | "provider-unauthorized" | "unsupported-method" | "provider-disconnected" | "chain-disconnected" | "wallet-locked" | "walletconnect-expired" | "walletconnect-uri-unavailable" | "walletconnect-pairing-failed" | "deeplink-failed" | "popup-blocked" | "popup-closed" | "unsupported-network" | "switch-network-declined" | "switch-network-unavailable" | "timeout" | "invalid-configuration" | "rate-limited" | "server-unavailable" | "usage-exceeded" | "unknown";
+type ConnectErrorSource = "evm-provider" | "solana-provider" | "walletconnect" | "wallet-registry" | "network-switch" | "trails-api" | "sdk-configuration" | "unknown";
+type ConnectErrorSeverity = "info" | "warning" | "error" | "fatal";
+type SerializedConnectError = {
+  causeMessage?: string;
+  code?: number | string;
+  message: string;
+  name?: string;
+  rawType: string;
+  stack?: string;
+};
+type ConnectWalletDisplay = {
+  ecosystem?: "evm" | "multi" | "solana";
+  icon?: string;
+  id?: string;
+  name?: string;
+};
+type ConnectNetworkDisplay = {
+  currentName?: string;
+  supportedNetworks?: Array<{
+    ecosystem: "evm" | "solana";
+    icon?: string;
+    id: string;
+    name: string;
+  }>;
+  targetName?: string;
+};
+type ConnectErrorViewModel = {
+  debugCode?: string;
+  details?: string;
+  helper?: string;
+  id: string;
+  kind: ConnectFailureKind;
+  message: string;
+  network?: ConnectNetworkDisplay;
+  primaryAction?: "choose-wallet" | "copy-link" | "install-wallet" | "retry" | "support" | "switch-network";
+  retryLabel?: string;
+  serializedError?: SerializedConnectError;
+  severity: ConnectErrorSeverity;
+  source: ConnectErrorSource;
+  title: string;
+  wallet?: ConnectWalletDisplay;
+  walletConnect?: {
+    linkMode?: "desktop" | "mobile" | "qr" | "web";
+    pairingExpiry?: number;
+    uri?: string;
+  };
+};
+//#endregion
+//#region src/widget/connect/errors.d.ts
+type ConnectErrorState = ConnectErrorViewModel & {
+  connectionType?: "evm" | "solana";
+  walletIcon?: string;
+  walletId?: string;
+  walletName?: string;
+};
+//#endregion
+//#region src/widget/connect/types.d.ts
+type ConnectWalletOption = Omit<TrailsUnifiedWalletConnectOption, "variants"> & {
+  disabledReason?: string;
+  variants?: readonly ConnectWalletOption[];
+};
+//#endregion
+//#region src/widget/connect/TrailsConnectWallet.d.ts
+type TrailsConnectWalletInitialPendingWallet = {
+  connectionType?: "evm" | "solana";
+  icon?: string;
+  id: string;
+  name?: string;
+};
+type ConnectedPayload = TrailsWalletConnection | {
+  address?: string;
+  namespace?: "eip155" | "solana";
+  walletId: string;
+};
+type WalletDisabledReasonResolver = (wallet: ConnectWalletOption) => string | undefined;
+interface TrailsConnectWalletProps {
+  className?: string;
+  hideBackButton?: boolean;
+  onBack?: () => void;
+  onClose?: () => void;
+  initialView?: "list" | "walletconnect" | "pending" | "error";
+  initialWalletId?: string;
+  initialPendingWallet?: TrailsConnectWalletInitialPendingWallet;
+  initialError?: ConnectErrorState | null;
+  initialIsConnecting?: boolean;
+  getWalletDisabledReason?: WalletDisabledReasonResolver;
+  onConnected?: (connection: ConnectedPayload) => void;
+  onError?: (error: ConnectErrorState) => void;
+  showFooter?: boolean;
+}
+declare const TrailsConnectWallet: React$1.FC<TrailsConnectWalletProps>;
+//#endregion
+//#region src/widget/connect/TrailsConnectDialog.d.ts
+interface TrailsConnectDialogProps extends Omit<TrailsConnectWalletProps, "className" | "onBack" | "onClose"> {
+  onClose: () => void;
+  open: boolean;
+}
+declare const TrailsConnectDialog: React$1.FC<TrailsConnectDialogProps>;
+//#endregion
+//#region src/widget/shared/methodMap.d.ts
+type FiatPaymentMethod = "CREDIT_DEBIT_CARD";
+type ExchangePaymentMethod = "EXCHANGE";
+type CryptoPaymentMethod = "CONNECTED_WALLET" | "CRYPTO_TRANSFER";
+type PaymentMethod = FiatPaymentMethod | ExchangePaymentMethod | CryptoPaymentMethod;
+//#endregion
+//#region src/widget/shared/types.d.ts
+type SupportedTokensByChain = {
+  chain: ChainIdentifier;
+  tokens: string[];
+};
+type DestinationSupportConfig = {
+  /** Destination chains visible/selectable in the widget. Accepts chain IDs, clear chain names, or viem Chain objects. */supportedChains?: ChainIdentifier[]; /** Destination token allowlist grouped by chain. Tokens can be symbols or contract addresses. */
+  supportedTokensByChain?: SupportedTokensByChain[];
+};
+/**
+ * Locked destination token on an initial destination chain.
+ * `token` is controlled, but `chain` still behaves as the initial chain context.
+ */
+type LockedDestinationToken = {
+  chain: ChainIdentifier; /** Locked destination token (symbol or contract address). */
+  token: string;
+  defaultChain?: never;
+  defaultToken?: never;
+} & DestinationSupportConfig;
+/**
+ * Default destination: chain and token are pre-selected, user can change.
+ * Cannot be combined with chain / token.
+ */
+type DefaultDestination = {
+  defaultChain: ChainIdentifier; /** Pre-selected destination token (user can change). */
+  defaultToken: string;
+  chain?: never;
+  token?: never;
+} & DestinationSupportConfig;
+/**
+ * Initial destination chain with a default destination token.
+ * Both are soft selections: the user can still choose another destination token.
+ */
+type InitialChainWithDefaultToken = {
+  chain: ChainIdentifier; /** Pre-selected destination token (user can change). */
+  defaultToken: string;
+  defaultChain?: never;
+  token?: never;
+} & DestinationSupportConfig;
+/** Destination chain/token config. `token` locks the token; `defaultToken` only preselects it. */
+type DestinationConfig = LockedDestinationToken | DefaultDestination | InitialChainWithDefaultToken;
+/**
+ * Pay is an invoice/request flow: the recipient declares the exact token,
+ * amount, and chain they want to be paid with. Soft destination selection does
+ * not apply here.
+ */
+type PayDestinationConfig = {
+  chain: ChainIdentifier; /** Locked destination token (symbol or contract address). */
+  token: string;
+} & DestinationSupportConfig;
+/**
+ * Strict-crypto origin shape additions that intersect with the `from` shape on
+ * EXCHANGE / CRYPTO / undefined `paymentMethod` arms (NOT the FIAT arm).
+ *
+ * Use `token` to specify the ERC20 source token (symbol or contract address).
+ * `from.currency` is reserved for ISO 4217 fiat codes on the fiat arm only.
+ */
+type CryptoOriginToken = {
+  /** ERC20 token identifier — symbol (e.g. "USDC") or contract address. */token?: string; /** `currency` is reserved for the fiat arm only; explicitly excluded here so TS catches misuse. */
+  currency?: never;
+};
+type OptionalDestinationConfig = ({
+  chain?: ChainIdentifier;
+  token?: string;
+  defaultChain?: never;
+  defaultToken?: never;
+} & DestinationSupportConfig) | ({
+  chain?: ChainIdentifier; /** Pre-selected destination token (user can change). */
+  defaultToken?: string;
+  defaultChain?: never;
+  token?: never;
+} & DestinationSupportConfig) | ({
+  defaultChain?: ChainIdentifier;
+  defaultToken?: string;
+  chain?: never;
+  token?: never;
+} & DestinationSupportConfig);
+type AppMetadata = {
+  name?: string;
+  url?: string;
+  imageUrl?: string;
+  description?: string;
+};
+type DevConfig = {
+  debug?: boolean;
+  toast?: boolean;
+  sequenceIndexerUrl?: string;
+  trailsApiUrl?: string;
+  trailsAppUrl?: string;
+  sequenceNodeGatewayUrl?: string;
+  sequenceMetadataUrl?: string;
+  sequenceApiUrl?: string;
+};
+type SharedWidgetProps = {
+  adapters?: TrailsWidgetProps["adapters"];
+  walletConnectProjectId?: string;
+  renderInline?: boolean;
+  theme?: TrailsWidgetProps["theme"];
+  customCss?: string | Record<string, string>;
+  disableCss?: boolean;
+  swapProvider?: string;
+  bridgeProvider?: string;
+  swapProviderFallback?: boolean;
+  bridgeProviderFallback?: boolean;
+  slippageTolerance?: number | string;
+  priceImpactWarningThresholdBps?: number;
+  priceImpactWarningMessage?: string;
+  priceImpactFallbackBridgeUrl?: string;
+  hideAddWallet?: boolean;
+  isSmartWallet?: boolean; /** Custom CTA button text (e.g. "Deposit Now", "Supply", "Bridge"). */
+  buttonText?: string; /** Force intent protocol version for quoting/execution instead of API default selection. */
+  intentProtocolVersion?: IntentProtocolVersion; /** Solana mainnet JSON-RPC for SDK-initiated reads. Falls back to env, then public default. */
+  solanaRpcUrl?: string;
+  appMetadata?: AppMetadata;
+  dev?: DevConfig;
+  onOpen?: () => void;
+  onClose?: () => void;
+  onOriginConfirmation?: TrailsWidgetProps["onOriginConfirmation"];
+  onDestinationConfirmation?: TrailsWidgetProps["onDestinationConfirmation"];
+  onQuote?: TrailsWidgetProps["onQuote"];
+  onSignRequest?: TrailsWidgetProps["onSignRequest"];
+  onSign?: TrailsWidgetProps["onSign"];
+  onSignReject?: TrailsWidgetProps["onSignReject"];
+  onStatus?: TrailsWidgetProps["onStatus"];
+  onApproveRequest?: TrailsWidgetProps["onApproveRequest"];
+  onApprove?: TrailsWidgetProps["onApprove"];
+  onApproveReject?: TrailsWidgetProps["onApproveReject"];
+  solanaWallet?: TrailsWidgetProps["solanaWallet"];
+};
+//#endregion
+//#region src/widget/shared/resolvePaymentSource.d.ts
+type FiatPaymentSourceFrom = {
+  /** ISO 4217 fiat currency code, e.g. "EUR", "GBP". */currency?: string; /** Fiat amount to charge (human-readable). Accepts `string` or `number`. */
+  amount?: string | number;
+};
+type CryptoPaymentSourceFrom = {
+  /** Source chain — chain ID, name (e.g. "base"), or viem Chain object. */chain: ChainIdentifier; /** Source amount in human-readable units. Accepts `string` or `number`. */
+  amount?: string | number; /** Wallet address to fund from. Defaults to the connected wallet. */
+  walletAddress?: string;
+} & CryptoOriginToken;
+type ExchangePaymentSourceFrom = CryptoPaymentSourceFrom & {
+  /** Mesh exchange key, e.g. "coinbase", "robinhoodDirect". Omit to let the user pick. */exchange?: string;
+};
+type PaymentSourceProps = {
+  /** Fiat on-ramp via credit or debit card. */paymentMethod: FiatPaymentMethod;
+  from?: FiatPaymentSourceFrom;
+} | {
+  /** Fund from a centralised exchange — "EXCHANGE". */paymentMethod: ExchangePaymentMethod;
+  from?: ExchangePaymentSourceFrom;
+} | {
+  /** Crypto transfer from a wallet — "CONNECTED_WALLET". */paymentMethod: CryptoPaymentMethod;
+  from?: CryptoPaymentSourceFrom;
+} | {
+  /** When omitted, all available payment methods are shown. */paymentMethod?: undefined;
+  from?: CryptoPaymentSourceFrom;
+};
+//#endregion
+//#region src/widget/modes/SwapWidget.d.ts
+type SwapPropsCommon = SharedWidgetProps & {
+  /** Trails API key used for authentication. Obtain one from the Trails dashboard. */apiKey: string;
+  to?: {
+    /** Desired output amount in human-readable units. Accepts `string` or `number`. */amount?: string | number; /** Optional low-level ABI-encoded calldata to execute on the destination chain after the swap lands. */
+    calldata?: string;
+  } & OptionalDestinationConfig; /** On-ramp provider configuration forwarded to the internal widget. */
+  onramp?: TrailsWidgetProps["onramp"]; /** Fires when the swap flow completes successfully. */
+  onSwapSuccess?: (data: {
+    sessionId: string;
+  }) => void; /** Fires when the user begins the swap flow. */
+  onSwapStart?: (data: {
+    sessionId: string;
+  }) => void; /** Fires when the swap flow encounters an error. */
+  onSwapError?: (data: {
+    sessionId: string;
+    error: unknown;
+  }) => void;
+};
+type SwapProps = SwapPropsCommon & PaymentSourceProps;
+declare const Swap: import("react").ForwardRefExoticComponent<SwapProps & import("react").RefAttributes<TrailsWidgetRef>>;
+//#endregion
+//#region src/widget/modes/WithdrawWidget.d.ts
+type WithdrawDestinationConfig = {
+  chain?: ChainIdentifier; /** Locked destination token (symbol or contract address). */
+  token?: string;
+  defaultChain?: never;
+  defaultToken?: never;
+} | {
+  chain?: ChainIdentifier; /** Pre-selected destination token (user can change). */
+  defaultToken?: string;
+  defaultChain?: never;
+  token?: never;
+} | {
+  defaultChain?: ChainIdentifier; /** Pre-selected destination token (user can change). */
+  defaultToken?: string;
+  chain?: never;
+  token?: never;
+};
+type WithdrawProps = SharedWidgetProps & {
+  apiKey: string;
+  from?: {
+    /** Source chain — chain ID, name (e.g. "base"), or viem Chain object. */chain?: ChainIdentifier; /** Withdraw amount in human-readable units. Accepts `string` or `number`. */
+    amount?: string | number; /** Wallet address to withdraw from. Defaults to the connected wallet. */
+    walletAddress?: string;
+  } & CryptoOriginToken & DestinationSupportConfig;
+  to?: {
+    /** Wallet address that receives the withdrawn tokens. Defaults to the connected wallet. */recipient?: string; /** Desired output amount in human-readable units. Accepts `string` or `number`. */
+    amount?: string | number; /** Optional low-level ABI-encoded calldata to execute on the destination chain after the withdrawal lands. */
+    calldata?: string;
+  } & WithdrawDestinationConfig; /** Fires when the withdrawal flow completes successfully. */
+  onWithdrawSuccess?: (data: {
+    sessionId: string;
+  }) => void; /** Fires when the user begins the withdrawal flow. */
+  onWithdrawStart?: (data: {
+    sessionId: string;
+  }) => void; /** Fires when the withdrawal flow encounters an error. */
+  onWithdrawError?: (data: {
+    sessionId: string;
+    error: unknown;
+  }) => void;
+};
+declare const Withdraw: import("react").ForwardRefExoticComponent<SharedWidgetProps & {
+  apiKey: string;
+  from?: {
+    /** Source chain — chain ID, name (e.g. "base"), or viem Chain object. */chain?: ChainIdentifier; /** Withdraw amount in human-readable units. Accepts `string` or `number`. */
+    amount?: string | number; /** Wallet address to withdraw from. Defaults to the connected wallet. */
+    walletAddress?: string;
+  } & CryptoOriginToken & DestinationSupportConfig;
+  to?: {
+    /** Wallet address that receives the withdrawn tokens. Defaults to the connected wallet. */recipient?: string; /** Desired output amount in human-readable units. Accepts `string` or `number`. */
+    amount?: string | number; /** Optional low-level ABI-encoded calldata to execute on the destination chain after the withdrawal lands. */
+    calldata?: string;
+  } & WithdrawDestinationConfig; /** Fires when the withdrawal flow completes successfully. */
+  onWithdrawSuccess?: (data: {
+    sessionId: string;
+  }) => void; /** Fires when the user begins the withdrawal flow. */
+  onWithdrawStart?: (data: {
+    sessionId: string;
+  }) => void; /** Fires when the withdrawal flow encounters an error. */
+  onWithdrawError?: (data: {
+    sessionId: string;
+    error: unknown;
+  }) => void;
+} & import("react").RefAttributes<TrailsWidgetRef>>;
+//#endregion
+//#region src/widget/modes/FundWidget.d.ts
+type FundPropsCommon = SharedWidgetProps & {
+  /** Trails API key used for authentication. Obtain one from the Trails dashboard. */apiKey: string;
+  to?: {
+    /** Wallet address that receives the funded tokens. Defaults to the connected wallet. */recipient?: string; /** Optional low-level ABI-encoded calldata to execute on the destination chain after the funding lands. */
+    calldata?: string;
+  } & OptionalDestinationConfig; /** Starting input mode. `"fiat"` shows a USD amount field; `"token"` shows a token amount field. */
+  defaultInputMode?: "fiat" | "token";
+  /**
+   * Funding direction.
+   *
+   * - `"EXACT_INPUT"` (default): the user specifies how much to fund with
+   *   (source amount); the destination amount is computed from the quote.
+   * - `"EXACT_OUTPUT"`: the user specifies how much to receive; the source
+   *   amount is computed from the quote. Only supported for the connected
+   *   wallet payment method — falls back to `"EXACT_INPUT"` for fiat onramps
+   *   and exchange transfers.
+   *
+   * @default "EXACT_INPUT"
+   */
+  type?: "EXACT_INPUT" | "EXACT_OUTPUT"; /** Hide the swap tab in the fund screen header. @default false */
+  hideSwap?: boolean; /** Wallet addresses to exclude from the funding wallet selection list. */
+  hideWallets?: string[];
+  /**
+   * Ordered list of funding methods shown to the user.
+   *
+   * Accepted values: `"connected-wallet"`, `"crypto-transfer"`, `"cc-onramp"`, `"exchange"`.
+   * Legacy alias `"exchange-onramp"` is still accepted.
+   *
+   * @example ["connected-wallet", "cc-onramp"]
+   */
+  fundMethodsList?: FundMethodListOption[];
+  /**
+   * When `true`, methods not listed in `fundMethodsList` are completely hidden.
+   * When `false` (default), unlisted methods are visible but disabled.
+   * @default false
+   */
+  hideUnlistedFundMethods?: boolean; /** On-ramp provider configuration forwarded to the internal widget. */
+  onramp?: TrailsWidgetProps["onramp"]; /** Fires when the funding flow completes successfully. */
+  onFundingSuccess?: (data: {
+    sessionId: string;
+  }) => void; /** Fires when the user begins the funding flow. */
+  onFundingStart?: (data: {
+    sessionId: string;
+  }) => void; /** Fires when the funding flow encounters an error. */
+  onFundingError?: (data: {
+    sessionId: string;
+    error: unknown;
+  }) => void;
+};
+type FundProps = FundPropsCommon & PaymentSourceProps;
+declare const Fund: import("react").ForwardRefExoticComponent<FundProps & import("react").RefAttributes<TrailsWidgetRef>>;
+//#endregion
+//#region src/widget/modes/PayWidget.d.ts
+type PayPropsCommon = SharedWidgetProps & {
+  /** Trails API key used for authentication. Obtain one from the Trails dashboard. */apiKey: string;
+  to: {
+    /** Wallet or contract address that receives the payment. */recipient: string; /** Payment amount in human-readable units (e.g. `"10"` for 10 USDC). Accepts `string` or `number`. */
+    amount: string | number; /** Optional low-level ABI-encoded calldata to execute on the destination chain after the payment lands. */
+    calldata?: string;
+  } & PayDestinationConfig; /** Custom message displayed to the user during the payment flow (e.g. "Pay for order #1234"). */
+  payMessage?: string; /** On-ramp provider configuration forwarded to the internal widget. */
+  onramp?: TrailsWidgetProps["onramp"]; /** Fires when the payment flow completes successfully. */
+  onPaymentSuccess?: (data: {
+    sessionId: string;
+  }) => void; /** Fires when the user begins the payment flow. */
+  onPaymentStart?: (data: {
+    sessionId: string;
+  }) => void; /** Fires when the payment flow encounters an error. */
+  onPaymentError?: (data: {
+    sessionId: string;
+    error: unknown;
+  }) => void;
+};
+type PayProps = PayPropsCommon & PaymentSourceProps;
+declare const Pay: import("react").ForwardRefExoticComponent<PayProps & import("react").RefAttributes<TrailsWidgetRef>>;
+//#endregion
+//#region src/widget/modes/EarnWidget.d.ts
+type EarnDestinationConfig = ({
+  chain?: ChainIdentifier; /** Locked destination token (symbol or contract address). */
+  token?: string;
+  defaultChain?: never;
+  defaultToken?: never;
+} & DestinationSupportConfig) | ({
+  defaultChain?: ChainIdentifier; /** Pre-selected destination token (user can change). */
+  defaultToken?: string;
+  chain?: never;
+  token?: never;
+} & DestinationSupportConfig);
+type EarnPropsCommon = SharedWidgetProps & {
+  /** Trails API key used for authentication. Obtain one from the Trails dashboard. */apiKey: string;
+  to?: {
+    recipient?: string; /** Deposit amount in human-readable units (e.g. `"100"` for 100 USDC). Accepts `string` or `number`. */
+    amount?: string | number; /** Optional low-level ABI-encoded calldata to execute on the `recipient` contract. */
+    calldata?: string;
+  } & EarnDestinationConfig; /** On-ramp provider configuration forwarded to the internal widget. */
+  onramp?: TrailsWidgetProps["onramp"]; /** Fires when the earn deposit flow completes successfully. */
+  onEarnSuccess?: (data: {
+    sessionId: string;
+  }) => void; /** Fires when the user begins the earn deposit flow. */
+  onEarnStart?: (data: {
+    sessionId: string;
+  }) => void; /** Fires when the earn deposit flow encounters an error. */
+  onEarnError?: (data: {
+    sessionId: string;
+    error: unknown;
+  }) => void;
+};
+type EarnProps = EarnPropsCommon & PaymentSourceProps;
+declare const Earn: import("react").ForwardRefExoticComponent<EarnProps & import("react").RefAttributes<TrailsWidgetRef>>;
+//#endregion
+//#region src/widget/shared/resolution.d.ts
+declare function resolveTokenAddress(tokenOrAddress: string, chainId: number): string;
+//#endregion
+//#region src/utils/tokenResolution.d.ts
+type ResolvedTokenInput = {
+  address: string;
+  token: Token$1 | null;
+};
+/**
+ * Resolves a token input (address or symbol) to a contract address and optional token metadata.
+ *
+ * - Address inputs pass through and are optionally enriched from the token catalog.
+ * - Symbol inputs are looked up case-insensitively in the token catalog for the chain.
+ * - Native currency symbols resolve to the zero address.
+ */
+declare function resolveTokenInput(tokenInput: string, chainId: number, trailsSupportedTokens: readonly Token$1[]): ResolvedTokenInput | null;
+//#endregion
+export { WrappedTrailsAdapterEntry as $, TrailsWidget as A, getActiveMeshMode as B, PaymentMethod as C, TrailsConnectWalletInitialPendingWallet as D, TrailsConnectWallet as E, WidgetFundMethod as F, SequenceEnv as G, useTrailsOnRamp as H, MeshConfig as I, TrailsAdapterManagedBy as J, TrailsAdapterConfig as K, TrailsOnRampConfig as L, createModalController as M, FundMethodListOption as N, TrailsConnectWalletProps as O, TrailsWidgetProps as P, TrailsProviderConfig as Q, TrailsOnRampProvider as R, FiatPaymentMethod as S, TrailsConnectDialogProps as T, EvmAdapterOptions as U, isMeshEnabled as V, evmAdapter as W, TrailsConfig as X, TrailsAdapterProviderProps as Y, TrailsProvider as Z, DevConfig as _, Earn as a, TrailsWaasFeeOptionsControllerValue as at, CryptoPaymentMethod as b, PayProps as c, TrailsModalProvider as ct, Withdraw as d, useTrails as et, WithdrawProps as f, DestinationConfig as g, AppMetadata as h, resolveTokenAddress as i, TrailsWaasFeeOptionsControllerProps as it, TrailsWidgetRef as j, TrailsHookModal as k, Fund as l, useTrailsModal as lt, SwapProps as m, ResolvedTokenInput as n, TrailsSequenceSupportConfig as nt, EarnProps as o, ModalSelectionParams as ot, Swap as p, TrailsAdapterEntry as q, resolveTokenInput as r, TrailsWaasFeeOptionConfirmation as rt, Pay as s, TrailsModalContextType as st, useWalletSession$1 as t, TrailsSequenceSupport as tt, FundProps as u, OptionalDestinationConfig as v, TrailsConnectDialog as w, ExchangePaymentMethod as x, SharedWidgetProps as y, TrailsOnRampProviderProps as z };