0xtrails 0.13.2 → 0.15.0

package/dist/{widget/hooks → hooks}/useOnRampQuote.d.ts

@@ -1,6 +1,6 @@
-import { MeldQuote } from '../../meld/utils/meld.js';
-import { TrailsOnramp } from '../../onrampClient.js';
-import { OnrampTrackingData } from '../types/analytics.js';
+import { MeldQuote } from '../meld/utils/meld.js';
+import { TrailsOnramp } from '../onrampClient.js';
+import { OnrampTrackingData } from '../widget/types/analytics.js';
 export type OnrampQuote = MeldQuote;
 export interface UseOnRampQuoteOptions {
     trailsClient?: TrailsOnramp | null;

package/dist/hooks/useOnRampQuote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOnRampQuote.d.ts","sourceRoot":"","sources":["../../src/hooks/useOnRampQuote.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAA;AAQtE,MAAM,MAAM,WAAW,GAAG,SAAS,CAAA;AAEnC,MAAM,WAAW,qBAAqB;IACpC,YAAY,CAAC,EAAE,YAAY,GAAG,IAAI,CAAA;IAClC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,WAAW,EAAE,CAAA;IACrB,aAAa,EAAE,WAAW,GAAG,IAAI,CAAA;IACjC,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;IACnB;;OAEG;IACH,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC5B;;OAEG;IACH,kBAAkB,EAAE,kBAAkB,GAAG,IAAI,CAAA;CAC9C;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,qBAAqB,GAC7B,oBAAoB,CA6RtB"}

package/dist/{widget/hooks → hooks}/useOnRampTransactionStatus.d.ts

@@ -1,4 +1,4 @@
-import { TrailsOnramp } from '../../onrampClient.js';
+import { TrailsOnramp } from '../onrampClient.js';
 export interface MeldTransactionStatusOptions {
     trailsClient?: TrailsOnramp | null;
     transactionId: string | null;

package/dist/hooks/useOnRampTransactionStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOnRampTransactionStatus.d.ts","sourceRoot":"","sources":["../../src/hooks/useOnRampTransactionStatus.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAGtD,MAAM,WAAW,4BAA4B;IAC3C,YAAY,CAAC,EAAE,YAAY,GAAG,IAAI,CAAA;IAClC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,MAAM,qBAAqB,GAC7B,SAAS,GACT,YAAY,GACZ,WAAW,GACX,QAAQ,GACR,WAAW,CAAA;AAEf,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,CAAA;IACrB,MAAM,EAAE,qBAAqB,CAAA;IAC7B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,gCAAgC;IAC/C;;OAEG;IACH,WAAW,EAAE,eAAe,GAAG,IAAI,CAAA;IACnC;;OAEG;IACH,SAAS,EAAE,OAAO,CAAA;IAClB;;OAEG;IACH,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;IACnB;;OAEG;IACH,UAAU,EAAE,OAAO,CAAA;IACnB;;OAEG;IACH,SAAS,EAAE,OAAO,CAAA;IAClB;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAA;IACjB;;OAEG;IACH,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,4BAA4B,GACpC,gCAAgC,CA4GlC"}

package/dist/{widget/hooks → hooks}/useOriginSelectedToken.d.ts

@@ -1,5 +1,5 @@
 import { default as React, ReactNode } from 'react';
-import { Token } from '../../tokens.js';
+import { Token } from '../tokens.js';
 interface OriginSelectedTokenContextType {
     selectedToken: Token | null;
     setSelectedToken: (token: Token | null) => void;

package/dist/hooks/useOriginSelectedToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOriginSelectedToken.d.ts","sourceRoot":"","sources":["../../src/hooks/useOriginSelectedToken.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAOZ,KAAK,SAAS,EACf,MAAM,OAAO,CAAA;AAEd,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAYzC,UAAU,8BAA8B;IACtC,aAAa,EAAE,KAAK,GAAG,IAAI,CAAA;IAC3B,gBAAgB,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,CAAA;IAC/C,kBAAkB,EAAE,MAAM,IAAI,CAAA;IAC9B,kBAAkB,EAAE,OAAO,CAAA;IAC3B,qBAAqB,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CAChD;AAMD,UAAU,gCAAgC;IACxC,QAAQ,EAAE,SAAS,CAAA;IACnB,YAAY,CAAC,EAAE,KAAK,GAAG,IAAI,CAAA;CAC5B;AAED,eAAO,MAAM,2BAA2B,EAAE,KAAK,CAAC,EAAE,CAChD,gCAAgC,CA+IjC,CAAA;AAED,wBAAgB,sBAAsB,IAAI,8BAA8B,CAUvE"}

package/dist/hooks/usePayMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePayMessage.d.ts","sourceRoot":"","sources":["../../src/hooks/usePayMessage.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AActC,MAAM,WAAW,cAAc;IAC7B,IAAI,EACA,MAAM,GACN,UAAU,GACV,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,WAAW,GACX,oBAAoB,GACpB,WAAW,GACX,UAAU,GACV,eAAe,GACf,aAAa,GACb,aAAa,GACb,cAAc,GACd,cAAc,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,SAAS,CAAA;IAClB,KAAK,EAAE,cAAc,EAAE,CAAA;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,aAAa,IAAI,mBAAmB,CAibnD"}

package/dist/hooks/usePriceImpactWarning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePriceImpactWarning.d.ts","sourceRoot":"","sources":["../../src/hooks/usePriceImpactWarning.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,wBAAwB;IACvC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AAKD,eAAO,MAAM,0BAA0B,2DAAqC,CAAA;AAE5E,wBAAgB,qBAAqB,IAAI,wBAAwB,CAGhE"}

package/dist/hooks/useQuote.d.ts

@@ -0,0 +1,619 @@
+import { TransactionReceipt, WalletClient } from 'viem';
+import { IntentTransaction, FeeOption, RouteProvider, PriceImpactDetails, IntentProtocolVersion } from '@0xtrails/api';
+import { FundMethod } from '../transactionIntent/types.js';
+import { Chain } from '../chains.js';
+import { Token } from '../tokens.js';
+import { TransactionState } from '../transactions.js';
+import { PrepareSendFees } from '../prepareSend.js';
+import { TrailsFeeBreakdown } from '../fees.js';
+import { CheckoutOnHandlers } from './useCheckout.js';
+import { OnrampTrackingData } from '../widget/types/analytics.js';
+import { ActionItem, Call } from '../actions/types.js';
+import { ChainIdentifier } from '../widget/shared/types.js';
+/**
+ * Discriminated error codes returned by {@link useQuote}.
+ *
+ * Use these to programmatically react to specific failure modes:
+ *
+ * ```ts
+ * if (quoteError?.code === "INSUFFICIENT_LIQUIDITY") {
+ *   // show "try a smaller amount" UI
+ * }
+ * ```
+ */
+export type QuoteErrorCode = "TIMEOUT" | "NO_ROUTE" | "INSUFFICIENT_BALANCE" | "INSUFFICIENT_LIQUIDITY" | "USER_REJECTED" | "NO_QUOTE" | "INVALID_TOKEN" | "INVALID_INPUT" | "HIGH_PRICE_IMPACT" | "RATE_LIMITED" | "API_ERROR" | "NETWORK_ERROR" | "ONRAMP_AMOUNT_TOO_LOW" | "CHAIN_MISMATCH" | "CALL_RESOLUTION_FAILED" | "UNKNOWN";
+/**
+ * Typed error thrown by the {@link useQuote} hook.
+ *
+ * Extends `Error` with a `code` property for programmatic handling.
+ *
+ * @example
+ * ```ts
+ * const { quoteError } = useQuote({ ... })
+ * if (quoteError) {
+ *   switch (quoteError.code) {
+ *     case "INSUFFICIENT_LIQUIDITY": // ...
+ *     case "NO_ROUTE":              // ...
+ *     case "RATE_LIMITED":          // ...
+ *   }
+ * }
+ * ```
+ */
+export declare class QuoteError extends Error {
+    readonly code: QuoteErrorCode;
+    constructor(code: QuoteErrorCode, message: string);
+}
+export declare const quoteKeys: {
+    readonly all: readonly ["trails"];
+    readonly quotes: () => readonly ["trails", "quote"];
+    readonly quote: (params: {
+        senderAddress: string | null | undefined;
+        fromToken: string | null;
+        fromChainId: number | null;
+        toToken: string | null;
+        toChainId: number | null;
+        amount: string | null;
+        isAmountRaw: boolean;
+        recipient: string | null;
+        calldata: string | null;
+        tradeType: string | null;
+        slippage: string | number | null | undefined;
+        swapProvider: string | null | undefined;
+        bridgeProvider: string | null | undefined;
+        swapProviderFallback: boolean | undefined;
+        bridgeProviderFallback: boolean | undefined;
+        intentProtocolVersion: string | null | undefined;
+        apiKey: string | null | undefined;
+        isSmartWallet: boolean | null | undefined;
+        fundMethod: string | null | undefined;
+    }) => readonly ["trails", "quote", {
+        senderAddress: string | null | undefined;
+        fromToken: string | null;
+        fromChainId: number | null;
+        toToken: string | null;
+        toChainId: number | null;
+        amount: string | null;
+        isAmountRaw: boolean;
+        recipient: string | null;
+        calldata: string | null;
+        tradeType: string | null;
+        slippage: string | number | null | undefined;
+        swapProvider: string | null | undefined;
+        bridgeProvider: string | null | undefined;
+        swapProviderFallback: boolean | undefined;
+        bridgeProviderFallback: boolean | undefined;
+        intentProtocolVersion: string | null | undefined;
+        apiKey: string | null | undefined;
+        isSmartWallet: boolean | null | undefined;
+        fundMethod: string | null | undefined;
+    }];
+};
+/**
+ * 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).
+ */
+export 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;
+};
+export 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 | Call[])[] | null;
+};
+export type UseQuoteProps = {
+    /** Wallet client override. If present, `walletClient.account.address` is the quote owner and takes priority over `walletAddress`. If omitted, the hook uses the wallet client from wagmi context when available. */
+    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 | 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[];
+};
+/**
+ * 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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;
+    destinationToken: Token;
+    originChain: Chain;
+    destinationChain: Chain;
+    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;
+    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.
+ */
+export 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;
+};
+export 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;
+};
+export declare function resolveQuoteOwnerAddress({ walletClientAccountAddress, walletAddress, }: {
+    walletClientAccountAddress?: string | null;
+    walletAddress?: string | null;
+}): string | null;
+/**
+ * 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. **`WagmiProvider`** (wagmi) — supplies wallet and account context
+ * 2. **`QueryClientProvider`** (@tanstack/react-query) — supplies the React Query cache
+ * 3. **`TrailsProvider`** — supplies the API key, indexer URLs, and SDK configuration
+ *
+ * ```tsx
+ * <WagmiProvider config={wagmiConfig}>
+ *   <QueryClientProvider client={queryClient}>
+ *     <TrailsProvider config={{ trailsApiKey: 'YOUR_KEY' }}>
+ *       <YourComponent />   {// ← useQuote works here}
+ *     </TrailsProvider>
+ *   </QueryClientProvider>
+ * </WagmiProvider>
+ * ```
+ *
+ * ## 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 wallet client from wagmi context 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}
+ */
+export 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, }: UseQuoteProps): UseQuoteReturn;
+//# sourceMappingURL=useQuote.d.ts.map