0xtrails 0.16.1 → 0.17.0

package/dist/offlineRecovery-BfgccnFf.d.ts

@@ -0,0 +1,1232 @@
+import { f as Call$1, h as ChainIdentifier, r as ActionItem } from "./types-BK0WkVnx.js";
+import { a as GetProvidersParams, f as getEarnBalances, m as getEarnProviders, p as getEarnMarkets, r as GetMarketsParams, v as EarnBalanceQuery } from "./utils-KPnWBA9x.js";
+import { t as Token$1 } from "./tokenTypes-D812t5L9.js";
+import { t as QuoteError } from "./quoteError-CmTH5Qm2.js";
+import { C as SwapReturn, D as ChainIdentifier$1, F as Chain$1, S as QuoteTo, st as IntentTransaction$1, w as UseQuoteProps, x as QuoteFrom } from "./useViewManager-BeUH_k1s.js";
+import { Config, Context, GenericTree, Payload, Signature } from "@0xsequence/wallet-primitives";
+import { DepositSignature, Intent, IntentReceipt, IntentStatus, Token, TokenPrice, TrailsApi } from "@0xtrails/api";
+import { Chain, PublicClient, TransactionReceipt, WalletClient } from "viem";
+import { UseQueryResult } from "@tanstack/react-query";
+import { Address, Hex } from "ox";
+import { NativeTokenBalance, Page, SequenceIndexerGateway, TokenBalance as TokenBalance$1 } from "@0xsequence/indexer";
+import { GetMeldServiceProvidersRequest, TrailsOnrampRpcClient } from "@0xtrails/api/onramp";
+
+//#region src/trailsClient.d.ts
+type TrailsClientConfig = {
+  apiKey: string;
+  jwt?: string;
+  hostname?: string;
+};
+declare class TrailsClient extends TrailsApi {}
+declare function getTrailsClient({
+  apiKey,
+  jwt,
+  hostname
+}: TrailsClientConfig): TrailsClient;
+declare const useTrailsClient: (configOverride?: Partial<TrailsClientConfig>) => TrailsClient;
+//#endregion
+//#region src/intentReceiptMonitor.d.ts
+type IntentReceiptStatus = {
+  intentReceipt: IntentReceipt | null;
+  done: boolean;
+  isLoading: boolean;
+  isError: boolean;
+  error: Error | null;
+};
+/**
+ * Hook to monitor intent execution status using the WaitIntentReceipt API.
+ * This replaces the old useMetaTxnsMonitor approach which polled individual meta-transactions.
+ *
+ * The WaitIntentReceipt API is a long-polling endpoint that:
+ * - Blocks up to 28 seconds waiting for status changes
+ * - Returns unified status for both origin and destination transactions
+ * - Sets done=true when intent reaches terminal status (SUCCEEDED or FAILED)
+ *
+ * @param intentId - The intent ID to monitor (usually committedOriginIntentAddress)
+ * @param trailsClient - TrailsClient instance for API calls
+ * @returns IntentReceiptStatus with current receipt, done flag, and loading states
+ */
+declare const useIntentReceiptMonitor: (intentId: string | undefined, trailsClient: TrailsClient) => IntentReceiptStatus;
+//#endregion
+//#region src/hooks/useTrailsSendTransaction.d.ts
+/**
+ * Origin (source) descriptor for a send.
+ *
+ * This is `useQuote`'s `QuoteFrom` verbatim, so the programmatic hook and the
+ * declarative widget mode wrappers (`<Fund>`, `<Pay>`, `<Earn>` `from`) share
+ * one shape (`chain`, `token`, `amount`). `amount` is a human-readable decimal
+ * string; `amountRaw`/`decimals` cover callers that already hold smallest-unit
+ * values.
+ *
+ * Note: there is no per-`from` wallet override here (the widget's
+ * `from.walletAddress`). This hook signs with the connected Trails wallet
+ * client. When no `from` is provided and `TrailsProvider` uses the built-in
+ * wallet runtime, the modal prompts the user to connect before token selection.
+ *
+ * Optional on `sendTransaction`: when omitted, the Trails modal opens so the
+ * user can choose the origin token, chain, and (for EXACT_INPUT) amount.
+ */
+type TrailsSendTransactionSource = QuoteFrom;
+/**
+ * Destination descriptor for a send.
+ *
+ * This is `useQuote`'s `QuoteTo` verbatim, shared with the widget mode
+ * wrappers' `to` object (`chain`, `token`, `recipient`, `calldata`).
+ *
+ * - `chain` is the destination chain. **Composable `actions` always execute on
+ *   this chain.**
+ * - `amount` (or `amountRaw`) makes the send EXACT_OUTPUT: the recipient
+ *   receives exactly this amount and the modal only needs origin token
+ *   selection. Omit it for EXACT_INPUT, where the modal also collects the
+ *   origin amount. `amount` is a human-readable decimal string.
+ * - Native tokens: pass the native symbol (e.g. `"ETH"`) or the zero address
+ *   as `token`.
+ */
+type TrailsSendTransactionDestination = QuoteTo;
+type TrailsSendTransactionVariables = {
+  /**
+   * Origin token/chain/amount. Omit to let the user pick the payment token in
+   * the Trails modal.
+   */
+  from?: TrailsSendTransactionSource; /** Destination token, chain, recipient, and optional receive amount. */
+  to: TrailsSendTransactionDestination;
+};
+type UseTrailsSendTransactionParameters = Omit<UseQuoteProps, "from" | "to" | "walletClient" | "selectedFeeOption"> & {
+  /**
+   * When `true` (default), and the quoted intent offers ERC-20 gas-fee tokens on
+   * an EVM origin chain, the modal shows a gas-fee selector on the confirmation
+   * screen so the user can choose to pay gas in a non-native token (e.g. USDC)
+   * before signing. Set to `false` to skip the selector and always pay native
+   * gas (the previous behavior).
+   */
+  showFeeOptions?: boolean;
+  /**
+   * Callback fired when the mutation is successful
+   */
+  onSuccess?: (data: SwapReturn, variables: TrailsSendTransactionVariables) => void;
+  /**
+   * Callback fired when the mutation encounters an error
+   */
+  onError?: (error: Error, variables: TrailsSendTransactionVariables) => void;
+  /**
+   * Callback fired when the mutation is either successfully fetched or encounters an error
+   */
+  onSettled?: (data: SwapReturn | undefined, error: Error | null, variables: TrailsSendTransactionVariables) => void;
+  /**
+   * Custom text for the receipt action button (default: "Transact Again")
+   */
+  receiptActionButtonText?: string;
+  /**
+   * Custom callback when receipt action button is clicked
+   */
+  onReceiptAction?: () => void;
+};
+type UseTrailsSendTransactionReturnType = {
+  sendTransaction: (variables: TrailsSendTransactionVariables, callbacks?: {
+    onSuccess?: (data: SwapReturn) => void;
+    onError?: (error: Error) => void;
+    onSettled?: (data: SwapReturn | undefined, error: Error | null) => void;
+  }) => void;
+  sendTransactionAsync: (variables: TrailsSendTransactionVariables, callbacks?: {
+    onSuccess?: (data: SwapReturn) => void;
+    onError?: (error: Error) => void;
+    onSettled?: (data: SwapReturn | undefined, error: Error | null) => void;
+  }) => Promise<SwapReturn>;
+  retry: () => void;
+  data: SwapReturn | undefined;
+  error: Error | null;
+  isPending: boolean;
+  isSuccess: boolean;
+  isError: boolean;
+  isIdle: boolean;
+  status: "idle" | "pending" | "error" | "success";
+  reset: () => void;
+  variables: TrailsSendTransactionVariables | undefined;
+};
+/**
+ * Hook for creating, signing, and sending transactions with the Trails SDK.
+ *
+ * `sendTransaction` is destination-first: you describe what the recipient
+ * should receive (`to`) and, optionally, how to pay for it (`from`). When
+ * `from` is omitted, the Trails modal opens so the user can pick the origin
+ * token, chain, and (for EXACT_INPUT) amount. When `to.amount` is provided,
+ * the send is EXACT_OUTPUT and the modal only needs origin token selection.
+ *
+ * Composable `actions` (configured on the hook) always execute on `to.chain`.
+ *
+ * Unlike `useQuote`, this hook cannot run as a disconnected preview: execution
+ * requires a connected wallet client with an account.
+ *
+ * @example
+ * ```ts
+ * const { sendTransaction } = useTrailsSendTransaction()
+ *
+ * // Native send (origin picked in the modal)
+ * sendTransaction({
+ *   to: { chain: "base", token: "ETH", recipient: "0x…", amount: "0.01" },
+ * })
+ *
+ * // Pay exactly 25 USDC on Polygon, user chooses the payment token
+ * sendTransaction({
+ *   to: { chain: "polygon", token: "USDC", recipient: "0x…", amount: "25" },
+ * })
+ *
+ * // Fully specified origin + destination (no modal when balance is sufficient)
+ * sendTransaction({
+ *   from: { chain: "base", token: "USDC", amount: "30" },
+ *   to: { chain: "polygon", token: "USDC", recipient: "0x…" },
+ * })
+ * ```
+ */
+declare function useTrailsSendTransaction(params?: UseTrailsSendTransactionParameters): UseTrailsSendTransactionReturnType;
+//#endregion
+//#region src/hooks/useGetIntent.d.ts
+interface UseGetIntentParams {
+  intentId: string | undefined;
+  enabled?: boolean;
+}
+interface UseGetIntentReturn {
+  intent: Intent | null;
+  isLoading: boolean;
+  isError: boolean;
+  error: Error | null;
+  refetch: () => Promise<void>;
+}
+/**
+ * Hook to fetch intent data from the Trails API
+ * @param params - Object containing intentId and optional enabled flag
+ * @returns Intent data, loading state, error state, and refetch function
+ */
+declare function useGetIntent({
+  intentId,
+  enabled
+}: UseGetIntentParams): UseGetIntentReturn;
+//#endregion
+//#region src/hooks/useIntentTransactionHistory.d.ts
+type UseIntentTransactionHistoryParams = {
+  accountAddress?: string;
+  edgeAddress?: string;
+  pageSize?: number;
+  enabled?: boolean;
+  refetchInterval?: number | false;
+  intentStatuses?: string[];
+};
+type UseIntentTransactionHistoryReturn = {
+  transactions: IntentTransaction$1[];
+  loading: boolean;
+  error: string | null;
+  isOffline: boolean;
+  refetch: () => Promise<void>;
+  loadMore: () => void;
+  hasMore: boolean;
+  page: number;
+  nextPage: () => void;
+  prevPage: () => void;
+  hasPrev: boolean;
+  totalPages?: number;
+  resetPagination: () => void;
+};
+declare function useIntentTransactionHistory({
+  accountAddress,
+  edgeAddress,
+  pageSize,
+  enabled,
+  refetchInterval,
+  intentStatuses
+}: UseIntentTransactionHistoryParams): UseIntentTransactionHistoryReturn;
+//#endregion
+//#region src/mutations.d.ts
+/**
+ * Hook for committing an intent to the Trails API
+ * Wraps trailsClient.commitIntent with mutation state and analytics tracking
+ */
+declare function useCommitIntent(): import("@tanstack/react-query").UseMutationResult<import("@0xtrails/api").CommitIntentResponse, Error, Intent, unknown>;
+/**
+ * Hook for executing an intent
+ * Wraps trailsClient.executeIntent with mutation state and analytics tracking
+ */
+declare function useExecuteIntent(): import("@tanstack/react-query").UseMutationResult<{
+  intentId: string;
+  intentStatus: IntentStatus;
+}, Error, {
+  intentId: string;
+  depositTransactionHash?: string;
+  depositSignature?: DepositSignature;
+}, unknown>;
+//#endregion
+//#region src/actions/hooks/useEarnMarkets.d.ts
+type UseEarnMarketsParams = GetMarketsParams;
+type UseEarnMarketsReturn = {
+  data: Awaited<ReturnType<typeof getEarnMarkets>>["items"] | undefined;
+  total: number;
+  offset: number;
+  limit: number;
+  isLoading: boolean;
+  error: Error | null;
+  refetch: () => void;
+};
+/**
+ * React Query hook for discovering earn markets usable by `lend` and
+ * `deposit` actions.
+ *
+ * Use the returned market `id` as the action `marketId`.
+ *
+ * @example
+ * ```ts
+ * const { data: markets } = useEarnMarkets({
+ *   chain: "base",
+ *   type: "lending",
+ *   provider: "aave",
+ *   search: "USDC",
+ * })
+ * ```
+ */
+declare function useEarnMarkets(params: UseEarnMarketsParams): UseEarnMarketsReturn;
+//#endregion
+//#region src/actions/hooks/useEarnBalances.d.ts
+type UseEarnBalancesBaseParams = {
+  walletAddress: string;
+  marketId?: string;
+  arguments?: EarnBalanceQuery["arguments"];
+  enabled?: boolean;
+};
+type UseEarnBalancesSingleChainParams = UseEarnBalancesBaseParams & {
+  chain: ChainIdentifier$1;
+  chains?: never;
+};
+type UseEarnBalancesMultiChainParams = UseEarnBalancesBaseParams & {
+  chains: ChainIdentifier$1[];
+  chain?: never;
+};
+type UseEarnBalancesParams = UseEarnBalancesSingleChainParams | UseEarnBalancesMultiChainParams;
+type UseEarnBalancesReturn = {
+  data: Awaited<ReturnType<typeof getEarnBalances>>["items"] | undefined;
+  errors: Awaited<ReturnType<typeof getEarnBalances>>["errors"];
+  isLoading: boolean;
+  error: Error | null;
+  refetch: () => void;
+};
+/**
+ * React Query hook for fetching a wallet's earn balances.
+ *
+ * Use `chain` for a single chain or `chains` to batch multiple chains into
+ * one aggregate balances request. `marketId` narrows the lookup to one market.
+ *
+ * @example
+ * ```ts
+ * const { data: balances } = useEarnBalances({
+ *   walletAddress,
+ *   chain: "polygon",
+ *   marketId: "polygon-usdc-aave-v3-lending",
+ * })
+ *
+ * const { data: multiChainBalances } = useEarnBalances({
+ *   walletAddress,
+ *   chains: ["polygon", "ethereum", "base"],
+ * })
+ * ```
+ */
+declare function useEarnBalances(params: UseEarnBalancesParams): UseEarnBalancesReturn;
+//#endregion
+//#region src/actions/hooks/useEarnProviders.d.ts
+type UseEarnProvidersParams = GetProvidersParams;
+type UseEarnProvidersReturn = {
+  data: Awaited<ReturnType<typeof getEarnProviders>>["items"] | undefined;
+  total: number;
+  offset: number;
+  limit: number;
+  isLoading: boolean;
+  error: Error | null;
+  refetch: () => void;
+};
+/**
+ * React Query hook for fetching earn providers supported by the Trails API.
+ *
+ * Use provider IDs from this hook to filter `useEarnMarkets({ provider })`.
+ */
+declare function useEarnProviders(params?: UseEarnProvidersParams): UseEarnProvidersReturn;
+//#endregion
+//#region src/actions/hooks/useResolveActions.d.ts
+type UseResolveActionsProps = {
+  actions: ActionItem[];
+  chainId: number | undefined;
+  destinationChain: ChainIdentifier;
+  userWalletAddress: `0x${string}` | undefined;
+  trailsClient: TrailsClient | null;
+  publicClient: PublicClient | null;
+};
+type UseResolveActionsReturn = {
+  calls: Call$1[] | null;
+  isLoading: boolean;
+  error: QuoteError | null;
+};
+declare function useResolveActions(props: UseResolveActionsProps): UseResolveActionsReturn;
+//#endregion
+//#region src/solana/solanaJsonRpcUrl.d.ts
+/**
+ * Solana **mainnet-beta** HTTP JSON-RPC only.
+ *
+ * Do not pass these URLs to viem/wagmi EVM transports. Use {@link getChainRpcClient} only for
+ * numeric EVM chain IDs. For SPL reads, Relay edge, or wallet-backed Solana flows, resolve URLs
+ * with {@link resolveSolanaMainnetJsonRpcUrl} or {@link getEdgeSolanaRpcUrls}.
+ */
+/** Public default (rate-limited); prefer wallet or edge `rpcUrl` when available. */
+declare const PUBLIC_SOLANA_MAINNET_JSON_RPC = "https://api.mainnet-beta.solana.com";
+/** Accepted shapes for configuring Solana RPC endpoints (single or ordered list). */
+type SolanaRpcUrlInput = string | readonly string[] | null | undefined;
+/** @deprecated Use {@link SolanaRpcUrlInput}. */
+type SolanaRpcInput = SolanaRpcUrlInput;
+/**
+ * Resolves the HTTP endpoint for Solana JSON-RPC (`getTokenAccountsByOwner`, etc.).
+ * When an edge or wallet provides an RPC URL, that value wins so traffic is not mixed with EVM config.
+ */
+declare function resolveSolanaMainnetJsonRpcUrl(preferredHttpRpc?: string | null): string;
+/**
+ * Resolves an ordered list of Solana mainnet RPC endpoints.
+ *
+ * Callers may provide multiple endpoints; the SDK appends only the Solana public
+ * mainnet endpoint as the final default fallback.
+ */
+declare function resolveSolanaMainnetJsonRpcUrls(preferredHttpRpc?: SolanaRpcInput): string[];
+/**
+ * Same as {@link resolveSolanaMainnetJsonRpcUrls} — explicit name for edge / SVM wallet wiring.
+ */
+declare function getEdgeSolanaRpcUrls(edgeOrWalletRpcUrls?: SolanaRpcInput): string[];
+/** @deprecated Use {@link getEdgeSolanaRpcUrls}. */
+declare function getEdgeSolanaRpcUrl(edgeOrWalletRpcUrl?: string | null): string;
+//#endregion
+//#region src/query/balance.fetchers.d.ts
+/**
+ * Flat balance data for a single account using Token type (converted from raw gateway data)
+ */
+type FlatTokenBalancesData = {
+  /** All tokens (native + ERC20) converted to Token type */tokens: Token$1[]; /** Native tokens only (converted to Token type) */
+  nativeTokens: Token$1[]; /** ERC20 tokens only (converted to Token type) */
+  erc20Tokens: Token$1[];
+  page: Page;
+};
+type GetTokenBalancesForMultipleAccountsReturn = {
+  [account: string]: FlatTokenBalancesData;
+};
+type GetTokenBalancesWithPriceReturn = {
+  balances: Token$1[];
+};
+type FetchTokenBalanceOnchainReturn = {
+  token: Token$1;
+};
+/**
+ * Checks if a specific token has sufficient balance for a given amount.
+ * Pure function — no queryClient, no React.
+ *
+ * `amount` accepts either:
+ * - a human-readable decimal string (e.g. `"1.5"`) — scaled via `parseUnits`
+ *   using the balance's decimals
+ * - a `bigint` raw wei value — compared directly against the on-chain
+ *   balance, no decimals lookup required
+ */
+declare function checkSufficientToken(balances: Token$1[], token: string, amount: string | bigint, chainId: number): boolean;
+//#endregion
+//#region src/query/balance.hooks.d.ts
+declare const MIN_REFETCH_INTERVAL: number;
+type UseTokenBalancesOptions = {
+  disabled?: boolean;
+  page?: number;
+  pageSize?: number;
+  refetchInterval?: number | false;
+  includeAllChains?: boolean;
+};
+declare function useTokenBalances(address: Address.Address | null, _tokenAddress?: string | null | undefined, options?: UseTokenBalancesOptions): {
+  isLoadingBalances: boolean;
+  isLoadingPrices: boolean;
+  isLoadingSortedTokens: boolean;
+  balanceError: Error | null;
+  sortedTokens: Token$1[];
+  refetch: () => Promise<void>;
+};
+type TokenBalancesForAccount = {
+  tokenBalancesData: FlatTokenBalancesData | undefined;
+  isLoading: boolean;
+  error: Error | null;
+};
+type UseTokenBalancesForMultipleAccountsReturn = {
+  /** Per-account token balances data, keyed by lowercase address */balancesByAccount: {
+    [account: string]: TokenBalancesForAccount;
+  }; /** Combined loading state - true if any account is loading */
+  isLoading: boolean; /** Combined error - first error encountered */
+  error: Error | null; /** Refetch function to manually trigger balance updates */
+  refetch: () => Promise<void>;
+};
+/**
+ * Hook to fetch token balances for multiple accounts in a single API call
+ * This is more efficient than calling useTokenBalances multiple times
+ */
+declare function useTokenBalancesForMultipleAccounts(addresses: (Address.Address | null)[], options?: {
+  page?: number;
+  pageSize?: number;
+  refetchInterval?: number;
+  staleTime?: number;
+}): UseTokenBalancesForMultipleAccountsReturn;
+type UseHasSufficientBalanceTokenParams = {
+  account?: string | null;
+  token?: string | null;
+  amount?: string | null;
+  chainId?: number | null;
+};
+type UseHasSufficientBalanceUsdParams = {
+  account?: string | null;
+  targetAmountUsd?: number | string | null;
+};
+declare function useHasSufficientBalanceToken({
+  account,
+  token,
+  amount,
+  chainId
+}: UseHasSufficientBalanceTokenParams): UseQueryResult<boolean, Error>;
+declare function useHasSufficientBalanceUsd({
+  account,
+  targetAmountUsd
+}: UseHasSufficientBalanceUsdParams): UseQueryResult<boolean, Error>;
+declare function useAccountTotalBalanceUsd(account: string | null): UseQueryResult<number, Error>;
+//#endregion
+//#region src/query/token.hooks.d.ts
+type TokenImageParams = {
+  chainId?: number;
+  contractAddress?: string;
+  symbol?: string;
+  fallbackImageUrl?: string;
+};
+declare function useSupportedTokens({
+  chainId,
+  disabled
+}?: {
+  chainId?: number;
+  disabled?: boolean;
+}): {
+  supportedTokens: Token$1[];
+  isLoadingTokens: boolean;
+  refetch: () => Promise<void>;
+};
+declare function useTokenAddress({
+  chainId,
+  tokenSymbol
+}: {
+  chainId?: number | null;
+  tokenSymbol?: string | null;
+}): string | null;
+declare function useTokenList(): {
+  tokens: Token$1[];
+  isLoadingTokens: boolean;
+};
+declare function useGetTokenImageUrl(): {
+  getTokenImageUrl: (params: TokenImageParams) => string;
+};
+declare function useGetSequenceMetadataTokenImageUrl(): {
+  getSequenceMetadataTokenImageUrl: (params: TokenImageParams & {
+    chainId: number;
+    contractAddress: string;
+  }) => string;
+};
+declare function useTokenInfo({
+  address,
+  chainId
+}: {
+  address: string;
+  chainId?: number;
+}): {
+  tokenInfo: Token$1 | null;
+  isLoading: boolean;
+  error: Error | null;
+};
+//#endregion
+//#region src/query/price.hooks.d.ts
+declare function useTokenPrices(tokens: Token[], disabled?: boolean): {
+  tokenPrices: NoInfer<import("@0xtrails/api").TokenPrice[]> | undefined;
+  isLoadingTokenPrices: boolean;
+  data: NoInfer<import("@0xtrails/api").TokenPrice[]>;
+  error: Error;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: true;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "error";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<import("@0xtrails/api").TokenPrice[]>, Error>>;
+  fetchStatus: import("@tanstack/react-query").FetchStatus;
+  promise: Promise<NoInfer<import("@0xtrails/api").TokenPrice[]>>;
+} | {
+  tokenPrices: NoInfer<import("@0xtrails/api").TokenPrice[]> | undefined;
+  isLoadingTokenPrices: boolean;
+  data: NoInfer<import("@0xtrails/api").TokenPrice[]>;
+  error: null;
+  isError: false;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: false;
+  status: "success";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<import("@0xtrails/api").TokenPrice[]>, Error>>;
+  fetchStatus: import("@tanstack/react-query").FetchStatus;
+  promise: Promise<NoInfer<import("@0xtrails/api").TokenPrice[]>>;
+} | {
+  tokenPrices: NoInfer<import("@0xtrails/api").TokenPrice[]> | undefined;
+  isLoadingTokenPrices: boolean;
+  data: undefined;
+  error: Error;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: true;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "error";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<import("@0xtrails/api").TokenPrice[]>, Error>>;
+  fetchStatus: import("@tanstack/react-query").FetchStatus;
+  promise: Promise<NoInfer<import("@0xtrails/api").TokenPrice[]>>;
+} | {
+  tokenPrices: NoInfer<import("@0xtrails/api").TokenPrice[]> | undefined;
+  isLoadingTokenPrices: boolean;
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoading: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "pending";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<import("@0xtrails/api").TokenPrice[]>, Error>>;
+  fetchStatus: import("@tanstack/react-query").FetchStatus;
+  promise: Promise<NoInfer<import("@0xtrails/api").TokenPrice[]>>;
+} | {
+  tokenPrices: NoInfer<import("@0xtrails/api").TokenPrice[]> | undefined;
+  isLoadingTokenPrices: boolean;
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "pending";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isLoading: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<import("@0xtrails/api").TokenPrice[]>, Error>>;
+  fetchStatus: import("@tanstack/react-query").FetchStatus;
+  promise: Promise<NoInfer<import("@0xtrails/api").TokenPrice[]>>;
+} | {
+  tokenPrices: NoInfer<import("@0xtrails/api").TokenPrice[]> | undefined;
+  isLoadingTokenPrices: boolean;
+  data: NoInfer<import("@0xtrails/api").TokenPrice[]>;
+  isError: false;
+  error: null;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: true;
+  status: "success";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<import("@0xtrails/api").TokenPrice[]>, Error>>;
+  fetchStatus: import("@tanstack/react-query").FetchStatus;
+  promise: Promise<NoInfer<import("@0xtrails/api").TokenPrice[]>>;
+};
+declare function useTokenPrice(token?: Token | null): {
+  tokenPrice: NoInfer<import("@0xtrails/api").TokenPrice | null> | undefined;
+  isLoadingTokenPrice: boolean;
+  data: NoInfer<import("@0xtrails/api").TokenPrice | null>;
+  error: Error;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: true;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "error";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<import("@0xtrails/api").TokenPrice | null>, Error>>;
+  fetchStatus: import("@tanstack/react-query").FetchStatus;
+  promise: Promise<NoInfer<import("@0xtrails/api").TokenPrice | null>>;
+} | {
+  tokenPrice: NoInfer<import("@0xtrails/api").TokenPrice | null> | undefined;
+  isLoadingTokenPrice: boolean;
+  data: NoInfer<import("@0xtrails/api").TokenPrice | null>;
+  error: null;
+  isError: false;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: false;
+  status: "success";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<import("@0xtrails/api").TokenPrice | null>, Error>>;
+  fetchStatus: import("@tanstack/react-query").FetchStatus;
+  promise: Promise<NoInfer<import("@0xtrails/api").TokenPrice | null>>;
+} | {
+  tokenPrice: NoInfer<import("@0xtrails/api").TokenPrice | null> | undefined;
+  isLoadingTokenPrice: boolean;
+  data: undefined;
+  error: Error;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: true;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "error";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<import("@0xtrails/api").TokenPrice | null>, Error>>;
+  fetchStatus: import("@tanstack/react-query").FetchStatus;
+  promise: Promise<NoInfer<import("@0xtrails/api").TokenPrice | null>>;
+} | {
+  tokenPrice: NoInfer<import("@0xtrails/api").TokenPrice | null> | undefined;
+  isLoadingTokenPrice: boolean;
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoading: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "pending";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<import("@0xtrails/api").TokenPrice | null>, Error>>;
+  fetchStatus: import("@tanstack/react-query").FetchStatus;
+  promise: Promise<NoInfer<import("@0xtrails/api").TokenPrice | null>>;
+} | {
+  tokenPrice: NoInfer<import("@0xtrails/api").TokenPrice | null> | undefined;
+  isLoadingTokenPrice: boolean;
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "pending";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isLoading: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<import("@0xtrails/api").TokenPrice | null>, Error>>;
+  fetchStatus: import("@tanstack/react-query").FetchStatus;
+  promise: Promise<NoInfer<import("@0xtrails/api").TokenPrice | null>>;
+} | {
+  tokenPrice: NoInfer<import("@0xtrails/api").TokenPrice | null> | undefined;
+  isLoadingTokenPrice: boolean;
+  data: NoInfer<import("@0xtrails/api").TokenPrice | null>;
+  isError: false;
+  error: null;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: true;
+  status: "success";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<import("@0xtrails/api").TokenPrice | null>, Error>>;
+  fetchStatus: import("@tanstack/react-query").FetchStatus;
+  promise: Promise<NoInfer<import("@0xtrails/api").TokenPrice | null>>;
+};
+//#endregion
+//#region src/query/chains.hooks.d.ts
+declare function useSupportedChains(): import("@tanstack/react-query").UseQueryResult<NoInfer<Chain$1[]>, Error>;
+declare function usePublicClientGetter(): (chainId: number, retryCount?: number) => PublicClient | null;
+declare function usePublicClient(chainId?: number): PublicClient | null;
+//#endregion
+//#region src/indexerClient.d.ts
+declare function useIndexerGatewayClient(): SequenceIndexerGateway;
+//#endregion
+//#region src/query/geo.hooks.d.ts
+declare function useCountryCode(options?: {
+  enabled?: boolean;
+}): import("@tanstack/react-query").UseQueryResult<string, Error>;
+declare function useCountryList(): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@0xtrails/api").Country[]>, Error>;
+//#endregion
+//#region src/query/fiat.hooks.d.ts
+declare function useFiatCurrencyList(): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@0xtrails/api").FiatCurrency[]>, Error>;
+interface UseExchangeRateOptions {
+  fromCurrency?: string;
+  toCurrency?: string;
+  disabled?: boolean;
+}
+interface UseExchangeRateResult {
+  exchangeRate: number | undefined;
+  isLoading: boolean;
+  error: Error | null;
+}
+/**
+ * Fetch the exchange rate between two currencies.
+ * Handles same-currency (returns 1) and direction inversion (X→USD = 1/rate).
+ */
+declare function useExchangeRate(options?: UseExchangeRateOptions): UseExchangeRateResult;
+//#endregion
+//#region src/query/meld.hooks.d.ts
+declare function useMeldPaymentMethods(fiatCurrency?: string): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@0xtrails/api/onramp").MeldPaymentMethod[]>, Error>;
+declare function useMeldServiceProviders(options?: Partial<GetMeldServiceProvidersRequest>): import("@tanstack/react-query").UseQueryResult<NoInfer<import("@0xtrails/api/onramp").MeldServiceProvider[]>, Error>;
+//#endregion
+//#region src/onramp-client/index.d.ts
+interface TrailsOnrampOptions {
+  apiKey?: string;
+  jwt?: string;
+  hostname?: string;
+}
+declare class TrailsOnramp extends TrailsOnrampRpcClient {
+  static fromTrailsApiClient(client: TrailsApi): TrailsOnramp;
+  constructor(apiKey: string, options?: TrailsOnrampOptions);
+}
+//#endregion
+//#region src/onrampClient.d.ts
+type OnrampClientConfig = {
+  apiKey: string;
+  jwt?: string;
+  hostname?: string;
+};
+declare function getOnrampClient({
+  apiKey,
+  jwt,
+  hostname
+}: OnrampClientConfig): TrailsOnramp;
+declare const useOnrampClient: (configOverride?: Partial<OnrampClientConfig>) => TrailsOnramp;
+//#endregion
+//#region src/keymachine/key-machine.gen.d.ts
+type Fetch = (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+//#endregion
+//#region src/keymachine/index.d.ts
+declare class KeyMachine {
+  private readonly service;
+  constructor(host?: string, fetcher?: Fetch);
+  getConfiguration(imageHash: Hex.Hex): Promise<Config.Config | undefined>;
+  getDeploy(wallet: Address.Address): Promise<{
+    imageHash: Hex.Hex;
+    context: Context.Context;
+  } | undefined>;
+  getTree(rootHash: Hex.Hex): Promise<GenericTree.Tree | undefined>;
+}
+//#endregion
+//#region src/keyMachineClient.d.ts
+declare class KeyMachineClient extends KeyMachine {}
+//#endregion
+//#region src/recover.d.ts
+/**
+ * Signs the payload hash for a refund transaction
+ */
+declare function signPayload(walletClient: WalletClient, intentAddress: Address.Address, chainId: number, payload: Payload.Calls): Promise<string>;
+interface BuildRefundTransactionWithSignatureParams {
+  trailsClient: TrailsClient;
+  intentId: string;
+  payload: Payload.Calls;
+  chainId: number;
+  intentAddress: Address.Address;
+  signature: string;
+}
+/**
+ * Builds a refund transaction using a pre-signed hash.
+ * Transaction construction is delegated to Trails API (`BuildIntentRecoveryTransaction`).
+ */
+declare function buildRefundTransactionWithSignature(params: BuildRefundTransactionWithSignatureParams): Promise<{
+  to: `0x${string}`;
+  data: Hex.Hex;
+}>;
+interface UseIntentRecoverParams {
+  intentId: string | undefined;
+  walletClient: WalletClient | undefined;
+  refundToAddress?: `0x${string}`;
+}
+interface UseIntentRecoverReturn {
+  intent: Intent | null;
+  isLoadingIntent: boolean;
+  isLoadingBalances: boolean;
+  intentError: Error | null;
+  balancesError: Error | null;
+  hasIntentBalance: boolean;
+  /** Token that will be recovered (the one with highest balance) */
+  recoverToken: Token$1 | null;
+  /** Information about which intent address will be recovered from */
+  selectedRecoveryTarget: {
+    address: Address.Address;
+    chainId: number;
+    chainName: string;
+    isOrigin: boolean;
+    tokenBalancesData: FlatTokenBalancesData | undefined;
+  } | null;
+  refetchIntent: () => void;
+  signPayload: () => Promise<{
+    signature: string;
+    payload: Payload.Calls;
+    refundCall: Payload.Call;
+  }>;
+  getRecoverTx: (params: {
+    signedHash: string;
+    payload: Payload.Calls;
+  }) => Promise<{
+    to: `0x${string}`;
+    data: `0x${string}`;
+    chainId: number;
+    chain: Chain;
+  }>;
+  recover: () => Promise<{
+    txHash: `0x${string}`;
+    receipt: TransactionReceipt;
+    chainId: number;
+  }>;
+  getRecoverStatus: (params: {
+    txHash: `0x${string}`;
+    chainId: number;
+  }) => Promise<{
+    status: "success" | "fail" | "pending";
+  }>;
+}
+interface UseIntentRecoverWithAddressParams {
+  intentId: string | undefined;
+  /** Signer for the recovery tx and default refund receiver */
+  walletAddress: `0x${string}` | undefined;
+  /** Optional. If set, refund is sent here instead of walletAddress (signer stays walletAddress). */
+  refundToAddress?: `0x${string}`;
+}
+interface UseIntentRecoverWithAddressReturn {
+  intent: Intent | null;
+  isLoadingIntent: boolean;
+  isLoadingBalances: boolean;
+  intentError: Error | null;
+  balancesError: Error | null;
+  hasIntentBalance: boolean;
+  recoverToken: Token$1 | null;
+  selectedRecoveryTarget: {
+    address: Address.Address;
+    chainId: number;
+    chainName: string;
+    isOrigin: boolean;
+    tokenBalancesData: FlatTokenBalancesData | undefined;
+  } | null;
+  refetchIntent: () => void;
+  /** Returns payload and EIP-712 typed data for the app to sign (e.g. with embedded wallet). */
+  getDataToSign: () => Promise<{
+    payload: Payload.Calls;
+    refundCall: Payload.Call;
+    chainId: number;
+    typedData: ReturnType<typeof Payload.toTyped>;
+  }>;
+  getRecoverTx: (params: {
+    signature: string;
+    payload: Payload.Calls;
+  }) => Promise<{
+    to: `0x${string}`;
+    data: `0x${string}`;
+    chainId: number;
+    chain: Chain;
+  }>;
+  getRecoverStatus: (params: {
+    txHash: `0x${string}`;
+    chainId: number;
+  }) => Promise<{
+    status: "success" | "fail" | "pending";
+  }>;
+}
+declare function useKeymachineIntentRecovery({
+  intent: intentData,
+  balancesByIntentAddress,
+  walletClient,
+  refundToAddress,
+  keyMachineClient,
+  onTransactionSubmitted
+}: UseKeymachineIntentRecoveryParams): UseKeymachineIntentRecoveryReturn;
+interface UseKeymachineIntentRecoveryParams {
+  intent: Intent | null;
+  balancesByIntentAddress: {
+    [account: string]: {
+      tokenBalancesData: FlatTokenBalancesData | undefined;
+      isLoading: boolean;
+      error: Error | null;
+    };
+  };
+  walletClient: WalletClient | undefined;
+  refundToAddress?: `0x${string}`;
+  keyMachineClient?: KeyMachineClient;
+  onTransactionSubmitted?: () => void;
+}
+interface UseKeymachineIntentRecoveryReturn {
+  intent: Intent | null;
+  hasIntentBalance: boolean;
+  recoverToken: Token$1 | null;
+  selectedRecoveryTarget: {
+    address: Address.Address;
+    chainId: number;
+    chainName: string;
+    isOrigin: boolean;
+    tokenBalancesData: FlatTokenBalancesData | undefined;
+  } | null;
+  signPayload: (prepared?: {
+    payload: Payload.Calls;
+    refundCall: Payload.Call;
+    chainId: number;
+    typedData: ReturnType<typeof Payload.toTyped>;
+  }) => Promise<{
+    signature: string;
+    signerAddress: `0x${string}`;
+    payload: Payload.Calls;
+    refundCall: Payload.Call;
+  }>;
+  getDataToSign: () => Promise<{
+    payload: Payload.Calls;
+    refundCall: Payload.Call;
+    chainId: number;
+    typedData: ReturnType<typeof Payload.toTyped>;
+  }>;
+  getRecoverTx: (params: {
+    signature: string;
+    signerAddress: `0x${string}`;
+    payload: Payload.Calls;
+  }) => Promise<{
+    to: `0x${string}`;
+    data: `0x${string}`;
+    chainId: number;
+    chain: Chain;
+  }>;
+  recover: () => Promise<{
+    txHash: `0x${string}`;
+    receipt: TransactionReceipt;
+    chainId: number;
+  }>;
+  getRecoverStatus: (params: {
+    txHash: `0x${string}`;
+    chainId: number;
+  }) => Promise<{
+    status: "success" | "fail" | "pending";
+  }>;
+}
+/**
+ * Hook for building and signing recover transactions.
+ * Wraps useIntentRecoverWithAddress and adds walletClient-based signing + sending.
+ * @example
+ * ```tsx
+ * const { signPayload, getRecoverTx, recover } = useIntentRecover({
+ *   intentId: "0x...",
+ *   walletClient: walletClient,
+ * })
+ *
+ * // Option 1: Manual flow
+ * const { signature, payload } = await signPayload()
+ * const recoverTx = await getRecoverTx({ signedHash: signature, payload })
+ * await recover()
+ *
+ * // Option 2: Automatic flow (recommended)
+ * const { txHash, receipt, chainId } = await recover()
+ * const status = await getRecoverStatus({ txHash, chainId })
+ * ```
+ */
+declare function useIntentRecover({
+  intentId,
+  walletClient,
+  refundToAddress
+}: UseIntentRecoverParams): UseIntentRecoverReturn;
+/**
+ * Recovery hook for apps that handle signing externally (e.g. embedded wallets)
+ * Use getDataToSign to get EIP-712 data, sign with walletAddress, then getRecoverTx(signature, payload).
+ * Refund goes to refundToAddress if provided, otherwise to walletAddress.
+ * @example
+ * ```tsx
+ * const { getDataToSign, getRecoverTx } = useIntentRecoverWithAddress({
+ *   intentId: "0x...",
+ *   walletAddress: "0x...",
+ *   refundToAddress: "0x...", // optional, allows for different refund address than signer
+ * })
+ * const { payload, typedData, chainId } = await getDataToSign()
+ * const signature = await myCustomWallet.signTypedData({ account: walletAddress, ...typedData })
+ * const recoverTx = await getRecoverTx({ signature, payload })
+ * const hash = await myCustomWallet.sendTransaction({ to: recoverTx.to, data: recoverTx.data, chain: recoverTx.chain })
+ * ```
+ */
+declare function useIntentRecoverWithAddress({
+  intentId,
+  walletAddress,
+  refundToAddress
+}: UseIntentRecoverWithAddressParams): UseIntentRecoverWithAddressReturn;
+//#endregion
+//#region src/offlineRecovery.d.ts
+interface TokenToCheck {
+  tokenAddress: string;
+  isNative: boolean;
+}
+interface TokenBalance extends TokenToCheck {
+  balance: bigint;
+}
+declare function fetchIntentTokenBalancesViaRpc(intentAddress: Address.Address, tokens: TokenToCheck[], chainId: number): Promise<TokenBalance[]>;
+interface UseOfflineIntentRecoveryParams {
+  intent: Intent | null;
+  walletClient: WalletClient | undefined;
+  ownerAddress: string;
+}
+interface UseOfflineIntentRecoveryReturn {
+  recover: () => Promise<`0x${string}`>;
+  isLoading: boolean;
+  error: Error | null;
+}
+declare function useOfflineIntentRecovery({
+  intent,
+  walletClient,
+  ownerAddress
+}: UseOfflineIntentRecoveryParams): UseOfflineIntentRecoveryReturn;
+//#endregion
+export { getEdgeSolanaRpcUrl as $, useTokenPrice as A, getTrailsClient as At, TokenBalance$1 as B, useFiatCurrencyList as C, TrailsSendTransactionVariables as Ct, usePublicClient as D, IntentReceiptStatus as Dt, useIndexerGatewayClient as E, useTrailsSendTransaction as Et, useTokenAddress as F, useHasSufficientBalanceUsd as G, UseHasSufficientBalanceUsdParams as H, useTokenInfo as I, FetchTokenBalanceOnchainReturn as J, useTokenBalances as K, useTokenList as L, useGetSequenceMetadataTokenImageUrl as M, useGetTokenImageUrl as N, usePublicClientGetter as O, useIntentReceiptMonitor as Ot, useSupportedTokens as P, PUBLIC_SOLANA_MAINNET_JSON_RPC as Q, MIN_REFETCH_INTERVAL as R, useExchangeRate as S, useGetIntent as St, useCountryList as T, UseTrailsSendTransactionReturnType as Tt, useAccountTotalBalanceUsd as U, UseHasSufficientBalanceTokenParams as V, useHasSufficientBalanceToken as W, GetTokenBalancesWithPriceReturn as X, GetTokenBalancesForMultipleAccountsReturn as Y, checkSufficientToken as Z, getOnrampClient as _, UseIntentTransactionHistoryParams as _t, BuildRefundTransactionWithSignatureParams as a, useResolveActions as at, useMeldPaymentMethods as b, UseGetIntentParams as bt, UseIntentRecoverWithAddressParams as c, useEarnProviders as ct, UseKeymachineIntentRecoveryReturn as d, useEarnBalances as dt, getEdgeSolanaRpcUrls as et, buildRefundTransactionWithSignature as f, UseEarnMarketsParams as ft, useKeymachineIntentRecovery as g, useExecuteIntent as gt, useIntentRecoverWithAddress as h, useCommitIntent as ht, useOfflineIntentRecovery as i, UseResolveActionsReturn as it, useTokenPrices as j, useTrailsClient as jt, useSupportedChains as k, TrailsClient as kt, UseIntentRecoverWithAddressReturn as l, UseEarnBalancesParams as lt, useIntentRecover as m, useEarnMarkets as mt, UseOfflineIntentRecoveryReturn as n, resolveSolanaMainnetJsonRpcUrls as nt, UseIntentRecoverParams as o, UseEarnProvidersParams as ot, signPayload as p, UseEarnMarketsReturn as pt, useTokenBalancesForMultipleAccounts as q, fetchIntentTokenBalancesViaRpc as r, UseResolveActionsProps as rt, UseIntentRecoverReturn as s, UseEarnProvidersReturn as st, UseOfflineIntentRecoveryParams as t, resolveSolanaMainnetJsonRpcUrl as tt, UseKeymachineIntentRecoveryParams as u, UseEarnBalancesReturn as ut, useOnrampClient as v, UseIntentTransactionHistoryReturn as vt, useCountryCode as w, UseTrailsSendTransactionParameters as wt, useMeldServiceProviders as x, UseGetIntentReturn as xt, TrailsOnramp as y, useIntentTransactionHistory as yt, NativeTokenBalance as z };