0xtrails 0.13.1 → 0.14.0

package/src/utils/time.ts

@@ -1,118 +0,0 @@
-// Naming borrows from date-fns where applicable (formatDuration, etc.)
-
-export const SECOND_MS = 1000
-export const MINUTE_MS = 60 * SECOND_MS
-export const HOUR_MS = 60 * MINUTE_MS
-export const DAY_MS = 24 * HOUR_MS
-
-export const MINUTE_S = 60
-export const HOUR_S = 60 * MINUTE_S
-
-export const now = (): number => Date.now()
-
-export const elapsed = (sinceMs: number): number => now() - sinceMs
-
-export const toSeconds = (ms: number): number => Math.floor(ms / SECOND_MS)
-
-export const isWithinCooldown = (
-  lastActionAtMs: number,
-  cooldownMs: number,
-): boolean => lastActionAtMs > 0 && elapsed(lastActionAtMs) < cooldownMs
-
-export const retryDelay = (attemptIndex: number): number =>
-  Math.min(SECOND_MS * 2 ** attemptIndex, 30 * SECOND_MS)
-
-export function formatDuration(seconds: number): string {
-  if (seconds < 60) {
-    return `${seconds}s`
-  }
-
-  const h = Math.floor(seconds / HOUR_S)
-  const m = Math.floor((seconds % HOUR_S) / 60)
-  const s = seconds % 60
-
-  if (h === 0) {
-    return s > 0 ? `${m}m${s}s` : `${m}m`
-  }
-
-  const tail = [m > 0 && `${m}m`, s > 0 && `${s}s`].filter(Boolean).join("")
-  return `${h}h${tail}`
-}
-
-/**
- * Format a date string into a relative label ("5m ago") and a full locale string.
- * Accepts ISO-8601 or any string parseable by `new Date()`.
- */
-export const formatRelativeDate = (dateString?: string) => {
-  if (!dateString) return { relative: null, full: null }
-
-  try {
-    const date = new Date(dateString)
-    const diffMs = now() - date.getTime()
-    const diffSeconds = Math.floor(diffMs / SECOND_MS)
-    const diffMinutes = Math.floor(diffSeconds / 60)
-    const diffHours = Math.floor(diffMinutes / 60)
-    const diffDays = Math.floor(diffHours / 24)
-    const diffWeeks = Math.floor(diffDays / 7)
-    const diffMonths = Math.floor(diffDays / 30)
-    const diffYears = Math.floor(diffDays / 365)
-
-    let relative: string
-    if (diffSeconds < 60) {
-      relative = "just now"
-    } else if (diffMinutes < 60) {
-      relative = `${diffMinutes}m ago`
-    } else if (diffHours < 24) {
-      relative = `${diffHours}h ago`
-    } else if (diffDays < 7) {
-      relative = diffDays === 1 ? "1 day ago" : `${diffDays} days ago`
-    } else if (diffWeeks < 4) {
-      relative = diffWeeks === 1 ? "1 week ago" : `${diffWeeks} weeks ago`
-    } else if (diffMonths < 12) {
-      relative = diffMonths === 1 ? "1 month ago" : `${diffMonths} months ago`
-    } else {
-      relative = diffYears === 1 ? "1 year ago" : `${diffYears} years ago`
-    }
-
-    const full = date.toLocaleDateString("en-US", {
-      month: "short",
-      day: "numeric",
-      year: "numeric",
-      hour: "2-digit",
-      minute: "2-digit",
-    })
-
-    return { relative, full }
-  } catch {
-    return { relative: null, full: null }
-  }
-}
-
-/** Format seconds as a MM:SS countdown string (e.g. "3:05"). */
-export function formatCountdown(seconds: number): string {
-  const mins = Math.floor(seconds / 60)
-  const secs = seconds % 60
-  return `${mins}:${secs.toString().padStart(2, "0")}`
-}
-
-export function timeAgo(timestamp?: number): string {
-  if (!timestamp) return "Sent just now"
-
-  const diffSeconds = toSeconds(elapsed(timestamp))
-
-  if (diffSeconds < 1) return "Sent just now"
-  if (diffSeconds === 1) return "Sent 1 second ago"
-  if (diffSeconds < 60) return `Sent ${diffSeconds} seconds ago`
-
-  const diffMinutes = Math.floor(diffSeconds / 60)
-  if (diffMinutes === 1) return "Sent 1 minute ago"
-  if (diffMinutes < 60) return `Sent ${diffMinutes} minutes ago`
-
-  const diffHours = Math.floor(diffMinutes / 60)
-  if (diffHours === 1) return "Sent 1 hour ago"
-  if (diffHours < 24) return `Sent ${diffHours} hours ago`
-
-  const diffInDays = Math.floor(diffHours / 24)
-  if (diffInDays === 1) return "Sent 1 day ago"
-  return `Sent ${diffInDays} days ago`
-}

package/src/utils/validation.ts

@@ -1,104 +0,0 @@
-// ── Number validators ──
-
-/** True if value is a finite number (not NaN, not ±Infinity). Number.isFinite already rejects NaN. */
-export function isValidNumber(value: number): boolean {
-  return Number.isFinite(value)
-}
-
-/** True if value is a finite number > 0. */
-export function isPositiveNumber(value: number): boolean {
-  return Number.isFinite(value) && value > 0
-}
-
-/** True if value is a finite number >= 0. */
-export function isNonNegativeNumber(value: number): boolean {
-  return Number.isFinite(value) && value >= 0
-}
-
-/**
- * Safely convert any value to a finite number.
- * Returns 0 for null, undefined, NaN, ±Infinity, or unparseable strings.
- */
-export function toSafeNumber(
-  value: string | number | null | undefined,
-): number {
-  if (value === null || value === undefined) return 0
-  const n = Number(value)
-  return Number.isFinite(n) ? n : 0
-}
-
-// ── Token / amount validators ──
-
-/** True if decimals is an integer in [1, 18]. */
-export function isValidDecimals(decimals: number): boolean {
-  return Number.isInteger(decimals) && decimals > 0 && decimals <= 18
-}
-
-/**
- * True if amount is a non-empty string representing a finite positive number.
- * Does NOT handle locale-formatted strings — expects plain numeric input.
- */
-export function isValidStringAmount(amount: string): boolean {
-  if (!amount || amount === "") return false
-  const n = Number(amount)
-  return Number.isFinite(n) && n > 0
-}
-
-/**
- * True if value can be parsed as a BigInt > 0.
- * Accepts both bigint values and numeric strings.
- */
-export function isPositiveBigInt(value: string | bigint): boolean {
-  try {
-    return BigInt(value) > 0n
-  } catch {
-    return false
-  }
-}
-
-// ── String format validators ──
-
-/**
- * True if value is a string representing a valid numeric value (digits with optional decimal).
- * Empty/null/undefined are considered valid (for form-validation use cases).
- */
-export function isValidNumeric(
-  value: number | string | null | undefined,
-): boolean {
-  if (value === null || value === undefined || value === "") {
-    return true // Empty values are considered valid
-  }
-  const strValue = String(value).trim()
-  return /^\d+(\.\d+)?$/.test(strValue)
-}
-
-/**
- * True if value is a string representing a valid integer (digits only).
- * Empty/null/undefined are considered valid (for form-validation use cases).
- */
-export function isValidInteger(
-  value: number | string | null | undefined,
-): boolean {
-  if (value === null || value === undefined || value === "") {
-    return true // Empty values are considered valid
-  }
-  const strValue = String(value).trim()
-  return /^\d+$/.test(strValue)
-}
-
-/**
- * Helper to check if an amount is zero or invalid.
- * Used to prevent API requests with zero amounts which return 400 errors.
- */
-export const isZeroOrInvalidAmount = (
-  amount: string | bigint | undefined,
-): boolean => {
-  if (amount === undefined || amount === null) return true
-  if (typeof amount === "bigint") return amount === 0n
-  if (amount === "") return true
-  try {
-    return BigInt(amount) === 0n
-  } catch {
-    return true
-  }
-}

package/src/utils.ts

@@ -1,112 +0,0 @@
-import { AbiFunction } from "ox"
-import { isValidNumber } from "./utils/validation.js"
-
-export async function requestWithTimeout<T>(
-  client: { request: (...args: any[]) => Promise<T> },
-  args: Parameters<typeof client.request>,
-  timeoutMs: number,
-): Promise<T> {
-  return Promise.race([
-    client.request(...args),
-    new Promise<never>((_, reject) =>
-      setTimeout(() => reject(new Error("Request timed out")), timeoutMs),
-    ),
-  ])
-}
-
-/**
- * Checks if a formatted value (string with currency symbols, commas, etc.) represents zero
- * Strips all non-numeric characters and checks if the numeric value is zero
- * @param value - The value to check (can be string like "$1,000.00" or number)
- * @returns True if the value represents zero
- */
-export function isValueZero(value?: string | number | null): boolean {
-  if (value === null || value === undefined) return true
-  if (typeof value === "number") return value === 0
-
-  // Strip all non-numeric characters except decimal point and minus sign
-  const numericString = value.replace(/[^0-9.-]/g, "")
-  if (!numericString || numericString === "-") return true
-
-  const numValue = parseFloat(numericString)
-  return !isValidNumber(numValue) || numValue === 0
-}
-
-/**
- * Gets the currency symbol for a given currency code
- */
-export function getCurrencySymbol(currencyCode?: string): string {
-  if (!currencyCode) return ""
-  const symbols: Record<string, string> = {
-    USD: "$",
-    EUR: "€",
-    GBP: "£",
-    JPY: "¥",
-    CAD: "$",
-    AUD: "$",
-    CHF: "₣",
-    BTC: "₿",
-    ETH: "Ξ",
-    USDC: "$",
-    USDT: "$",
-  }
-  return symbols[currencyCode.toUpperCase()] || currencyCode
-}
-
-/**
- * Parses currency code to extract symbol and chain info
- * Handles cases like "USDC_BASE", "ETH_ETHEREUM", etc.
- */
-export function parseCurrencyCode(currencyCode?: string): {
-  symbol: string
-  chainId?: number
-} {
-  if (!currencyCode) return { symbol: "" }
-
-  // Handle cases like "USDC_BASE", "ETH_ETHEREUM", etc.
-  const parts = currencyCode.split("_")
-  const symbol = parts[0] || currencyCode
-  const chainName = parts[1]
-
-  // Map common chain names to chain IDs
-  const chainMapping: Record<string, number> = {
-    BASE: 8453,
-    ETHEREUM: 1,
-    ETH: 1,
-    POLYGON: 137,
-    ARBITRUM: 42161,
-    OPTIMISM: 10,
-    BSC: 56,
-    AVALANCHE: 43114,
-  }
-
-  const chainId = chainName ? chainMapping[chainName.toUpperCase()] : undefined
-
-  return { symbol, chainId }
-}
-
-/**
- * Gets country flag emoji from country code
- */
-export function getCountryFlag(countryCode?: string): string {
-  if (!countryCode || countryCode.length !== 2) return ""
-  // Convert country code to flag emoji
-  const codePoints = countryCode
-    .toUpperCase()
-    .split("")
-    .map((char) => 0x1f1e6 + char.charCodeAt(0) - 65)
-  return String.fromCodePoint(...codePoints)
-}
-
-/**
- * Encodes ERC20 transfer function call data
- * @param to - The recipient address
- * @param amount - The amount to transfer (in token's smallest unit)
- * @returns Encoded transfer function call data
- */
-export function getERC20TransferData(to: string, amount: bigint): string {
-  const erc20Transfer = AbiFunction.from(
-    "function transfer(address,uint256) returns (bool)",
-  )
-  return AbiFunction.encodeData(erc20Transfer, [to as `0x${string}`, amount])
-}

package/src/version.ts

@@ -1,8 +0,0 @@
-// Import package.json to get version dynamically
-import packageJson from "../package.json" with { type: "json" }
-
-export const SDK_VERSION = packageJson.version
-
-export function getVersion(): string {
-  return SDK_VERSION
-}

package/src/vite-env.d.ts

@@ -1,4 +0,0 @@
-declare module "*.css?inline" {
-  const content: string
-  export default content
-}

package/src/walletUtils.ts

@@ -1,292 +0,0 @@
-import type { Connector } from "wagmi"
-import {
-  BaseError,
-  formatTransactionRequest,
-  InvalidInputRpcError,
-  InvalidParamsRpcError,
-  MethodNotFoundRpcError,
-  MethodNotSupportedRpcError,
-  UnknownRpcError,
-  type RpcTransactionRequest,
-  type WalletClient,
-} from "viem"
-import { parseAccount } from "viem/accounts"
-import { attemptSwitchChain } from "./chainSwitch.js"
-import { getIsContract } from "./contractUtils.js"
-import { SECOND_MS } from "./utils/time.js"
-import { logger } from "./logger.js"
-
-type WalletSendTransactionParams = Parameters<
-  WalletClient["sendTransaction"]
->[0]
-
-// Matches viem fallback trigger errors while probing wallet_sendTransaction:
-// https://github.com/wevm/viem/blob/main/src/actions/wallet/sendTransaction.ts
-function isUnsupportedWalletNamespaceError(error: unknown): boolean {
-  return (
-    error instanceof InvalidInputRpcError ||
-    error instanceof InvalidParamsRpcError ||
-    error instanceof MethodNotFoundRpcError ||
-    error instanceof MethodNotSupportedRpcError
-  )
-}
-
-// EIP-1474 defines "method not supported" as -32004:
-// https://eips.ethereum.org/EIPS/eip-1474#error-codes
-// Some Privy RPC endpoints currently return non-standard -32604 for
-// wallet_sendTransaction, which viem surfaces as UnknownRpcError instead of
-// MethodNotSupportedRpcError. We normalize that shape here so fallback can run.
-function isUnsupportedPrivyWalletSendTransactionError(error: unknown): boolean {
-  if (!(error instanceof UnknownRpcError)) {
-    return false
-  }
-
-  const details = error.details.toLowerCase()
-  return (
-    details.includes("method is not supported") || details.includes("-32604")
-  )
-}
-
-function isRecoverableWalletSendError(error: unknown): boolean {
-  if (
-    isUnsupportedWalletNamespaceError(error) ||
-    isUnsupportedPrivyWalletSendTransactionError(error)
-  ) {
-    return true
-  }
-
-  if (error instanceof BaseError) {
-    return (
-      error.walk(
-        (innerError) =>
-          isUnsupportedWalletNamespaceError(innerError) ||
-          isUnsupportedPrivyWalletSendTransactionError(innerError),
-      ) !== null
-    )
-  }
-
-  return false
-}
-
-function buildEthSendTransactionRequest(
-  txParams: WalletSendTransactionParams,
-): RpcTransactionRequest {
-  if (!txParams.account) {
-    throw new Error(
-      "Wallet account address is required for eth_sendTransaction fallback",
-    )
-  }
-
-  const { chain: _chain, account, ...request } = txParams
-
-  return formatTransactionRequest({
-    ...request,
-    account: parseAccount(account),
-  })
-}
-
-async function getTransportChainId(
-  transport: WalletClient["transport"],
-): Promise<number> {
-  if (!transport || typeof transport.request !== "function") {
-    throw new Error("Invalid wallet transport")
-  }
-
-  const currentChainIdHex = await transport.request({ method: "eth_chainId" })
-  if (typeof currentChainIdHex !== "string") {
-    throw new Error("Wallet transport returned an invalid chain ID")
-  }
-
-  const currentChainId = Number.parseInt(currentChainIdHex, 16)
-  if (!Number.isSafeInteger(currentChainId)) {
-    throw new Error("Wallet transport returned an invalid chain ID")
-  }
-
-  return currentChainId
-}
-
-async function assertFallbackTransportMatchesChain(
-  walletClient: WalletClient,
-  txParams: WalletSendTransactionParams,
-): Promise<void> {
-  const expectedChainId = txParams.chain?.id
-  if (!expectedChainId) {
-    return
-  }
-
-  const transport = walletClient.transport
-  let currentChainId = await getTransportChainId(transport)
-
-  if (currentChainId !== expectedChainId) {
-    logger.console.warn(
-      "[wallet-utils] Switching wallet transport chain before eth_sendTransaction fallback",
-      {
-        currentChainId,
-        expectedChainId,
-      },
-    )
-
-    await attemptSwitchChain({
-      walletClient,
-      desiredChainId: expectedChainId,
-    })
-
-    currentChainId = await getTransportChainId(transport)
-    if (currentChainId !== expectedChainId) {
-      throw new Error(
-        `Wallet transport chain ID ${currentChainId} does not match requested chain ID ${expectedChainId}`,
-      )
-    }
-  }
-}
-
-export async function sendWalletTransaction(
-  walletClient: WalletClient,
-  txParams: WalletSendTransactionParams,
-): Promise<`0x${string}`> {
-  try {
-    return await walletClient.sendTransaction(txParams)
-  } catch (error) {
-    if (!isRecoverableWalletSendError(error)) {
-      throw error
-    }
-
-    logger.console.warn(
-      "[wallet-utils] Falling back to eth_sendTransaction for wallet send",
-      {
-        error: error instanceof Error ? error.message : String(error),
-      },
-    )
-
-    const fallbackRequest = buildEthSendTransactionRequest(txParams)
-    const transport = walletClient.transport
-    if (!transport || typeof transport.request !== "function") {
-      throw new Error("Invalid wallet transport")
-    }
-
-    await assertFallbackTransportMatchesChain(walletClient, txParams)
-
-    // Send directly through transport with eth_sendTransaction to bypass
-    // wallet namespace probing for providers that reject wallet_sendTransaction.
-    // Related viem logic:
-    // https://github.com/wevm/viem/blob/main/src/actions/wallet/sendTransaction.ts
-    const txHash = await transport.request({
-      method: "eth_sendTransaction",
-      params: [fallbackRequest],
-    })
-
-    return txHash as `0x${string}`
-  }
-}
-
-/**
- * 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")
-}
-
-export function isWalletConnectConnector(
-  connector: Connector | undefined,
-): boolean {
-  if (!connector) return false
-  const connectorName = connector.name?.toLowerCase() || ""
-  const connectorId = connector.id?.toLowerCase() || ""
-  return (
-    connectorName.includes("walletconnect") ||
-    connectorId.includes("walletconnect")
-  )
-}
-
-/**
- * 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
-  }
-}
-
-/**
- * Checks if a wallet provider is still responsive
- * @param walletClient - The wallet client to check
- * @param timeoutMs - Timeout in milliseconds (default 10s)
- * @throws Error if the provider is unresponsive or disconnected
- */
-export async function checkProviderHealth(
-  walletClient: WalletClient,
-  timeoutMs = 10 * SECOND_MS,
-): Promise<void> {
-  const transport = walletClient.transport
-  if (!transport || typeof transport.request !== "function") {
-    throw new Error("Invalid wallet transport")
-  }
-
-  const timeoutPromise = new Promise<never>((_, reject) => {
-    setTimeout(
-      () => reject(new Error("Provider health check timeout")),
-      timeoutMs,
-    )
-  })
-
-  try {
-    await Promise.race([
-      transport.request({ method: "eth_chainId" }),
-      timeoutPromise,
-    ])
-  } catch (error) {
-    logger.console.error("[wallet-utils] Provider health check failed:", error)
-    throw new Error(
-      "Wallet connection lost. Please reconnect your wallet and try again.",
-    )
-  }
-}
-
-/**
- * Wraps a signature request with a timeout to prevent indefinite hanging
- * @param signaturePromise - The signature promise to wrap
- * @param operation - Description of the operation for error messages
- * @param timeoutMs - Timeout in milliseconds (default 120s)
- * @returns The signature or throws on timeout
- */
-export async function signWithTimeout<T>(
-  signaturePromise: Promise<T>,
-  operation = "Signature",
-  timeoutMs = 120 * SECOND_MS,
-): Promise<T> {
-  const timeoutPromise = new Promise<never>((_, reject) => {
-    setTimeout(() => {
-      reject(
-        new Error(
-          `${operation} request timed out. The wallet may be disconnected or unresponsive. Please check your wallet and try again.`,
-        ),
-      )
-    }, timeoutMs)
-  })
-
-  return await Promise.race([signaturePromise, timeoutPromise])
-}