0xtrails 0.5.0 → 0.6.0

package/src/transactions.ts

@@ -1,11 +1,9 @@
 import { useQuery } from "@tanstack/react-query"
 import { getChainInfo } from "./chains.js"
-import { getTrailsClient } from "./trailsClient.js"
 import type { GuestModuleEvent, TrailsTokenSweeperEvent } from "./decoders.js"
 import { logger } from "./logger.js"
-import { bigintReplacer } from "./utils.js"
 import { getExplorerUrl } from "./explorer.js"
-import { SortOrder, type IntentSummary } from "@0xsequence/trails-api"
+import { JsonEncode } from "@0xsequence/trails-api"
 import { getChainIndexerUrl } from "./indexerClient.js"
 import { abortControllerRegistry } from "./abortController.js"
 import { useTrails } from "./widget/providers/TrailsProvider.js"
@@ -222,7 +220,7 @@ export async function getAccountTransactionHistory({
         "Content-Type": "application/json",
         "X-Access-Key": apiKey,
       },
-      body: JSON.stringify(requestBody, bigintReplacer, 2),
+      body: JsonEncode(requestBody),
       signal: abortSignal || operationAbortController.signal,
     })
 
@@ -278,6 +276,9 @@ export type IntentTransaction = {
   destinationTokenAmount?: string
   destinationToAddress?: string
   createdAt?: string
+  // Transaction hashes from API response
+  originTransactionHash?: string // Transaction hash from API
+  destinationTransactionHash?: string // Transaction hash from API
   // Enriched token information
   originToken?: {
     symbol: string
@@ -313,155 +314,6 @@ export type IntentTransactionHistoryResponse = {
   transactions: IntentTransaction[]
 }
 
-export type GetIntentTransactionHistoryParams = {
-  accountAddress: string
-  pageSize?: number
-  page?: number
-}
-
-export async function getIntentTransactionHistory({
-  accountAddress,
-  pageSize = 10,
-  page = 1,
-  apiKey,
-  apiUrl,
-}: GetIntentTransactionHistoryParams & {
-  apiKey: string
-  apiUrl: string
-}): Promise<IntentTransactionHistoryResponse> {
-  if (!apiKey) {
-    throw new Error("Trails api key is required")
-  }
-
-  try {
-    const trailsClient = getTrailsClient({ apiKey, hostname: apiUrl })
-
-    const requestParams = {
-      byOwnerAddress: accountAddress,
-      page: {
-        pageSize,
-        sort: [
-          {
-            column: "created_at",
-            order: SortOrder.DESC,
-          },
-        ],
-      },
-    }
-
-    logger.console.log(
-      "[trails-sdk] getIntentTransactionHistory request:",
-      requestParams,
-    )
-
-    // Use the hybrid client's getIntentTransactionHistory method which tries Trails API first, then Sequence API
-    const result = await trailsClient.getIntentTransactionHistory(requestParams)
-
-    logger.console.log("[trails-sdk] getIntentTransactionHistory response:", {
-      intentCount: result.intents?.length || 0,
-      hasNextPage: !!result.nextPage,
-      firstIntent: result.intents?.[0],
-    })
-
-    // Map the API response to our local type structure
-    const mappedTransactions: IntentTransaction[] = (result.intents || []).map(
-      (intent: IntentSummary) => {
-        // Map API status to UI status format
-        const mapStatus = (apiStatus: string): string => {
-          const status = apiStatus?.toUpperCase() || "UNKNOWN"
-          switch (status) {
-            case "SUCCEEDED":
-              return "completed"
-            case "EXECUTING":
-              return "processing"
-            case "PENDING":
-              return "pending"
-            case "FAILED":
-              return "failed"
-            case "CREATED":
-              return "created"
-            default:
-              return apiStatus?.toLowerCase() || "unknown"
-          }
-        }
-
-        return {
-          originIntentAddress: intent.originIntentAddress,
-          destinationIntentAddress: intent.destinationIntentAddress,
-          mainSigner: intent.ownerAddress,
-          metaTxnId: intent.intentId,
-          txnHash:
-            intent.originTransactionHash ||
-            intent.destinationTransactionHash ||
-            undefined,
-          executionStatus: mapStatus(intent.status),
-          originChainId: intent.originChainId,
-          destinationChainId: intent.destinationChainId,
-          originTokenAddress: intent.originTokenAddress,
-          originTokenAmount: intent.originTokenAmount.toString(),
-          destinationTokenAddress: intent.destinationTokenAddress,
-          destinationTokenAmount: intent.destinationTokenAmount.toString(),
-          destinationToAddress: intent.ownerAddress,
-          createdAt: intent.createdAt,
-          // Map origin token metadata if available
-          originToken: intent.originTokenMetadata
-            ? ({
-                symbol: intent.originTokenMetadata.symbol || "",
-                name: intent.originTokenMetadata.name || "",
-                decimals: intent.originTokenMetadata.decimals ?? 18,
-                imageUrl: intent.originTokenMetadata.logoUri ?? "",
-                chainId: intent.originTokenMetadata.chainId,
-              } as {
-                symbol: string
-                name: string
-                decimals: number
-                imageUrl: string
-                chainId: number
-              })
-            : undefined,
-          // Map destination token metadata if available
-          destinationToken: intent.destinationTokenMetadata
-            ? ({
-                symbol: intent.destinationTokenMetadata.symbol || "",
-                name: intent.destinationTokenMetadata.name || "",
-                decimals: intent.destinationTokenMetadata.decimals ?? 18,
-                imageUrl: intent.destinationTokenMetadata.logoUri ?? "",
-                chainId: intent.destinationTokenMetadata.chainId,
-              } as {
-                symbol: string
-                name: string
-                decimals: number
-                imageUrl: string
-                chainId: number
-              })
-            : undefined,
-        }
-      },
-    )
-
-    return {
-      page: result.nextPage
-        ? {
-            page,
-            pageSize,
-            more: result.nextPage.more || false,
-          }
-        : {
-            page,
-            pageSize,
-            more: false,
-          },
-      transactions: mappedTransactions,
-    }
-  } catch (error) {
-    logger.console.error(
-      "[trails-sdk] Error fetching intent transaction history:",
-      error,
-    )
-    throw error
-  }
-}
-
 export type UseAccountTransactionHistoryParams = {
   chainId?: number | null
   accountAddress?: string | null
@@ -510,7 +362,7 @@ export function useAccountTransactionHistory({
         page,
         includeMetadata,
         abortSignal: effectiveSignal,
-        apiKey: trailsApiKey,
+        apiKey: trailsApiKey || "",
         indexerUrl: sequenceIndexerUrl!,
       })
     },
@@ -529,52 +381,3 @@ export function useAccountTransactionHistory({
     error: error as Error | null,
   }
 }
-
-export type UseIntentTransactionHistoryParams = {
-  accountAddress?: string | null
-  pageSize?: number
-  page?: number
-}
-
-export type UseIntentTransactionHistoryReturn = {
-  data: IntentTransactionHistoryResponse | undefined
-  isLoading: boolean
-  error: Error | null
-}
-
-export function useIntentTransactionHistory({
-  accountAddress,
-  pageSize = 10,
-  page = 1,
-}: UseIntentTransactionHistoryParams): UseIntentTransactionHistoryReturn {
-  const { trailsApiKey, trailsApiUrl } = useTrails()
-  const { data, isLoading, error } = useQuery({
-    queryKey: ["intentTransactionHistory", accountAddress, pageSize, page],
-    queryFn: async () => {
-      if (!accountAddress) {
-        return undefined
-      }
-
-      return await getIntentTransactionHistory({
-        accountAddress,
-        pageSize,
-        page,
-        apiKey: trailsApiKey,
-        apiUrl: trailsApiUrl!,
-      })
-    },
-    enabled: Boolean(accountAddress),
-    staleTime: 30 * 1000, // Consider data fresh for 30 seconds
-    refetchOnWindowFocus: false,
-    refetchOnMount: false,
-    refetchInterval: false,
-    retry: 2,
-    refetchOnReconnect: true,
-  })
-
-  return {
-    data,
-    isLoading,
-    error: error as Error | null,
-  }
-}

package/src/umd.tsx

@@ -1,6 +1,5 @@
 import React from "react"
 import { createRoot } from "react-dom/client"
-import type { RelayerEnv } from "./relayer.js"
 import type { Theme } from "./theme.js"
 import { TrailsWidget } from "./widget/widget.js"
 
@@ -8,10 +7,9 @@ interface TrailsGlobal {
   render: (
     element: HTMLElement,
     options: {
-      projectAccessKey: string
+      apiKey: string
       sequenceIndexerUrl?: string
       trailsApiUrl?: string
-      sequenceEnv?: RelayerEnv
       toAddress?: string | null
       toAmount?: string | null
       toChainId?: number | string | null

package/src/utils.ts

@@ -1,3 +1,5 @@
+import { ethAddress, zeroAddress } from "viem"
+
 export async function requestWithTimeout<T>(
   client: { request: (...args: any[]) => Promise<T> },
   args: Parameters<typeof client.request>,
@@ -11,10 +13,6 @@ export async function requestWithTimeout<T>(
   ])
 }
 
-export function bigintToString(n: bigint): string {
-  return n.toString()
-}
-
 /**
  * Formats completion time in seconds to human-readable format
  * @param seconds - Time in seconds
@@ -69,10 +67,6 @@ export function getTimeAgo(timestamp?: number): string {
   return `Sent ${diffInDays} days ago`
 }
 
-export function bigintReplacer(_key: string, value: any) {
-  return typeof value === "bigint" ? value.toString() : value
-}
-
 /**
  * Truncates an Ethereum address to show first 6 and last 4 characters
  * @param address - The full Ethereum address
@@ -86,3 +80,29 @@ export function truncateAddress(
   if (!address) return ""
   return `${address.slice(0, start)}…${address.slice(-end)}`
 }
+
+/**
+ * Checks if an address represents a native token (ETH or zero address)
+ * @param address - The token address to check
+ * @param caseInsensitive - Whether to perform case-insensitive comparison (default: true)
+ * @returns True if the address is a native token address
+ */
+export function isNativeToken(
+  address?: string | null,
+  caseInsensitive = true,
+): boolean {
+  if (!address) {
+    return false
+  }
+
+  const addresses = caseInsensitive
+    ? [zeroAddress.toLowerCase(), ethAddress.toLowerCase()]
+    : [zeroAddress, ethAddress]
+
+  const normalizedAddress = caseInsensitive ? address.toLowerCase() : address
+
+  return addresses.includes(normalizedAddress)
+}
+
+export const normalizeAddress = (address?: string | null): string =>
+  (address ?? "").toLowerCase()

package/src/walletUtils.ts

@@ -0,0 +1,42 @@
+import type { Connector } from "wagmi"
+import { getIsContract } from "./contractUtils.js"
+
+/**
+ * Checks if a wallet connector is a Sequence wallet.
+ * @param connector - The wagmi connector to check
+ * @returns true if the connector is a Sequence wallet, false otherwise
+ */
+export function isSequenceWallet(connector: Connector | undefined): boolean {
+  if (!connector) return false
+  const connectorName = connector.name?.toLowerCase() || ""
+  const connectorId = connector.id?.toLowerCase() || ""
+  return connectorName.includes("sequence") || connectorId.includes("sequence")
+}
+
+/**
+ * Checks if a wallet ID indicates a Sequence wallet.
+ * @param walletId - The wallet ID to check
+ * @returns true if the wallet ID indicates a Sequence wallet, false otherwise
+ */
+export function isSequenceWalletById(walletId: string | undefined): boolean {
+  if (!walletId) return false
+  return walletId.toLowerCase().includes("sequence")
+}
+
+/**
+ * Checks if an address is a smart contract wallet.
+ * @param address - The wallet address to check
+ * @param chainId - The chain ID to check the wallet on
+ * @returns Promise that resolves to true if the address is a smart contract, false otherwise
+ */
+export async function isSmartContractWallet(
+  address: string,
+  chainId: number,
+): Promise<boolean> {
+  try {
+    return await getIsContract(address as `0x${string}`, chainId)
+  } catch {
+    // Return false on error to be safe
+    return false
+  }
+}