0xtrails 0.2.5 → 0.3.0

package/src/trails.ts

@@ -1,21 +1,19 @@
 import type {
-  AddressOverrides,
-  GetIntentCallsPayloadsArgs,
-  GetIntentConfigReturn,
-  IntentCallsPayload,
-  IntentPrecondition,
+  TransactionPrecondition,
+  Intent,
+  QuoteIntentRequest,
+  MetaTxn,
+  IntentCalls,
 } from "@0xsequence/trails-api"
 import type { TrailsClient } from "./trailsClient.js"
-import type { RelayerOperationStatus } from "./relayer.js"
 import { useMutation, useQuery } from "@tanstack/react-query"
 import { Address } from "ox"
-import { useCallback, useEffect, useMemo, useRef, useState } from "react"
+import { useCallback, useEffect, useState } from "react"
 import type { Hex } from "viem"
 import {
-  createPublicClient,
   createWalletClient,
   custom,
-  http,
+  ethAddress,
   isAddress,
   isAddressEqual,
   zeroAddress,
@@ -32,23 +30,23 @@ import { attemptSwitchChain } from "./chainSwitch.js"
 import { getChainInfo } from "./chains.js"
 import { getERC20TransferData } from "./encoders.js"
 import type {
-  GetIntentCallsPayloadsReturn,
   OriginCallParams,
-  QuoteProvider,
-  TrailsFee,
+  TrailsFee as LocalTrailsFee,
 } from "./intents.js"
 import {
   calculateIntentAddress,
   calculateOriginAndDestinationIntentAddresses,
-  getIntentCallsPayloads as getIntentCallsPayloadsFromIntents,
+  getIntent as getIntentFromIntents,
 } from "./intents.js"
-import type { MetaTxn } from "./metaTxnMonitor.js"
-import { useMetaTxnsMonitor } from "./metaTxnMonitor.js"
+import {
+  useIntentReceiptMonitor,
+  type IntentReceiptStatus,
+} from "./intentReceiptMonitor.js"
 import { findPreconditionAddresses } from "./preconditions.js"
-import { getBackupRelayer, useRelayers } from "./relayer.js"
 import { queueCCTPTransfer } from "./cctpqueue.js"
 import { logger } from "./logger.js"
-import { SEQUENCE_V3_CONTRACT_ADDRESSES_OVERRIDES } from "./constants.js"
+import { useCommitIntent, useExecuteIntent } from "./mutations.js"
+// Removed: import { SEQUENCE_V3_CONTRACT_ADDRESSES_OVERRIDES } from "./constants.js"
 
 export type WagmiAccount = {
   address: `0x${string}`
@@ -60,18 +58,15 @@ export type WagmiAccount = {
 export type UseTrailsConfig = {
   account: WagmiAccount
   disableAutoExecute?: boolean
-  env: "local" | "cors-anywhere" | "dev" | "prod"
   sequenceProjectAccessKey?: string
 }
 
 export type UseTrailsReturn = {
   trailsClient: TrailsClient
-  metaTxns: GetIntentCallsPayloadsReturn["payloads"]["metaTxns"] | null
-  intentCallsPayloads: GetIntentCallsPayloadsReturn["payloads"]["calls"] | null
-  intentPreconditions:
-    | GetIntentCallsPayloadsReturn["payloads"]["preconditions"]
-    | null
-  trailsFee: TrailsFee | null
+  metaTxns: MetaTxn[] | null
+  intentCallsPayloads: IntentCalls[] | null
+  intentPreconditions: TransactionPrecondition[] | null
+  trailsFee: LocalTrailsFee | null
   txnHash: Hex | undefined
   committedOriginIntentAddress: string | null
   committedDestinationIntentAddress: string | null
@@ -82,39 +77,29 @@ export type UseTrailsReturn = {
     receivedOriginAddress?: string
     receivedDestinationAddress?: string
   } | null
-  getRelayer: (chainId: number) => any // TODO: Add proper type
   estimatedGas: bigint | undefined
   isEstimateError: boolean
   estimateError: Error | null
   calculateIntentAddress: typeof calculateIntentAddress
   calculateOriginAndDestinationIntentAddresses: typeof calculateOriginAndDestinationIntentAddresses
-  committedIntentConfig: GetIntentConfigReturn | undefined
+  committedIntentConfig: Intent | undefined
   isLoadingCommittedConfig: boolean
   committedConfigError: Error | null
-  commitIntentConfig: (args: {
-    mainSignerAddress: string
-    calls: IntentCallsPayload[]
-    preconditions: IntentPrecondition[]
-    quoteProvider: QuoteProvider
-    addressOverrides?: AddressOverrides
+  commitIntent: (intent: Intent) => void
+  commitIntentPending: boolean
+  commitIntentSuccess: boolean
+  commitIntentError: Error | null
+  commitIntentArgs: Intent | undefined
+  executeIntent: (args: {
+    intentId: string
+    depositTransactionHash: string
   }) => void
-  commitIntentConfigPending: boolean
-  commitIntentConfigSuccess: boolean
-  commitIntentConfigError: Error | null
-  commitIntentConfigArgs:
-    | {
-        mainSignerAddress: string
-        calls: IntentCallsPayload[]
-        preconditions: IntentPrecondition[]
-        quoteProvider: QuoteProvider
-        addressOverrides?: AddressOverrides
-      }
-    | undefined
-  getIntentCallsPayloads: (
-    args: GetIntentCallsPayloadsArgs,
-  ) => Promise<GetIntentCallsPayloadsReturn>
+  executeIntentPending: boolean
+  executeIntentSuccess: boolean
+  executeIntentError: Error | null
+  getIntent: (args: QuoteIntentRequest) => Promise<Intent>
   operationHashes: { [key: string]: Hex }
-  callIntentCallsPayload: (args: GetIntentCallsPayloadsArgs) => void
+  callIntentCallsPayload: (args: QuoteIntentRequest) => void
   sendOriginTransaction: () => Promise<void>
   switchChain: any // TODO: Add proper type
   isSwitchingChain: boolean
@@ -148,18 +133,13 @@ export type UseTrailsReturn = {
   hasAutoExecuted: boolean
   originCallSuccess: boolean
   sentMetaTxns: { [key: string]: number }
-  sendMetaTxn: (selectedId: string | null) => void
-  sendMetaTxnPending: boolean
-  sendMetaTxnSuccess: boolean
-  sendMetaTxnError: Error | null
-  sendMetaTxnArgs: { selectedId: string | null } | undefined
   clearIntent: () => void
-  metaTxnMonitorStatuses: { [key: string]: RelayerOperationStatus }
-  createIntent: (args: GetIntentCallsPayloadsArgs) => void
+  intentReceiptStatus: IntentReceiptStatus | null
+  createIntent: (args: QuoteIntentRequest) => void
   createIntentPending: boolean
   createIntentSuccess: boolean
   createIntentError: Error | null
-  createIntentArgs: GetIntentCallsPayloadsArgs | undefined
+  createIntentArgs: QuoteIntentRequest | undefined
   originCallParams: OriginCallParams | null
   updateOriginCallParams: (
     args: { originChainId: number; tokenAddress: string } | null,
@@ -172,13 +152,10 @@ export type UseTrailsReturn = {
   destinationIntentAddress: string | null
 }
 
-const RETRY_WINDOW_MS = 10_000
-
 export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
   const {
     account,
     disableAutoExecute = false,
-    env,
     sequenceProjectAccessKey,
   } = config
   const trailsClient = useTrailsClient({
@@ -194,16 +171,15 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
   )
 
   // State declarations
-  const [metaTxns, setMetaTxns] = useState<
-    GetIntentCallsPayloadsReturn["payloads"]["metaTxns"] | null
-  >(null)
+  const [metaTxns, setMetaTxns] = useState<MetaTxn[] | null>(null)
   const [intentCallsPayloads, setIntentCallsPayloads] = useState<
-    GetIntentCallsPayloadsReturn["payloads"]["calls"] | null
+    IntentCalls[] | null
   >(null)
   const [intentPreconditions, setIntentPreconditions] = useState<
-    GetIntentCallsPayloadsReturn["payloads"]["preconditions"] | null
+    TransactionPrecondition[] | null
   >(null)
-  const [trailsFee, setTrailsFee] = useState<TrailsFee | null>(null)
+  const [trailsFee, setTrailsFee] = useState<LocalTrailsFee | null>(null)
+  const [quoteIntent, setQuoteIntent] = useState<Intent | null>(null)
   const [txnHash, setTxnHash] = useState<Hex | undefined>()
   const [committedOriginIntentAddress, setCommittedOriginIntentAddress] =
     useState<string | null>(null)
@@ -259,10 +235,6 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
     receivedDestinationAddress?: string
   } | null>(null)
 
-  const { getRelayer, relayers } = useRelayers({
-    env,
-  })
-
   // Add gas estimation hook with proper types
   const {
     data: estimatedGas,
@@ -279,36 +251,20 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
       : undefined,
   )
 
-  const commitIntentConfigMutation = useMutation({
-    mutationFn: async (args: {
-      mainSignerAddress: string
-      calls: IntentCallsPayload[]
-      preconditions: IntentPrecondition[]
-      quoteProvider: QuoteProvider
-      addressOverrides?: AddressOverrides
-    }) => {
+  // Commit intent mutation with verification logic wrapper
+  const baseCommitIntentMutation = useCommitIntent()
+
+  const commitIntentMutation = useMutation({
+    mutationFn: async (intent: Intent) => {
       logger.console.log(
-        "[useTrails] commitIntentConfigMutation started with args:",
-        args,
+        "[useTrails] commitIntentMutation started with intent:",
+        intent,
       )
-      if (!trailsClient) {
-        logger.console.error("[useTrails] API client not available")
-        throw new Error("API client not available")
-      }
-      if (!args.quoteProvider) {
-        logger.console.error("[useTrails] quoteProvider is required")
-        throw new Error("quoteProvider is required")
-      }
 
       try {
-        logger.console.log("[useTrails] Calculating intent address...")
-        logger.console.log("[useTrails] Main signer:", args.mainSignerAddress)
-        logger.console.log("[useTrails] Calls:", args.calls)
-
-        const originChainId =
-          createIntentMutation.variables?.params.originChainId
+        const originChainId = createIntentMutation.variables?.originChainId
         const destinationChainId =
-          createIntentMutation.variables?.params.destinationChainId
+          createIntentMutation.variables?.destinationChainId
 
         if (!originChainId || !destinationChainId) {
           logger.console.error(
@@ -319,17 +275,21 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
           )
         }
 
+        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(
-            args.mainSignerAddress,
-            args.calls,
+            intent.ownerAddress,
+            intent.calls,
           )
 
         const {
           originAddress: originPreconditionAddress,
           destinationAddress: destinationPreconditionAddress,
         } = findPreconditionAddresses(
-          args.preconditions,
+          intent.preconditions,
           originChainId,
           destinationChainId,
         )
@@ -387,21 +347,9 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
           )
         }
 
-        // Commit the intent config
-        logger.console.log("[useTrails] Committing intent config to API...")
-        const response = await trailsClient.commitIntentConfig({
-          params: {
-            originIntentAddress: originIntentAddress.toString(),
-            destinationIntentAddress: destinationIntentAddress.toString(),
-            mainSigner: args.mainSignerAddress,
-            calls: args.calls,
-            preconditions: args.preconditions,
-            addressOverrides: {
-              ...SEQUENCE_V3_CONTRACT_ADDRESSES_OVERRIDES,
-              ...args.addressOverrides,
-            },
-          },
-        })
+        // Commit the intent that was returned from quoteIntent
+        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(),
@@ -432,13 +380,16 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
     },
   })
 
+  // Execute intent mutation
+  const executeIntentMutation = useExecuteIntent()
+
   // New Query to fetch committed intent config
   const {
     data: committedIntentConfig,
     isLoading: isLoadingCommittedConfig,
     error: committedConfigError,
-  } = useQuery<GetIntentConfigReturn, Error>({
-    queryKey: ["getIntentConfig", committedOriginIntentAddress],
+  } = useQuery<Intent, Error>({
+    queryKey: ["getIntent", committedOriginIntentAddress],
     queryFn: async () => {
       if (!trailsClient || !committedOriginIntentAddress) {
         throw new Error("API client or committed intent address not available")
@@ -447,42 +398,32 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
         "Fetching intent config for address:",
         committedOriginIntentAddress,
       )
-      return await trailsClient.getIntentConfig({
-        intentAddress: committedOriginIntentAddress,
+      const response = await trailsClient.getIntent({
+        intentId: committedOriginIntentAddress,
       })
+      return response.intent
     },
     enabled:
       !!committedOriginIntentAddress &&
       !!trailsClient &&
-      commitIntentConfigMutation.isSuccess,
+      commitIntentMutation.isSuccess,
     staleTime: 1000 * 60 * 5, // 5 minutes
     retry: 1,
   })
 
-  async function getIntentCallsPayloads(args: GetIntentCallsPayloadsArgs) {
-    return getIntentCallsPayloadsFromIntents(trailsClient, {
-      params: {
-        ...args.params,
-        addressOverrides: {
-          ...SEQUENCE_V3_CONTRACT_ADDRESSES_OVERRIDES,
-          ...args.params.addressOverrides,
-        },
-      },
-    })
+  async function getIntent(args: QuoteIntentRequest) {
+    const { intent } = await getIntentFromIntents(trailsClient, args)
+    return intent
   }
 
   // TODO: Add type for args
-  const createIntentMutation = useMutation<
-    GetIntentCallsPayloadsReturn,
-    Error,
-    GetIntentCallsPayloadsArgs
-  >({
-    mutationFn: async (args: GetIntentCallsPayloadsArgs) => {
+  const createIntentMutation = useMutation<Intent, Error, QuoteIntentRequest>({
+    mutationFn: async (args: QuoteIntentRequest) => {
       if (
-        args.params.originChainId === args.params.destinationChainId &&
+        args.originChainId === args.destinationChainId &&
         isAddressEqual(
-          Address.from(args.params.originTokenAddress),
-          Address.from(args.params.destinationTokenAddress),
+          Address.from(args.originTokenAddress),
+          Address.from(args.destinationTokenAddress),
         )
       ) {
         throw new Error(
@@ -503,14 +444,15 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
       setOriginIntentAddress(null)
       setDestinationIntentAddress(null)
 
-      const data = await getIntentCallsPayloads(args)
+      const { intent: data } = await getIntentFromIntents(trailsClient, args)
 
-      setMetaTxns(data.payloads.metaTxns)
-      setIntentCallsPayloads(data.payloads.calls)
-      setIntentPreconditions(data.payloads.preconditions)
-      setTrailsFee(data.payloads.trailsFee!)
-      setOriginIntentAddress(data.payloads.originIntentAddress)
-      setDestinationIntentAddress(data.payloads.destinationIntentAddress)
+      setMetaTxns(data.metaTxns)
+      setIntentCallsPayloads(data.calls)
+      setIntentPreconditions(data.preconditions)
+      setTrailsFee(data.fees as any)
+      setOriginIntentAddress(data.originIntentAddress)
+      setDestinationIntentAddress(data.destinationIntentAddress)
+      setQuoteIntent(data)
       setCommittedOriginIntentAddress(null)
       setCommittedDestinationIntentAddress(null)
 
@@ -520,21 +462,21 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
     onSuccess: (data) => {
       logger.console.log("Intent Config Success:", data)
 
-      setTrailsFee(data.payloads.trailsFee || null)
-      setOriginIntentAddress(data.payloads.originIntentAddress)
-      setDestinationIntentAddress(data.payloads.destinationIntentAddress)
+      setTrailsFee((data.fees || null) as any)
+      setOriginIntentAddress(data.originIntentAddress)
+      setDestinationIntentAddress(data.destinationIntentAddress)
 
       if (
-        data.payloads?.calls &&
-        data.payloads.calls.length > 0 &&
-        data.payloads.preconditions &&
-        data.payloads.preconditions.length > 0 &&
-        data.payloads.metaTxns &&
-        data.payloads.metaTxns.length > 0
+        data?.calls &&
+        data.calls.length > 0 &&
+        data.preconditions &&
+        data.preconditions.length > 0 &&
+        data.metaTxns &&
+        data.metaTxns.length > 0
       ) {
-        setIntentCallsPayloads(data.payloads.calls)
-        setIntentPreconditions(data.payloads.preconditions)
-        setMetaTxns(data.payloads.metaTxns)
+        setIntentCallsPayloads(data.calls)
+        setIntentPreconditions(data.preconditions)
+        setMetaTxns(data.metaTxns)
       } else {
         logger.console.warn("API returned success but no operations found.")
         setIntentCallsPayloads(null)
@@ -553,7 +495,7 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
     },
   })
 
-  function callIntentCallsPayload(args: GetIntentCallsPayloadsArgs) {
+  function callIntentCallsPayload(args: QuoteIntentRequest) {
     createIntentMutation.mutate(args)
   }
 
@@ -819,7 +761,6 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
   })
 
   // Modify the effect that watches for transaction status
-  // biome-ignore lint/correctness/useExhaustiveDependencies: False positive
   useEffect(() => {
     if (!txnHash) {
       // Only reset these when txnHash is cleared
@@ -871,35 +812,8 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
             : undefined,
       })
 
-      if (newStatus === "Success" && receipt.blockNumber) {
-        const fetchTimestamp = async () => {
-          try {
-            if (!originCallParams?.chainId) {
-              logger.console.error(
-                "[Trails] Origin chainId not available for fetching origin block timestamp.",
-              )
-              setOriginBlockTimestamp(null)
-              return
-            }
-            const chainConfig = getChainInfo(originCallParams.chainId)!
-            const client = createPublicClient({
-              chain: chainConfig,
-              transport: http(),
-            })
-            const block = await client.getBlock({
-              blockNumber: BigInt(receipt.blockNumber),
-            })
-            setOriginBlockTimestamp(Number(block.timestamp))
-          } catch (error) {
-            logger.console.error(
-              "[Trails] Error fetching origin block timestamp:",
-              error,
-            )
-            setOriginBlockTimestamp(null)
-          }
-        }
-        fetchTimestamp()
-      } else if (newStatus !== "Success") {
+      // Timestamp is now available from transaction receipts via the API (txnMinedAt)
+      if (newStatus !== "Success") {
         setOriginBlockTimestamp(null)
       }
 
@@ -911,9 +825,16 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
         !metaTxns.some((tx: MetaTxn) => sentMetaTxns[`${tx.chainId}-${tx.id}`])
       ) {
         logger.console.log(
-          "Origin transaction successful, auto-sending all meta transactions...",
+          "Origin transaction successful, calling executeIntent and auto-sending all meta transactions...",
         )
-        sendMetaTxnMutation.mutate({ selectedId: null })
+
+        // Call executeIntent with intentId and depositTransactionHash
+        if (committedOriginIntentAddress && txnHash) {
+          executeIntentMutation.mutate({
+            intentId: committedOriginIntentAddress,
+            depositTransactionHash: txnHash,
+          })
+        }
       }
     } else if (receiptIsError) {
       setOriginCallStatus({
@@ -937,16 +858,17 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
     metaTxns,
     sentMetaTxns,
     isAutoExecute,
-    originCallParams?.chainId,
     originCallStatus?.status,
     originCallStatus?.txnHash,
+    committedOriginIntentAddress,
+    executeIntentMutation,
   ])
 
   // Modify the auto-execute effect
   useEffect(() => {
     const shouldAutoSend =
       isAutoExecute &&
-      commitIntentConfigMutation.isSuccess &&
+      commitIntentMutation.isSuccess &&
       originCallParams?.chainId &&
       account.chainId === originCallParams.chainId &&
       !originCallParams.error &&
@@ -1002,7 +924,7 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
     }
   }, [
     isAutoExecute,
-    commitIntentConfigMutation.isSuccess,
+    commitIntentMutation.isSuccess,
     originCallParams,
     account.chainId,
     sendOriginTxn.isPending,
@@ -1023,286 +945,25 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
       trailsFee &&
       account.address &&
       originIntentAddress &&
-      !commitIntentConfigMutation.isPending &&
-      !commitIntentConfigMutation.isSuccess
+      !commitIntentMutation.isPending &&
+      !commitIntentMutation.isSuccess
     ) {
       logger.console.log("Auto-committing intent configuration...")
-      commitIntentConfigMutation.mutate({
-        mainSignerAddress: account.address,
-        calls: intentCallsPayloads,
-        preconditions: intentPreconditions,
-        quoteProvider: trailsFee.quoteProvider as QuoteProvider,
-        addressOverrides:
-          createIntentMutation.variables?.params.addressOverrides,
-      })
+      if (quoteIntent) {
+        commitIntentMutation.mutate(quoteIntent)
+      }
     }
   }, [
     isAutoExecute,
+    quoteIntent,
     intentCallsPayloads,
     intentPreconditions,
     trailsFee,
     account.address,
     originIntentAddress,
-    commitIntentConfigMutation,
-    createIntentMutation.variables,
+    commitIntentMutation,
   ])
 
-  // Update the sendMetaTxn mutation
-  const sendMetaTxnMutation = useMutation({
-    mutationFn: async ({ selectedId }: { selectedId: string | null }) => {
-      logger.console.log("[trails-sdk] Starting sendMetaTxn mutation", {
-        selectedId,
-        hasIntentCallsPayloads: !!intentCallsPayloads,
-        hasIntentPreconditions: !!intentPreconditions,
-        hasMetaTxns: !!metaTxns,
-        hasAccountAddress: !!account.address,
-        quoteProvider: trailsFee?.quoteProvider,
-      })
-
-      if (
-        !intentCallsPayloads ||
-        !intentPreconditions ||
-        !metaTxns ||
-        !account.address
-      ) {
-        throw new Error("Missing required data for meta-transaction")
-      }
-
-      if (!trailsFee?.quoteProvider) {
-        throw new Error("quoteProvider is required")
-      }
-
-      const intentAddress = calculateIntentAddress(
-        account.address,
-        intentCallsPayloads as any[],
-      )
-
-      // If no specific ID is selected, send all meta transactions
-      const txnsToSend = selectedId
-        ? [metaTxns.find((tx: MetaTxn) => tx.id === selectedId)]
-        : metaTxns
-
-      logger.console.log("[trails-sdk] Selected transactions to send", {
-        selectedId,
-        totalMetaTxns: metaTxns.length,
-        txnsToSendCount: txnsToSend.filter((tx) => tx).length,
-        txnsToSend: txnsToSend
-          .filter((tx) => tx)
-          .map((tx) => ({
-            id: tx?.id,
-            chainId: tx?.chainId,
-            walletAddress: tx?.walletAddress,
-            contract: tx?.contract,
-          })),
-      })
-
-      if (!txnsToSend || (selectedId && !txnsToSend[0])) {
-        throw new Error("Meta transaction not found")
-      }
-
-      const results = []
-
-      for (const metaTxn of txnsToSend) {
-        if (!metaTxn) continue
-
-        const operationKey = `${metaTxn.chainId}-${metaTxn.id}`
-        const lastSentTime = sentMetaTxns[operationKey]
-        const now = Date.now()
-
-        logger.console.log(
-          `[trails-sdk] Processing meta transaction ${operationKey}`,
-          {
-            metaTxnId: metaTxn.id,
-            chainId: metaTxn.chainId,
-            walletAddress: metaTxn.walletAddress,
-            contract: metaTxn.contract,
-            intentAddress,
-          },
-        )
-
-        if (lastSentTime && now - lastSentTime < RETRY_WINDOW_MS) {
-          const timeLeft = Math.ceil(
-            (RETRY_WINDOW_MS - (now - lastSentTime)) / 1000,
-          )
-          logger.console.log(
-            `[trails-sdk] Meta transaction for ${operationKey} was sent recently. Wait ${timeLeft}s before retry`,
-            {
-              lastSentTime,
-              now,
-              timeLeft,
-            },
-          )
-          continue
-        }
-
-        try {
-          const chainId = parseInt(metaTxn.chainId, 10)
-          if (Number.isNaN(chainId) || chainId <= 0) {
-            logger.console.error(
-              `[trails-sdk] Invalid chainId for meta transaction`,
-              {
-                chainId,
-                operationKey,
-                metaTxn,
-              },
-            )
-            throw new Error(`Invalid chainId for meta transaction: ${chainId}`)
-          }
-          const chainRelayer = getRelayer(chainId)
-          if (!chainRelayer) {
-            logger.console.error(`[trails-sdk] No relayer found for chainId`, {
-              chainId,
-              operationKey,
-              availableRelayers: Array.from(relayers.keys()),
-            })
-            throw new Error(`No relayer found for chainId: ${chainId}`)
-          }
-
-          const relevantPreconditions = intentPreconditions.filter(
-            (p: IntentPrecondition) =>
-              p.chainId && parseInt(p.chainId, 10) === chainId,
-          )
-
-          logger.console.log(
-            `[trails-sdk] Relaying meta transaction ${operationKey} to intent ${intentAddress} via relayer`,
-            {
-              chainId,
-              operationKey,
-              intentAddress,
-              relayer: !!chainRelayer,
-              preconditionsCount: relevantPreconditions.length,
-            },
-          )
-
-          const { opHash } = await chainRelayer.sendMetaTxn(
-            metaTxn.walletAddress as Address.Address,
-            metaTxn.contract as Address.Address,
-            metaTxn.input as Hex,
-            Number(metaTxn.chainId),
-            undefined,
-            relevantPreconditions,
-          )
-
-          logger.console.log(
-            `[trails-sdk] Successfully sent meta transaction ${operationKey}`,
-            {
-              operationKey,
-              opHash,
-              chainId,
-            },
-          )
-
-          const useBackupRelayer = false // Disable backup relayer for now
-          if (useBackupRelayer) {
-            try {
-              // Fire and forget send tx to backup relayer
-              const backupRelayer = getBackupRelayer(chainId)
-
-              backupRelayer
-                ?.sendMetaTxn(
-                  metaTxn.walletAddress as Address.Address,
-                  metaTxn.contract as Address.Address,
-                  metaTxn.input as Hex,
-                  Number(metaTxn.chainId),
-                  undefined,
-                  relevantPreconditions,
-                )
-                .then(() => {
-                  logger.console.log(
-                    `[trails-sdk] Backup relayer sent for ${operationKey}`,
-                  )
-                })
-                .catch((backupError) => {
-                  logger.console.warn(
-                    `[trails-sdk] Backup relayer failed for ${operationKey}`,
-                    backupError,
-                  )
-                })
-            } catch {}
-          }
-
-          results.push({
-            operationKey,
-            opHash,
-            success: true,
-          })
-        } catch (error: unknown) {
-          const errorMessage =
-            error instanceof Error ? error.message : "Unknown error"
-          logger.console.error(
-            `[trails-sdk] Failed to send meta transaction ${operationKey}`,
-            {
-              operationKey,
-              error: errorMessage,
-              chainId: metaTxn.chainId,
-              metaTxnId: metaTxn.id,
-              walletAddress: metaTxn.walletAddress,
-              contract: metaTxn.contract,
-            },
-          )
-
-          results.push({
-            operationKey,
-            error: errorMessage,
-            success: false,
-          })
-        }
-      }
-
-      return results
-    },
-    onSuccess: (results) => {
-      logger.console.log(
-        "[trails-sdk] sendMetaTxn mutation completed successfully",
-        {
-          totalResults: results.length,
-          successfulResults: results.filter((r) => r.success).length,
-          failedResults: results.filter((r) => !r.success).length,
-          results: results.map((r) => ({
-            operationKey: r.operationKey,
-            success: r.success,
-            opHash: r.opHash || null,
-            error: r.error || null,
-          })),
-        },
-      )
-
-      // Update states based on results
-      results.forEach(({ operationKey, opHash, success }) => {
-        if (success && opHash) {
-          setSentMetaTxns((prev) => ({
-            ...prev,
-            [operationKey]: Date.now(),
-          }))
-
-          setOperationHashes((prev) => ({
-            ...prev,
-            [operationKey]: opHash,
-          }))
-        } else {
-          logger.console.warn(
-            `[trails-sdk] Not updating state for failed meta transaction ${operationKey}`,
-            {
-              operationKey,
-              error: results.find((r) => r.operationKey === operationKey)
-                ?.error,
-            },
-          )
-        }
-      })
-    },
-    onError: (error) => {
-      logger.console.error("[trails-sdk] Error in meta-transaction process", {
-        error: error instanceof Error ? error.message : String(error),
-        errorType:
-          error instanceof Error ? error.constructor.name : typeof error,
-        stack: error instanceof Error ? error.stack : undefined,
-      })
-    },
-    retry: 5, // Allow up to 2 retries
-    retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000), // Exponential backoff
-  })
-
   const [tokenAddress, setTokenAddress] = useState<string | null>(null)
   const [originChainId, setOriginChainId] = useState<number | null>(null)
 
@@ -1333,39 +994,36 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
 
       const recipientAddress = intentAddressString
 
-      const isNative = tokenAddress === zeroAddress
+      const isNative =
+        tokenAddress === zeroAddress || tokenAddress === ethAddress
 
       if (isNative) {
         const nativePrecondition = intentPreconditions.find(
-          (p: IntentPrecondition) =>
+          (p: TransactionPrecondition) =>
             (p.type === "transfer-native" || p.type === "native-balance") &&
-            p.chainId === originChainId.toString(),
+            p.chainId === originChainId,
         )
-        const nativeMinAmount = nativePrecondition?.data?.min?.toString()
+        const nativeMinAmount = nativePrecondition?.minAmount?.toString()
         if (nativeMinAmount === undefined) {
-          throw new Error(
-            "Could not find native precondition (transfer-native or native-balance) or min amount",
-          )
+          throw new Error("Could not find precondition or min amount")
         }
         calcValue = BigInt(nativeMinAmount)
         calcTo = recipientAddress
       } else {
         const erc20Precondition = intentPreconditions.find(
-          (p: IntentPrecondition) =>
+          (p: TransactionPrecondition) =>
             p.type === "erc20-balance" &&
-            p.chainId === originChainId.toString() &&
-            p.data?.token &&
+            p.chainId === originChainId &&
+            p.tokenAddress &&
             isAddressEqual(
-              Address.from(p.data.token),
+              Address.from(p.tokenAddress),
               Address.from(tokenAddress),
             ),
         )
 
-        const erc20MinAmount = erc20Precondition?.data?.min?.toString()
+        const erc20MinAmount = erc20Precondition?.minAmount?.toString()
         if (erc20MinAmount === undefined) {
-          throw new Error(
-            "Could not find ERC20 balance precondition or min amount",
-          )
+          throw new Error("Could not find precondition or min amount")
         }
         calcData = getERC20TransferData({
           recipient: recipientAddress,
@@ -1444,232 +1102,91 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
   //   }
   // }, [intentPreconditions, checkPreconditionStatuses])
 
-  // Add monitoring for each meta transaction
-  const metaTxnMonitorStatuses = useMetaTxnsMonitor(
-    metaTxns as unknown as MetaTxn[] | undefined,
-    getRelayer,
+  // Use the new WaitIntentReceipt API to monitor intent execution
+  // This replaces the old per-meta-transaction polling approach
+  const intentReceiptStatus = useIntentReceiptMonitor(
+    committedOriginIntentAddress ?? undefined,
+    trailsClient,
   )
 
-  // Create a stable dependency for the meta timestamp effect
-  const _stableMetaTxnStatusesKey = useMemo(() => {
-    if (!metaTxns || Object.keys(metaTxnMonitorStatuses).length === 0) {
-      return "no_statuses"
-    }
-    // Sort by a stable key (e.g., id) to ensure consistent order if metaTxns array order changes
-    // but content is the same, though metaTxns itself is a dependency, so this might be redundant if metaTxns order is stable.
-    const sortedTxnIds = metaTxns
-      .map((tx: MetaTxn) => `${tx.chainId}-${tx.id}`)
-      .sort()
-
-    return sortedTxnIds
-      .map((key: string) => {
-        const statusObj = metaTxnMonitorStatuses[key]
-        return `${key}:${statusObj ? statusObj.status : "loading"}`
-      })
-      .join(",")
-  }, [metaTxns, metaTxnMonitorStatuses])
-
-  const processedTxns = useRef(new Set<string>())
-  const lastQueuedCctpSourceTxHash = useRef<string | null>(null)
-
-  // Effect to fetch meta-transaction block timestamps
+  // Simplified block timestamp tracking using IntentReceipt API
+  // The IntentReceipt provides unified status for both origin and destination transactions
   useEffect(() => {
-    logger.console.log(
-      "[trails-sdk] Running meta-transaction block timestamp effect:",
-      {
-        metaTxnsLength: metaTxns?.length,
-        monitorStatusesLength: Object.keys(metaTxnMonitorStatuses).length,
-      },
-    )
-
-    if (!metaTxns || metaTxns.length === 0) {
-      logger.console.log(
-        "[trails-sdk] No meta transactions, clearing timestamps",
-      )
-      processedTxns.current.clear()
-      if (Object.keys(metaTxnBlockTimestamps).length > 0) {
-        setMetaTxnBlockTimestamps({})
-      }
-      return
-    }
+    logger.console.log("[trails-sdk] Intent receipt status update:", {
+      intentId: committedOriginIntentAddress,
+      done: intentReceiptStatus.done,
+      hasReceipt: !!intentReceiptStatus.intentReceipt,
+    })
 
-    if (!Object.keys(metaTxnMonitorStatuses).length) {
-      logger.console.log("[trails-sdk] No monitor statuses yet, waiting...")
+    if (!intentReceiptStatus.intentReceipt) {
+      logger.console.log("[trails-sdk] No intent receipt yet, waiting...")
       return
     }
 
-    metaTxns.forEach(async (metaTxn: MetaTxn, index: number) => {
-      const operationKey = `${metaTxn.chainId}-${metaTxn.id}`
-
-      // Skip if already processed
-      if (processedTxns.current.has(operationKey)) {
-        logger.console.log(
-          `[trails-sdk] MetaTxn ${operationKey}: Already processed, skipping`,
-        )
-        return
-      }
-
-      const monitorStatus = metaTxnMonitorStatuses[operationKey]
-      if (!monitorStatus || monitorStatus.status !== "confirmed") {
-        logger.console.log(
-          `[trails-sdk] MetaTxn ${operationKey}: Status not confirmed, skipping`,
-        )
-        return
-      }
+    // Update block timestamps from intent receipt transactions
+    const newTimestamps: typeof metaTxnBlockTimestamps = {}
 
-      // Type assertion since we know it exists when status is "confirmed"
-      const transactionHash = monitorStatus.transactionHash as Hex | undefined
-      if (!transactionHash) {
-        logger.console.log(
-          `[trails-sdk] MetaTxn ${operationKey}: No transaction hash, skipping`,
-        )
-        return
-      }
-
-      logger.console.log(
-        `[trails-sdk] MetaTxn ${operationKey}: Processing transaction ${transactionHash}`,
-      )
-      processedTxns.current.add(operationKey)
+    if (intentReceiptStatus.intentReceipt.originTransaction) {
+      const originTx = intentReceiptStatus.intentReceipt.originTransaction
+      const key = `${originTx.chainId}-${originTx.metaTxnId}`
+      newTimestamps[key] = { timestamp: null } // TODO: fetch actual block timestamp
+    }
 
-      try {
-        const chainId = parseInt(metaTxn.chainId, 10)
-        if (Number.isNaN(chainId) || chainId <= 0) {
-          throw new Error(
-            `Invalid chainId for meta transaction: ${metaTxn.chainId}`,
-          )
-        }
+    if (intentReceiptStatus.intentReceipt.destinationTransaction) {
+      const destTx = intentReceiptStatus.intentReceipt.destinationTransaction
+      const key = `${destTx.chainId}-${destTx.metaTxnId}`
+      newTimestamps[key] = { timestamp: null } // TODO: fetch actual block timestamp
+    }
 
-        const chainConfig = getChainInfo(chainId)!
-        const client = createPublicClient({
-          chain: chainConfig,
-          transport: http(),
-        })
+    setMetaTxnBlockTimestamps(newTimestamps)
+  }, [
+    intentReceiptStatus.intentReceipt,
+    intentReceiptStatus.done,
+    committedOriginIntentAddress,
+  ])
 
-        const receipt = await client.getTransactionReceipt({
-          hash: transactionHash,
-        })
+  // 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,
+      })
 
-        if (receipt && typeof receipt.blockNumber === "bigint") {
-          const block = await client.getBlock({
-            blockNumber: receipt.blockNumber,
-          })
-          logger.console.log(
-            `[trails-sdk] MetaTxn ${operationKey}: Got block timestamp ${block.timestamp}`,
-          )
-          setMetaTxnBlockTimestamps((prev) => ({
-            ...prev,
-            [operationKey]: {
-              timestamp: Number(block.timestamp),
-              error: undefined,
-            },
-          }))
-
-          // Queue CCTP transfer using the first confirmed origin meta-tx hash
+      // Handle CCTP transfers if needed
+      if (intentReceiptStatus.intentReceipt.originTransaction?.txnHash) {
+        const providerFromQuote = trailsFee?.quoteProvider
+          ? String(trailsFee.quoteProvider).toLowerCase()
+          : undefined
+        const providerFromArgs = createIntentMutation.variables?.options
+          ?.quoteProvider
+          ? String(
+              createIntentMutation.variables.options.quoteProvider,
+            ).toLowerCase()
+          : undefined
+        const isCctp =
+          providerFromQuote === "cctp" || providerFromArgs === "cctp"
+
+        if (isCctp && createIntentMutation.variables) {
           try {
-            const providerFromQuote = trailsFee?.quoteProvider
-              ? String(trailsFee.quoteProvider).toLowerCase()
-              : undefined
-            const providerFromArgs = createIntentMutation.variables?.params
-              .provider
-              ? String(
-                  createIntentMutation.variables.params.provider,
-                ).toLowerCase()
-              : undefined
-            const isCctp =
-              providerFromQuote === "cctp" || providerFromArgs === "cctp"
-
-            const originChainIdForCctp =
-              createIntentMutation.variables?.params.originChainId
-            const destinationChainIdForCctp =
-              createIntentMutation.variables?.params.destinationChainId
-
-            logger.console.log("[Trails] isCctp", isCctp)
-            logger.console.log("[Trails] providerFromQuote", providerFromQuote)
-            logger.console.log("[Trails] providerFromArgs", providerFromArgs)
-            logger.console.log("[Trails] trailsFee", trailsFee)
-            logger.console.log(
-              "[Trails] createIntentMutation.variables",
-              createIntentMutation.variables,
-            )
-            logger.console.log(
-              "[Trails] createIntentMutation.variables.params.provider",
-              createIntentMutation.variables?.params.provider,
-            )
-            logger.console.log(
-              "[Trails] createIntentMutation.variables.params.originChainId",
-              createIntentMutation.variables?.params.originChainId,
-            )
-            logger.console.log(
-              "[Trails] createIntentMutation.variables.params.destinationChainId",
-              createIntentMutation.variables?.params.destinationChainId,
-            )
-            logger.console.log(
-              "[Trails] lastQueuedCctpSourceTxHash",
-              lastQueuedCctpSourceTxHash.current,
-            )
-            logger.console.log("[Trails] transactionHash", transactionHash)
-            logger.console.log(
-              "[Trails] originChainIdForCctp",
-              originChainIdForCctp,
-            )
-            logger.console.log(
-              "[Trails] destinationChainIdForCctp",
-              destinationChainIdForCctp,
-            )
-
-            if (
-              isCctp &&
-              trailsClient &&
-              transactionHash &&
-              typeof originChainIdForCctp === "number" &&
-              typeof destinationChainIdForCctp === "number" &&
-              lastQueuedCctpSourceTxHash.current !== transactionHash &&
-              index === 0
-            ) {
-              lastQueuedCctpSourceTxHash.current = transactionHash
-              await queueCCTPTransfer({
-                trailsClient,
-                sourceTxHash: transactionHash,
-                sourceChainId: originChainIdForCctp,
-                destinationChainId: destinationChainIdForCctp,
-              })
-            }
-          } catch (err) {
-            logger.console.error(
-              `[trails-sdk] Queue CCTP on meta-tx error (${operationKey}):`,
-              err,
-            )
+            queueCCTPTransfer({
+              sourceTxHash: intentReceiptStatus.intentReceipt.originTransaction
+                .txnHash as `0x${string}`,
+              sourceChainId: createIntentMutation.variables.originChainId,
+              destinationChainId:
+                createIntentMutation.variables.destinationChainId,
+              trailsClient,
+            })
+          } catch (error) {
+            logger.console.error("[Trails] queueCCTPTransfer error", error)
           }
-        } else {
-          logger.console.warn(
-            `[trails-sdk] MetaTxn ${operationKey}: No block number in receipt`,
-          )
-          setMetaTxnBlockTimestamps((prev) => ({
-            ...prev,
-            [operationKey]: {
-              timestamp: null,
-              error: "Block number not found in receipt",
-            },
-          }))
         }
-      } catch (error: any) {
-        logger.console.error(
-          `[trails-sdk] MetaTxn ${operationKey}: Error:`,
-          error,
-        )
-        setMetaTxnBlockTimestamps((prev) => ({
-          ...prev,
-          [operationKey]: {
-            timestamp: null,
-            error: error.message || "Failed to fetch receipt/timestamp",
-          },
-        }))
       }
-    })
+    }
   }, [
-    metaTxns,
-    metaTxnMonitorStatuses,
-    metaTxnBlockTimestamps,
+    intentReceiptStatus.done,
+    intentReceiptStatus.intentReceipt,
+    committedOriginIntentAddress,
     trailsFee,
     createIntentMutation.variables,
     trailsClient,
@@ -1679,22 +1196,13 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
     setIsAutoExecute(enabled)
   }
 
-  function createIntent(args: GetIntentCallsPayloadsArgs) {
-    createIntentMutation.mutate({
-      ...args,
-      destinationSalt: Date.now().toString(),
-    } as GetIntentCallsPayloadsArgs)
+  function createIntent(args: QuoteIntentRequest) {
+    createIntentMutation.mutate(args)
   }
 
-  function commitIntentConfig(args: {
-    mainSignerAddress: string
-    calls: IntentCallsPayload[]
-    preconditions: IntentPrecondition[]
-    quoteProvider: QuoteProvider
-    addressOverrides?: AddressOverrides
-  }) {
-    logger.console.log("[trails-sdk] commitIntentConfig", args)
-    commitIntentConfigMutation.mutate(args)
+  function commitIntent(intent: Intent) {
+    logger.console.log("[trails-sdk] commitIntent", intent)
+    commitIntentMutation.mutate(intent)
   }
 
   function updateOriginCallParams(
@@ -1709,10 +1217,6 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
     setTokenAddress(tokenAddress)
   }
 
-  function sendMetaTxn(selectedId: string | null) {
-    sendMetaTxnMutation.mutate({ selectedId })
-  }
-
   const { chainId } = account
 
   const originChainIdFromParams = originCallParams?.chainId
@@ -1722,15 +1226,21 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
   const createIntentError = createIntentMutation.error
   const createIntentArgs = createIntentMutation.variables
 
-  const commitIntentConfigPending = commitIntentConfigMutation.isPending
-  const commitIntentConfigSuccess = commitIntentConfigMutation.isSuccess
-  const commitIntentConfigError = commitIntentConfigMutation.error
-  const commitIntentConfigArgs = commitIntentConfigMutation.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
 
-  const sendMetaTxnPending = sendMetaTxnMutation.isPending
-  const sendMetaTxnSuccess = sendMetaTxnMutation.isSuccess
-  const sendMetaTxnError = sendMetaTxnMutation.error
-  const sendMetaTxnArgs = sendMetaTxnMutation.variables
+  function executeIntent(args: {
+    intentId: string
+    depositTransactionHash: string
+  }) {
+    executeIntentMutation.mutate(args)
+  }
 
   return {
     trailsClient,
@@ -1742,7 +1252,6 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
     committedOriginIntentAddress,
     committedDestinationIntentAddress,
     verificationStatus,
-    getRelayer,
     estimatedGas,
     isEstimateError,
     estimateError,
@@ -1751,12 +1260,16 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
     committedIntentConfig,
     isLoadingCommittedConfig,
     committedConfigError,
-    commitIntentConfig,
-    commitIntentConfigPending,
-    commitIntentConfigSuccess,
-    commitIntentConfigError,
-    commitIntentConfigArgs,
-    getIntentCallsPayloads,
+    commitIntent,
+    commitIntentPending,
+    commitIntentSuccess,
+    commitIntentError,
+    commitIntentArgs,
+    executeIntent,
+    executeIntentPending,
+    executeIntentSuccess,
+    executeIntentError,
+    getIntent,
     operationHashes,
     callIntentCallsPayload,
     sendOriginTransaction,
@@ -1781,13 +1294,8 @@ export function useTrails(config: UseTrailsConfig): UseTrailsReturn {
     hasAutoExecuted,
     originCallSuccess: sendOriginTxn.isSuccess,
     sentMetaTxns,
-    sendMetaTxn,
-    sendMetaTxnPending,
-    sendMetaTxnSuccess,
-    sendMetaTxnError,
-    sendMetaTxnArgs,
     clearIntent,
-    metaTxnMonitorStatuses,
+    intentReceiptStatus,
     createIntent,
     createIntentPending,
     createIntentSuccess,