0xtrails 0.12.0 → 0.12.2

package/src/query/fiat.hooks.ts

@@ -0,0 +1,71 @@
+import { useQuery } from "@tanstack/react-query"
+import { useTrailsClient } from "../trailsClient.js"
+import { fiatQueries } from "./fiat.queries.js"
+
+// ============================================================================
+// Fiat Currency List
+// ============================================================================
+
+export function useFiatCurrencyList() {
+  const trailsClient = useTrailsClient()
+  return useQuery(fiatQueries.currencyList(trailsClient))
+}
+
+// ============================================================================
+// Exchange Rate
+// ============================================================================
+
+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).
+ */
+export function useExchangeRate(
+  options: UseExchangeRateOptions = {},
+): UseExchangeRateResult {
+  const { fromCurrency = "USD", toCurrency = "USD", disabled = false } = options
+  const trailsClient = useTrailsClient()
+
+  const isSameCurrency = fromCurrency === toCurrency
+  const targetCurrency = fromCurrency === "USD" ? toCurrency : fromCurrency
+
+  // Pass null when disabled or same-currency → factory uses skipToken
+  const { data, isLoading, error } = useQuery(
+    fiatQueries.exchangeRate(
+      trailsClient,
+      disabled || isSameCurrency ? null : targetCurrency,
+    ),
+  )
+
+  // Calculate the exchange rate based on the conversion direction
+  let exchangeRate: number | undefined
+
+  if (isSameCurrency) {
+    exchangeRate = 1
+  } else if (data?.value) {
+    if (fromCurrency === "USD" && toCurrency !== "USD") {
+      // USD to another currency — use the rate directly
+      exchangeRate = data.value
+    } else if (fromCurrency !== "USD" && toCurrency === "USD") {
+      // Currency to USD — invert the rate
+      exchangeRate = 1 / data.value
+    }
+  }
+
+  return {
+    exchangeRate,
+    isLoading: isSameCurrency ? false : isLoading,
+    error: isSameCurrency ? null : (error as Error | null),
+  }
+}

package/src/query/fiat.queries.ts

@@ -0,0 +1,67 @@
+import { queryOptions, skipToken } from "@tanstack/react-query"
+import type { ExchangeRate, FiatCurrency } from "@0xtrails/api"
+import type { TrailsClient } from "../trailsClient.js"
+import { DAY_MS, MINUTE_MS, HOUR_MS } from "../utils/time.js"
+import { createRetry, retryDelay } from "./helpers.js"
+import { queryPersister } from "./persister.js"
+import { getFiatCurrencyList, getExchangeRate } from "./fiat.fetchers.js"
+
+// ============================================================================
+// Fiat Query Factory
+//
+// Single factory following the TanStack Query v5 canonical pattern.
+// Key-only entries (all, currencies, exchangeRates) enable hierarchical
+// invalidation. Leaf entries return full queryOptions objects.
+//
+// Usage:
+//   useQuery(fiatQueries.currencyList(trailsClient))
+//   queryClient.invalidateQueries({ queryKey: fiatQueries.all })
+//   fiatQueries.exchangeRate(trailsClient, "EUR").queryKey
+// ============================================================================
+
+export const fiatQueries = {
+  // -- invalidation root (key-only) --
+  all: ["fiat"] as const,
+
+  // -- currency list --
+  currencies: () => [...fiatQueries.all, "currencies"] as const,
+
+  currencyList: (trailsClient: TrailsClient | null | undefined) => {
+    const canFetch = !!trailsClient
+    return queryOptions<FiatCurrency[]>({
+      queryKey: [...fiatQueries.currencies()] as const,
+      queryFn: canFetch ? () => getFiatCurrencyList(trailsClient) : skipToken,
+      staleTime: DAY_MS,
+      gcTime: DAY_MS,
+      retry: createRetry(3),
+      retryDelay,
+      persister: queryPersister.persisterFn,
+      refetchOnMount: false,
+      refetchOnReconnect: false,
+    })
+  },
+
+  // -- exchange rates --
+  exchangeRates: () => [...fiatQueries.all, "exchangeRate"] as const,
+
+  exchangeRate: (
+    trailsClient: TrailsClient | null | undefined,
+    targetCurrency: string | null | undefined,
+  ) => {
+    const canFetch = !!trailsClient && !!targetCurrency
+    return queryOptions<ExchangeRate>({
+      queryKey: [
+        ...fiatQueries.exchangeRates(),
+        targetCurrency ?? null,
+      ] as const,
+      queryFn: canFetch
+        ? () => getExchangeRate(trailsClient, targetCurrency)
+        : skipToken,
+      staleTime: 5 * MINUTE_MS,
+      gcTime: HOUR_MS,
+      retry: createRetry(2),
+      retryDelay,
+      persister: queryPersister.persisterFn,
+    })
+  },
+}

package/src/query/meld.fetchers.ts

@@ -0,0 +1,97 @@
+/**
+ * Pure async fetcher functions for Meld/onramp queries.
+ * This is a leaf module — NO React imports, NO queryClient.
+ */
+import type { TrailsOnramp } from "../onrampClient.js"
+import type {
+  MeldServiceProvider,
+  GetMeldServiceProvidersRequest,
+  MeldPaymentMethod,
+  MeldFiatCurrency,
+  MeldCryptoCurrency,
+  MeldCountryDefault,
+  MeldTransaction,
+} from "../onramp-client/trails-onramp.gen.js"
+import { normalizeAddress } from "../utils/address.js"
+
+export interface MeldCountryDefaults {
+  defaultCurrencyCode: string | undefined
+  defaultPaymentMethods: string[]
+}
+
+export type {
+  MeldServiceProvider,
+  MeldPaymentMethod,
+  MeldFiatCurrency,
+  MeldCryptoCurrency,
+  MeldCountryDefault,
+}
+
+export type { MeldTransaction }
+
+export async function fetchMeldPaymentMethods(
+  onrampClient: TrailsOnramp,
+  fiatCurrency: string,
+): Promise<MeldPaymentMethod[]> {
+  const response = await onrampClient.getMeldPaymentMethods({ fiatCurrency })
+  return Array.isArray(response.paymentMethods) ? response.paymentMethods : []
+}
+
+export async function fetchMeldCryptoCurrencies(
+  onrampClient: TrailsOnramp,
+  countryCode: string,
+): Promise<MeldCryptoCurrency[]> {
+  const response = await onrampClient.getMeldCryptoCurrencies({ countryCode })
+  return Array.isArray(response.cryptoCurrencies)
+    ? response.cryptoCurrencies
+    : []
+}
+
+export async function fetchMeldServiceProviders(
+  onrampClient: TrailsOnramp,
+  options: Partial<GetMeldServiceProvidersRequest> = {},
+): Promise<MeldServiceProvider[]> {
+  const response = await onrampClient.getMeldServiceProviders(options)
+  return response.serviceProviders || []
+}
+
+export async function fetchMeldFiatCurrencies(
+  onrampClient: TrailsOnramp,
+  countryCode: string,
+): Promise<MeldFiatCurrency[]> {
+  const response = await onrampClient.getMeldFiatCurrencies({ countryCode })
+  return Array.isArray(response.fiatCurrencies) ? response.fiatCurrencies : []
+}
+
+export async function fetchMeldCountryDefaults(
+  onrampClient: TrailsOnramp,
+  countryCode: string,
+): Promise<MeldCountryDefaults> {
+  const response = await onrampClient.getMeldCountryDefaults({ countryCode })
+  const defaults = response.defaults?.[0]
+  return {
+    defaultCurrencyCode: defaults?.defaultCurrencyCode ?? undefined,
+    defaultPaymentMethods: defaults?.defaultPaymentMethods || [],
+  }
+}
+
+export interface MeldTransactionHistoryResult {
+  transactions: MeldTransaction[]
+  hasMore: boolean
+}
+
+export async function fetchMeldTransactionHistory(
+  onrampClient: TrailsOnramp,
+  walletAddress: string,
+  limit: number,
+): Promise<MeldTransactionHistoryResult> {
+  const response = await onrampClient.searchMeldTransactions({
+    externalCustomerIds: normalizeAddress(walletAddress),
+    limit,
+  })
+  const transactions = response.transactions?.transactions || []
+  return {
+    transactions,
+    hasMore: transactions.length >= limit,
+  }
+}

package/src/query/meld.hooks.ts

@@ -0,0 +1,18 @@
+import { useQuery } from "@tanstack/react-query"
+import { useOnrampClient } from "../onrampClient.js"
+import type { GetMeldServiceProvidersRequest } from "../onramp-client/trails-onramp.gen.js"
+import { meldQueries } from "./meld.queries.js"
+
+export function useMeldPaymentMethods(fiatCurrency?: string) {
+  const onrampClient = useOnrampClient()
+  return useQuery(
+    meldQueries.paymentMethodList(onrampClient, fiatCurrency ?? null),
+  )
+}
+
+export function useMeldServiceProviders(
+  options?: Partial<GetMeldServiceProvidersRequest>,
+) {
+  const onrampClient = useOnrampClient()
+  return useQuery(meldQueries.serviceProviderList(onrampClient, options))
+}

package/src/query/meld.queries.ts

@@ -0,0 +1,184 @@
+import { queryOptions, skipToken } from "@tanstack/react-query"
+import type { TrailsOnramp } from "../onrampClient.js"
+import type {
+  GetMeldServiceProvidersRequest,
+  MeldServiceProvider,
+} from "../onramp-client/trails-onramp.gen.js"
+import { DAY_MS, MINUTE_MS } from "../utils/time.js"
+import { createRetry, retryDelay, STATIC_QUERY_OPTIONS } from "./helpers.js"
+import { queryPersister } from "./persister.js"
+import {
+  fetchMeldPaymentMethods,
+  fetchMeldCryptoCurrencies,
+  fetchMeldServiceProviders,
+  fetchMeldFiatCurrencies,
+  fetchMeldCountryDefaults,
+  fetchMeldTransactionHistory,
+  type MeldPaymentMethod,
+  type MeldCountryDefaults,
+  type MeldFiatCurrency,
+  type MeldCryptoCurrency,
+  type MeldTransactionHistoryResult,
+} from "./meld.fetchers.js"
+
+// ============================================================================
+// Meld Query Factory
+//
+// Single factory following the TanStack Query v5 canonical pattern.
+// Key-only entries (all, paymentMethods, etc.) enable hierarchical
+// invalidation. Leaf entries return full queryOptions objects.
+//
+// Usage:
+//   useQuery(meldQueries.paymentMethodList(client, "USD"))
+//   queryClient.invalidateQueries({ queryKey: meldQueries.all })
+//   meldQueries.fiatCurrencyList(client, "US").queryKey
+// ============================================================================
+
+export const meldQueries = {
+  // -- invalidation root (key-only) --
+  all: ["meld"] as const,
+
+  // -- payment methods --
+  paymentMethods: () => [...meldQueries.all, "paymentMethods"] as const,
+
+  paymentMethodList: (
+    onrampClient: TrailsOnramp | null | undefined,
+    fiatCurrency: string | null | undefined,
+  ) => {
+    const canFetch = !!onrampClient && !!fiatCurrency
+    return queryOptions<MeldPaymentMethod[]>({
+      queryKey: [
+        ...meldQueries.paymentMethods(),
+        fiatCurrency ?? null,
+      ] as const,
+      queryFn: canFetch
+        ? () => fetchMeldPaymentMethods(onrampClient, fiatCurrency)
+        : skipToken,
+      staleTime: DAY_MS,
+      gcTime: DAY_MS,
+      retry: createRetry(2),
+      retryDelay,
+      persister: queryPersister.persisterFn,
+      ...STATIC_QUERY_OPTIONS,
+    })
+  },
+
+  // -- crypto currencies --
+  cryptoCurrencies: () => [...meldQueries.all, "cryptoCurrencies"] as const,
+
+  cryptoCurrencyList: (
+    onrampClient: TrailsOnramp | null | undefined,
+    countryCode: string | null | undefined,
+  ) => {
+    const canFetch = !!onrampClient && !!countryCode
+    return queryOptions<MeldCryptoCurrency[]>({
+      queryKey: [
+        ...meldQueries.cryptoCurrencies(),
+        countryCode ?? null,
+      ] as const,
+      queryFn: canFetch
+        ? () => fetchMeldCryptoCurrencies(onrampClient, countryCode)
+        : skipToken,
+      staleTime: DAY_MS,
+      gcTime: DAY_MS,
+      retry: createRetry(2),
+      retryDelay,
+      persister: queryPersister.persisterFn,
+      ...STATIC_QUERY_OPTIONS,
+    })
+  },
+
+  // -- service providers --
+  serviceProviders: () => [...meldQueries.all, "serviceProviders"] as const,
+
+  serviceProviderList: (
+    onrampClient: TrailsOnramp | null | undefined,
+    options?: Partial<GetMeldServiceProvidersRequest>,
+  ) => {
+    const canFetch = !!onrampClient
+    return queryOptions<MeldServiceProvider[]>({
+      queryKey: [...meldQueries.serviceProviders(), options ?? null] as const,
+      queryFn: canFetch
+        ? () => fetchMeldServiceProviders(onrampClient, options)
+        : skipToken,
+      staleTime: DAY_MS,
+      gcTime: DAY_MS,
+      retry: createRetry(2),
+      retryDelay,
+      persister: queryPersister.persisterFn,
+      ...STATIC_QUERY_OPTIONS,
+    })
+  },
+
+  // -- fiat currencies --
+  fiatCurrencies: () => [...meldQueries.all, "fiatCurrencies"] as const,
+
+  fiatCurrencyList: (
+    onrampClient: TrailsOnramp | null | undefined,
+    countryCode: string | null | undefined,
+  ) => {
+    const canFetch = !!onrampClient && !!countryCode
+    return queryOptions<MeldFiatCurrency[]>({
+      queryKey: [...meldQueries.fiatCurrencies(), countryCode ?? null] as const,
+      queryFn: canFetch
+        ? () => fetchMeldFiatCurrencies(onrampClient, countryCode)
+        : skipToken,
+      staleTime: DAY_MS,
+      gcTime: DAY_MS,
+      retry: createRetry(2),
+      retryDelay,
+      persister: queryPersister.persisterFn,
+      ...STATIC_QUERY_OPTIONS,
+    })
+  },
+
+  // -- country defaults --
+  countryDefaults: () => [...meldQueries.all, "countryDefaults"] as const,
+
+  countryDefaultsByCode: (
+    onrampClient: TrailsOnramp | null | undefined,
+    countryCode: string | null | undefined,
+  ) => {
+    const canFetch = !!onrampClient && !!countryCode
+    return queryOptions<MeldCountryDefaults>({
+      queryKey: [
+        ...meldQueries.countryDefaults(),
+        countryCode ?? null,
+      ] as const,
+      queryFn: canFetch
+        ? () => fetchMeldCountryDefaults(onrampClient, countryCode)
+        : skipToken,
+      staleTime: 10 * MINUTE_MS,
+      gcTime: 30 * MINUTE_MS,
+      retry: createRetry(2),
+      retryDelay,
+      persister: queryPersister.persisterFn,
+      ...STATIC_QUERY_OPTIONS,
+    })
+  },
+
+  // -- transaction history (no persister/STATIC_QUERY_OPTIONS — mutable user data that should refetch on focus) --
+  transactionHistory: () => [...meldQueries.all, "transactionHistory"] as const,
+
+  transactionHistoryList: (
+    onrampClient: TrailsOnramp | null | undefined,
+    walletAddress: string | null | undefined,
+    limit: number = 20,
+  ) => {
+    const canFetch = !!onrampClient && !!walletAddress
+    return queryOptions<MeldTransactionHistoryResult>({
+      queryKey: [
+        ...meldQueries.transactionHistory(),
+        walletAddress ?? null,
+        limit,
+      ] as const,
+      queryFn: canFetch
+        ? () => fetchMeldTransactionHistory(onrampClient, walletAddress, limit)
+        : skipToken,
+      staleTime: 5 * MINUTE_MS,
+      gcTime: 30 * MINUTE_MS,
+      retry: createRetry(2),
+      retryDelay,
+    })
+  },
+}

package/src/recover.ts

@@ -5,6 +5,7 @@ import {
   Payload,
   Signature,
 } from "@0xsequence/wallet-primitives"
+import { isPositiveBigInt } from "./utils/validation.js"
 import {
   IntentProtocolVersion,
   type Intent,
@@ -620,7 +621,7 @@ function checkAnyIntentBalance(
   const hasBalance = (data: { tokens?: Token[] } | undefined): boolean => {
     if (!data?.tokens) return false
     for (const token of data.tokens) {
-      if (BigInt(token.balance || "0") > 0n) return true
+      if (isPositiveBigInt(token.balance || "0")) return true
     }
     return false
   }
@@ -1066,6 +1067,8 @@ export function useIntentRecover({
     refundToAddress: refundToAddress || walletAddress,
   })
 
+  // TODO: temporary ignore this Biome warning for now; do not refactor code in this pass.
+  // biome-ignore lint/correctness/useExhaustiveDependencies: Preserve current dependency shape per requested no-code-change rollback.
   const signPayload = useCallback(async (): Promise<{
     signature: string
     payload: Payload.Calls
@@ -1098,6 +1101,8 @@ export function useIntentRecover({
     return { signature, payload, refundCall }
   }, [walletClient, inner.getDataToSign])
 
+  // TODO: temporary ignore this Biome warning for now; do not refactor code in this pass.
+  // biome-ignore lint/correctness/useExhaustiveDependencies: Preserve current dependency shape per requested no-code-change rollback.
   const getRecoverTx = useCallback(
     async (params: {
       signedHash: string

package/src/tokens.ts

@@ -14,6 +14,16 @@ import {
   polygon,
   mainnet,
   avalanche,
+  gnosis,
+  zksync,
+  scroll,
+  blast,
+  sonic,
+  fantom,
+  hyperEvm,
+  ink,
+  katana,
+  berachain,
   etherlink,
   linea,
   unichain,
@@ -1739,13 +1749,28 @@ export const commonTokens: Token[] = [
   },
 ]
 
+// wrapped-native addresses
 export const wethAddresses: Record<string, string> = {
-  1: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
-  10: "0x4200000000000000000000000000000000000006",
-  8453: "0x4200000000000000000000000000000000000006",
-  42161: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
-  137: "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619",
-  100: "0x6a023ccd1ff6f2045c3309768ead9e68f978f6e1",
+  [mainnet.id]: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+  [optimism.id]: "0x4200000000000000000000000000000000000006",
+  [bsc.id]: "0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c",
+  [gnosis.id]: "0xe91d153e0b41518a2ce8dd3d7944fa863463a97d",
+  [unichain.id]: "0x4200000000000000000000000000000000000006",
+  [base.id]: "0x4200000000000000000000000000000000000006",
+  [sonic.id]: "0x039e2fb66102314ce7b64ce5ce3e5183bc94ad38",
+  [fantom.id]: "0x21be370d5312f44cb42ce377bc9b8a0cef1a4c83",
+  [zksync.id]: "0x5aea5775959fbc2557cc8789bc1bf90a239d9a91",
+  [worldchain.id]: "0x4200000000000000000000000000000000000006",
+  [hyperEvm.id]: "0x5555555555555555555555555555555555555555",
+  [polygon.id]: "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
+  [ink.id]: "0x4200000000000000000000000000000000000006",
+  [linea.id]: "0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f",
+  [arbitrum.id]: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
+  [avalanche.id]: "0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7",
+  [scroll.id]: "0x5300000000000000000000000000000000000004",
+  [katana.id]: "0xee7d8bcfb72bc1880d0cf19822eb0a2e6577ab62",
+  [berachain.id]: "0x6969696969696969696969696969696969696969",
+  [blast.id]: "0x4300000000000000000000000000000000000004",
 }
 
 export function getWethAddress(chainId: number): string | null {

package/src/transactionIntent/deposits/depositOrchestrator.ts

@@ -236,6 +236,8 @@ export async function attemptUserDepositTx({
       sequenceIndexerUrl,
       abortSignal,
       depositTransaction: depositTransaction,
+      intentId,
+      executeIntentFn,
     })
   }
 

package/src/transactionIntent/deposits/gaslessDeposit.ts

@@ -32,7 +32,7 @@ import {
   getPermitSignature,
   validateGaslessSignature,
 } from "../../gasless.js"
-import { getIsUserRejectionError } from "../../error.js"
+import { getIsPopupBlockedError, getIsUserRejectionError } from "../../error.js"
 import { getChainRpcClient } from "../../chains.js"
 import { TRAILS_CONTRACTS } from "../../constants.js"
 
@@ -524,7 +524,14 @@ export async function attemptGaslessDeposit({
             checkoutOnHandlers.triggerCheckoutSignatureRejected(error)
           }
         }
-        throw error
+        if (getIsPopupBlockedError(error)) {
+          throw new Error(
+            "Wallet signature popup was blocked by your browser. " +
+              "Please allow pop-ups for this site and try again. " +
+              "More details: " +
+              error,
+          )
+        }
       }
     }
 

package/src/transactionIntent/deposits/standardDeposit.ts

@@ -6,6 +6,7 @@ import type {
   TransactionReceipt,
 } from "viem"
 import { parseUnits } from "viem"
+import type { ExecuteIntentResponse } from "@0xtrails/api"
 import type { TransactionState } from "../../transactions.js"
 import type { CheckoutOnHandlers } from "../../widget/hooks/useCheckout.js"
 import { logger } from "../../logger.js"
@@ -24,7 +25,10 @@ import { SECOND_MS } from "../../utils/time.js"
 import { updatePersistentToast } from "../../toast.js"
 import { getChainInfo } from "../../chains.js"
 import { trackTransactionConfirmed } from "../../analytics.js"
-import { getIsUserRejectionError } from "../../error.js"
+import {
+  getIsAlreadyExecutingError,
+  getIsUserRejectionError,
+} from "../../error.js"
 import {
   trackDepositResilient,
   isRecoverableDepositError,
@@ -67,6 +71,8 @@ export async function attemptStandardDeposit({
   sequenceProjectAccessKey,
   sequenceIndexerUrl,
   abortSignal,
+  intentId,
+  executeIntentFn,
 }: {
   queryClient?: QueryClient
   originTokenAddress: string
@@ -95,6 +101,11 @@ export async function attemptStandardDeposit({
   sequenceProjectAccessKey?: string
   sequenceIndexerUrl?: string
   abortSignal?: AbortSignal
+  intentId?: string
+  executeIntentFn?: (params: {
+    intentId: string
+    depositTransactionHash?: string
+  }) => Promise<ExecuteIntentResponse>
   depositTransaction?: {
     to: string
     data: string
@@ -393,20 +404,30 @@ export async function attemptStandardDeposit({
       ) // TODO: Add proper type
       logger.console.log("[trails-sdk] origin tx", txHash)
 
-      // NOTE: executeIntent is called by the handler after receipt confirmation
-      // Do not call it here to avoid duplicate execution errors
-
-      // SIMULATE RPC ERROR: Throw error after successful transaction send
-      // This simulates the scenario where tx is broadcast but RPC fails immediately after
-      // if (true) { // Always enabled for testing
-      //   logger.console.warn(
-      //     "[trails-sdk] SIMULATING RPC ERROR after transaction send",
-      //     { txHash }
-      //   )
-      //   throw new Error("SIMULATED: RPC connection lost after transaction broadcast")
-      // }
+      // Call executeIntent immediately after getting txHash (before waiting for receipt).
+      // This ensures the backend knows about the intent as soon as the tx is broadcast,
+      // allowing integrators to call WaitIntentReceipt right after onCheckoutSignatureConfirmed.
+      // Fire-and-forget: errors are logged but don't block the receipt wait.
+      if (intentId && txHash && executeIntentFn) {
+        executeIntentFn({
+          intentId,
+          depositTransactionHash: txHash,
+        }).catch((error) => {
+          // "EXECUTING" means the backend already picked up the intent — that's fine
+          if (getIsAlreadyExecutingError(error)) {
+            logger.console.log(
+              "[trails-sdk] Intent already executing after early executeIntent call, continuing...",
+            )
+          } else {
+            logger.console.error(
+              "[trails-sdk] Early executeIntent call failed (will retry after receipt):",
+              error,
+            )
+          }
+        })
+      }
 
-      // Trigger signature confirmed callback after successful signing
+      // Trigger signature confirmed callback after early executeIntent
       if (checkoutOnHandlers?.triggerCheckoutSignatureConfirmed) {
         checkoutOnHandlers?.triggerCheckoutSignatureConfirmed?.()
       }