0xtrails 0.13.2 → 0.14.0

package/src/transactionIntent/deposits/standardDeposit.ts

@@ -1,590 +0,0 @@
-import type {
-  Account,
-  Chain,
-  PublicClient,
-  WalletClient,
-  TransactionReceipt,
-} from "viem"
-import { parseUnits } from "viem"
-import type { TransactionState } from "../../transactions.js"
-import type { CheckoutOnHandlers } from "../../widget/hooks/useCheckout.js"
-import { logger } from "../../logger.js"
-import { sendOriginTransaction } from "../../intents.js"
-import { getIsCustomCalldata } from "../../contractUtils.js"
-import type { QueryClient } from "@tanstack/react-query"
-import { attemptSwitchChain } from "../../chainSwitch.js"
-import { requestWithTimeout } from "../../utils.js"
-import { isNativeToken, addressEqual } from "../../utils/address.js"
-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 {
-  trackDepositResilient,
-  isRecoverableDepositError,
-} from "../utils/resilientDepositTracker.js"
-import { ensureErc20Approval } from "../utils/erc20Approval.js"
-
-/**
- * Handles the deposit transaction for the INTENT FLOW (non-passthrough).
- *
- * This is used when:
- * - Cross-chain swaps (different origin/destination chains)
- * - Different token swaps (origin token !== destination token)
- * - Gasless/ERC20 fee option selected (not native token)
- * - Non-wallet fund methods (onramp, direct-transfer, etc.)
- *
- * For same-chain same-token with native gas, the passthrough flow
- * (executePassthrough in intentHandler.ts) is used instead.
- */
-export async function attemptStandardDeposit({
-  originTokenAddress,
-  depositAmount,
-  onOriginSend,
-  publicClient,
-  walletClient,
-  originChainId,
-  chain,
-  account,
-  originIntentAddress,
-  onTransactionStateChange,
-  depositTransaction,
-  transactionStates,
-  originTokenSymbol,
-  destinationTokenSymbol,
-  depositAmountUsd,
-  checkoutOnHandlers,
-  isSameChainSameToken,
-  recipient,
-  destinationCalldata,
-  sequenceProjectAccessKey,
-  sequenceIndexerUrl,
-  abortSignal,
-}: {
-  queryClient?: QueryClient
-  originTokenAddress: string
-  depositAmount: string
-  onOriginSend?: () => void
-  publicClient: PublicClient
-  walletClient: WalletClient
-  originChainId: number
-  chain: Chain
-  account: Account
-  sourceTokenPriceUsd?: number | null
-  destinationTokenPriceUsd?: number | null
-  swapAmount: string
-  destinationTokenDecimals: number
-  sourceTokenDecimals: number
-  originIntentAddress: string
-  onTransactionStateChange: (transactionStates: TransactionState[]) => void
-  transactionStates: TransactionState[]
-  originTokenSymbol: string
-  destinationTokenSymbol: string
-  depositAmountUsd: number
-  checkoutOnHandlers?: Partial<CheckoutOnHandlers>
-  isSameChainSameToken?: boolean
-  recipient?: string
-  destinationCalldata?: string
-  sequenceProjectAccessKey?: string
-  sequenceIndexerUrl?: string
-  abortSignal?: AbortSignal
-  depositTransaction?: {
-    to: string
-    data: string
-    value?: string | bigint
-    chainId: number
-  }
-}): Promise<TransactionReceipt | null> {
-  logger.console.log("[trails-sdk] [standard-deposit] initiating deposit...")
-  let depositUserTxnReceipt: TransactionReceipt | null = null
-  const needsNativeFee = false
-
-  let nativeFee = parseUnits("0.00005", 18).toString()
-  if (originChainId === 137) {
-    nativeFee = parseUnits("1.5", 18).toString()
-  }
-
-  logger.console.log("[trails-sdk] needsNativeFee", needsNativeFee)
-
-  const effectiveRecipient = recipient || originIntentAddress
-  const isIntentRecipient = addressEqual(
-    effectiveRecipient,
-    originIntentAddress,
-  )
-  const hasCustomCalldataForDeposit =
-    !!isSameChainSameToken &&
-    getIsCustomCalldata(destinationCalldata) &&
-    !isIntentRecipient
-
-  // Use API-provided depositTransaction directly
-  if (!depositTransaction) {
-    throw new Error("depositTransaction is required from API")
-  }
-  if (!depositTransaction.to) {
-    throw new Error("depositTransaction.to is required from API")
-  }
-  if (!depositTransaction.data) {
-    throw new Error("depositTransaction.data is required from API")
-  }
-  if (depositTransaction.value == null) {
-    throw new Error("depositTransaction.value is required from API")
-  }
-  if (chain.id !== depositTransaction.chainId) {
-    throw new Error(
-      `Chain ID mismatch: expected ${chain.id}, got ${depositTransaction.chainId}`,
-    )
-  }
-  const originCallParamsBase = {
-    to: depositTransaction.to,
-    data: depositTransaction.data,
-    value: depositTransaction.value,
-    chain,
-  }
-
-  const hasCustomCalldata = hasCustomCalldataForDeposit
-
-  // Handle ERC20 approval for intent flow with custom calldata.
-  // This is needed when the recipient contract (e.g., Aave) needs to
-  // transferFrom the user's tokens via the intent system.
-  if (
-    isSameChainSameToken &&
-    !isNativeToken(originTokenAddress) &&
-    hasCustomCalldata &&
-    recipient
-  ) {
-    await ensureErc20Approval({
-      tokenAddress: originTokenAddress,
-      spender: recipient,
-      requiredAmount: BigInt(depositAmount),
-      account,
-      publicClient,
-      walletClient,
-      chain,
-      depositAmountUsd,
-      checkoutOnHandlers,
-      logPrefix: "[trails-sdk] [intent-flow]",
-    })
-  }
-
-  await attemptSwitchChain({
-    walletClient,
-    desiredChainId: originChainId,
-  })
-
-  let useSendCalls = false
-  const moreThan1Tx = needsNativeFee
-
-  if (moreThan1Tx) {
-    try {
-      // the reason for the timeout is some users experience this call to hang indefinitely on metamask on all chains.
-      // not sure why this is happening, but it happens.
-      const capabilities = await requestWithTimeout<Record<string, any>>(
-        walletClient,
-        [
-          {
-            method: "wallet_getCapabilities",
-            params: [account.address],
-          },
-        ],
-        10000,
-      )
-
-      logger.console.log("[trails-sdk] capabilities", capabilities)
-
-      // Check if the chain supports atomic transactions
-      const chainHex = `0x${originChainId.toString(16)}` as const
-      const chainCapabilities = capabilities[chainHex]
-      useSendCalls = chainCapabilities?.atomic?.status === "supported"
-    } catch (error) {
-      logger.console.error("[trails-sdk] Error getting capabilities", error)
-    }
-  }
-
-  if (useSendCalls) {
-    logger.console.log("[trails-sdk] using sendCalls")
-  } else {
-    logger.console.log("[trails-sdk] using sendTransaction")
-  }
-
-  if (useSendCalls) {
-    const calls: Array<{
-      to: `0x${string}`
-      data: `0x${string}`
-      value?: `0x${string}`
-    }> = []
-    if (needsNativeFee) {
-      calls.push({
-        to: originIntentAddress as `0x${string}`,
-        data: "0x00",
-        value: `0x${BigInt(nativeFee).toString(16)}` as `0x${string}`,
-      })
-    }
-
-    // Add the origin call
-    calls.push({
-      to: originCallParamsBase.to as `0x${string}`,
-      data: originCallParamsBase.data as `0x${string}`,
-      value: originCallParamsBase.value
-        ? `0x${BigInt(originCallParamsBase.value).toString(16)}`
-        : "0x0",
-    })
-
-    // Update persistent toast before wallet interaction
-    updatePersistentToast(
-      "Waiting for Confirmation",
-      "Please confirm the transaction in your wallet...",
-      "info",
-    )
-
-    // Send the batched call via EIP-7702
-    const result = (await walletClient.request({
-      method: "wallet_sendCalls",
-      params: [
-        {
-          version: "2.0.0",
-          chainId: `0x${originChainId.toString(16)}`,
-          atomicRequired: true,
-          calls,
-        },
-      ],
-    })) as { requestId: `0x${string}` }
-
-    logger.console.log("[trails-sdk] sendCalls result", result)
-    const requestId = result.requestId || (result as any).id
-
-    // Poll to check if the tx has been submitted
-    let txHash: `0x${string}` | undefined
-    while (!txHash) {
-      const status = (await walletClient.request({
-        method: "wallet_getCallsStatus",
-        params: [requestId],
-      })) as {
-        status: "pending" | "submitted" | "failed"
-        transactionHash?: `0x${string}`
-        error?: string
-      }
-
-      logger.console.log("[trails-sdk] getCallsStatus result", status)
-      const receipt = (status as any)?.receipts?.[0]
-
-      if ((status as any).status === 200 && receipt?.transactionHash) {
-        txHash = receipt.transactionHash
-        break
-      } else if ((status as any).status === 500) {
-        throw new Error(`Transaction failed: ${status.error}`)
-      }
-
-      // wait a bit before polling again
-      await new Promise((r) => setTimeout(r, 2 * SECOND_MS))
-    }
-
-    if (onOriginSend) {
-      onOriginSend()
-    }
-
-    // Update persistent toast after transaction sent
-    const chainInfo = getChainInfo(originChainId)
-    updatePersistentToast(
-      "Transaction Submitted",
-      `Waiting for confirmation on ${chainInfo?.name || "chain"}...`,
-      "info",
-    )
-
-    const receipt = await publicClient.waitForTransactionReceipt({
-      hash: txHash as `0x${string}`,
-      retryCount: 10,
-      onReplaced: (replacement) => {
-        logger.console.log(
-          "[trails-sdk] wallet_sendCalls deposit transaction replaced",
-          {
-            reason: replacement.reason,
-            replacedHash: replacement.replacedTransaction.hash,
-            replacementHash: replacement.transaction.hash,
-          },
-        )
-      },
-    })
-    logger.console.log("[trails-sdk] receipt", receipt)
-    depositUserTxnReceipt = receipt
-  } else {
-    if (needsNativeFee) {
-      // Trigger signature request callback before prompting wallet
-      if (checkoutOnHandlers?.triggerCheckoutSignatureRequest) {
-        checkoutOnHandlers.triggerCheckoutSignatureRequest()
-      }
-
-      try {
-        const txHashNativeFee = await sendOriginTransaction(
-          account,
-          walletClient,
-          {
-            to: originIntentAddress,
-            data: "0x00",
-            value: nativeFee,
-            chainId: originChainId,
-            chain,
-          } as any,
-          {
-            depositTokenAmountUsd: depositAmountUsd?.toString(),
-          },
-        ) // TODO: Add proper type
-        logger.console.log("[trails-sdk] origin tx native fee", txHashNativeFee)
-
-        // Trigger signature confirmed callback after successful signing
-        if (checkoutOnHandlers?.triggerCheckoutSignatureConfirmed) {
-          checkoutOnHandlers.triggerCheckoutSignatureConfirmed()
-        }
-        // Wait for transaction receipt
-        const feeReceipt = await publicClient.waitForTransactionReceipt({
-          hash: txHashNativeFee,
-          retryCount: 10,
-          onReplaced: (replacement) => {
-            logger.console.log("[trails-sdk] Native fee transaction replaced", {
-              reason: replacement.reason,
-              replacedHash: replacement.replacedTransaction.hash,
-              replacementHash: replacement.transaction.hash,
-            })
-          },
-        })
-        logger.console.log("[trails-sdk] nativeFeeReceipt", feeReceipt)
-      } catch (error) {
-        // Check if this is a user rejection error
-        if (getIsUserRejectionError(error)) {
-          if (checkoutOnHandlers?.triggerCheckoutSignatureRejected) {
-            checkoutOnHandlers.triggerCheckoutSignatureRejected(error)
-          }
-        }
-        throw error
-      }
-    }
-
-    // Show persistent toast for checkout flow
-    updatePersistentToast(
-      "Payment Started",
-      "Waiting for wallet confirmation...",
-      "info",
-    )
-
-    // Trigger signature request callback before prompting wallet
-    if (checkoutOnHandlers?.triggerCheckoutSignatureRequest) {
-      checkoutOnHandlers.triggerCheckoutSignatureRequest()
-    }
-
-    let txHash: `0x${string}` | null = null
-    let sendError: unknown = null
-
-    try {
-      txHash = await sendOriginTransaction(
-        account,
-        walletClient,
-        originCallParamsBase as any,
-        {
-          depositTokenAmountUsd: depositAmountUsd?.toString(),
-        },
-      ) // TODO: Add proper type
-      logger.console.log("[trails-sdk] origin tx", txHash)
-
-      // Trigger signature confirmed callback after early executeIntent
-      if (checkoutOnHandlers?.triggerCheckoutSignatureConfirmed) {
-        checkoutOnHandlers?.triggerCheckoutSignatureConfirmed?.()
-      }
-    } catch (error) {
-      sendError = error
-      logger.console.error(
-        "[trails-sdk] Error sending deposit transaction",
-        error,
-      )
-
-      // Check if this is a user rejection error
-      if (getIsUserRejectionError(error)) {
-        if (checkoutOnHandlers?.triggerCheckoutSignatureRejected) {
-          checkoutOnHandlers.triggerCheckoutSignatureRejected(error)
-        }
-        throw error // User rejections should fail immediately
-      }
-
-      // For recoverable errors, log but don't throw yet
-      if (!isRecoverableDepositError(error)) {
-        throw error // Non-recoverable errors should fail
-      }
-
-      logger.console.log(
-        "[trails-sdk] Deposit send failed with recoverable error, will attempt polling",
-        { error: (error as Error)?.message },
-      )
-    }
-
-    // Handle successful transaction hash or fall back to resilient tracking
-    if (txHash) {
-      if (onOriginSend) {
-        onOriginSend()
-      }
-
-      if (transactionStates[0]) {
-        transactionStates[0].state = "pending"
-        transactionStates[0].transactionHash = txHash
-
-        try {
-          onTransactionStateChange(transactionStates)
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error calling onTransactionStateChange:",
-            error,
-          )
-        }
-      }
-
-      // Try normal receipt retrieval first
-      try {
-        // Wait for transaction receipt
-        const receipt = await publicClient.waitForTransactionReceipt({
-          hash: txHash,
-          retryCount: 10,
-          onReplaced: (replacement) => {
-            logger.console.log("[trails-sdk] Deposit transaction replaced", {
-              reason: replacement.reason,
-              replacedHash: replacement.replacedTransaction.hash,
-              replacementHash: replacement.transaction.hash,
-            })
-          },
-        })
-
-        const chainInfo = getChainInfo(originChainId)
-        updatePersistentToast(
-          "Transfer Confirmed",
-          `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
-          "info",
-        )
-
-        trackTransactionConfirmed({
-          transactionHash: txHash,
-          chainId: originChainId,
-          userAddress: account.address,
-          blockNumber: Number(receipt.blockNumber),
-          originIntentAddress,
-          originTokenSymbol,
-          destinationTokenSymbol,
-          depositTokenAmountUsd: depositAmountUsd?.toString(),
-        })
-
-        logger.console.log("[trails-sdk] receipt", receipt)
-        depositUserTxnReceipt = receipt
-      } catch (receiptError) {
-        logger.console.warn(
-          "[trails-sdk] Could not get receipt, using resilient tracking",
-          { txHash, error: (receiptError as Error)?.message },
-        )
-
-        // Fall back to resilient tracking with known tx hash
-        depositUserTxnReceipt = await trackDepositResilient({
-          publicClient,
-          originChainId,
-          originIntentAddress,
-          originTokenAddress,
-          depositAmount,
-          txHash,
-          abortSignal,
-          sequenceProjectAccessKey,
-          sequenceIndexerUrl,
-          onDepositDetected: (hash, receipt) => {
-            const chainInfo = getChainInfo(originChainId)
-            updatePersistentToast(
-              "Transfer Confirmed",
-              `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
-              "info",
-            )
-
-            if (receipt?.status === "success" && hash) {
-              trackTransactionConfirmed({
-                transactionHash: hash,
-                chainId: originChainId,
-                userAddress: account.address,
-                blockNumber: Number(receipt.blockNumber || 0),
-                originIntentAddress,
-                originTokenSymbol,
-                destinationTokenSymbol,
-                depositTokenAmountUsd: depositAmountUsd?.toString(),
-              })
-            }
-          },
-        })
-      }
-    } else if (sendError && isRecoverableDepositError(sendError)) {
-      // No transaction hash but error is recoverable - start polling
-      logger.console.log(
-        "[trails-sdk] Starting resilient deposit tracking after send failure",
-      )
-
-      updatePersistentToast(
-        "Checking Transaction",
-        "Verifying transaction status...",
-        "info",
-      )
-
-      depositUserTxnReceipt = await trackDepositResilient({
-        publicClient,
-        originChainId,
-        originIntentAddress,
-        originTokenAddress,
-        depositAmount,
-        txHash: null,
-        abortSignal,
-        sequenceProjectAccessKey,
-        sequenceIndexerUrl,
-        onDepositDetected: (detectedHash, receipt) => {
-          logger.console.log(
-            "[trails-sdk] Deposit detected via resilient tracking",
-            { hash: detectedHash },
-          )
-
-          if (onOriginSend) {
-            onOriginSend()
-          }
-
-          if (transactionStates[0] && detectedHash) {
-            transactionStates[0].state = "pending"
-            transactionStates[0].transactionHash = detectedHash
-
-            try {
-              onTransactionStateChange(transactionStates)
-            } catch (error) {
-              logger.console.error(
-                "[trails-sdk] Error calling onTransactionStateChange:",
-                error,
-              )
-            }
-          }
-
-          const chainInfo = getChainInfo(originChainId)
-          updatePersistentToast(
-            "Transfer Confirmed",
-            `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
-            "info",
-          )
-
-          if (receipt?.status === "success" && detectedHash) {
-            trackTransactionConfirmed({
-              transactionHash: detectedHash,
-              chainId: originChainId,
-              userAddress: account.address,
-              blockNumber: Number(receipt.blockNumber || 0),
-              originIntentAddress,
-              originTokenSymbol,
-              destinationTokenSymbol,
-              depositTokenAmountUsd: depositAmountUsd?.toString(),
-            })
-          }
-        },
-      })
-
-      if (!depositUserTxnReceipt) {
-        throw new Error(
-          "Deposit transaction could not be confirmed. Please check your wallet and try again.",
-        )
-      }
-    }
-  }
-
-  return depositUserTxnReceipt
-}

package/src/transactionIntent/execution/index.ts

@@ -1 +0,0 @@
-export * from "./transactionState.js"

package/src/transactionIntent/execution/transactionState.ts

@@ -1,38 +0,0 @@
-import type { TransactionReceipt } from "viem"
-import type { IntentTransaction } from "@0xtrails/api"
-import type {
-  TransactionState,
-  TransactionStateStatus,
-} from "../../transactions.js"
-import { getExplorerUrl } from "../../explorer.js"
-
-export function getTransactionStateFromReceipt(
-  receipt: TransactionReceipt | IntentTransaction,
-  chainId: number,
-  label: string = "Transaction",
-): TransactionState {
-  let txHash: string = ""
-  let state: TransactionStateStatus = "pending"
-  let blockNumber: number = 0
-  if ("transactionHash" in receipt) {
-    txHash = receipt.transactionHash
-    state = receipt.status === "success" ? "confirmed" : "failed"
-    blockNumber = Number(receipt.blockNumber)
-  } else if ("txnHash" in receipt) {
-    txHash = receipt.txnHash || ""
-    state = receipt.status === "SUCCEEDED" ? "confirmed" : "failed"
-    blockNumber = 0 // IntentTransaction doesn't have blockNumber
-  }
-
-  const txnMinedAt = "txnMinedAt" in receipt ? receipt.txnMinedAt : undefined
-
-  return {
-    transactionHash: txHash,
-    explorerUrl: getExplorerUrl({ txHash, chainId }),
-    chainId,
-    blockNumber,
-    state,
-    label,
-    txnMinedAt,
-  }
-}

package/src/transactionIntent/handlers/index.ts

@@ -1 +0,0 @@
-export * from "./intentHandler.js"