0xtrails 0.2.5 → 0.3.0

package/src/config.ts

@@ -1,11 +1,9 @@
 import {
   PROD_SEQUENCE_INDEXER_URL,
-  PROD_SEQUENCE_API_URL,
   DEFAULT_WALLETCONNECT_PROJECT_ID,
   DEFAULT_SLIPPAGE_TOLERANCE,
   PROD_SEQUENCE_PROJECT_ACCESS_KEY,
   DEV_SEQUENCE_INDEXER_URL,
-  DEV_SEQUENCE_API_URL,
   DEV_TRAILS_API_URL,
   DEV_SEQUENCE_PROJECT_ACCESS_KEY,
   DEFAULT_SEQUENCE_ENV,
@@ -23,7 +21,6 @@ export const globalConfig: {
   sequenceProjectAccessKey: string
   sequenceIndexerUrl: string
   sequenceNodeGatewayUrl: string
-  sequenceApiUrl: string
   trailsApiUrl: string
   sequenceEnv: SequenceEnv
   walletConnectProjectId: string
@@ -36,7 +33,6 @@ export const globalConfig: {
   sequenceProjectAccessKey: declareSequenceProjectAccessKey(),
   sequenceIndexerUrl: declareSequenceIndexerUrl(),
   sequenceNodeGatewayUrl: declareSequenceNodeGatewayUrl(),
-  sequenceApiUrl: declareSequenceApiUrl(),
   trailsApiUrl: declareTrailsApiUrl(),
   walletConnectProjectId: DEFAULT_WALLETCONNECT_PROJECT_ID,
   slippageTolerance: DEFAULT_SLIPPAGE_TOLERANCE,
@@ -48,27 +44,38 @@ export function declareSequenceEnv(): SequenceEnv {
   if (typeof window !== "undefined" && (import.meta as any)?.hot) {
     return "local"
   }
-  if (typeof process !== "undefined") {
-    if (getEnvVar("ENV") === "local") {
-      return "local"
-    }
-    if (getEnvVar("ENV") === "development" || getEnvVar("ENV") === "dev") {
-      return "dev"
-    }
 
-    // Special handling for Cloudflare Pages branches
-    const cfPagesBranch = getEnvVar("CF_PAGES_BRANCH")
-    if (cfPagesBranch) {
-      // If running on Cloudflare Pages, all branches except "production" default to dev
-      if (cfPagesBranch === "prod" || cfPagesBranch === "production") {
-        return "prod"
-      }
-      return "dev"
-    }
+  // Check explicit ENV variable first
+  const explicitEnv = getEnvVar("ENV")
+  if (explicitEnv === "local") {
+    return "local"
+  }
+  if (explicitEnv === "development" || explicitEnv === "dev") {
+    return "dev"
+  }
+  if (explicitEnv === "production" || explicitEnv === "prod") {
+    return "prod"
+  }
 
-    if (getEnvVar("ENV") === "production" || getEnvVar("ENV") === "prod") {
+  // Special handling for Cloudflare Pages branches
+  const cfPagesBranch = getEnvVar("CF_PAGES_BRANCH")
+  if (cfPagesBranch) {
+    // If running on Cloudflare Pages, all branches except "production" default to dev
+    if (cfPagesBranch === "prod" || cfPagesBranch === "production") {
       return "prod"
     }
+    // Preview mode and other branches default to dev
+    return "dev"
+  }
+
+  // If we're in a browser/Cloudflare environment but no explicit env is set,
+  // check if we have dev environment variables set (indicating non-prod)
+  // This helps with Cloudflare Workers preview mode
+  if (typeof window !== "undefined" || typeof process === "undefined") {
+    // In browser/Cloudflare Workers context, if no explicit prod indicators,
+    // default to dev for safety (unless explicitly set to prod)
+    // This prevents accidental prod usage in preview/staging environments
+    return "dev"
   }
 
   return DEFAULT_SEQUENCE_ENV
@@ -81,16 +88,6 @@ export function declareSequenceIndexerUrl() {
   return DEV_SEQUENCE_INDEXER_URL
 }
 
-export function declareSequenceApiUrl() {
-  if (declareSequenceEnv() === "prod") {
-    return PROD_SEQUENCE_API_URL
-  }
-  if (declareSequenceEnv() === "local") {
-    return getEnvVar("SEQUENCE_API_URL") || DEV_SEQUENCE_API_URL
-  }
-  return DEV_SEQUENCE_API_URL
-}
-
 export function declareTrailsApiUrl() {
   if (declareSequenceEnv() === "prod") {
     return PROD_TRAILS_API_URL
@@ -109,17 +106,18 @@ export function declareSequenceNodeGatewayUrl() {
 }
 
 export function declareSequenceProjectAccessKey() {
-  const sequenceEnv = declareSequenceEnv()
-
-  // Check for explicit env var override
-  if (typeof process !== "undefined") {
-    const envVarKey = getEnvVar("SEQUENCE_PROJECT_ACCESS_KEY")
-    if (envVarKey) {
-      return envVarKey
-    }
+  // Check for explicit env var override first (works in all environments)
+  const envVarKey =
+    getEnvVar("SEQUENCE_PROJECT_ACCESS_KEY") ||
+    getEnvVar("PROJECT_ACCESS_KEY") ||
+    getEnvVar("VITE_SEQUENCE_PROJECT_ACCESS_KEY") ||
+    getEnvVar("VITE_PROJECT_ACCESS_KEY")
+  if (envVarKey) {
+    return envVarKey
   }
 
   // Use dev/prod keys based on environment
+  const sequenceEnv = declareSequenceEnv()
   if (sequenceEnv === "prod") {
     return PROD_SEQUENCE_PROJECT_ACCESS_KEY
   }
@@ -171,14 +169,6 @@ export function getSequenceNodeGatewayUrl() {
   return globalConfig.sequenceNodeGatewayUrl
 }
 
-export function setSequenceApiUrl(sequenceApiUrl: string) {
-  globalConfig.sequenceApiUrl = sequenceApiUrl
-}
-
-export function getSequenceApiUrl() {
-  return globalConfig.sequenceApiUrl
-}
-
 export function setTrailsApiUrl(trailsApiUrl: string) {
   globalConfig.trailsApiUrl = trailsApiUrl
 }
@@ -192,16 +182,12 @@ export function setSequenceEnv(sequenceEnv: SequenceEnv) {
 
   if (sequenceEnv === "prod") {
     setSequenceIndexerUrl(PROD_SEQUENCE_INDEXER_URL)
-    setSequenceApiUrl(PROD_SEQUENCE_API_URL)
     setTrailsApiUrl(PROD_TRAILS_API_URL)
     setSequenceNodeGatewayUrl(PROD_SEQUENCE_NODE_GATEWAY_URL)
     setSequenceProjectAccessKey(PROD_SEQUENCE_PROJECT_ACCESS_KEY)
   }
 
   if (sequenceEnv === "local") {
-    if (getEnvVar("SEQUENCE_API_URL")) {
-      setSequenceApiUrl(getEnvVar("SEQUENCE_API_URL"))
-    }
     if (getEnvVar("TRAILS_API_URL")) {
       setTrailsApiUrl(getEnvVar("TRAILS_API_URL"))
     }
@@ -209,7 +195,6 @@ export function setSequenceEnv(sequenceEnv: SequenceEnv) {
 
   if (sequenceEnv === "dev") {
     setSequenceIndexerUrl(DEV_SEQUENCE_INDEXER_URL)
-    setSequenceApiUrl(DEV_SEQUENCE_API_URL)
     setTrailsApiUrl(DEV_TRAILS_API_URL)
     setSequenceNodeGatewayUrl(DEV_SEQUENCE_NODE_GATEWAY_URL)
     setSequenceProjectAccessKey(DEV_SEQUENCE_PROJECT_ACCESS_KEY)
@@ -272,14 +257,28 @@ export const FeatureFlags = {
 }
 
 export function getEnvVar(name: string) {
-  if (typeof process !== "undefined") {
-    return process?.env?.[name]
-  }
+  // In Vite/browser environments, check import.meta.env first
+  // This is where Vite injects environment variables at build time
   if ((import.meta as any)?.env) {
-    return (import.meta as any).env[name]
+    // Check for VITE_ prefixed version first (Vite convention)
+    const vitePrefixed = (import.meta as any).env[`VITE_${name}`]
+    if (vitePrefixed !== undefined && vitePrefixed !== "") {
+      return vitePrefixed
+    }
+    // Check direct name (for variables injected via vite.config.ts define)
+    const direct = (import.meta as any).env[name]
+    if (direct !== undefined && direct !== "") {
+      return direct
+    }
   }
-  if ((import.meta as any).env[`VITE_${name}`]) {
-    return (import.meta as any).env[`VITE_${name}`]
+
+  // Fall back to process.env for Node.js environments
+  if (typeof process !== "undefined" && process?.env) {
+    const value = process.env[name]
+    if (value !== undefined && value !== "") {
+      return value
+    }
   }
+
   return undefined
 }

package/src/constants.ts

@@ -1,4 +1,4 @@
-import type { AddressOverrides } from "@0xsequence/trails-api"
+import type { TrailsAddressOverrides } from "@0xsequence/trails-api"
 import type { Context as ContextLike } from "@0xsequence/wallet-primitives"
 import type { Address } from "ox"
 
@@ -10,12 +10,13 @@ export const SEQUENCE_V3_CONTRACT_ADDRESSES: ContextLike.Context = {
     "0x6041600e3d396021805130553df33d3d36153402601f57363d3d373d363d30545af43d82803e903d91601f57fd5bf3" as Address.Address,
 }
 
-export const SEQUENCE_V3_CONTRACT_ADDRESSES_OVERRIDES: AddressOverrides = {
-  sequenceWalletFactoryAddress: SEQUENCE_V3_CONTRACT_ADDRESSES.factory,
-  sequenceWalletMainModuleAddress: SEQUENCE_V3_CONTRACT_ADDRESSES.stage1,
-  sequenceWalletMainModuleUpgradableAddress:
-    SEQUENCE_V3_CONTRACT_ADDRESSES.stage2,
-} as AddressOverrides
+export const SEQUENCE_V3_CONTRACT_ADDRESSES_OVERRIDES: TrailsAddressOverrides =
+  {
+    sequenceWalletFactoryAddress: SEQUENCE_V3_CONTRACT_ADDRESSES.factory,
+    sequenceWalletMainModuleAddress: SEQUENCE_V3_CONTRACT_ADDRESSES.stage1,
+    sequenceWalletMainModuleUpgradableAddress:
+      SEQUENCE_V3_CONTRACT_ADDRESSES.stage2,
+  } as TrailsAddressOverrides
 
 export const TRAILS_ROUTER_ADDRESS: Address.Address =
   "0xc4415c5CabD726bA06042af752a528B3dbc263F7"
@@ -30,11 +31,9 @@ export const DEFAULT_SEQUENCE_ENV = "prod"
 
 export const PROD_SEQUENCE_NODE_GATEWAY_URL = "https://nodes.sequence.app"
 export const PROD_SEQUENCE_INDEXER_URL = "https://indexer.sequence.app"
-export const PROD_SEQUENCE_API_URL = "https://api.sequence.app"
 export const PROD_TRAILS_API_URL = "https://trails-api.sequence.app"
 export const DEV_SEQUENCE_NODE_GATEWAY_URL = "https://dev-nodes.sequence.app"
 export const DEV_SEQUENCE_INDEXER_URL = "https://dev-indexer.sequence.app"
-export const DEV_SEQUENCE_API_URL = "https://dev-api.sequence.app"
 export const DEV_TRAILS_API_URL = "https://dev-trails-api.sequence-dev.app"
 
 export const LOCAL_TRAILS_API_URL = "http://localhost:4422"
@@ -55,3 +54,6 @@ export const DEFAULT_WALLETCONNECT_PROJECT_ID =
 export const SITE_URL = "https://trails.build/"
 
 export const DEFAULT_SLIPPAGE_TOLERANCE = "0.05" // 0.001 = 0.1%, 0.005 = 0.5%, 0.03 = 3%, 0.05 = 5%
+
+export const DEFAULT_MODE = "pay"
+export const DEFAULT_THEME = "light"

package/src/error.ts

@@ -21,7 +21,18 @@ export function getErrorString(err: unknown): string {
   return err instanceof Error ? err.message : (err?.toString() ?? "")
 }
 
-export function getIsWalletRejectedError(err: unknown) {
+export function getIsUserRejectionError(
+  err: unknown,
+): err is UserRejectionError {
+  // Check if it's an instance of UserRejectionError (or has the name property)
+  if (
+    err instanceof UserRejectionError ||
+    (err instanceof Error && err.name === "UserRejectionError")
+  ) {
+    return true
+  }
+
+  // Check if the error message indicates a user rejection
   const isRejected = /rejected|denied|user rejected the request/gi.test(
     getErrorString(err).toLowerCase(),
   )
@@ -43,6 +54,13 @@ export class InsufficientBalanceError extends Error {
   }
 }
 
+export class UserRejectionError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = "UserRejectionError"
+  }
+}
+
 export function getIsApiError(err: unknown) {
   const isApiError = /request aborted|not deployed/gi.test(
     getErrorString(err).toLowerCase(),
@@ -144,8 +162,8 @@ export function getPrettifiedErrorMessage(
   if (isApiError) {
     return "An API error occurred. Please try again later."
   }
-  const isWalletRejectedError = getIsWalletRejectedError(err)
-  if (isWalletRejectedError) {
+  const isUserRejectionError = getIsUserRejectionError(err)
+  if (isUserRejectionError) {
     return "The wallet rejected the request. Please try again."
   }
   const isWalletAlreadyConnected = getIsWalletAlreadyConnectedError(err)

package/src/fees.ts

@@ -0,0 +1,210 @@
+import type { Intent } from "@0xsequence/trails-api"
+import { getTokenInfo } from "./tokens.js"
+import { formatRawAmount, formatUsdAmountDisplay } from "./tokenBalances.js"
+import { zeroAddress } from "viem"
+
+export interface FeeItem {
+  amount: string
+  tokenSymbol: string
+  tokenAddress: string
+  chainId: number
+  usdValue: string
+}
+
+export interface TrailsFeeBreakdown {
+  originRelayFee?: FeeItem
+  destinationRelayFee?: FeeItem
+  providerFee?: FeeItem
+  trailsFee?: FeeItem
+  totalUsdValue?: string
+  originChainId?: number
+  destinationChainId?: number
+}
+
+// Helper function to format token amounts with proper decimal conversion
+async function formatTokenAmount(
+  amount: string | number | undefined,
+  tokenAddress: string,
+  chainId: number,
+): Promise<string> {
+  if (!amount) return "0"
+  const num = typeof amount === "string" ? parseFloat(amount) : amount
+  if (num === 0) return "0"
+
+  // Get token info to determine decimals
+  const tokenInfo = await getTokenInfo(chainId, tokenAddress)
+  if (!tokenInfo?.decimals) {
+    throw new Error(
+      `Token decimals not found for token ${tokenAddress} on chain ${chainId}`,
+    )
+  }
+
+  // Use existing formatRawAmount utility
+  const formatted = formatRawAmount(BigInt(Math.floor(num)), tokenInfo.decimals)
+
+  // Handle very small amounts
+  const numFormatted = parseFloat(formatted)
+  if (numFormatted < 0.000001 && numFormatted > 0) return "<0.000001"
+
+  return formatted
+}
+
+// Extract fee breakdown from intent data
+export async function extractTrailsFeeBreakdown(
+  intent: Intent,
+): Promise<TrailsFeeBreakdown | null> {
+  const fees = intent?.fees
+  if (!fees) {
+    return null
+  }
+
+  // Get chain IDs from the calls array to determine origin and destination chains
+  const calls = intent?.calls || []
+  const originChainId: number | undefined = calls[0]?.chainId // First call is origin chain
+  const destinationChainId: number | undefined = calls[1]?.chainId // Second call is destination chain
+
+  // Use the origin and destination gas fees
+  const originChainQuote = fees.originGas
+  const destinationChainQuote = fees.destinationGas
+
+  // If we can't find any chain quotes, return null
+  if (!originChainQuote && !destinationChainQuote) {
+    console.warn(
+      "[trails-sdk] Could not find any chain quotes for fee breakdown",
+      {
+        originChainId,
+        destinationChainId,
+      },
+    )
+    return null
+  }
+
+  const breakdown: TrailsFeeBreakdown = {}
+
+  // Extract origin relay fee if available
+  if (originChainQuote && originChainId !== undefined) {
+    const originTokenSymbol = originChainQuote.nativeTokenSymbol || "ETH"
+    const originChainIdNum =
+      typeof originChainId === "bigint" ? Number(originChainId) : originChainId
+    const nativeTokenAddress = zeroAddress
+
+    breakdown.originRelayFee = {
+      amount: await formatTokenAmount(
+        originChainQuote.totalFeeAmount.toString(),
+        nativeTokenAddress,
+        originChainIdNum,
+      ),
+      tokenSymbol: originTokenSymbol,
+      tokenAddress: nativeTokenAddress,
+      chainId: originChainIdNum,
+      usdValue: formatUsdAmountDisplay(originChainQuote.totalFeeUsd),
+    }
+    breakdown.originChainId = originChainIdNum
+  }
+
+  // Extract destination relay fee if available
+  if (destinationChainQuote && destinationChainId !== undefined) {
+    const destinationTokenSymbol =
+      destinationChainQuote.nativeTokenSymbol || "ETH"
+    const destinationChainIdNum =
+      typeof destinationChainId === "bigint"
+        ? Number(destinationChainId)
+        : destinationChainId
+    const nativeTokenAddress = zeroAddress
+
+    breakdown.destinationRelayFee = {
+      amount: await formatTokenAmount(
+        destinationChainQuote.totalFeeAmount.toString(),
+        nativeTokenAddress,
+        destinationChainIdNum,
+      ),
+      tokenSymbol: destinationTokenSymbol,
+      tokenAddress: nativeTokenAddress,
+      chainId: destinationChainIdNum,
+      usdValue: formatUsdAmountDisplay(destinationChainQuote.totalFeeUsd),
+    }
+    breakdown.destinationChainId = destinationChainIdNum
+  }
+
+  // Extract provider fee from provider fees if available
+  const providerFeeAmount = fees.provider?.quoteProviderFeeUsd
+  const providerFeeRawAmount = fees.provider?.quoteProviderFee
+  if (
+    (providerFeeAmount !== undefined || providerFeeRawAmount !== undefined) &&
+    originChainId !== undefined
+  ) {
+    const feeTokenAddress = fees.feeTokenAddress || zeroAddress
+    const originChainIdNum =
+      typeof originChainId === "bigint" ? Number(originChainId) : originChainId
+
+    // Get token info to determine the actual token symbol
+    const feeTokenInfo = await getTokenInfo(originChainIdNum, feeTokenAddress)
+    if (!feeTokenInfo?.symbol) {
+      throw new Error(
+        `Token symbol not found for provider fee token ${feeTokenAddress} on chain ${originChainIdNum}`,
+      )
+    }
+
+    breakdown.providerFee = {
+      amount: await formatTokenAmount(
+        providerFeeRawAmount?.toString(),
+        feeTokenAddress,
+        originChainIdNum,
+      ),
+      tokenSymbol: feeTokenInfo.symbol,
+      tokenAddress: feeTokenAddress,
+      chainId: originChainIdNum,
+      usdValue: formatUsdAmountDisplay(providerFeeAmount),
+    }
+  }
+
+  // Extract Trails platform fee from provider fees if available
+  const trailsFeeAmount = fees.provider?.trailsFeeUsd
+  const trailsFeeRawAmount = fees.provider?.trailsFee
+  if (
+    (trailsFeeAmount !== undefined || trailsFeeRawAmount !== undefined) &&
+    originChainId !== undefined
+  ) {
+    const feeTokenAddress = fees.feeTokenAddress || zeroAddress
+    const originChainIdNum =
+      typeof originChainId === "bigint" ? Number(originChainId) : originChainId
+
+    // Get token info to determine the actual token symbol
+    const feeTokenInfo = await getTokenInfo(originChainIdNum, feeTokenAddress)
+    if (!feeTokenInfo?.symbol) {
+      throw new Error(
+        `Token symbol not found for trails fee token ${feeTokenAddress} on chain ${originChainIdNum}`,
+      )
+    }
+
+    breakdown.trailsFee = {
+      amount: await formatTokenAmount(
+        trailsFeeRawAmount?.toString(),
+        feeTokenAddress,
+        originChainIdNum,
+      ),
+      tokenSymbol: feeTokenInfo.symbol,
+      tokenAddress: feeTokenAddress,
+      chainId: originChainIdNum,
+      usdValue: formatUsdAmountDisplay(trailsFeeAmount),
+    }
+  }
+
+  // Calculate total USD value from the actual data
+  const originUsd =
+    typeof originChainQuote?.totalFeeUsd === "string"
+      ? parseFloat(originChainQuote.totalFeeUsd)
+      : originChainQuote?.totalFeeUsd || 0
+  const destinationUsd =
+    typeof destinationChainQuote?.totalFeeUsd === "string"
+      ? parseFloat(destinationChainQuote.totalFeeUsd)
+      : destinationChainQuote?.totalFeeUsd || 0
+  const providerUsd =
+    typeof providerFeeAmount === "number" ? providerFeeAmount : 0
+  const trailsUsd = typeof trailsFeeAmount === "number" ? trailsFeeAmount : 0
+  const totalUsd = originUsd + destinationUsd + providerUsd + trailsUsd
+
+  breakdown.totalUsdValue = formatUsdAmountDisplay(totalUsd)
+
+  return breakdown
+}

package/src/index.ts

@@ -1,6 +1,10 @@
 // Be explicit about what we export
 
-export { getAPIClient, useAPIClient } from "./apiClient.js"
+export {
+  InsufficientBalanceError,
+  UserRejectionError,
+  getIsUserRejectionError,
+} from "./error.js"
 export {
   getSupportedChains,
   useSupportedChains,
@@ -13,7 +17,6 @@ export {
   useIndexerGatewayClient,
 } from "./indexerClient.js"
 export type {
-  GetIntentCallsPayloadsReturn,
   OriginCallParams,
   QuoteProvider,
   TrailsFee,
@@ -21,15 +24,20 @@ export type {
 export {
   calculateIntentAddress,
   calculateOriginAndDestinationIntentAddresses,
-  commitIntentConfig,
-  getIntentCallsPayloads,
+  commitIntent,
+  getIntent,
   sendOriginTransaction,
 } from "./intents.js"
-export type {
-  MetaTxn,
-  MetaTxnStatus,
-} from "./metaTxnMonitor.js"
-export { useMetaTxnsMonitor } from "./metaTxnMonitor.js"
+export type { IntentReceiptStatus } from "./intentReceiptMonitor.js"
+export { useIntentReceiptMonitor } from "./intentReceiptMonitor.js"
+export {
+  pollIntentReceipt,
+  type IntentReceiptPollerOptions,
+  type IntentReceiptPollerCallbacks,
+  type OnOriginTransactionFound,
+  type OnDestinationTransactionFound,
+  type OnReceiptUpdate,
+} from "./intentReceiptPoller.js"
 export {
   prepareSend,
   useQuote,
@@ -82,20 +90,20 @@ export type { SupportedToken } from "./tokens.js"
 export { getTxTimeDiff } from "./transactions.js"
 export { useTrails } from "./trails.js"
 export type { WagmiAccount } from "./trails.js"
+export {
+  useCommitIntent,
+  useExecuteIntent,
+} from "./mutations.js"
 export type { Mode } from "./mode.js"
 export { TRAILS_ROUTER_PLACEHOLDER_AMOUNT } from "./trailsRouter.js"
 export { getERC20TransferData } from "./encoders.js"
-export { getRelayer, useRelayers } from "./relayer.js"
-export { relayerSendMetaTx, getMetaTxnReceipt } from "./metaTxns.js"
 export {
   declareSequenceEnv,
   getSequenceProjectAccessKey,
-  getSequenceApiUrl,
   getTrailsApiUrl,
   getSequenceIndexerUrl,
   getSequenceEnv,
   setSequenceProjectAccessKey,
-  setSequenceApiUrl,
   setTrailsApiUrl,
   setSequenceIndexerUrl,
   setSequenceNodeGatewayUrl,
@@ -115,3 +123,17 @@ export {
   useTrailsClient,
   TrailsClient,
 } from "./trailsClient.js"
+export type {
+  IntentReceipt,
+  IntentTransaction as IntentTransactionReceipt,
+  IntentStatus,
+  TransactionStatus,
+  WaitIntentReceiptRequest,
+  WaitIntentReceiptResponse,
+  GetIntentReceiptRequest,
+  GetIntentReceiptResponse,
+  QuoteIntentRequest,
+  Intent,
+  ExecuteIntentRequest,
+  ExecuteIntentResponse,
+} from "@0xsequence/trails-api"

package/src/intentReceiptMonitor.ts

@@ -0,0 +1,102 @@
+import type { TrailsClient } from "./trailsClient.js"
+import type {
+  IntentReceipt,
+  WaitIntentReceiptResponse,
+} from "@0xsequence/trails-api"
+import { type Query, useQuery } from "@tanstack/react-query"
+import { logger } from "./logger.js"
+
+const POLL_INTERVAL = 150 // 150 ms
+
+export type IntentReceiptStatus = {
+  intentReceipt: IntentReceipt | null
+  done: boolean
+  isLoading: boolean
+  isError: boolean
+  error: Error | null
+}
+
+/**
+ * Hook to monitor intent execution status using the WaitIntentReceipt API.
+ * This replaces the old useMetaTxnsMonitor approach which polled individual meta-transactions.
+ *
+ * The WaitIntentReceipt API is a long-polling endpoint that:
+ * - Blocks up to 28 seconds waiting for status changes
+ * - Returns unified status for both origin and destination transactions
+ * - Sets done=true when intent reaches terminal status (SUCCEEDED or FAILED)
+ *
+ * @param intentId - The intent ID to monitor (usually committedOriginIntentAddress)
+ * @param trailsClient - TrailsClient instance for API calls
+ * @returns IntentReceiptStatus with current receipt, done flag, and loading states
+ */
+export const useIntentReceiptMonitor = (
+  intentId: string | undefined,
+  trailsClient: TrailsClient,
+): IntentReceiptStatus => {
+  const queryResult = useQuery({
+    queryKey: ["waitIntentReceipt", intentId],
+    queryFn: async (): Promise<WaitIntentReceiptResponse> => {
+      if (!intentId) {
+        throw new Error("Intent ID is required for monitoring")
+      }
+
+      logger.console.log(
+        `[trails-sdk] 🔍 Monitoring intent receipt for ${intentId}`,
+      )
+
+      const response = await trailsClient.waitIntentReceipt({
+        intentId,
+      })
+
+      logger.console.log(
+        `[trails-sdk] 📊 Intent ${intentId} status: ${response.intentReceipt.status}, done: ${response.done}`,
+      )
+
+      return response
+    },
+    enabled: !!intentId,
+    refetchIntervalInBackground: true,
+    refetchInterval: (
+      query: Query<
+        WaitIntentReceiptResponse,
+        Error,
+        WaitIntentReceiptResponse,
+        ReadonlyArray<unknown>
+      >,
+    ) => {
+      const data = query.state.data
+
+      // If no data yet, continue polling
+      if (!data) return POLL_INTERVAL
+
+      // If done flag is true, stop polling
+      if (data.done) {
+        logger.console.log(
+          `[trails-sdk] ✅ Intent monitoring complete for ${intentId}`,
+        )
+        return false
+      }
+
+      // Otherwise continue polling
+      return POLL_INTERVAL
+    },
+    retry: (failureCount: number, error: Error) => {
+      if (failureCount >= 30) {
+        logger.console.error(
+          `[trails-sdk] ❌ Giving up on intent ${intentId} after 30 failed API attempts:`,
+          error,
+        )
+        return false
+      }
+      return true
+    },
+  })
+
+  return {
+    intentReceipt: queryResult.data?.intentReceipt ?? null,
+    done: queryResult.data?.done ?? false,
+    isLoading: queryResult.isLoading,
+    isError: queryResult.isError,
+    error: queryResult.error,
+  }
+}