0xtrails 0.13.2 → 0.14.0

package/src/widget/hooks/useIsConnectedWalletSmartContract.ts

@@ -1,43 +0,0 @@
-import { useEffect, useState } from "react"
-import { useAccount } from "wagmi"
-import { isSmartContractWallet as checkIsSmartContractWallet } from "../../walletUtils.js"
-import { logger } from "../../logger.js"
-
-/**
- * Hook to check if the currently connected wallet is a smart contract.
- * @param chainId - The chain ID to check the wallet on
- * @returns true if the connected wallet is a smart contract, false otherwise
- */
-export function useIsConnectedWalletSmartContract(chainId?: number): boolean {
-  const { address } = useAccount()
-  const [isSmartContractWallet, setIsSmartContractWallet] = useState(false)
-
-  useEffect(() => {
-    const checkIfContract = async () => {
-      if (address && chainId) {
-        try {
-          const isContract = await checkIsSmartContractWallet(address, chainId)
-          setIsSmartContractWallet(isContract)
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error checking if wallet is contract:",
-            error,
-          )
-          setIsSmartContractWallet(false)
-        }
-      } else {
-        setIsSmartContractWallet(false)
-      }
-    }
-
-    checkIfContract()
-  }, [address, chainId])
-
-  logger.console.log("[trails-sdk] isSmartContractWallet:", {
-    isSmartContractWallet,
-    address,
-    chainId,
-  })
-
-  return isSmartContractWallet
-}

package/src/widget/hooks/useIsMobile.tsx

@@ -1,50 +0,0 @@
-import { useState, useEffect } from "react"
-
-/**
- * Hook to detect if the browser is on iOS or Android mobile
- */
-export function useIsMobile(): boolean {
-  const [isMobile, setIsMobile] = useState(false)
-
-  useEffect(() => {
-    const checkMobile = () => {
-      if (typeof window === "undefined") {
-        return false
-      }
-
-      const userAgent =
-        window.navigator.userAgent ||
-        window.navigator.vendor ||
-        (window as unknown as { opera?: string }).opera
-
-      if (!userAgent) {
-        return false
-      }
-
-      // Check for iOS
-      const isIOS =
-        /iPad|iPhone|iPod/.test(userAgent) &&
-        !(window as unknown as { MSStream?: unknown }).MSStream
-
-      // Check for Android
-      const isAndroid = /android/i.test(userAgent)
-
-      // Also check screen width as a fallback
-      const isSmallScreen = window.innerWidth <= 768
-
-      return isIOS || isAndroid || isSmallScreen
-    }
-
-    setIsMobile(checkMobile())
-
-    // Listen for resize events to handle orientation changes
-    const handleResize = () => {
-      setIsMobile(checkMobile())
-    }
-
-    window.addEventListener("resize", handleResize)
-    return () => window.removeEventListener("resize", handleResize)
-  }, [])
-
-  return isMobile
-}

package/src/widget/hooks/useIsSequenceWallet.ts

@@ -1,17 +0,0 @@
-import { useMemo } from "react"
-import { useAccount } from "wagmi"
-import { isSequenceWallet as checkIsSequenceWallet } from "../../walletUtils.js"
-
-/**
- * Hook to check if the currently connected wallet is a Sequence wallet.
- * @returns true if the connected wallet is a Sequence wallet, false otherwise
- */
-export function useIsSequenceWallet(): boolean {
-  const { connector } = useAccount()
-
-  const isSequenceWallet = useMemo(() => {
-    return checkIsSequenceWallet(connector)
-  }, [connector])
-
-  return isSequenceWallet
-}

package/src/widget/hooks/useLocalePreference.tsx

@@ -1,187 +0,0 @@
-import React, {
-  createContext,
-  useContext,
-  useState,
-  useEffect,
-  type ReactNode,
-} from "react"
-import { localeStore } from "../utils/localeStore.js"
-
-interface LocaleOption {
-  code: string
-  name: string
-  flag: string
-  countryName: string
-}
-
-export const SUPPORTED_LOCALES: LocaleOption[] = [
-  {
-    code: "en-US",
-    name: "United States",
-    flag: "🇺🇸",
-    countryName: "United States",
-  },
-  {
-    code: "en-GB",
-    name: "United Kingdom",
-    flag: "🇬🇧",
-    countryName: "United Kingdom",
-  },
-  { code: "en-CA", name: "Canada", flag: "🇨🇦", countryName: "Canada" },
-  { code: "en-AU", name: "Australia", flag: "🇦🇺", countryName: "Australia" },
-  { code: "de-DE", name: "Germany", flag: "🇩🇪", countryName: "Germany" },
-  { code: "fr-FR", name: "France", flag: "🇫🇷", countryName: "France" },
-  { code: "es-ES", name: "Spain", flag: "🇪🇸", countryName: "Spain" },
-  { code: "it-IT", name: "Italy", flag: "🇮🇹", countryName: "Italy" },
-  { code: "pt-BR", name: "Brazil", flag: "🇧🇷", countryName: "Brazil" },
-  { code: "pt-PT", name: "Portugal", flag: "🇵🇹", countryName: "Portugal" },
-  {
-    code: "nl-NL",
-    name: "Netherlands",
-    flag: "🇳🇱",
-    countryName: "Netherlands",
-  },
-  { code: "ja-JP", name: "Japan", flag: "🇯🇵", countryName: "Japan" },
-  {
-    code: "ko-KR",
-    name: "South Korea",
-    flag: "🇰🇷",
-    countryName: "South Korea",
-  },
-  { code: "zh-CN", name: "China", flag: "🇨🇳", countryName: "China" },
-  { code: "ru-RU", name: "Russia", flag: "🇷🇺", countryName: "Russia" },
-  { code: "hi-IN", name: "India", flag: "🇮🇳", countryName: "India" },
-  {
-    code: "ar-SA",
-    name: "Saudi Arabia",
-    flag: "🇸🇦",
-    countryName: "Saudi Arabia",
-  },
-  { code: "tr-TR", name: "Turkey", flag: "🇹🇷", countryName: "Turkey" },
-  { code: "sv-SE", name: "Sweden", flag: "🇸🇪", countryName: "Sweden" },
-  { code: "no-NO", name: "Norway", flag: "🇳🇴", countryName: "Norway" },
-  { code: "da-DK", name: "Denmark", flag: "🇩🇰", countryName: "Denmark" },
-  { code: "fi-FI", name: "Finland", flag: "🇫🇮", countryName: "Finland" },
-]
-
-interface LocalePreferenceContextType {
-  selectedLocale: string | null
-  setSelectedLocale: (locale: string) => void
-  resetLocalePreference: () => void
-  getEffectiveLocale: () => string
-}
-
-const LocalePreferenceContext = createContext<
-  LocalePreferenceContextType | undefined
->(undefined)
-
-interface LocalePreferenceProviderProps {
-  children: ReactNode
-}
-
-const LOCALE_PREFERENCE_KEY = "trails-locale-preference"
-
-export const LocalePreferenceProvider: React.FC<
-  LocalePreferenceProviderProps
-> = ({ children }) => {
-  const [selectedLocale, setSelectedLocaleState] = useState<string | null>(
-    () => {
-      try {
-        const stored = localStorage.getItem(LOCALE_PREFERENCE_KEY)
-        if (stored && SUPPORTED_LOCALES.some((l) => l.code === stored)) {
-          return stored
-        }
-        return null
-      } catch (error) {
-        console.warn(
-          "Failed to read locale preference from localStorage:",
-          error,
-        )
-        return null
-      }
-    },
-  )
-
-  useEffect(() => {
-    try {
-      if (selectedLocale) {
-        localStorage.setItem(LOCALE_PREFERENCE_KEY, selectedLocale)
-      } else {
-        localStorage.removeItem(LOCALE_PREFERENCE_KEY)
-      }
-      // Sync with the singleton store
-      localeStore.setLocale(selectedLocale)
-    } catch (error) {
-      console.warn("Failed to save locale preference to localStorage:", error)
-    }
-  }, [selectedLocale])
-
-  const setSelectedLocale = (locale: string) => {
-    if (SUPPORTED_LOCALES.some((l) => l.code === locale)) {
-      setSelectedLocaleState(locale)
-    } else {
-      console.warn(`Unsupported locale: ${locale}`)
-    }
-  }
-
-  const resetLocalePreference = () => {
-    try {
-      localStorage.removeItem(LOCALE_PREFERENCE_KEY)
-      setSelectedLocaleState(null)
-    } catch (error) {
-      console.warn("Failed to reset locale preference:", error)
-      setSelectedLocaleState(null)
-    }
-  }
-
-  const getEffectiveLocale = () => {
-    if (selectedLocale) {
-      return selectedLocale
-    }
-
-    if (typeof navigator !== "undefined" && navigator.language) {
-      // Check if browser locale is in our supported list
-      const browserLocale = navigator.language
-      if (SUPPORTED_LOCALES.some((l) => l.code === browserLocale)) {
-        return browserLocale
-      }
-      // Try to match just the language part (e.g., "en" from "en-CA")
-      const languageCode = browserLocale.split("-")[0]
-      if (languageCode) {
-        const match = SUPPORTED_LOCALES.find((l) =>
-          l.code.startsWith(languageCode),
-        )
-        if (match) {
-          return match.code
-        }
-      }
-    }
-
-    return "en-US"
-  }
-
-  const value: LocalePreferenceContextType = {
-    selectedLocale,
-    setSelectedLocale,
-    resetLocalePreference,
-    getEffectiveLocale,
-  }
-
-  return (
-    <LocalePreferenceContext.Provider value={value}>
-      {children}
-    </LocalePreferenceContext.Provider>
-  )
-}
-
-export function useLocalePreference(): LocalePreferenceContextType {
-  const context = useContext(LocalePreferenceContext)
-
-  if (context === undefined) {
-    throw new Error(
-      "useLocalePreference must be used within a LocalePreferenceProvider",
-    )
-  }
-
-  return context
-}

package/src/widget/hooks/useMeldTransactionHistory.ts

@@ -1,184 +0,0 @@
-import { useMemo } from "react"
-import { useQuery } from "@tanstack/react-query"
-import { useAccount } from "wagmi"
-import { useOnrampClient } from "../../onrampClient.js"
-import { SECOND_MS } from "../../utils/time.js"
-import { addressEqual } from "../../utils/address.js"
-import {
-  getCurrencySymbol,
-  parseCurrencyCode,
-  getCountryFlag,
-} from "../../utils.js"
-import { useMeldPaymentMethods } from "../../query/meld.hooks.js"
-import { meldQueries } from "../../query/meld.queries.js"
-import type {
-  MeldTransaction,
-  MeldPaymentMethod,
-} from "../../query/meld.fetchers.js"
-
-export type MeldTransactionStatus =
-  | "PENDING"
-  | "PROCESSING"
-  | "COMPLETED"
-  | "SETTLED"
-  | "FAILED"
-  | "DECLINED"
-  | "CANCELLED"
-  | "REFUNDED"
-  | "ERROR"
-
-export interface MeldTransactionData {
-  id: string
-  status: MeldTransactionStatus
-  sourceAmount?: string
-  sourceCurrencyCode?: string
-  destinationAmount?: string
-  destinationCurrencyCode?: string
-  walletAddress?: string
-  createdAt?: string
-  updatedAt?: string
-  serviceProvider?: string
-  paymentMethod?: string
-  transactionHash?: string
-  externalSessionId?: string
-  externalCustomerId?: string
-  countryCode?: string
-  exchangeRate?: number
-  totalFee?: number
-  networkFee?: number
-  transactionFee?: number
-  institutionName?: string
-  lowKyc?: boolean
-  sourceCurrencySymbol?: string
-  destinationCurrencySymbol?: string
-  paymentMethodLogo?: string
-  currencyFlag?: string
-  sourceTokenSymbol?: string
-  sourceTokenChainId?: number
-  sourceTokenAddress?: string
-  destinationTokenSymbol?: string
-  destinationTokenChainId?: number
-  destinationTokenAddress?: string
-}
-
-export interface UseMeldTransactionHistoryParams {
-  enabled?: boolean
-  limit?: number
-  autoRefetch?: boolean
-  refetchInterval?: number
-}
-
-export interface UseMeldTransactionHistoryReturn {
-  transactions: MeldTransactionData[]
-  loading: boolean
-  error: string | null
-  refetch: () => Promise<void>
-  hasMore: boolean
-}
-
-function parseMeldTransaction(
-  transaction: MeldTransaction,
-  paymentMethods?: MeldPaymentMethod[],
-): MeldTransactionData {
-  const txn = transaction as any
-
-  const sourceCurrencyCode = txn.sourceCurrencyCode || txn.fiatCurrency
-  const destinationCurrencyCode =
-    txn.destinationCurrencyCode || txn.cryptoCurrency
-
-  const sourceToken = parseCurrencyCode(sourceCurrencyCode)
-  const destinationToken = parseCurrencyCode(destinationCurrencyCode)
-
-  return {
-    id: transaction.id || txn.transactionId || "",
-    status: txn.status || "PENDING",
-    sourceAmount: txn.sourceAmount,
-    sourceCurrencyCode,
-    destinationAmount: txn.destinationAmount,
-    destinationCurrencyCode,
-    walletAddress: txn.walletAddress || txn.destinationAddress,
-    createdAt: txn.createdAt || txn.createdDate || txn.timestamp,
-    updatedAt: txn.updatedAt || txn.updatedDate,
-    serviceProvider: txn.serviceProvider || txn.provider || txn.institutionName,
-    paymentMethod: txn.paymentMethod || txn.paymentMethodType,
-    transactionHash: txn.transactionHash || txn.hash,
-    externalSessionId: txn.externalSessionId || txn.sessionId,
-    externalCustomerId: txn.externalCustomerId || txn.customerId,
-    countryCode: txn.countryCode,
-    exchangeRate: txn.exchangeRate,
-    totalFee: txn.totalFee,
-    networkFee: txn.networkFee,
-    transactionFee: txn.transactionFee,
-    institutionName: txn.institutionName,
-    lowKyc: txn.lowKyc,
-    sourceCurrencySymbol: getCurrencySymbol(sourceToken.symbol),
-    destinationCurrencySymbol: getCurrencySymbol(destinationToken.symbol),
-    paymentMethodLogo: getPaymentMethodLogo(
-      txn.paymentMethod || txn.paymentMethodType,
-      paymentMethods,
-    ),
-    currencyFlag: getCountryFlag(txn.countryCode),
-    sourceTokenSymbol: sourceToken.symbol,
-    sourceTokenChainId: sourceToken.chainId,
-    sourceTokenAddress: undefined,
-    destinationTokenSymbol: destinationToken.symbol,
-    destinationTokenChainId: destinationToken.chainId,
-    destinationTokenAddress: undefined,
-  }
-}
-
-function getPaymentMethodLogo(
-  paymentMethod?: string,
-  paymentMethods?: MeldPaymentMethod[],
-): string {
-  if (!paymentMethod || !paymentMethods) return ""
-
-  const methodData = paymentMethods.find(
-    (method) =>
-      addressEqual(method.paymentMethod, paymentMethod) ||
-      addressEqual(method.name, paymentMethod),
-  )
-
-  if (methodData?.logos) {
-    return methodData.logos.light || methodData.logos.dark || ""
-  }
-
-  return ""
-}
-
-export function useMeldTransactionHistory({
-  enabled = true,
-  limit = 20,
-  autoRefetch = false,
-  refetchInterval = 10 * SECOND_MS,
-}: UseMeldTransactionHistoryParams = {}): UseMeldTransactionHistoryReturn {
-  const { address: walletAddress } = useAccount()
-  const onrampClient = useOnrampClient()
-
-  const { data: paymentMethods } = useMeldPaymentMethods("USD")
-
-  const { data, isLoading, error, refetch, isFetching } = useQuery({
-    ...meldQueries.transactionHistoryList(onrampClient, walletAddress, limit),
-    enabled,
-    ...(autoRefetch && { staleTime: 0 }),
-    refetchInterval: autoRefetch ? refetchInterval : false,
-    placeholderData: (previousData) => previousData,
-  })
-
-  const transactions = useMemo(() => {
-    if (!data?.transactions?.length) return []
-    return data.transactions.map((txn) =>
-      parseMeldTransaction(txn, paymentMethods),
-    )
-  }, [data, paymentMethods])
-
-  return {
-    transactions,
-    loading: isLoading || isFetching,
-    error: error instanceof Error ? error.message : null,
-    refetch: async () => {
-      await refetch()
-    },
-    hasMore: data?.hasMore ?? false,
-  }
-}