0xtrails 0.2.5 → 0.3.0

package/src/mutations.ts

@@ -0,0 +1,129 @@
+import { useMutation } from "@tanstack/react-query"
+import type { Intent, DepositSignature } from "@0xsequence/trails-api"
+import { useTrailsClient } from "./trailsClient.js"
+import { logger } from "./logger.js"
+import { getFullErrorMessage } from "./error.js"
+import {
+  trackIntentCommitStarted,
+  trackIntentCommitCompleted,
+  trackIntentCommitError,
+} from "./analytics.js"
+
+/**
+ * Hook for committing an intent to the Trails API
+ * Wraps trailsClient.commitIntent with mutation state and analytics tracking
+ */
+export function useCommitIntent() {
+  const trailsClient = useTrailsClient()
+
+  return useMutation({
+    mutationFn: async (intent: Intent) => {
+      logger.console.log("[trails-sdk] useCommitIntent: Starting commit", {
+        intentId: intent.intentId,
+        originIntentAddress: intent.originIntentAddress,
+      })
+
+      const originChainIdStr = intent.calls[0]?.chainId
+      const destinationChainIdStr = intent.calls[1]?.chainId
+
+      try {
+        // Track intent commit start
+        trackIntentCommitStarted({
+          intentAddress: intent.originIntentAddress,
+          userAddress: intent.ownerAddress,
+          originChainId: originChainIdStr
+            ? Number(originChainIdStr)
+            : undefined,
+          destinationChainId: destinationChainIdStr
+            ? Number(destinationChainIdStr)
+            : undefined,
+        })
+
+        // Commit the intent
+        const response = await trailsClient.commitIntent({ intent })
+
+        logger.console.log("[trails-sdk] useCommitIntent: Commit successful", {
+          intentId: intent.intentId,
+          response,
+        })
+
+        // Track successful intent commit
+        trackIntentCommitCompleted({
+          intentAddress: intent.originIntentAddress,
+          userAddress: intent.ownerAddress,
+          originChainId: originChainIdStr
+            ? Number(originChainIdStr)
+            : undefined,
+          destinationChainId: destinationChainIdStr
+            ? Number(destinationChainIdStr)
+            : undefined,
+        })
+
+        return response
+      } catch (error) {
+        // Track intent commit error
+        trackIntentCommitError({
+          error: getFullErrorMessage(error),
+          userAddress: intent.ownerAddress,
+          intentAddress: intent.originIntentAddress,
+          originChainId: originChainIdStr
+            ? Number(originChainIdStr)
+            : undefined,
+          destinationChainId: destinationChainIdStr
+            ? Number(destinationChainIdStr)
+            : undefined,
+        })
+        throw error
+      }
+    },
+  })
+}
+
+/**
+ * Hook for executing an intent
+ * Wraps trailsClient.executeIntent with mutation state and analytics tracking
+ */
+export function useExecuteIntent() {
+  const trailsClient = useTrailsClient()
+
+  return useMutation({
+    mutationFn: async ({
+      intentId,
+      depositTransactionHash,
+      depositSignature,
+    }: {
+      intentId: string
+      depositTransactionHash?: string
+      depositSignature?: DepositSignature
+    }) => {
+      logger.console.log("[trails-sdk] useExecuteIntent: Starting execution", {
+        intentId,
+        depositTransactionHash,
+        hasDepositSignature: !!depositSignature,
+      })
+
+      // Validate that we have either traditional or gasless deposit params
+      if (!depositTransactionHash && !depositSignature) {
+        throw new Error(
+          "[trails-sdk] Either depositTransactionHash or depositSignature must be provided",
+        )
+      }
+
+      const response = await trailsClient.executeIntent({
+        intentId,
+        depositTransactionHash,
+        depositSignature,
+      })
+
+      logger.console.log(
+        "[trails-sdk] useExecuteIntent: Execution successful",
+        {
+          intentId,
+          response,
+        },
+      )
+
+      return response
+    },
+  })
+}

package/src/preconditions.ts

@@ -1,38 +1,35 @@
-import type { IntentPrecondition } from "@0xsequence/trails-api"
+import type { TransactionPrecondition } from "@0xsequence/trails-api"
+
+// Backward compatibility alias
+export type IntentPrecondition = TransactionPrecondition
 
 export function findPreconditionAddresses(
-  preconditions: IntentPrecondition[],
+  preconditions: TransactionPrecondition[],
   originChainId: number,
   destinationChainId: number,
 ): { originAddress?: string; destinationAddress?: string } {
   const origin = preconditions.find(
-    (p) => p.chainId === originChainId.toString() && p.data?.address,
+    (p) => p.chainId === originChainId && p.ownerAddress,
   )
   const destination = preconditions.find(
-    (p) => p.chainId === destinationChainId.toString() && p.data?.address,
+    (p) => p.chainId === destinationChainId && p.ownerAddress,
   )
 
   return {
-    originAddress: origin?.data?.address,
-    destinationAddress: destination?.data?.address,
+    originAddress: origin?.ownerAddress,
+    destinationAddress: destination?.ownerAddress,
   }
 }
 
 export function findChainAndAddressesFromPreconditions(
-  preconditions: IntentPrecondition[],
+  preconditions: TransactionPrecondition[],
 ): { chainId: number; address: string }[] {
   const addressesFromPreconditions: { chainId: number; address: string }[] = []
   preconditions.forEach((p) => {
-    if (
-      (p.type === "erc20-balance" ||
-        p.type === "native-balance" ||
-        p.type === "transfer-native") &&
-      p.data?.address &&
-      p.chainId
-    ) {
+    if (p.type === "tokenMinBalance" && p.ownerAddress && p.chainId) {
       addressesFromPreconditions.push({
-        chainId: parseInt(p.chainId, 10),
-        address: p.data.address,
+        chainId: p.chainId,
+        address: p.ownerAddress,
       })
     }
   })
@@ -40,13 +37,11 @@ export function findChainAndAddressesFromPreconditions(
 }
 
 export function findFirstPreconditionForChainId(
-  preconditions: IntentPrecondition[],
+  preconditions: TransactionPrecondition[],
   chainId: number,
-): IntentPrecondition | null {
+): TransactionPrecondition | null {
   const precondition = preconditions.find(
-    (p) =>
-      (p.type === "erc20-balance" || p.type === "native-balance") &&
-      p.chainId === chainId?.toString(),
+    (p) => p.type === "tokenMinBalance" && p.chainId === chainId,
   )
   return precondition ?? null
 }