0xtrails 0.4.2 → 0.5.0

package/src/trails.ts

@@ -1,1303 +0,0 @@
-import type {
-  TransactionPrecondition,
-  Intent,
-  QuoteIntentRequest,
-  MetaTxn,
-  IntentCalls,
-} from "@0xsequence/trails-api"
-import type { TrailsClient } from "./trailsClient.js"
-import { useMutation, useQuery } from "@tanstack/react-query"
-import { Address } from "ox"
-import { useCallback, useEffect, useState } from "react"
-import type { Hex } from "viem"
-import {
-  createWalletClient,
-  custom,
-  ethAddress,
-  isAddress,
-  isAddressEqual,
-  zeroAddress,
-} from "viem"
-import type { Connector } from "wagmi"
-import {
-  useEstimateGas,
-  useSendTransaction,
-  useSwitchChain,
-  useWaitForTransactionReceipt,
-} from "wagmi"
-import { useTrailsClient } from "./trailsClient.js"
-import { attemptSwitchChain } from "./chainSwitch.js"
-import { getChainInfo } from "./chains.js"
-import { getERC20TransferData } from "./encoders.js"
-import type {
-  OriginCallParams,
-  TrailsFee as LocalTrailsFee,
-} from "./intents.js"
-import {
-  calculateIntentAddress,
-  calculateOriginAndDestinationIntentAddresses,
-  quoteIntent as quoteIntentFromIntents,
-} from "./intents.js"
-import {
-  useIntentReceiptMonitor,
-  type IntentReceiptStatus,
-} from "./intentReceiptMonitor.js"
-import { findPreconditionAddresses } from "./preconditions.js"
-import { queueCCTPTransfer } from "./cctpqueue.js"
-import { logger } from "./logger.js"
-import { useCommitIntent, useExecuteIntent } from "./mutations.js"
-// Removed: import { SEQUENCE_V3_CONTRACT_ADDRESSES_OVERRIDES } from "./constants.js"
-
-export type WagmiAccount = {
-  address: `0x${string}`
-  isConnected: boolean
-  chainId: number
-  connector?: Connector
-}
-
-export type UseTrailsConfig = {
-  account: WagmiAccount
-  disableAutoExecute?: boolean
-  sequenceProjectAccessKey?: string
-}
-
-export type UseTrailsReturn = {
-  trailsClient: TrailsClient
-  metaTxns: MetaTxn[] | null
-  intentCalls: IntentCalls[] | null
-  intentPreconditions: TransactionPrecondition[] | null
-  trailsFee: LocalTrailsFee | null
-  txnHash: Hex | undefined
-  committedOriginIntentAddress: string | null
-  committedDestinationIntentAddress: string | null
-  verificationStatus: {
-    success: boolean
-    calculatedOriginAddress?: string
-    calculatedDestinationAddress?: string
-    receivedOriginAddress?: string
-    receivedDestinationAddress?: string
-  } | null
-  estimatedGas: bigint | undefined
-  isEstimateError: boolean
-  estimateError: Error | null
-  calculateIntentAddress: typeof calculateIntentAddress
-  calculateOriginAndDestinationIntentAddresses: typeof calculateOriginAndDestinationIntentAddresses
-  committedIntent: Intent | undefined
-  isLoadingCommittedIntent: boolean
-  committedConfigError: Error | null
-  commitIntent: (intent: Intent) => void
-  commitIntentPending: boolean
-  commitIntentSuccess: boolean
-  commitIntentError: Error | null
-  commitIntentArgs: Intent | undefined
-  executeIntent: (args: {
-    intentId: string
-    depositTransactionHash: string
-  }) => void
-  executeIntentPending: boolean
-  executeIntentSuccess: boolean
-  executeIntentError: Error | null
-  getIntentFromQuoteIntent: (args: QuoteIntentRequest) => Promise<Intent>
-  operationHashes: { [key: string]: Hex }
-  sendOriginTransaction: () => Promise<void>
-  switchChain: any // TODO: Add proper type
-  isSwitchingChain: boolean
-  switchChainError: Error | null
-  isTransactionInProgress: boolean
-  isChainSwitchRequired: boolean
-  sendTransaction: any // TODO: Add proper type
-  isSendingTransaction: boolean
-  originCallStatus: {
-    txnHash?: string
-    status?: string
-    revertReason?: string | null
-    gasUsed?: number
-    effectiveGasPrice?: string
-  } | null
-  updateOriginCallStatus: (
-    hash: Hex | undefined,
-    status: "success" | "reverted" | "pending" | "sending",
-    gasUsed?: bigint,
-    effectiveGasPrice?: bigint,
-    revertReason?: string | null,
-  ) => void
-  isEstimatingGas: boolean
-  isAutoExecute: boolean
-  updateAutoExecute: (enabled: boolean) => void
-  receipt: any // TODO: Add proper type
-  isWaitingForReceipt: boolean
-  receiptIsSuccess: boolean
-  receiptIsError: boolean
-  receiptError: Error | null
-  hasAutoExecuted: boolean
-  originCallSuccess: boolean
-  sentMetaTxns: { [key: string]: number }
-  clearIntent: () => void
-  intentReceiptStatus: IntentReceiptStatus | null
-  quoteIntent: (args: QuoteIntentRequest) => void
-  quoteIntentPending: boolean
-  quoteIntentSuccess: boolean
-  quoteIntentError: Error | null
-  quoteIntentArgs: QuoteIntentRequest | undefined
-  originCallParams: OriginCallParams | null
-  updateOriginCallParams: (
-    args: { originChainId: number; tokenAddress: string } | null,
-  ) => void
-  originBlockTimestamp: number | null
-  metaTxnBlockTimestamps: {
-    [key: string]: { timestamp: number | null; error?: string }
-  }
-  originIntentAddress: string | null
-  destinationIntentAddress: string | null
-}
-
-export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
-  const {
-    account,
-    disableAutoExecute = false,
-    sequenceProjectAccessKey,
-  } = config
-  const trailsClient = useTrailsClient({
-    apiKey: sequenceProjectAccessKey,
-  })
-
-  const [isAutoExecute, setIsAutoExecute] = useState(!disableAutoExecute)
-  const [hasAutoExecuted, setHasAutoExecuted] = useState(false)
-
-  // Track timestamps of when each meta-transaction was last sent
-  const [sentMetaTxns, setSentMetaTxns] = useState<{ [key: string]: number }>(
-    {},
-  )
-
-  // State declarations
-  const [metaTxns, setMetaTxns] = useState<MetaTxn[] | null>(null)
-  const [intentCalls, setIntentCalls] = useState<IntentCalls[] | null>(null)
-  const [intentPreconditions, setIntentPreconditions] = useState<
-    TransactionPrecondition[] | null
-  >(null)
-  const [trailsFee, setTrailsFee] = useState<LocalTrailsFee | null>(null)
-  const [intent, setIntent] = useState<Intent | null>(null)
-  const [txnHash, setTxnHash] = useState<Hex | undefined>()
-  const [committedOriginIntentAddress, setCommittedOriginIntentAddress] =
-    useState<string | null>(null)
-  const [
-    committedDestinationIntentAddress,
-    setCommittedDestinationIntentAddress,
-  ] = useState<string | null>(null)
-  const [originIntentAddress, setOriginIntentAddress] = useState<string | null>(
-    null,
-  )
-  const [destinationIntentAddress, setDestinationIntentAddress] = useState<
-    string | null
-  >(null)
-  // const [preconditionStatuses, setPreconditionStatuses] = useState<boolean[]>([])
-
-  const [originCallParams, setOriginCallParams] =
-    useState<OriginCallParams | null>(null)
-
-  const [operationHashes, setOperationHashes] = useState<{
-    [key: string]: Hex
-  }>({})
-  const [isTransactionInProgress, setIsTransactionInProgress] = useState(false)
-  const [isChainSwitchRequired, setIsChainSwitchRequired] = useState(false)
-  const {
-    switchChain,
-    isPending: isSwitchingChain,
-    error: switchChainError,
-  } = useSwitchChain()
-
-  const sendOriginTxn = useSendTransaction()
-
-  const [isEstimatingGas, setIsEstimatingGas] = useState(false)
-  const [originCallStatus, setOriginCallStatus] = useState<{
-    txnHash?: string
-    status?: string
-    revertReason?: string | null
-    gasUsed?: number
-    effectiveGasPrice?: string
-  } | null>(null)
-
-  const [originBlockTimestamp, setOriginBlockTimestamp] = useState<
-    number | null
-  >(null)
-  const [metaTxnBlockTimestamps, setMetaTxnBlockTimestamps] = useState<{
-    [key: string]: { timestamp: number | null; error?: string }
-  }>({})
-
-  const [verificationStatus, setVerificationStatus] = useState<{
-    success: boolean
-    calculatedOriginAddress?: string
-    calculatedDestinationAddress?: string
-    receivedOriginAddress?: string
-    receivedDestinationAddress?: string
-  } | null>(null)
-
-  // Add gas estimation hook with proper types
-  const {
-    data: estimatedGas,
-    isError: isEstimateError,
-    error: estimateError,
-  } = useEstimateGas(
-    originCallParams?.to && originCallParams?.chainId && !originCallParams.error
-      ? {
-          to: originCallParams.to || undefined,
-          data: originCallParams.data || undefined,
-          value: originCallParams.value || undefined,
-          chainId: originCallParams.chainId || undefined,
-        }
-      : undefined,
-  )
-
-  // Commit intent mutation with verification logic wrapper
-  const baseCommitIntentMutation = useCommitIntent()
-
-  const commitIntentMutation = useMutation({
-    mutationFn: async (intent: Intent) => {
-      logger.console.log(
-        "[useTrails] commitIntentMutation started with intent:",
-        intent,
-      )
-
-      try {
-        const originChainId = quoteIntentMutation.variables?.originChainId
-        const destinationChainId =
-          quoteIntentMutation.variables?.destinationChainId
-
-        if (!originChainId || !destinationChainId) {
-          logger.console.error(
-            "[useTrails] Could not determine origin/destination chain IDs for verification.",
-          )
-          throw new Error(
-            "Could not determine origin/destination chain IDs for verification.",
-          )
-        }
-
-        logger.console.log("[useTrails] Calculating intent address...")
-        logger.console.log("[useTrails] Main signer:", intent.ownerAddress)
-        logger.console.log("[useTrails] Calls:", intent.calls)
-
-        const { originIntentAddress, destinationIntentAddress } =
-          calculateOriginAndDestinationIntentAddresses(
-            intent.ownerAddress,
-            intent.calls,
-          )
-
-        const {
-          originAddress: originPreconditionAddress,
-          destinationAddress: destinationPreconditionAddress,
-        } = findPreconditionAddresses(
-          intent.preconditions,
-          originChainId,
-          destinationChainId,
-        )
-
-        logger.console.log("[useTrails] Verification addresses:", {
-          calculatedOrigin: originIntentAddress.toString(),
-          calculatedDestination: destinationIntentAddress.toString(),
-          preconditionOrigin: originPreconditionAddress,
-          preconditionDestination: destinationPreconditionAddress,
-        })
-
-        const isOriginVerified =
-          !!originPreconditionAddress &&
-          isAddressEqual(
-            Address.from(originPreconditionAddress),
-            originIntentAddress,
-          )
-
-        logger.console.log("[useTrails] Origin verified:", isOriginVerified)
-
-        // For single chain, destination address may not be in preconditions,
-        // but the destination intent address should be the zero address.
-        const isDestinationVerified =
-          (destinationPreconditionAddress &&
-            isAddressEqual(
-              Address.from(destinationPreconditionAddress),
-              destinationIntentAddress,
-            )) ||
-          (!destinationPreconditionAddress &&
-            originChainId === destinationChainId &&
-            isAddressEqual(destinationIntentAddress, zeroAddress))
-
-        logger.console.log(
-          "[useTrails] Destination verified:",
-          isDestinationVerified,
-        )
-
-        const isVerified = isOriginVerified && isDestinationVerified
-
-        setVerificationStatus({
-          success: isVerified,
-          receivedOriginAddress: originPreconditionAddress,
-          receivedDestinationAddress: destinationPreconditionAddress,
-          calculatedOriginAddress: originIntentAddress.toString(),
-          calculatedDestinationAddress: destinationIntentAddress.toString(),
-        })
-
-        if (!isVerified) {
-          logger.console.error("[useTrails] Address verification failed.", {
-            isOriginVerified,
-            isDestinationVerified,
-          })
-          throw new Error(
-            `Address verification failed. Origin verified: ${isOriginVerified}, Destination verified: ${isDestinationVerified}`,
-          )
-        }
-
-        // Commit the intent that was returned from intent
-        logger.console.log("[useTrails] Committing intent to API...")
-        const response = await baseCommitIntentMutation.mutateAsync(intent)
-        logger.console.log("[useTrails] API Commit Response:", response)
-        return {
-          originIntentAddress: originIntentAddress.toString(),
-          destinationIntentAddress: destinationIntentAddress.toString(),
-          response,
-        }
-      } catch (error) {
-        console.error("[useTrails] Error during commit intent mutation:", error)
-        throw error
-      }
-    },
-    onSuccess: (data) => {
-      logger.console.log(
-        "[useTrails] Intent config committed successfully. Data:",
-        data,
-      )
-      logger.console.log(
-        "[useTrails] Setting committedOriginIntentAddress:",
-        data.originIntentAddress,
-      )
-      setCommittedOriginIntentAddress(data.originIntentAddress)
-      setCommittedDestinationIntentAddress(data.destinationIntentAddress)
-    },
-    onError: (error) => {
-      logger.console.error("[useTrails] Failed to commit intent config:", error)
-      setCommittedOriginIntentAddress(null)
-      setCommittedDestinationIntentAddress(null)
-    },
-  })
-
-  // Execute intent mutation
-  const executeIntentMutation = useExecuteIntent()
-
-  // New Query to fetch committed intent config
-  const {
-    data: committedIntent,
-    isLoading: isLoadingCommittedIntent,
-    error: committedConfigError,
-  } = useQuery<Intent, Error>({
-    queryKey: ["getIntent", committedOriginIntentAddress],
-    queryFn: async () => {
-      if (!trailsClient || !committedOriginIntentAddress) {
-        throw new Error("API client or committed intent address not available")
-      }
-      logger.console.log(
-        "Fetching intent config for address:",
-        committedOriginIntentAddress,
-      )
-      const response = await trailsClient.getIntent({
-        intentId: committedOriginIntentAddress,
-      })
-      return response.intent
-    },
-    enabled:
-      !!committedOriginIntentAddress &&
-      !!trailsClient &&
-      commitIntentMutation.isSuccess,
-    staleTime: 1000 * 60 * 5, // 5 minutes
-    retry: 1,
-  })
-
-  async function getIntentFromQuoteIntent(args: QuoteIntentRequest) {
-    const { intent } = await quoteIntentFromIntents(trailsClient, args)
-    return intent
-  }
-
-  // TODO: Add type for args
-  const quoteIntentMutation = useMutation<Intent, Error, QuoteIntentRequest>({
-    mutationFn: async (args: QuoteIntentRequest) => {
-      if (
-        args.originChainId === args.destinationChainId &&
-        isAddressEqual(
-          Address.from(args.originTokenAddress),
-          Address.from(args.destinationTokenAddress),
-        )
-      ) {
-        throw new Error(
-          "The same token cannot be used as both the source and destination token.",
-        )
-      }
-      if (!account.address) {
-        throw new Error("Missing selected token or account address")
-      }
-      // Reset commit state when generating a new intent
-      setCommittedOriginIntentAddress(null)
-      setCommittedDestinationIntentAddress(null)
-      setVerificationStatus(null)
-      setTrailsFee(null)
-      setMetaTxns(null)
-      setIntentCalls(null)
-      setIntentPreconditions(null)
-      setOriginIntentAddress(null)
-      setDestinationIntentAddress(null)
-
-      const { intent: data } = await quoteIntentFromIntents(trailsClient, args)
-
-      setMetaTxns(data.metaTxns)
-      setIntentCalls(data.calls)
-      setIntentPreconditions(data.preconditions)
-      setTrailsFee(data.fees as any)
-      setOriginIntentAddress(data.originIntentAddress)
-      setDestinationIntentAddress(data.destinationIntentAddress)
-      setIntent(data)
-      setCommittedOriginIntentAddress(null)
-      setCommittedDestinationIntentAddress(null)
-
-      setVerificationStatus(null)
-      return data
-    },
-    onSuccess: (data) => {
-      logger.console.log("Intent Config Success:", data)
-
-      setTrailsFee((data.fees || null) as any)
-      setOriginIntentAddress(data.originIntentAddress)
-      setDestinationIntentAddress(data.destinationIntentAddress)
-
-      if (
-        data?.calls &&
-        data.calls.length > 0 &&
-        data.preconditions &&
-        data.preconditions.length > 0 &&
-        data.metaTxns &&
-        data.metaTxns.length > 0
-      ) {
-        setIntentCalls(data.calls)
-        setIntentPreconditions(data.preconditions)
-        setMetaTxns(data.metaTxns)
-      } else {
-        logger.console.warn("API returned success but no operations found.")
-        setIntentCalls(null)
-        setIntentPreconditions(null)
-        setMetaTxns(null)
-      }
-    },
-    onError: (error) => {
-      console.error("Intent Config Error:", error)
-      setIntentCalls(null)
-      setIntentPreconditions(null)
-      setMetaTxns(null)
-      setTrailsFee(null)
-      setOriginIntentAddress(null)
-      setDestinationIntentAddress(null)
-    },
-  })
-
-  const clearIntent = useCallback(() => {
-    logger.console.log("[Trails] Clearing intent state")
-    setIntentCalls(null)
-    setIntentPreconditions(null)
-    setMetaTxns(null)
-    setTrailsFee(null)
-    setCommittedOriginIntentAddress(null)
-    setCommittedDestinationIntentAddress(null)
-    setVerificationStatus(null)
-    setOriginIntentAddress(null)
-    setDestinationIntentAddress(null)
-    setOperationHashes({})
-    setHasAutoExecuted(false)
-    setMetaTxnBlockTimestamps({})
-  }, []) // Empty deps array since these setters are stable
-
-  const updateOriginCallStatus = useCallback(
-    (
-      hash: Hex | undefined,
-      status: "success" | "reverted" | "pending" | "sending",
-      gasUsed?: bigint,
-      effectiveGasPrice?: bigint,
-      revertReason?: string | null,
-    ) => {
-      setOriginCallStatus({
-        txnHash: hash,
-        status:
-          status === "success"
-            ? "Success"
-            : status === "reverted"
-              ? "Failed"
-              : status === "sending"
-                ? "Sending..."
-                : "Pending",
-        revertReason:
-          status === "reverted"
-            ? revertReason || "Transaction reverted"
-            : undefined,
-        gasUsed: gasUsed ? Number(gasUsed) : undefined,
-        effectiveGasPrice: effectiveGasPrice?.toString(),
-      })
-    },
-    [],
-  )
-
-  const sendOriginTransaction = async () => {
-    logger.console.log("Sending origin transaction...")
-    logger.console.log(
-      isTransactionInProgress,
-      originCallParams,
-      originCallParams?.error,
-      originCallParams?.to,
-      originCallParams?.data,
-      originCallParams?.value,
-      originCallParams?.chainId,
-    )
-    if (
-      isTransactionInProgress || // Prevent duplicate transactions
-      !originCallParams ||
-      originCallParams.error ||
-      !originCallParams.to ||
-      originCallParams.data === null ||
-      originCallParams.value === null ||
-      originCallParams.chainId === null
-    ) {
-      logger.console.error(
-        "Origin call parameters not available or invalid:",
-        originCallParams,
-      )
-      updateOriginCallStatus(
-        undefined,
-        "reverted",
-        undefined,
-        undefined,
-        "Origin call parameters not ready",
-      )
-      return
-    }
-
-    // Check if we need to switch chains
-    if (account.chainId !== originCallParams.chainId) {
-      setIsChainSwitchRequired(true)
-      updateOriginCallStatus(
-        undefined,
-        "pending",
-        undefined,
-        undefined,
-        `Switching to chain ${originCallParams.chainId}...`,
-      )
-
-      const walletClient = createWalletClient({
-        chain: getChainInfo(originCallParams.chainId)!,
-        transport: custom((await account.connector!.getProvider()) as any), // TODO: Add proper type
-      })
-
-      try {
-        await attemptSwitchChain({
-          walletClient,
-          desiredChainId: originCallParams.chainId,
-        })
-        setIsChainSwitchRequired(false)
-      } catch (error: unknown) {
-        logger.console.error("Chain switch failed:", error)
-        if (error instanceof Error && error.message.includes("User rejected")) {
-          setIsAutoExecute(false)
-        }
-        updateOriginCallStatus(
-          undefined,
-          "reverted",
-          undefined,
-          undefined,
-          error instanceof Error
-            ? error.message
-            : "Unknown error switching chain",
-        )
-        setIsChainSwitchRequired(false)
-        return // Stop execution on switch failure
-      }
-    }
-
-    // Ensure only one transaction is sent at a time
-    if (!isTransactionInProgress) {
-      setIsTransactionInProgress(true) // Mark transaction as in progress
-      setTxnHash(undefined)
-      updateOriginCallStatus(undefined, "sending")
-
-      if (!estimatedGas && !isEstimateError) {
-        setIsEstimatingGas(true)
-        return // Wait for gas estimation
-      }
-
-      if (isEstimateError) {
-        logger.console.error("Gas estimation failed:", estimateError)
-        updateOriginCallStatus(
-          undefined,
-          "reverted",
-          undefined,
-          undefined,
-          `Gas estimation failed: ${estimateError?.message}`,
-        )
-        setIsTransactionInProgress(false)
-        return
-      }
-
-      // Add 20% buffer to estimated gas
-      const gasLimit = estimatedGas
-        ? BigInt(Math.floor(Number(estimatedGas) * 1.2))
-        : undefined
-
-      sendOriginTxn.sendTransaction(
-        {
-          to: originCallParams.to,
-          data: originCallParams.data,
-          value: originCallParams.value,
-          chainId: originCallParams.chainId,
-          gas: gasLimit,
-        },
-        {
-          onSuccess: (hash: Hex) => {
-            logger.console.log("Transaction sent, hash:", hash)
-            setTxnHash(hash)
-            setIsTransactionInProgress(false) // Reset transaction state
-          },
-          onError: (error: unknown) => {
-            logger.console.error("Transaction failed:", error)
-            if (
-              error instanceof Error &&
-              (error.message.includes("User rejected") ||
-                error.message.includes("user rejected"))
-            ) {
-              setIsAutoExecute(false)
-            }
-            updateOriginCallStatus(
-              undefined,
-              "reverted",
-              undefined,
-              undefined,
-              error instanceof Error ? error.message : "Unknown error",
-            )
-            setIsTransactionInProgress(false)
-          },
-        },
-      )
-    } else {
-      logger.console.warn(
-        "Transaction already in progress. Skipping duplicate request.",
-      )
-    }
-  }
-
-  // Remove the chain change effect that might be resetting state
-  useEffect(() => {
-    if (switchChainError) {
-      logger.console.error("Chain switch error:", switchChainError)
-      updateOriginCallStatus(
-        undefined,
-        "reverted",
-        undefined,
-        undefined,
-        `Chain switch failed: ${switchChainError.message || "Unknown error"}`,
-      )
-      setIsChainSwitchRequired(false)
-    }
-  }, [switchChainError, updateOriginCallStatus])
-
-  // Reset gas estimation state when parameters change
-  useEffect(() => {
-    setIsEstimatingGas(false)
-  }, [])
-
-  // Only update chain switch required state when needed
-  useEffect(() => {
-    if (
-      originCallParams?.chainId &&
-      account.chainId === originCallParams.chainId
-    ) {
-      logger.console.log("No chain switch required")
-      setIsChainSwitchRequired(false)
-    }
-  }, [account.chainId, originCallParams?.chainId])
-
-  // Effect to handle chain switching
-  useEffect(() => {
-    if (
-      originCallParams?.chainId &&
-      account.chainId !== originCallParams.chainId
-    ) {
-      async function check() {
-        try {
-          const chainId = originCallParams!.chainId!
-          const walletClient = createWalletClient({
-            chain: getChainInfo(chainId)!,
-            transport: custom((await account.connector!.getProvider()) as any), // TODO: Add proper type
-          })
-          await attemptSwitchChain({
-            walletClient,
-            desiredChainId: chainId,
-          })
-        } catch (error) {
-          logger.console.error("Chain switch failed:", error)
-        }
-      }
-      check().catch(logger.console.error)
-    }
-  }, [account, originCallParams])
-
-  // Hook to wait for transaction receipt
-  const {
-    data: receipt,
-    isLoading: isWaitingForReceipt,
-    isSuccess: receiptIsSuccess,
-    isError: receiptIsError,
-    error: receiptError,
-  } = useWaitForTransactionReceipt({
-    hash: txnHash,
-    confirmations: 1,
-    query: {
-      enabled: !!txnHash,
-    },
-  })
-
-  // Modify the effect that watches for transaction status
-  useEffect(() => {
-    if (!txnHash) {
-      // Only reset these when txnHash is cleared
-      if (originCallStatus?.txnHash) {
-        setOriginCallStatus(null)
-      }
-      setOriginBlockTimestamp(null)
-      if (Object.keys(sentMetaTxns).length > 0) {
-        setSentMetaTxns({})
-      }
-      return
-    }
-
-    if (
-      originCallStatus?.txnHash === txnHash &&
-      (originCallStatus?.status === "Success" ||
-        originCallStatus?.status === "Failed") &&
-      !isWaitingForReceipt
-    ) {
-      return
-    }
-
-    if (isWaitingForReceipt) {
-      setOriginCallStatus((prevStatus) => ({
-        ...(prevStatus?.txnHash === txnHash
-          ? prevStatus
-          : {
-              gasUsed: undefined,
-              effectiveGasPrice: undefined,
-              revertReason: undefined,
-            }),
-        txnHash,
-        status: "Pending",
-      }))
-      return
-    }
-
-    if (receiptIsSuccess && receipt) {
-      const newStatus = receipt.status === "success" ? "Success" : "Failed"
-      setOriginCallStatus({
-        txnHash: receipt.transactionHash,
-        status: newStatus,
-        gasUsed: receipt.gasUsed ? Number(receipt.gasUsed) : undefined,
-        effectiveGasPrice: receipt.effectiveGasPrice?.toString(),
-        revertReason:
-          receipt.status === "reverted"
-            ? ((receiptError as any)?.message as string | undefined) ||
-              "Transaction reverted by receipt"
-            : undefined,
-      })
-
-      // Timestamp is now available from transaction receipts via the API (txnMinedAt)
-      if (newStatus !== "Success") {
-        setOriginBlockTimestamp(null)
-      }
-
-      if (
-        newStatus === "Success" &&
-        metaTxns &&
-        metaTxns.length > 0 &&
-        isAutoExecute &&
-        !metaTxns.some((tx: MetaTxn) => sentMetaTxns[`${tx.chainId}-${tx.id}`])
-      ) {
-        logger.console.log(
-          "Origin transaction successful, calling executeIntent and auto-sending all meta transactions...",
-        )
-
-        // Call executeIntent with intentId and depositTransactionHash
-        if (committedOriginIntentAddress && txnHash) {
-          executeIntentMutation.mutate({
-            intentId: committedOriginIntentAddress,
-            depositTransactionHash: txnHash,
-          })
-        }
-      }
-    } else if (receiptIsError) {
-      setOriginCallStatus({
-        txnHash,
-        status: "Failed",
-        revertReason:
-          ((receiptError as any)?.message as string | undefined) ||
-          "Failed to get receipt",
-        gasUsed: undefined,
-        effectiveGasPrice: undefined,
-      })
-      setOriginBlockTimestamp(null)
-    }
-  }, [
-    txnHash,
-    isWaitingForReceipt,
-    receiptIsSuccess,
-    receiptIsError,
-    receipt,
-    receiptError,
-    metaTxns,
-    sentMetaTxns,
-    isAutoExecute,
-    originCallStatus?.status,
-    originCallStatus?.txnHash,
-    committedOriginIntentAddress,
-    executeIntentMutation,
-  ])
-
-  // Modify the auto-execute effect
-  useEffect(() => {
-    const shouldAutoSend =
-      isAutoExecute &&
-      commitIntentMutation.isSuccess &&
-      originCallParams?.chainId &&
-      account.chainId === originCallParams.chainId &&
-      !originCallParams.error &&
-      originCallParams.to &&
-      originCallParams.data !== null &&
-      originCallParams.value !== null &&
-      !sendOriginTxn.isPending &&
-      !isWaitingForReceipt &&
-      !txnHash &&
-      !isChainSwitchRequired &&
-      !originCallStatus &&
-      !hasAutoExecuted
-
-    if (shouldAutoSend) {
-      logger.console.log("Auto-executing transaction: All conditions met.")
-      setHasAutoExecuted(true)
-
-      // Set initial status
-      setOriginCallStatus({
-        status: "Sending...",
-      })
-
-      sendOriginTxn.sendTransaction(
-        {
-          to: originCallParams.to!,
-          data: originCallParams.data!,
-          value: originCallParams.value!,
-          chainId: originCallParams.chainId!,
-        },
-        {
-          onSuccess: (hash: Hex) => {
-            logger.console.log("Auto-executed transaction sent, hash:", hash)
-            setTxnHash(hash)
-          },
-          onError: (error: unknown) => {
-            logger.console.error("Auto-executed transaction failed:", error)
-            if (
-              error instanceof Error &&
-              (error.message.includes("User rejected") ||
-                error.message.includes("user rejected"))
-            ) {
-              setIsAutoExecute(false)
-            }
-            setOriginCallStatus({
-              status: "Failed",
-              revertReason:
-                error instanceof Error ? error.message : "Unknown error",
-            })
-            setHasAutoExecuted(false)
-          },
-        },
-      )
-    }
-  }, [
-    isAutoExecute,
-    commitIntentMutation.isSuccess,
-    originCallParams,
-    account.chainId,
-    sendOriginTxn.isPending,
-    isWaitingForReceipt,
-    txnHash,
-    isChainSwitchRequired,
-    originCallStatus,
-    hasAutoExecuted,
-    sendOriginTxn,
-  ])
-
-  // Effect to auto-commit when intent calls payloads are ready
-  useEffect(() => {
-    if (
-      isAutoExecute &&
-      intentCalls &&
-      intentPreconditions &&
-      trailsFee &&
-      account.address &&
-      originIntentAddress &&
-      !commitIntentMutation.isPending &&
-      !commitIntentMutation.isSuccess
-    ) {
-      logger.console.log("Auto-committing intent configuration...")
-      if (intent) {
-        commitIntentMutation.mutate(intent)
-      }
-    }
-  }, [
-    isAutoExecute,
-    intent,
-    intentCalls,
-    intentPreconditions,
-    trailsFee,
-    account.address,
-    originIntentAddress,
-    commitIntentMutation,
-  ])
-
-  const [tokenAddress, setTokenAddress] = useState<string | null>(null)
-  const [originChainId, setOriginChainId] = useState<number | null>(null)
-
-  useEffect(() => {
-    if (
-      !originIntentAddress ||
-      !intentCalls?.[0]?.chainId ||
-      !tokenAddress ||
-      !originChainId ||
-      !intentPreconditions ||
-      !account.address
-    ) {
-      setOriginCallParams(null)
-      return
-    }
-
-    try {
-      const intentAddressString = originIntentAddress as Address.Address
-
-      if (!intentAddressString || !isAddress(intentAddressString)) {
-        setOriginCallParams(null)
-        return
-      }
-
-      let calcTo: Address.Address
-      let calcData: Hex = "0x"
-      let calcValue: bigint = 0n
-
-      const recipientAddress = intentAddressString
-
-      const isNative =
-        tokenAddress === zeroAddress || tokenAddress === ethAddress
-
-      if (isNative) {
-        const nativePrecondition = intentPreconditions.find(
-          (p: TransactionPrecondition) =>
-            (p.type === "transfer-native" || p.type === "native-balance") &&
-            p.chainId === originChainId,
-        )
-        const nativeMinAmount = nativePrecondition?.minAmount?.toString()
-        if (nativeMinAmount === undefined) {
-          throw new Error("Could not find precondition or min amount")
-        }
-        calcValue = BigInt(nativeMinAmount)
-        calcTo = recipientAddress
-      } else {
-        const erc20Precondition = intentPreconditions.find(
-          (p: TransactionPrecondition) =>
-            p.type === "erc20-balance" &&
-            p.chainId === originChainId &&
-            p.tokenAddress &&
-            isAddressEqual(
-              Address.from(p.tokenAddress),
-              Address.from(tokenAddress),
-            ),
-        )
-
-        const erc20MinAmount = erc20Precondition?.minAmount?.toString()
-        if (erc20MinAmount === undefined) {
-          throw new Error("Could not find precondition or min amount")
-        }
-        calcData = getERC20TransferData({
-          recipient: recipientAddress,
-          amount: BigInt(erc20MinAmount),
-        })
-        calcTo = tokenAddress as Address.Address
-      }
-
-      setOriginCallParams({
-        to: calcTo,
-        data: calcData,
-        value: calcValue,
-        chainId: originChainId,
-        error: undefined,
-      })
-    } catch (error: unknown) {
-      logger.console.error(
-        "[trails-sdk] Failed to calculate origin call params for UI:",
-        error,
-      )
-      setOriginCallParams({
-        to: null,
-        data: null,
-        value: null,
-        chainId: null,
-        error: error instanceof Error ? error.message : "Unknown error",
-      })
-    }
-  }, [
-    intentCalls,
-    tokenAddress,
-    originChainId,
-    intentPreconditions,
-    account.address,
-    originIntentAddress,
-  ])
-
-  // const checkPreconditionStatuses = useCallback(async () => {
-  //   if (!intentPreconditions) return
-
-  //   const statuses = await Promise.all(
-  //     intentPreconditions.map(async (precondition) => {
-  //       try {
-  //         const chainIdString = precondition.chainId
-  //         if (!chainIdString) {
-  //           console.warn('[trails-sdk] Precondition missing chainId:', precondition)
-  //           return false
-  //         }
-  //         const chainId = parseInt(chainIdString)
-  //         if (isNaN(chainId) || chainId <= 0) {
-  //           console.warn('[trails-sdk] Precondition has invalid chainId:', chainIdString, precondition)
-  //           return false
-  //         }
-
-  //         const chainRelayer = getRelayer(chainId)
-  //         if (!chainRelayer) {
-  //           console.error(`[trails-sdk] No relayer found for chainId: ${chainId}`)
-  //           return false
-  //         }
-
-  //         return await chainRelayer.checkPrecondition(precondition)
-  //       } catch (error) {
-  //         console.error('[trails-sdk] Error checking precondition:', error, 'Precondition:', precondition)
-  //         return false
-  //       }
-  //     }),
-  //   )
-
-  //   setPreconditionStatuses(statuses)
-  // }, [intentPreconditions, getRelayer])
-
-  // useEffect(() => {
-  //   // TODO: Remove this once we have a way to check precondition statuses
-  //   if (false) {
-  //     checkPreconditionStatuses()
-  //   }
-  // }, [intentPreconditions, checkPreconditionStatuses])
-
-  // Use the new WaitIntentReceipt API to monitor intent execution
-  // This replaces the old per-meta-transaction polling approach
-  const intentReceiptStatus = useIntentReceiptMonitor(
-    committedOriginIntentAddress ?? undefined,
-    trailsClient,
-  )
-
-  // Simplified block timestamp tracking using IntentReceipt API
-  // The IntentReceipt provides unified status for both origin and destination transactions
-  useEffect(() => {
-    logger.console.log("[trails-sdk] Intent receipt status update:", {
-      intentId: committedOriginIntentAddress,
-      done: intentReceiptStatus.done,
-      hasReceipt: !!intentReceiptStatus.intentReceipt,
-    })
-
-    if (!intentReceiptStatus.intentReceipt) {
-      logger.console.log("[trails-sdk] No intent receipt yet, waiting...")
-      return
-    }
-
-    // Update block timestamps from intent receipt transactions
-    const newTimestamps: typeof metaTxnBlockTimestamps = {}
-
-    if (intentReceiptStatus.intentReceipt.originTransaction) {
-      const originTx = intentReceiptStatus.intentReceipt.originTransaction
-      const key = `${originTx.chainId}-${originTx.metaTxnId}`
-      newTimestamps[key] = { timestamp: null } // TODO: fetch actual block timestamp
-    }
-
-    if (intentReceiptStatus.intentReceipt.destinationTransaction) {
-      const destTx = intentReceiptStatus.intentReceipt.destinationTransaction
-      const key = `${destTx.chainId}-${destTx.metaTxnId}`
-      newTimestamps[key] = { timestamp: null } // TODO: fetch actual block timestamp
-    }
-
-    setMetaTxnBlockTimestamps(newTimestamps)
-  }, [
-    intentReceiptStatus.intentReceipt,
-    intentReceiptStatus.done,
-    committedOriginIntentAddress,
-  ])
-
-  // Effect to handle completed intent
-  useEffect(() => {
-    if (intentReceiptStatus.done && intentReceiptStatus.intentReceipt) {
-      logger.console.log("[trails-sdk] Intent execution completed", {
-        intentId: committedOriginIntentAddress,
-        status: intentReceiptStatus.intentReceipt.status,
-      })
-
-      // Handle CCTP transfers if needed
-      if (intentReceiptStatus.intentReceipt.originTransaction?.txnHash) {
-        const providerFromQuote = trailsFee?.quoteProvider
-          ? String(trailsFee.quoteProvider).toLowerCase()
-          : undefined
-        const providerFromArgs = quoteIntentMutation.variables?.options
-          ?.quoteProvider
-          ? String(
-              quoteIntentMutation.variables.options.quoteProvider,
-            ).toLowerCase()
-          : undefined
-        const isCctp =
-          providerFromQuote === "cctp" || providerFromArgs === "cctp"
-
-        if (isCctp && quoteIntentMutation.variables) {
-          try {
-            queueCCTPTransfer({
-              sourceTxHash: intentReceiptStatus.intentReceipt.originTransaction
-                .txnHash as `0x${string}`,
-              sourceChainId: quoteIntentMutation.variables.originChainId,
-              destinationChainId:
-                quoteIntentMutation.variables.destinationChainId,
-              trailsClient,
-            })
-          } catch (error) {
-            logger.console.error("[Trails] queueCCTPTransfer error", error)
-          }
-        }
-      }
-    }
-  }, [
-    intentReceiptStatus.done,
-    intentReceiptStatus.intentReceipt,
-    committedOriginIntentAddress,
-    trailsFee,
-    quoteIntentMutation.variables,
-    trailsClient,
-  ])
-
-  const updateAutoExecute = (enabled: boolean) => {
-    setIsAutoExecute(enabled)
-  }
-
-  function quoteIntent(args: QuoteIntentRequest) {
-    quoteIntentMutation.mutate(args)
-  }
-
-  function commitIntent(intent: Intent) {
-    logger.console.log("[trails-sdk] commitIntent", intent)
-    commitIntentMutation.mutate(intent)
-  }
-
-  function updateOriginCallParams(
-    args: { originChainId: number; tokenAddress: string } | null,
-  ) {
-    if (!args) {
-      setOriginCallParams(null)
-      return
-    }
-    const { originChainId, tokenAddress } = args
-    setOriginChainId(originChainId)
-    setTokenAddress(tokenAddress)
-  }
-
-  const { chainId } = account
-
-  const originChainIdFromParams = originCallParams?.chainId
-
-  const quoteIntentPending = quoteIntentMutation.isPending
-  const quoteIntentSuccess = quoteIntentMutation.isSuccess
-  const quoteIntentError = quoteIntentMutation.error
-  const quoteIntentArgs = quoteIntentMutation.variables
-
-  const commitIntentPending = commitIntentMutation.isPending
-  const commitIntentSuccess = commitIntentMutation.isSuccess
-  const commitIntentError = commitIntentMutation.error
-  const commitIntentArgs = commitIntentMutation.variables
-
-  const executeIntentPending = executeIntentMutation.isPending
-  const executeIntentSuccess = executeIntentMutation.isSuccess
-  const executeIntentError = executeIntentMutation.error
-
-  function executeIntent(args: {
-    intentId: string
-    depositTransactionHash: string
-  }) {
-    executeIntentMutation.mutate(args)
-  }
-
-  return {
-    trailsClient,
-    metaTxns,
-    intentCalls,
-    intentPreconditions,
-    trailsFee,
-    txnHash,
-    committedOriginIntentAddress,
-    committedDestinationIntentAddress,
-    verificationStatus,
-    estimatedGas,
-    isEstimateError,
-    estimateError,
-    calculateIntentAddress,
-    calculateOriginAndDestinationIntentAddresses,
-    committedIntent,
-    isLoadingCommittedIntent,
-    committedConfigError,
-    commitIntent,
-    commitIntentPending,
-    commitIntentSuccess,
-    commitIntentError,
-    commitIntentArgs,
-    executeIntent,
-    executeIntentPending,
-    executeIntentSuccess,
-    executeIntentError,
-    getIntentFromQuoteIntent,
-    operationHashes,
-    sendOriginTransaction,
-    switchChain,
-    isSwitchingChain,
-    switchChainError,
-    isTransactionInProgress,
-    isChainSwitchRequired:
-      chainId !== originChainIdFromParams && !!originChainIdFromParams,
-    sendTransaction: sendOriginTxn.sendTransaction,
-    isSendingTransaction: sendOriginTxn.isPending,
-    originCallStatus,
-    updateOriginCallStatus,
-    isEstimatingGas,
-    isAutoExecute,
-    updateAutoExecute,
-    receipt,
-    isWaitingForReceipt,
-    receiptIsSuccess,
-    receiptIsError,
-    receiptError,
-    hasAutoExecuted,
-    originCallSuccess: sendOriginTxn.isSuccess,
-    sentMetaTxns,
-    clearIntent,
-    intentReceiptStatus,
-    quoteIntent,
-    quoteIntentPending,
-    quoteIntentSuccess,
-    quoteIntentError,
-    quoteIntentArgs,
-    originCallParams,
-    updateOriginCallParams,
-    originBlockTimestamp,
-    metaTxnBlockTimestamps,
-    originIntentAddress,
-    destinationIntentAddress,
-  }
-}