0xtrails 0.13.1 → 0.14.0

package/src/transactionIntent/validators.ts

@@ -1,27 +0,0 @@
-import { addressEqual } from "../utils/address.js"
-
-export function isSameChain(
-  originChainId: number,
-  destinationChainId: number,
-): boolean {
-  return originChainId?.toString() === destinationChainId?.toString()
-}
-
-export function isSameToken(
-  originTokenAddress: string,
-  destinationTokenAddress: string,
-): boolean {
-  return addressEqual(originTokenAddress, destinationTokenAddress)
-}
-
-export function isSameChainAndToken(
-  originChainId: number,
-  originTokenAddress: string,
-  destinationChainId: number,
-  destinationTokenAddress: string,
-): boolean {
-  return (
-    isSameChain(originChainId, destinationChainId) &&
-    isSameToken(originTokenAddress, destinationTokenAddress)
-  )
-}

package/src/transactions.ts

@@ -1,426 +0,0 @@
-import { useQuery } from "@tanstack/react-query"
-import { SECOND_MS, toSeconds } from "./utils/time.js"
-import { getChainInfo } from "./chains.js"
-import type { GuestModuleEvent, TokenSweeperEvent } from "./decoders.js"
-import { logger } from "./logger.js"
-import { getExplorerUrl } from "./explorer.js"
-import { SequenceIndexer } from "@0xsequence/indexer"
-import { getChainIndexerUrl } from "./indexerClient.js"
-import { abortControllerRegistry } from "./abortController.js"
-import { useTrails } from "./widget/providers/TrailsProvider.js"
-
-import { normalizeAddress } from "./utils/address.js"
-export type TransactionStateStatus =
-  | "pending"
-  | "failed"
-  | "confirmed"
-  | "aborted"
-
-export type TransactionState = {
-  id?: string
-  transactionHash: string
-  explorerUrl: string
-  blockNumber?: number
-  chainId: number
-  state: TransactionStateStatus
-  label: string
-  statusReason?: string
-  decodedTokenSweeperEvents?: TokenSweeperEvent[]
-  decodedGuestModuleEvents?: GuestModuleEvent[]
-  refunded?: boolean
-  refundTransactionHash?: string
-  refundTransactionChainId?: number
-  txnMinedAt?: string
-}
-
-export type TransferType = "SEND" | "RECEIVE"
-export type ContractType = "ERC20" | "ERC721" | "ERC1155" | "NATIVE"
-
-export type ContractInfo = {
-  chainId: number
-  address: string
-  source: string
-  name: string
-  type: ContractType
-  symbol: string
-  decimals: number
-  logoURI: string
-  deployed: boolean
-  bytecodeHash: string
-  extensions: {
-    link: string
-    description: string
-    ogImage: string
-    ogName: string
-    originChainId: number
-    originAddress: string
-    verified: boolean
-    verifiedBy: string
-  }
-  updatedAt: string
-  queuedAt: string
-  status: string
-}
-
-export type Transfer = {
-  transferType: TransferType
-  contractAddress: string
-  contractType: ContractType
-  from: string
-  to: string
-  tokenIds: string[]
-  amounts: string[]
-  logIndex: number
-  contractInfo: ContractInfo
-}
-
-export type TransactionHistoryItemFromAPI = Awaited<
-  ReturnType<SequenceIndexer["getTransactionHistory"]>
->["transactions"][number]
-
-export type TransactionHistoryItem = TransactionHistoryItemFromAPI & {
-  explorerUrl?: string
-  chainName?: string
-}
-
-export type TransactionHistoryResponse = {
-  page: {
-    column?: string
-    pageSize?: number
-    more?: boolean
-  }
-  transactions: TransactionHistoryItem[]
-}
-
-export type GetAccountTransactionHistoryParams = {
-  chainId: number
-  accountAddress: string
-  pageSize?: number
-  includeMetadata?: boolean
-  page?: number
-  abortSignal?: AbortSignal
-}
-
-export function isSyntheticTransactionHash(
-  transactionHash?: string | null,
-): boolean {
-  const normalizedHash = transactionHash?.toLowerCase()
-
-  return Boolean(normalizedHash && /0{10,}$/.test(normalizedHash))
-}
-
-export function isDisplayableTransactionHash(
-  transactionHash?: string | null,
-): transactionHash is string {
-  return Boolean(
-    transactionHash && !isSyntheticTransactionHash(transactionHash),
-  )
-}
-
-function isTransactionHistoryItemFromApi(
-  value: unknown,
-): value is TransactionHistoryItemFromAPI {
-  if (!value || typeof value !== "object") return false
-
-  const candidate = value as Record<string, unknown>
-  return (
-    typeof candidate.txnHash === "string" &&
-    typeof candidate.chainId === "number" &&
-    typeof candidate.timestamp === "string" &&
-    Array.isArray(candidate.transfers)
-  )
-}
-
-// Standalone function to calculate time difference between two transactions
-export async function getTxTimeDiff(
-  firstTx?: TransactionState,
-  lastTx?: TransactionState,
-): Promise<number> {
-  if (!firstTx?.chainId || !lastTx?.chainId || !firstTx || !lastTx) {
-    return 0
-  }
-
-  if (
-    !(firstTx.blockNumber || firstTx.transactionHash) ||
-    !(lastTx.blockNumber || lastTx.transactionHash)
-  ) {
-    return 0
-  }
-
-  if (
-    firstTx.blockNumber === lastTx.blockNumber &&
-    firstTx.transactionHash === lastTx.transactionHash
-  ) {
-    return 0
-  }
-
-  try {
-    // Use txnMinedAt timestamps from API if available
-    if (firstTx.txnMinedAt && lastTx.txnMinedAt) {
-      const firstTs = toSeconds(new Date(firstTx.txnMinedAt).getTime())
-      const lastTs = toSeconds(new Date(lastTx.txnMinedAt).getTime())
-
-      const diff = lastTs - firstTs
-      if (diff < 1) {
-        return 1 // round up to 1 second
-      }
-
-      return diff
-    }
-
-    // Fallback: return 0 if txnMinedAt is not available
-    logger.console.warn(
-      "[trails-sdk] txnMinedAt not available for transactions, cannot calculate time difference",
-    )
-    return 0
-  } catch (error) {
-    logger.console.error(
-      "[trails-sdk] Error calculating transaction time difference:",
-      error,
-    )
-    return 0
-  }
-}
-
-export async function getAccountTransactionHistory({
-  chainId,
-  accountAddress,
-  pageSize = 10,
-  page = 1,
-  includeMetadata = true,
-  abortSignal,
-  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
-  const operationId = `account-tx-history-${chainId}-${accountAddress}-${page}-${Date.now()}`
-
-  // Create an abort controller for this specific operation
-  const operationAbortController = new AbortController()
-
-  // Register this operation with the global registry
-  abortControllerRegistry.register(operationId, operationAbortController)
-
-  try {
-    // Check if we should abort before starting
-    if (abortSignal?.aborted || operationAbortController.signal.aborted) {
-      logger.console.log(
-        "[trails-sdk] Aborting account transaction history fetch",
-      )
-      throw new Error("Operation aborted")
-    }
-
-    // Get the chain-specific indexer URL
-    const chainIndexerUrl = getChainIndexerUrl(chainId, indexerUrl)
-    if (!chainIndexerUrl) {
-      throw new Error(`Unsupported chain ID: ${chainId}`)
-    }
-
-    // Check abort signal before making the request
-    if (abortSignal?.aborted || operationAbortController.signal.aborted) {
-      logger.console.log(
-        "[trails-sdk] Aborting account transaction history fetch before request",
-      )
-      throw new Error("Operation aborted")
-    }
-
-    const indexer = new SequenceIndexer(chainIndexerUrl, apiKey)
-    const data = await indexer.getTransactionHistory(
-      {
-        filter: {
-          accountAddress: normalizeAddress(accountAddress),
-        },
-        includeMetadata,
-        page: {
-          page,
-          pageSize,
-        },
-      },
-      {},
-      abortSignal || operationAbortController.signal,
-    )
-
-    const transactions = data.transactions
-      .filter(isTransactionHistoryItemFromApi)
-      .map((tx) => ({
-        ...tx,
-        transfers: tx.transfers ?? [],
-        explorerUrl: getExplorerUrl({
-          txHash: tx.txnHash,
-          chainId: tx.chainId,
-        }),
-        chainName: getChainInfo(tx.chainId)?.name,
-      }))
-
-    return {
-      ...data,
-      transactions,
-    }
-  } catch (error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      logger.console.log(
-        "[trails-sdk] Account transaction history fetch was aborted",
-      )
-      throw new Error("Operation aborted")
-    }
-
-    logger.console.error(
-      "[trails-sdk] Error fetching transaction history:",
-      error,
-    )
-    throw error
-  } finally {
-    // Always unregister when operation completes or is aborted
-    abortControllerRegistry.unregister(operationId)
-  }
-}
-
-export type IntentTransaction = {
-  originIntentAddress: string
-  destinationIntentAddress: string
-  mainSigner: string
-  intentId?: string
-  metaTxnId?: string
-  txnHash?: string
-  intentStatus?: string // Top-level intent status returned by Trails API history
-  executionStatus?: string // Derived transaction-level status used for detailed progress states
-  originChainId?: number
-  destinationChainId?: number
-  originTokenAddress?: string
-  originTokenAmount?: string
-  destinationTokenAddress?: string
-  destinationTokenAmount?: string
-  destinationToAddress?: string
-  createdAt?: string
-  // Transaction hashes from API response
-  depositTransactionHash?: string // Deposit transaction hash from API
-  originTransactionHash?: string // Transaction hash from API
-  destinationTransactionHash?: string // Transaction hash from API
-  // Transaction statuses from API response
-  depositTransactionStatus?: string // Deposit transaction status from API
-  originTransactionStatus?: string // Origin transaction status from API
-  destinationTransactionStatus?: string // Destination transaction status from API
-  // Enriched token information
-  originToken?: {
-    symbol: string
-    name: string
-    decimals: number
-    imageUrl: string
-    chainId: number
-  }
-  destinationToken?: {
-    symbol: string
-    name: string
-    decimals: number
-    imageUrl: string
-    chainId: number
-  }
-  // Intent wallet transaction hashes
-  originIntentTxHash?: string // First action tx FROM origin intent (not deposit into it)
-  destinationIntentTxHash?: string // First action tx FROM destination intent (not deposit into it)
-  originIntentTxExplorerUrl?: string
-  destinationIntentTxExplorerUrl?: string
-  originIntentDepositTxHash?: string // First deposit tx INTO origin intent
-  destinationIntentDepositTxHash?: string // First deposit tx INTO destination intent
-  originIntentDepositTxExplorerUrl?: string
-  destinationIntentDepositTxExplorerUrl?: string
-  // Server-side balance data (from includeBalances API param)
-  balances?: Array<{
-    intentAddress: string
-    chainId: number
-    tokens: Array<{
-      contractAddress: string
-      balance: string
-      decimals: number
-      chainId: number
-      symbol: string
-    }>
-  }>
-  hasBalance?: boolean
-}
-
-export type IntentTransactionHistoryResponse = {
-  page?: {
-    page?: number
-    pageSize?: number
-    more?: boolean
-  }
-  transactions: IntentTransaction[]
-}
-
-export type UseAccountTransactionHistoryParams = {
-  chainId?: number | null
-  accountAddress?: string | null
-  pageSize?: number
-  page?: number
-  includeMetadata?: boolean
-  abortSignal?: AbortSignal
-  refetchInterval?: number | false
-}
-
-export type UseAccountTransactionHistoryReturn = {
-  data: TransactionHistoryResponse | undefined
-  isLoading: boolean
-  error: Error | null
-}
-
-export function useAccountTransactionHistory({
-  chainId,
-  accountAddress,
-  pageSize = 10,
-  page = 1,
-  includeMetadata = true,
-  abortSignal,
-  refetchInterval = false,
-}: UseAccountTransactionHistoryParams): UseAccountTransactionHistoryReturn {
-  const { trailsApiKey, sequenceIndexerUrl } = useTrails()
-  const { data, isLoading, error } = useQuery({
-    queryKey: [
-      "accountTransactionHistory",
-      chainId,
-      accountAddress,
-      pageSize,
-      page,
-      includeMetadata,
-    ],
-    queryFn: async ({ signal }) => {
-      if (!chainId || !accountAddress) {
-        return undefined
-      }
-
-      // Use the React Query signal if no external abort signal is provided
-      const effectiveSignal = abortSignal || signal
-
-      return await getAccountTransactionHistory({
-        chainId,
-        accountAddress,
-        pageSize,
-        page,
-        includeMetadata,
-        abortSignal: effectiveSignal,
-        apiKey: trailsApiKey || "",
-        indexerUrl: sequenceIndexerUrl!,
-      })
-    },
-    enabled: Boolean(chainId && accountAddress),
-    staleTime: 5 * SECOND_MS, // Consider data fresh for 5 seconds
-    refetchOnWindowFocus: false,
-    refetchOnMount: false,
-    refetchInterval: refetchInterval,
-    retry: 10,
-    refetchOnReconnect: true,
-  })
-
-  return {
-    data,
-    isLoading,
-    error: error as Error | null,
-  }
-}

package/src/types.d.ts

@@ -1,16 +0,0 @@
-declare global {
-  interface Window {
-    Buffer: typeof import("buffer").Buffer
-    ethereum?: any
-  }
-}
-
-declare module "*.svg" {
-  const content: string
-  export default content
-}
-
-declare module "*.png" {
-  const content: string
-  export default content
-}

package/src/umd.tsx

@@ -1,33 +0,0 @@
-import React from "react"
-import { createRoot } from "react-dom/client"
-import { TrailsWidget, type TrailsWidgetProps } from "./widget/widget.js"
-
-interface TrailsGlobal {
-  render: (element: HTMLElement, options: TrailsWidgetProps) => void
-}
-
-const TrailsGlobal: TrailsGlobal = {
-  render: (element, options) => {
-    const root = createRoot(element)
-    root.render(
-      <React.StrictMode>
-        <TrailsWidget {...options} />
-      </React.StrictMode>,
-    )
-  },
-}
-
-// Export for both UMD and ESM/CJS
-export default TrailsGlobal
-
-// Explicitly set the global for UMD
-if (typeof window !== "undefined") {
-  window.TrailsWidget = TrailsGlobal
-}
-
-// Add type declaration for window object
-declare global {
-  interface Window {
-    TrailsWidget: TrailsGlobal
-  }
-}

package/src/utils/address.ts

@@ -1,78 +0,0 @@
-import { ethAddress, zeroAddress, getAddress } from "viem"
-
-export const normalizeAddress = (address?: string | null): string =>
-  (address ?? "").toLowerCase()
-
-/** Null-safe, case-insensitive address comparison. Returns false if either is missing. */
-export function addressEqual(
-  a: string | null | undefined,
-  b: string | null | undefined,
-): boolean {
-  if (!a || !b) return false
-  return a.toLowerCase() === b.toLowerCase()
-}
-
-/**
- * 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)
-}
-
-/**
- * Checks if an address is the zero address (0x0000...0000)
- * Use this for recipient/account addresses, not for token addresses.
- * For token addresses, use isNativeToken() instead.
- * @param address - The address to check
- * @returns True if the address is the zero address
- */
-export function isZeroAccount(address?: string | null): boolean {
-  if (!address) {
-    return false
-  }
-
-  return addressEqual(address, zeroAddress)
-}
-
-/**
- * Truncates an Ethereum address to show first and last characters
- * Also checksums the address for proper capitalization
- * @param address - The full Ethereum address
- * @param start - Number of characters to show at start (default: 6, includes 0x)
- * @param end - Number of characters to show at end (default: 4)
- * @returns Truncated checksummed address string (e.g., "0x1234...aBcD")
- */
-export function truncateAddress(
-  address?: string | null,
-  start = 6,
-  end = 4,
-): string {
-  if (!address) return ""
-
-  // Try to checksum the address first
-  let checksummedAddress = address
-  try {
-    checksummedAddress = getAddress(address)
-  } catch {
-    // If checksumming fails, use the original address
-    checksummedAddress = address
-  }
-
-  return `${checksummedAddress.slice(0, start)}…${checksummedAddress.slice(-end)}`
-}

package/src/utils/allowance.ts

@@ -1,47 +0,0 @@
-import type { PublicClient } from "viem"
-import { erc20Abi } from "viem"
-import { logger } from "../logger.js"
-
-/**
- * Check if an ERC20 token has sufficient allowance for a given amount
- * @param params - Object containing the allowance check parameters
- * @param params.publicClient - The public client to use for reading the contract
- * @param params.tokenAddress - The ERC20 token address
- * @param params.owner - The owner address whose allowance is being checked
- * @param params.spender - The spender address that needs the allowance
- * @param params.requiredAmount - The amount of tokens that need to be approved
- * @returns Promise<boolean> - True if allowance is sufficient, false otherwise
- */
-export async function getHasEnoughAllowance({
-  publicClient,
-  tokenAddress,
-  owner,
-  spender,
-  requiredAmount,
-}: {
-  publicClient: PublicClient
-  tokenAddress: string
-  owner: string
-  spender: string
-  requiredAmount: bigint
-}): Promise<boolean> {
-  try {
-    const currentAllowance = (await publicClient.readContract({
-      address: tokenAddress as `0x${string}`,
-      abi: erc20Abi,
-      functionName: "allowance",
-      args: [owner as `0x${string}`, spender as `0x${string}`],
-    })) as bigint
-
-    return currentAllowance >= requiredAmount
-  } catch (error) {
-    logger.console.error("[trails-sdk] Failed to read allowance", {
-      tokenAddress,
-      owner,
-      spender,
-      requiredAmount: requiredAmount.toString(),
-      error,
-    })
-    return false
-  }
-}

package/src/utils/fiat.ts

@@ -1,32 +0,0 @@
-/** Currencies with 0 decimal places */
-const ZERO_DECIMAL_CURRENCIES = ["JPY", "KRW", "VND", "CLP", "ISK"]
-
-/** Currency symbol mapping */
-const CURRENCY_SYMBOLS: Record<string, string> = {
-  USD: "$",
-  EUR: "€",
-  GBP: "£",
-  JPY: "¥",
-  CNY: "¥",
-  KRW: "₩",
-  INR: "₹",
-  CAD: "C$",
-  AUD: "A$",
-  CHF: "CHF",
-  SEK: "kr",
-  NOK: "kr",
-  DKK: "kr",
-}
-
-/**
- * Get formatting info for a fiat currency code.
- */
-export function getCurrencyInfo(currencyCode: string): {
-  decimals: number
-  symbol: string
-} {
-  return {
-    decimals: ZERO_DECIMAL_CURRENCIES.includes(currencyCode) ? 0 : 2,
-    symbol: CURRENCY_SYMBOLS[currencyCode] || currencyCode,
-  }
-}