0xtrails 0.12.2 → 0.13.0

package/src/transactionIntent/helpers/transactionStateHelpers.ts

@@ -1,5 +1,5 @@
 import type { TransactionReceipt } from "viem"
-import type { TransactionStateInfo } from "@0xtrails/api"
+import type { IntentReceipt, TransactionStateInfo } from "@0xtrails/api"
 import type {
   TransactionState,
   TransactionStateStatus,
@@ -10,6 +10,7 @@ import {
   decodeGuestModuleEvents,
 } from "../../decoders.js"
 import { logger } from "../../logger.js"
+import { isDisplayableTransactionHash } from "../../transactions.js"
 
 // Re-export for convenience
 export type { TransactionStateInfo } from "@0xtrails/api"
@@ -195,6 +196,112 @@ export function updateTransactionStateAtIndex(
   })
 }
 
+export function mapIntentTransactionStatus(
+  status?: string | null,
+): TransactionStateStatus | null {
+  if (!status) return null
+  if (status === "SUCCEEDED") return "confirmed"
+  if (status === "ABORTED") return "aborted"
+  if (status === "FAILED" || status === "ERRORED" || status === "REVERTED") {
+    return "failed"
+  }
+  return "pending"
+}
+
+export function applyIntentReceiptToTransactionStates(params: {
+  currentStates: TransactionState[]
+  receipt: IntentReceipt
+}): { transactionStates: TransactionState[]; changed: boolean } {
+  const { currentStates, receipt } = params
+
+  if (currentStates.length === 0) {
+    return { transactionStates: currentStates, changed: false }
+  }
+
+  const nextStates = [...currentStates]
+  let changed = false
+
+  const applyAtIndex = (
+    index: number,
+    status?: string | null,
+    txnHash?: string | null,
+    txnMinedAt?: string | null,
+  ) => {
+    const targetState = nextStates[index]
+    const mappedState = mapIntentTransactionStatus(status)
+    if (!targetState || !mappedState) {
+      return
+    }
+
+    const displayableHash = isDisplayableTransactionHash(txnHash) ? txnHash : ""
+    const nextExplorerUrl = displayableHash
+      ? getExplorerUrl({
+          txHash: displayableHash,
+          chainId: targetState.chainId,
+        })
+      : ""
+
+    const stateChanged =
+      targetState.state !== mappedState ||
+      targetState.transactionHash !== displayableHash ||
+      targetState.explorerUrl !== nextExplorerUrl ||
+      targetState.txnMinedAt !== (txnMinedAt || undefined)
+
+    if (!stateChanged) {
+      return
+    }
+
+    nextStates[index] = {
+      ...targetState,
+      state: mappedState,
+      transactionHash: displayableHash,
+      explorerUrl: nextExplorerUrl,
+      txnMinedAt: txnMinedAt || undefined,
+    }
+    changed = true
+  }
+
+  applyAtIndex(
+    0,
+    receipt.depositTransaction?.status,
+    receipt.depositTransaction?.txnHash,
+    receipt.depositTransaction?.txnMinedAt,
+  )
+
+  const originStateIndex = nextStates.length > 1 ? 1 : 0
+  applyAtIndex(
+    originStateIndex,
+    receipt.originTransaction?.status,
+    receipt.originTransaction?.txnHash,
+    receipt.originTransaction?.txnMinedAt,
+  )
+
+  const destinationStateIndex = nextStates.length - 1
+  applyAtIndex(
+    destinationStateIndex,
+    receipt.destinationTransaction?.status,
+    receipt.destinationTransaction?.txnHash,
+    receipt.destinationTransaction?.txnMinedAt,
+  )
+
+  return {
+    transactionStates: changed ? nextStates : currentStates,
+    changed,
+  }
+}
+
+export function hasIntentReceiptObservedFundingProgress(
+  receipt: IntentReceipt,
+): boolean {
+  return (
+    receipt.depositTransaction?.status === "SUCCEEDED" ||
+    receipt.originTransaction?.status === "MINING" ||
+    receipt.originTransaction?.status === "SUCCEEDED" ||
+    receipt.destinationTransaction?.status === "MINING" ||
+    receipt.destinationTransaction?.status === "SUCCEEDED"
+  )
+}
+
 /**
  * Apply refund information from an intent receipt to the transaction states.
  * Finds the appropriate transaction by chainId and updates refund fields.

package/src/transactionIntent/types.ts

@@ -52,6 +52,19 @@ export function toApiFundMethod(fundMethod: FundMethod): ApiFundMethod {
   }
 }
 
+export function isExternalFundingMethod(
+  fundMethod: FundMethod | null | undefined,
+): fundMethod is Extract<
+  FundMethod,
+  "direct-transfer" | "onramp-mesh" | "onramp-meld"
+> {
+  return (
+    fundMethod === "direct-transfer" ||
+    fundMethod === "onramp-mesh" ||
+    fundMethod === "onramp-meld"
+  )
+}
+
 export type PrepareSendOptions = {
   account: Account
   originTokenAddress: string
@@ -100,10 +113,7 @@ export type PrepareSendOptions = {
   // Optional QueryClient to use instead of the singleton (for decoupled mode)
   queryClient?: QueryClient
   // Optional mutation callbacks for React Query integration
-  commitIntentFn?: (
-    intent: Intent,
-    options?: { skipIntentMonitoring?: boolean },
-  ) => Promise<CommitIntentResponse>
+  commitIntentFn?: (intent: Intent) => Promise<CommitIntentResponse>
   executeIntentFn?: (params: {
     intentId: string
     depositTransactionHash?: string
@@ -215,15 +225,11 @@ export type PrepareSendReturn = {
     selectedFeeOption,
     depositTransactionHash,
     skipCommit,
-    commitOnly,
-    skipIntentMonitoring,
   }: {
     onOriginSend?: () => void
     selectedFeeOption?: FeeOption | null
     depositTransactionHash?: string
     skipCommit?: boolean
-    commitOnly?: boolean
-    skipIntentMonitoring?: boolean
   }) => Promise<SendReturn>
 }
 

package/src/transactionIntent/utils/resilientDepositTracker.ts

@@ -1,10 +1,6 @@
 import type { PublicClient, TransactionReceipt } from "viem"
 import { logger } from "../../logger.js"
 import { POLLING_INTERVALS } from "../constants.js"
-import { getAccountTransactionHistory } from "../../transactions.js"
-import type { Account } from "viem"
-import { checkAccountBalance } from "./balanceChecker.js"
-import { MINUTE_MS } from "../../utils/time.js"
 
 export interface ResilientDepositTrackerOptions {
   publicClient: PublicClient
@@ -24,213 +20,106 @@ export interface ResilientDepositTrackerOptions {
 }
 
 /**
- * Resilient deposit tracker that handles RPC failures gracefully
- * Falls back to polling when transaction submission fails
+ * Resilient deposit tracker that validates a known deposit transaction hash
+ * via receipt polling, including replacement tx handling.
  */
 export async function trackDepositResilient({
   publicClient,
-  originChainId,
-  originIntentAddress,
-  originTokenAddress,
   depositAmount,
   txHash,
   abortSignal,
-  sequenceProjectAccessKey,
-  sequenceIndexerUrl,
   maxRetries = 60, // 60 attempts = ~3 minutes with 3s intervals
   onDepositDetected,
 }: ResilientDepositTrackerOptions): Promise<TransactionReceipt | null> {
   logger.console.log("[trails-sdk] Starting resilient deposit tracking", {
     hasHash: !!txHash,
     txHash,
-    originIntentAddress,
     depositAmount,
   })
 
-  let attempts = 0
-  let lastError: Error | null = null
-
-  // If we have a transaction hash, try to get its receipt first
-  if (txHash) {
-    while (attempts < maxRetries) {
-      if (abortSignal?.aborted) {
-        logger.console.log("[trails-sdk] Deposit tracking aborted by signal")
-        return null
-      }
-
-      try {
-        // Try to get the transaction receipt
-        const receipt = await publicClient.getTransactionReceipt({
-          hash: txHash,
-        })
-
-        if (receipt) {
-          logger.console.log("[trails-sdk] Deposit transaction receipt found", {
-            hash: receipt.transactionHash,
-            status: receipt.status,
-            blockNumber: receipt.blockNumber,
-          })
-
-          // Notify callback if provided
-          if (onDepositDetected) {
-            onDepositDetected(txHash, receipt)
-          }
-
-          return receipt
-        }
-      } catch (error) {
-        // Receipt not found yet, this is expected for pending transactions
-        if (attempts === 0) {
-          logger.console.log(
-            "[trails-sdk] Transaction receipt not available yet, will continue polling",
-            { txHash, error: (error as Error)?.message },
-          )
-        }
-        lastError = error as Error
-      }
-
-      attempts++
-      await new Promise((resolve) =>
-        setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_RECEIPT),
-      )
-    }
-
+  if (!txHash) {
     logger.console.warn(
-      "[trails-sdk] Could not get receipt for known transaction hash after retries",
-      {
-        txHash,
-        attempts,
-        lastError: lastError?.message,
-      },
+      "[trails-sdk] Resilient deposit tracker requires a tx hash; skipping receipt wait",
     )
+    return null
   }
 
-  // Fall back to polling the intent address for deposits
-  logger.console.log(
-    "[trails-sdk] Falling back to intent address polling for deposit detection",
-  )
-
-  attempts = 0
-  const pollingStartTime = Date.now()
-  const maxPollingDuration = 10 * MINUTE_MS // 10 minutes max
-
-  while (attempts < maxRetries) {
-    if (abortSignal?.aborted) {
-      logger.console.log("[trails-sdk] Deposit tracking aborted by signal")
-      return null
-    }
-
-    // Check if we've exceeded maximum polling duration
-    if (Date.now() - pollingStartTime > maxPollingDuration) {
-      logger.console.warn(
-        "[trails-sdk] Maximum polling duration exceeded for deposit detection",
-      )
-      break
-    }
-
-    try {
-      // Primary method: Check transaction history via indexer to find ANY transaction to intent address
-      if (sequenceIndexerUrl && sequenceProjectAccessKey) {
-        try {
-          const response = await getAccountTransactionHistory({
-            chainId: originChainId,
-            accountAddress: originIntentAddress,
-            abortSignal,
-            apiKey: sequenceProjectAccessKey,
-            indexerUrl: sequenceIndexerUrl,
-          })
-
-          if (response.transactions.length > 0) {
-            const recentTx = response.transactions[0]
-            if (recentTx?.txnHash) {
-              logger.console.log(
-                "[trails-sdk] Found deposit transaction to intent address via indexer",
-                { txHash: recentTx.txnHash },
-              )
-
-              // Get the full receipt
-              const receipt = await publicClient.getTransactionReceipt({
-                hash: recentTx.txnHash as `0x${string}`,
-              })
-
-              logger.console.log(
-                "[trails-sdk] Deposit transaction detected - proceeding",
-                {
-                  txHash: receipt.transactionHash,
-                  to: receipt.to,
-                  status: receipt.status,
-                },
-              )
-
-              // Notify callback if provided
-              if (onDepositDetected) {
-                onDepositDetected(
-                  receipt.transactionHash as `0x${string}`,
-                  receipt,
-                )
-              }
-
-              return receipt
-            }
-          }
-        } catch (indexerError) {
-          logger.console.debug(
-            "[trails-sdk] Indexer check failed, will continue polling",
-            { error: (indexerError as Error)?.message },
-          )
-        }
-      }
-
-      // Fallback method: Check if ANY balance exists at the intent address
-      // This indicates a transaction has occurred even if we can't find the specific tx
-      const balanceCheck = await checkAccountBalance({
-        account: {
-          address: originIntentAddress as `0x${string}`,
-        } as Account,
-        tokenAddress: originTokenAddress,
-        depositAmount: "1", // Check for any non-zero balance
-        publicClient: publicClient,
-      })
+  if (abortSignal?.aborted) {
+    logger.console.log("[trails-sdk] Deposit tracking aborted by signal")
+    return null
+  }
 
-      if (balanceCheck.hasEnoughBalance) {
+  let resolvedHash: `0x${string}` = txHash
+  const timeoutMs = maxRetries * POLLING_INTERVALS.TRANSACTION_RECEIPT
+  let timeoutId: ReturnType<typeof setTimeout> | null = null
+
+  try {
+    const receiptPromise = publicClient.waitForTransactionReceipt({
+      hash: txHash,
+      retryCount: maxRetries,
+      retryDelay: POLLING_INTERVALS.TRANSACTION_RECEIPT,
+      onReplaced: (replacement) => {
+        resolvedHash = replacement.transaction.hash
         logger.console.log(
-          "[trails-sdk] Detected funds at intent address (transaction occurred)",
+          "[trails-sdk] Deposit transaction replaced while waiting for receipt",
           {
-            balance: balanceCheck.balanceFormatted,
-            intentAddress: originIntentAddress,
+            reason: replacement.reason,
+            replacedHash: replacement.replacedTransaction.hash,
+            replacementHash: replacement.transaction.hash,
           },
         )
-
-        // We detected a deposit via balance, but don't have the tx hash
-        // This means a transaction definitely occurred
-        // Return null to indicate we detected funds but have no transaction details
-        logger.console.log(
-          "[trails-sdk] Funds detected but no transaction hash available - proceeding anyway",
-        )
-        return null
-      }
-    } catch (error) {
-      logger.console.debug("[trails-sdk] Error during deposit polling", {
-        attempt: attempts,
-        error: (error as Error)?.message,
-      })
+      },
+    })
+
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      timeoutId = setTimeout(() => {
+        reject(new Error("Timed out waiting for transaction receipt"))
+      }, timeoutMs)
+    })
+
+    const abortPromise = new Promise<never>((_, reject) => {
+      if (!abortSignal) return
+      abortSignal.addEventListener(
+        "abort",
+        () =>
+          reject(new Error("Aborted while waiting for transaction receipt")),
+        { once: true },
+      )
+    })
+
+    const receipt = await Promise.race([
+      receiptPromise,
+      timeoutPromise,
+      abortPromise,
+    ])
+
+    logger.console.log("[trails-sdk] Deposit transaction receipt found", {
+      hash: receipt.transactionHash,
+      status: receipt.status,
+      blockNumber: receipt.blockNumber,
+    })
+
+    if (onDepositDetected) {
+      onDepositDetected(resolvedHash, receipt)
     }
 
-    attempts++
-    await new Promise((resolve) =>
-      setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY),
+    return receipt
+  } catch (error) {
+    logger.console.warn(
+      "[trails-sdk] Could not get receipt for known transaction hash",
+      {
+        txHash,
+        resolvedHash,
+        timeoutMs,
+        error: (error as Error)?.message,
+      },
     )
+    return null
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId)
+    }
   }
-
-  logger.console.warn(
-    "[trails-sdk] Deposit tracking ended without detecting deposit",
-    {
-      attempts,
-      duration: Date.now() - pollingStartTime,
-    },
-  )
-
-  return null
 }
 
 /**

package/src/transactions.ts

@@ -101,6 +101,22 @@ export type GetAccountTransactionHistoryParams = {
   abortSignal?: AbortSignal
 }
 
+export function isSyntheticTransactionHash(
+  transactionHash?: string | null,
+): boolean {
+  const normalizedHash = transactionHash?.toLowerCase()
+
+  return Boolean(normalizedHash && /0{10,}$/.test(normalizedHash))
+}
+
+export function isDisplayableTransactionHash(
+  transactionHash?: string | null,
+): transactionHash is string {
+  return Boolean(
+    transactionHash && !isSyntheticTransactionHash(transactionHash),
+  )
+}
+
 function isTransactionHistoryItemFromApi(
   value: unknown,
 ): value is TransactionHistoryItemFromAPI {

package/src/walletUtils.ts

@@ -1,9 +1,184 @@
 import type { Connector } from "wagmi"
-import type { WalletClient } from "viem"
+import {
+  BaseError,
+  formatTransactionRequest,
+  InvalidInputRpcError,
+  InvalidParamsRpcError,
+  MethodNotFoundRpcError,
+  MethodNotSupportedRpcError,
+  UnknownRpcError,
+  type RpcTransactionRequest,
+  type WalletClient,
+} from "viem"
+import { parseAccount } from "viem/accounts"
+import { attemptSwitchChain } from "./chainSwitch.js"
 import { getIsContract } from "./contractUtils.js"
 import { SECOND_MS } from "./utils/time.js"
 import { logger } from "./logger.js"
 
+type WalletSendTransactionParams = Parameters<
+  WalletClient["sendTransaction"]
+>[0]
+
+// Matches viem fallback trigger errors while probing wallet_sendTransaction:
+// https://github.com/wevm/viem/blob/main/src/actions/wallet/sendTransaction.ts
+function isUnsupportedWalletNamespaceError(error: unknown): boolean {
+  return (
+    error instanceof InvalidInputRpcError ||
+    error instanceof InvalidParamsRpcError ||
+    error instanceof MethodNotFoundRpcError ||
+    error instanceof MethodNotSupportedRpcError
+  )
+}
+
+// EIP-1474 defines "method not supported" as -32004:
+// https://eips.ethereum.org/EIPS/eip-1474#error-codes
+// Some Privy RPC endpoints currently return non-standard -32604 for
+// wallet_sendTransaction, which viem surfaces as UnknownRpcError instead of
+// MethodNotSupportedRpcError. We normalize that shape here so fallback can run.
+function isUnsupportedPrivyWalletSendTransactionError(error: unknown): boolean {
+  if (!(error instanceof UnknownRpcError)) {
+    return false
+  }
+
+  const details = error.details.toLowerCase()
+  return (
+    details.includes("method is not supported") || details.includes("-32604")
+  )
+}
+
+function isRecoverableWalletSendError(error: unknown): boolean {
+  if (
+    isUnsupportedWalletNamespaceError(error) ||
+    isUnsupportedPrivyWalletSendTransactionError(error)
+  ) {
+    return true
+  }
+
+  if (error instanceof BaseError) {
+    return (
+      error.walk(
+        (innerError) =>
+          isUnsupportedWalletNamespaceError(innerError) ||
+          isUnsupportedPrivyWalletSendTransactionError(innerError),
+      ) !== null
+    )
+  }
+
+  return false
+}
+
+function buildEthSendTransactionRequest(
+  txParams: WalletSendTransactionParams,
+): RpcTransactionRequest {
+  if (!txParams.account) {
+    throw new Error(
+      "Wallet account address is required for eth_sendTransaction fallback",
+    )
+  }
+
+  const { chain: _chain, account, ...request } = txParams
+
+  return formatTransactionRequest({
+    ...request,
+    account: parseAccount(account),
+  })
+}
+
+async function getTransportChainId(
+  transport: WalletClient["transport"],
+): Promise<number> {
+  if (!transport || typeof transport.request !== "function") {
+    throw new Error("Invalid wallet transport")
+  }
+
+  const currentChainIdHex = await transport.request({ method: "eth_chainId" })
+  if (typeof currentChainIdHex !== "string") {
+    throw new Error("Wallet transport returned an invalid chain ID")
+  }
+
+  const currentChainId = Number.parseInt(currentChainIdHex, 16)
+  if (!Number.isSafeInteger(currentChainId)) {
+    throw new Error("Wallet transport returned an invalid chain ID")
+  }
+
+  return currentChainId
+}
+
+async function assertFallbackTransportMatchesChain(
+  walletClient: WalletClient,
+  txParams: WalletSendTransactionParams,
+): Promise<void> {
+  const expectedChainId = txParams.chain?.id
+  if (!expectedChainId) {
+    return
+  }
+
+  const transport = walletClient.transport
+  let currentChainId = await getTransportChainId(transport)
+
+  if (currentChainId !== expectedChainId) {
+    logger.console.warn(
+      "[wallet-utils] Switching wallet transport chain before eth_sendTransaction fallback",
+      {
+        currentChainId,
+        expectedChainId,
+      },
+    )
+
+    await attemptSwitchChain({
+      walletClient,
+      desiredChainId: expectedChainId,
+    })
+
+    currentChainId = await getTransportChainId(transport)
+    if (currentChainId !== expectedChainId) {
+      throw new Error(
+        `Wallet transport chain ID ${currentChainId} does not match requested chain ID ${expectedChainId}`,
+      )
+    }
+  }
+}
+
+export async function sendWalletTransaction(
+  walletClient: WalletClient,
+  txParams: WalletSendTransactionParams,
+): Promise<`0x${string}`> {
+  try {
+    return await walletClient.sendTransaction(txParams)
+  } catch (error) {
+    if (!isRecoverableWalletSendError(error)) {
+      throw error
+    }
+
+    logger.console.warn(
+      "[wallet-utils] Falling back to eth_sendTransaction for wallet send",
+      {
+        error: error instanceof Error ? error.message : String(error),
+      },
+    )
+
+    const fallbackRequest = buildEthSendTransactionRequest(txParams)
+    const transport = walletClient.transport
+    if (!transport || typeof transport.request !== "function") {
+      throw new Error("Invalid wallet transport")
+    }
+
+    await assertFallbackTransportMatchesChain(walletClient, txParams)
+
+    // Send directly through transport with eth_sendTransaction to bypass
+    // wallet namespace probing for providers that reject wallet_sendTransaction.
+    // Related viem logic:
+    // https://github.com/wevm/viem/blob/main/src/actions/wallet/sendTransaction.ts
+    const txHash = await transport.request({
+      method: "eth_sendTransaction",
+      params: [fallbackRequest],
+    })
+
+    return txHash as `0x${string}`
+  }
+}
+
 /**
  * Checks if a wallet connector is a Sequence wallet.
  * @param connector - The wagmi connector to check
@@ -26,6 +201,18 @@ export function isSequenceWalletById(walletId: string | undefined): boolean {
   return walletId.toLowerCase().includes("sequence")
 }
 
+export function isWalletConnectConnector(
+  connector: Connector | undefined,
+): boolean {
+  if (!connector) return false
+  const connectorName = connector.name?.toLowerCase() || ""
+  const connectorId = connector.id?.toLowerCase() || ""
+  return (
+    connectorName.includes("walletconnect") ||
+    connectorId.includes("walletconnect")
+  )
+}
+
 /**
  * Checks if an address is a smart contract wallet.
  * @param address - The wallet address to check