0xtrails 0.2.5 → 0.3.0

package/src/transactionIntent/deposits/standardDeposit.ts

@@ -0,0 +1,379 @@
+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 { getNeedsLifiNativeFee } from "../utils/lifiHelpers.js"
+import {
+  buildCrossChainDepositParams,
+  buildSameChainSameTokenTransactionParams,
+  sendOriginTransaction,
+} from "../../intents.js"
+import { estimateGasLimit } from "../../estimate.js"
+import { attemptSwitchChain } from "../../chainSwitch.js"
+import { requestWithTimeout } from "../../utils.js"
+import { updatePersistentToast } from "../../toast.js"
+import { getChainInfo } from "../../chains.js"
+import { trackTransactionConfirmed } from "../../analytics.js"
+
+export async function attemptStandardDeposit({
+  originTokenAddress,
+  firstPreconditionMin,
+  onOriginSend,
+  publicClient,
+  walletClient,
+  originChainId,
+  chain,
+  account,
+  fee,
+  dryMode,
+  sourceTokenPriceUsd,
+  destinationTokenPriceUsd,
+  swapAmount,
+  destinationTokenDecimals,
+  sourceTokenDecimals,
+  originIntentAddress,
+  onTransactionStateChange,
+  transactionStates,
+  originTokenSymbol,
+  destinationTokenSymbol,
+  depositAmountUsd,
+  checkoutOnHandlers,
+  isSameChainSameToken,
+  recipient,
+}: {
+  originTokenAddress: string
+  firstPreconditionMin: string
+  onOriginSend?: () => void
+  publicClient: PublicClient
+  walletClient: WalletClient
+  originChainId: number
+  chain: Chain
+  account: Account
+  fee: string
+  dryMode: boolean
+  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?: CheckoutOnHandlers
+  isSameChainSameToken?: boolean
+  recipient?: string
+}): Promise<TransactionReceipt | null> {
+  let depositUserTxnReceipt: TransactionReceipt | null = null
+  const usingLIfi = false
+  let needsNativeFee = false
+
+  if (usingLIfi) {
+    needsNativeFee = getNeedsLifiNativeFee({
+      originTokenAddress,
+      destinationTokenAmount: swapAmount,
+      destinationTokenDecimals,
+      sourceTokenDecimals,
+      sourceTokenPriceUsd: sourceTokenPriceUsd ?? null,
+      destinationTokenPriceUsd: destinationTokenPriceUsd ?? null,
+      depositAmount: firstPreconditionMin,
+    })
+  }
+  let nativeFee = parseUnits("0.00005", 18).toString()
+  if (originChainId === 137) {
+    nativeFee = parseUnits("1.5", 18).toString()
+  }
+
+  logger.console.log("[trails-sdk] needsNativeFee", needsNativeFee)
+
+  // Build origin call params
+  // For same-chain deposits, send directly to recipient (not intent address)
+  // For cross-chain deposits, send to intent address for backend processing
+  const originCallParamsBase = isSameChainSameToken
+    ? buildSameChainSameTokenTransactionParams({
+        hasCustomCalldata: false,
+        recipient: recipient || originIntentAddress,
+        effectiveOriginTokenAddress: originTokenAddress,
+        swapAmount: firstPreconditionMin,
+        effectiveOriginChainId: originChainId,
+        effectiveOriginChain: chain,
+      })
+    : buildCrossChainDepositParams({
+        originTokenAddress,
+        originIntentAddress,
+        depositAmount: firstPreconditionMin,
+        fee,
+        originChainId,
+        chain,
+      })
+
+  // Estimate gas limit for consistency with actual transaction
+  const gasLimit = await estimateGasLimit(
+    publicClient,
+    {
+      account: account.address,
+      to: originCallParamsBase.to,
+      data: originCallParamsBase.data,
+      value: BigInt(originCallParamsBase.value),
+    },
+    "deposit",
+  )
+
+  const originCallParams = {
+    ...originCallParamsBase,
+    gasLimit,
+  }
+
+  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 (dryMode) {
+    logger.console.log("[trails-sdk] dry mode, skipping send calls")
+  }
+
+  if (useSendCalls) {
+    logger.console.log("[trails-sdk] using sendCalls")
+  } else {
+    logger.console.log("[trails-sdk] using sendTransaction")
+  }
+
+  if (useSendCalls) {
+    if (!dryMode) {
+      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: originCallParams.to as `0x${string}`,
+        data: originCallParams.data as `0x${string}`,
+        value: originCallParams.value
+          ? `0x${BigInt(originCallParams.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, 2000))
+      }
+
+      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}`,
+      })
+      logger.console.log("[trails-sdk] receipt", receipt)
+      depositUserTxnReceipt = receipt
+    }
+  } else {
+    if (!dryMode) {
+      if (needsNativeFee) {
+        // Trigger signature request callback before prompting wallet
+        if (checkoutOnHandlers?.triggerCheckoutSignatureRequest) {
+          checkoutOnHandlers.triggerCheckoutSignatureRequest()
+        }
+
+        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,
+        })
+        logger.console.log("[trails-sdk] nativeFeeReceipt", feeReceipt)
+      }
+
+      // 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()
+      }
+
+      const txHash = await sendOriginTransaction(
+        account,
+        walletClient,
+        originCallParams as any,
+        {
+          depositTokenAmountUsd: depositAmountUsd?.toString(),
+        },
+      ) // TODO: Add proper type
+      logger.console.log("[trails-sdk] origin tx", txHash)
+
+      // Trigger signature confirmed callback after successful signing
+      if (checkoutOnHandlers?.triggerCheckoutSignatureConfirmed) {
+        checkoutOnHandlers.triggerCheckoutSignatureConfirmed()
+      }
+
+      if (onOriginSend) {
+        onOriginSend()
+      }
+
+      if (transactionStates[0]) {
+        transactionStates[0].state = "pending"
+
+        try {
+          onTransactionStateChange(transactionStates)
+        } catch (error) {
+          logger.console.error(
+            "[trails-sdk] Error calling onTransactionStateChange:",
+            error,
+          )
+        }
+      }
+
+      // Wait for transaction receipt
+      const receipt = await publicClient.waitForTransactionReceipt({
+        hash: txHash,
+      })
+
+      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
+    }
+  }
+
+  return depositUserTxnReceipt
+}

package/src/transactionIntent/execution/index.ts

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

package/src/transactionIntent/execution/transactionState.ts

@@ -0,0 +1,35 @@
+import type { TransactionReceipt } from "viem"
+import type { MetaTxnReceipt } from "../types.js"
+import type {
+  TransactionState,
+  TransactionStateStatus,
+} from "../../transactions.js"
+import { getExplorerUrl } from "../../explorer.js"
+
+export function getTransactionStateFromReceipt(
+  receipt: TransactionReceipt | MetaTxnReceipt,
+  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
+  }
+
+  return {
+    transactionHash: txHash,
+    explorerUrl: getExplorerUrl({ txHash, chainId }),
+    chainId,
+    blockNumber,
+    state,
+    label,
+  }
+}