0xtrails 0.4.3 → 0.6.0

package/src/transactions.ts

@@ -1,14 +1,12 @@
 import { useQuery } from "@tanstack/react-query"
 import { getChainInfo } from "./chains.js"
-import { getSequenceProjectAccessKey } from "./config.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 } 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"
 
 export type TransactionStateStatus =
   | "pending"
@@ -161,11 +159,14 @@ export async function getAccountTransactionHistory({
   page = 1,
   includeMetadata = true,
   abortSignal,
-}: GetAccountTransactionHistoryParams): Promise<TransactionHistoryResponse> {
-  const accessKey = getSequenceProjectAccessKey()
-
-  if (!accessKey) {
-    throw new Error("Sequence project access key is required")
+  apiKey,
+  indexerUrl,
+}: GetAccountTransactionHistoryParams & {
+  apiKey: string
+  indexerUrl: string
+}): Promise<TransactionHistoryResponse> {
+  if (!apiKey) {
+    throw new Error("Trails api key is required")
   }
 
   // Create a unique ID for this operation
@@ -187,7 +188,7 @@ export async function getAccountTransactionHistory({
     }
 
     // Get the chain-specific indexer URL
-    const chainIndexerUrl = getChainIndexerUrl(chainId)
+    const chainIndexerUrl = getChainIndexerUrl(chainId, indexerUrl)
     if (!chainIndexerUrl) {
       throw new Error(`Unsupported chain ID: ${chainId}`)
     }
@@ -217,9 +218,9 @@ export async function getAccountTransactionHistory({
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "X-Access-Key": accessKey,
+        "X-Access-Key": apiKey,
       },
-      body: JSON.stringify(requestBody, bigintReplacer, 2),
+      body: JsonEncode(requestBody),
       signal: abortSignal || operationAbortController.signal,
     })
 
@@ -275,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
@@ -310,66 +314,6 @@ export type IntentTransactionHistoryResponse = {
   transactions: IntentTransaction[]
 }
 
-export type GetIntentTransactionHistoryParams = {
-  accountAddress: string
-  pageSize?: number
-  page?: number
-}
-
-export async function getIntentTransactionHistory({
-  accountAddress: _accountAddress,
-  pageSize = 10,
-  page = 1,
-}: GetIntentTransactionHistoryParams): Promise<IntentTransactionHistoryResponse> {
-  const accessKey = getSequenceProjectAccessKey()
-
-  if (!accessKey) {
-    throw new Error("Sequence project access key is required")
-  }
-
-  try {
-    const trailsClient = getTrailsClient()
-
-    // Use the hybrid client's getIntentTransactionHistory method which tries Trails API first, then Sequence API
-    const result = await trailsClient.getIntentTransactionHistory({
-      page: {
-        pageSize,
-        sort: [
-          {
-            column: "created_at",
-            order: SortOrder.DESC,
-          },
-        ],
-      },
-    })
-
-    // Note: The new API has a different IntentTransaction structure.
-    // We need to map the API response to our local type structure.
-    // For now, return an empty result as the API structure has changed significantly.
-    // TODO: Implement proper mapping from new API IntentTransaction to SDK IntentTransaction
-    return {
-      page: result.nextPage
-        ? {
-            page,
-            pageSize,
-            more: true,
-          }
-        : {
-            page,
-            pageSize,
-            more: false,
-          },
-      transactions: [], // TODO: Map result.transactions to SDK IntentTransaction format
-    }
-  } catch (error) {
-    logger.console.error(
-      "[trails-sdk] Error fetching intent transaction history:",
-      error,
-    )
-    throw error
-  }
-}
-
 export type UseAccountTransactionHistoryParams = {
   chainId?: number | null
   accountAddress?: string | null
@@ -393,6 +337,7 @@ export function useAccountTransactionHistory({
   includeMetadata = true,
   abortSignal,
 }: UseAccountTransactionHistoryParams): UseAccountTransactionHistoryReturn {
+  const { trailsApiKey, sequenceIndexerUrl } = useTrails()
   const { data, isLoading, error } = useQuery({
     queryKey: [
       "accountTransactionHistory",
@@ -417,6 +362,8 @@ export function useAccountTransactionHistory({
         page,
         includeMetadata,
         abortSignal: effectiveSignal,
+        apiKey: trailsApiKey || "",
+        indexerUrl: sequenceIndexerUrl!,
       })
     },
     enabled: Boolean(chainId && accountAddress),
@@ -434,49 +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 { data, isLoading, error } = useQuery({
-    queryKey: ["intentTransactionHistory", accountAddress, pageSize, page],
-    queryFn: async () => {
-      if (!accountAddress) {
-        return undefined
-      }
-
-      return await getIntentTransactionHistory({
-        accountAddress,
-        pageSize,
-        page,
-      })
-    },
-    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
+  }
+}