0xtrails 0.13.2 → 0.14.0

package/src/buffer.ts

@@ -1,10 +0,0 @@
-import { Buffer as BufferPolyfill } from "buffer"
-
-// Polyfill Buffer globally if it doesn't exist.
-// Buffer is required by some 0xsequence packages.
-// This is a temporary solution.
-if (typeof window !== "undefined" && !window.Buffer) {
-  window.Buffer = BufferPolyfill
-}
-
-export { BufferPolyfill as Buffer }

package/src/chainSwitch.ts

@@ -1,95 +0,0 @@
-import type { WalletClient } from "viem"
-import { getChainInfo } from "./chains.js"
-import { logger } from "./logger.js"
-
-export type AttemptSwitchChainParams = {
-  walletClient: WalletClient
-  desiredChainId: number
-}
-
-/**
- * Detects whether a switchChain error means the chain is not added to the wallet.
- * Checks EIP-3326 error code 4902, MetaMask Mobile's nested error format,
- * and viem's error message as a fallback.
- */
-function isChainNotAddedError(error: unknown): boolean {
-  // Standard EIP-3326 error code for "Unrecognized chain ID"
-  if (typeof error === "object" && error !== null && "code" in error) {
-    if ((error as { code: number }).code === 4902) return true
-  }
-
-  // MetaMask Mobile wraps the real error inside data.originalError
-  // https://github.com/MetaMask/metamask-mobile/issues/2944
-  if (typeof error === "object" && error !== null && "data" in error) {
-    const nestedError = error as {
-      data?: {
-        originalError?: {
-          code?: unknown
-        }
-      }
-    }
-    if (nestedError.data?.originalError?.code === 4902) {
-      return true
-    }
-  }
-
-  // Fallback: viem formats the error message to mention wallet_addEthereumChain
-  if (
-    error instanceof Error &&
-    error.message.includes("wallet_addEthereumChain")
-  ) {
-    return true
-  }
-
-  return false
-}
-
-export async function attemptSwitchChain({
-  walletClient,
-  desiredChainId,
-}: AttemptSwitchChainParams): Promise<void> {
-  try {
-    // Check if the chain was switched successfully
-    let currentChainId = await walletClient.getChainId()
-    if (currentChainId === desiredChainId) {
-      logger.console.log(
-        "[trails-sdk] Chain already switched to:",
-        desiredChainId,
-      )
-      return
-    }
-
-    logger.console.log(
-      "[trails-sdk] Switching to chain:",
-      desiredChainId,
-      "currentChainId",
-      currentChainId,
-    )
-    await walletClient.switchChain({ id: desiredChainId })
-
-    // Check if the chain was switched successfully
-    currentChainId = await walletClient.getChainId()
-    if (currentChainId !== desiredChainId) {
-      throw new Error("Failed to switch chain")
-    }
-
-    logger.console.log("[trails-sdk] Chain switched to:", desiredChainId)
-  } catch (error: unknown) {
-    if (isChainNotAddedError(error)) {
-      const chainInfo = getChainInfo(desiredChainId, {
-        usePublicRpc: true,
-      })
-      if (chainInfo) {
-        await walletClient.addChain({
-          chain: chainInfo,
-        })
-        return attemptSwitchChain({ walletClient, desiredChainId })
-      }
-    }
-
-    logger.console.error("[trails-sdk] Chain switch failed:", error)
-    throw new Error(
-      `[trails-sdk] Failed to switch chain: ${error instanceof Error ? error.message : "Unknown error"}`,
-    )
-  }
-}

package/src/chains.ts

@@ -1,570 +0,0 @@
-import type { Chain as ViemChain, PublicClient } from "viem"
-import { createPublicClient, http } from "viem"
-import { TrailsApi, type ChainInfo as ApiChainInfo } from "@0xtrails/api"
-import { logger } from "./logger.js"
-import { getConfig } from "./config.js"
-import { SECOND_MS } from "./utils/time.js"
-
-import {
-  arbitrum,
-  base,
-  mainnet,
-  optimism,
-  gnosis,
-  polygon,
-  soneium,
-  xai,
-  apeChain,
-  arbitrumNova,
-  avalanche,
-  b3,
-  blast,
-  bsc,
-  katana,
-  etherlink,
-  berachain,
-  sonic,
-  arbitrumSepolia,
-  avalancheFuji,
-  b3Sepolia,
-  baseSepolia,
-  blastSepolia,
-  bscTestnet,
-  sepolia,
-  gnosisChiado,
-  polygonAmoy,
-  optimismSepolia,
-  soneiumMinato,
-  xaiTestnet,
-  etherlinkTestnet,
-  somniaTestnet,
-  monad,
-  monadTestnet,
-  berachainBepolia,
-  sonicTestnet,
-  hyperEvm,
-  hyperliquidEvmTestnet,
-} from "viem/chains"
-import { somnia } from "./customChains.js"
-
-export function getShouldFetchVersions(overrideTrailsApiUrl?: string): boolean {
-  const trailsApiUrl = overrideTrailsApiUrl || getConfig("trailsApiUrl") || ""
-  const normalized = trailsApiUrl.toLowerCase()
-
-  const isDev =
-    normalized.includes("dev-trails-api.sequence-dev.app") ||
-    normalized.includes("dev2-trails-api.sequence-dev.app")
-  const isLocal =
-    normalized.includes("localhost") || normalized.includes("127.0.0.1")
-
-  return isDev || isLocal
-}
-
-// Extended Chain type with imageUrl
-export interface Chain extends ViemChain {
-  imageUrl?: string
-}
-
-/**
- * Simplified chain info type for UI components.
- * Uses `chainId` instead of `id` for consistency with component props.
- */
-export interface ChainListItem {
-  chainId: number
-  name: string
-  imageUrl?: string
-}
-
-function mapSupportedApiChains(apiChains: ApiChainInfo[]): Chain[] {
-  const mapped = sortChainsByOrder(
-    apiChains
-      .map(mapApiChainToViemChain)
-      .filter((chain): chain is Chain => chain !== null),
-  )
-  if (mapped.length === 0) {
-    throw new Error("[trails-sdk] getChains mapped to zero supported chains")
-  }
-  return mapped
-}
-
-// Function to get chain image URL
-export function getChainImageUrl(chainId: number): string {
-  // Use Sequence's chain image assets
-  return `https://assets.sequence.info/images/networks/large/${chainId}.webp`
-}
-
-export function getAllChains(): readonly [Chain, ...Chain[]] {
-  return [
-    arbitrum,
-    base,
-    mainnet,
-    optimism,
-    gnosis,
-    polygon,
-    soneium,
-    somnia,
-    xai,
-    apeChain,
-    arbitrumNova,
-    avalanche,
-    b3,
-    blast,
-    bsc,
-    katana,
-    etherlink,
-    berachain,
-    hyperEvm,
-    sonic,
-    arbitrumSepolia,
-    avalancheFuji,
-    b3Sepolia,
-    baseSepolia,
-    blastSepolia,
-    bscTestnet,
-    sepolia,
-    gnosisChiado,
-    polygonAmoy,
-    optimismSepolia,
-    soneiumMinato,
-    xaiTestnet,
-    etherlinkTestnet,
-    somniaTestnet,
-    monad,
-    monadTestnet,
-    berachainBepolia,
-    sonicTestnet,
-    hyperliquidEvmTestnet,
-  ]
-}
-
-function getSequenceRpcUrlFromSlug(
-  chainSlug: string,
-  sequenceNodeGatewayUrl: string,
-): string {
-  return `${sequenceNodeGatewayUrl}/${chainSlug}`
-}
-
-// Dynamic function to get sequence RPC URLs (computed at runtime to respect environment changes)
-function getSequenceRpcUrls(
-  sequenceNodeGatewayUrl: string,
-): Record<number, string> {
-  return {
-    [arbitrum.id]: getSequenceRpcUrlFromSlug(
-      "arbitrum",
-      sequenceNodeGatewayUrl,
-    ),
-    [base.id]: getSequenceRpcUrlFromSlug("base", sequenceNodeGatewayUrl),
-    [mainnet.id]: getSequenceRpcUrlFromSlug("mainnet", sequenceNodeGatewayUrl),
-    [optimism.id]: getSequenceRpcUrlFromSlug(
-      "optimism",
-      sequenceNodeGatewayUrl,
-    ),
-    [gnosis.id]: getSequenceRpcUrlFromSlug("gnosis", sequenceNodeGatewayUrl),
-    [polygon.id]: getSequenceRpcUrlFromSlug("polygon", sequenceNodeGatewayUrl),
-    [soneium.id]: getSequenceRpcUrlFromSlug("soneium", sequenceNodeGatewayUrl),
-    [somnia.id]: getSequenceRpcUrlFromSlug("somnia", sequenceNodeGatewayUrl),
-    [xai.id]: getSequenceRpcUrlFromSlug("xai", sequenceNodeGatewayUrl),
-    [apeChain.id]: getSequenceRpcUrlFromSlug(
-      "apechain",
-      sequenceNodeGatewayUrl,
-    ),
-    [arbitrumNova.id]: getSequenceRpcUrlFromSlug(
-      "arbitrum-nova",
-      sequenceNodeGatewayUrl,
-    ),
-    [avalanche.id]: getSequenceRpcUrlFromSlug(
-      "avalanche",
-      sequenceNodeGatewayUrl,
-    ),
-    [b3.id]: getSequenceRpcUrlFromSlug("b3", sequenceNodeGatewayUrl),
-    [blast.id]: getSequenceRpcUrlFromSlug("blast", sequenceNodeGatewayUrl),
-    [bsc.id]: getSequenceRpcUrlFromSlug("bsc", sequenceNodeGatewayUrl),
-    [katana.id]: getSequenceRpcUrlFromSlug("katana", sequenceNodeGatewayUrl),
-    [etherlink.id]: getSequenceRpcUrlFromSlug(
-      "etherlink",
-      sequenceNodeGatewayUrl,
-    ),
-    [monad.id]: getSequenceRpcUrlFromSlug("monad", sequenceNodeGatewayUrl),
-    [berachain.id]: getSequenceRpcUrlFromSlug(
-      "berachain",
-      sequenceNodeGatewayUrl,
-    ),
-    [hyperEvm.id]: getSequenceRpcUrlFromSlug(
-      "hyperevm",
-      sequenceNodeGatewayUrl,
-    ),
-    [sonic.id]: getSequenceRpcUrlFromSlug("sonic", sequenceNodeGatewayUrl),
-  }
-}
-
-export const getRpcUrl = (
-  chainId: number,
-  sequenceProjectAccessKey: string,
-  sequenceNodeGatewayUrl: string,
-): string | null => {
-  const sequenceRpcUrls = getSequenceRpcUrls(sequenceNodeGatewayUrl)
-  if (!sequenceRpcUrls[chainId]) {
-    return null
-  }
-  return `${sequenceRpcUrls[chainId]}/${sequenceProjectAccessKey}`
-}
-
-const TRANSPORT_OPTIONS = {
-  retryCount: 5,
-  retryDelay: SECOND_MS,
-  timeout: 30 * SECOND_MS,
-}
-
-function createHttpTransport(
-  chainId: number,
-  trailsApiKey?: string,
-  sequenceNodeGatewayUrl?: string,
-  retryCount?: number,
-) {
-  const transportOptions =
-    retryCount === undefined
-      ? TRANSPORT_OPTIONS
-      : { ...TRANSPORT_OPTIONS, retryCount }
-
-  if (trailsApiKey && sequenceNodeGatewayUrl) {
-    const rpcUrl = getRpcUrl(chainId, trailsApiKey, sequenceNodeGatewayUrl)
-    if (rpcUrl) {
-      return http(rpcUrl, transportOptions)
-    }
-  }
-
-  return http(undefined, transportOptions)
-}
-
-export function getChainTransport(
-  chainId: number,
-  config?: {
-    trailsApiKey?: string
-    sequenceNodeGatewayUrl?: string
-  },
-  retryCount?: number,
-) {
-  const resolvedConfig = config ?? getConfig()
-  return createHttpTransport(
-    chainId,
-    resolvedConfig.trailsApiKey,
-    resolvedConfig.sequenceNodeGatewayUrl,
-    retryCount,
-  )
-}
-
-/**
- * Create a public RPC client for a chain using Sequence RPC URLs
- * This is a temporary solution to use global config for RPC URLs
- * @param chainId - The chain ID to create the public client for
- * @param retryCount - The number of retry attempts for the RPC client
- * @returns Viem PublicClient configured with Sequence RPC URL if available
- */
-export function getChainRpcClient(
-  chainId: number,
-  retryCount?: number,
-): PublicClient {
-  const chainInfo = getChainInfo(chainId)
-  if (!chainInfo) {
-    logger.console.warn(
-      `[trails-sdk] Chain ${chainId} not found. Falling back to a generic public client.`,
-    )
-    return createPublicClient({
-      transport: getChainTransport(chainId, undefined, retryCount),
-    })
-  }
-  return createPublicClient({
-    chain: chainInfo,
-    transport: getChainTransport(chainId, undefined, retryCount),
-  })
-}
-
-export async function getSupportedSequenceChains(config?: {
-  trailsApiUrl?: string
-  trailsApiKey?: string
-}): Promise<Chain[]> {
-  const globalCfg = getConfig()
-  const cfg = {
-    trailsApiUrl: config?.trailsApiUrl ?? globalCfg.trailsApiUrl,
-    trailsApiKey: config?.trailsApiKey ?? globalCfg.trailsApiKey,
-  }
-  const trailsApi = new TrailsApi(cfg.trailsApiKey || "", {
-    hostname: cfg.trailsApiUrl,
-  })
-  const response = await trailsApi.getChains({})
-  const chains = response?.chains || []
-  if (chains.length === 0) {
-    throw new Error("[trails-sdk] getChains returned no supported chains")
-  }
-
-  return mapSupportedApiChains(chains)
-}
-
-function mapApiChainToViemChain(apiChain: ApiChainInfo): Chain | null {
-  const chainInfo = getChainInfo(apiChain.id)
-  if (!chainInfo) {
-    logger.console.warn(
-      `[trails-sdk] chain ${apiChain.id} from GetChains is not mapped in SDK, skipping`,
-    )
-    return null
-  }
-
-  const tokenName =
-    apiChain.nativeCurrency?.name || chainInfo.nativeCurrency.name
-  const tokenSymbol =
-    apiChain.nativeCurrency?.symbol || chainInfo.nativeCurrency.symbol
-  const tokenDecimals =
-    apiChain.nativeCurrency?.decimals || chainInfo.nativeCurrency.decimals
-  const blockExplorerUrl =
-    apiChain.blockExplorer?.url || chainInfo.blockExplorers?.default?.url
-  const blockExplorerName =
-    apiChain.blockExplorer?.name ||
-    chainInfo.blockExplorers?.default?.name ||
-    "Explorer"
-
-  return {
-    ...chainInfo,
-    name: apiChain.name || chainInfo.name,
-    nativeCurrency: {
-      ...chainInfo.nativeCurrency,
-      name: tokenName,
-      symbol: tokenSymbol,
-      decimals: tokenDecimals,
-    },
-    blockExplorers: blockExplorerUrl
-      ? {
-          default: {
-            name: blockExplorerName,
-            url: blockExplorerUrl,
-          },
-        }
-      : chainInfo.blockExplorers,
-  }
-}
-
-export const supportedSequenceTestnetChains: Record<number, Chain> = {
-  [arbitrumSepolia.id]: getChainInfo(arbitrumSepolia.id)!,
-  [avalancheFuji.id]: getChainInfo(avalancheFuji.id)!,
-  [b3Sepolia.id]: getChainInfo(b3Sepolia.id)!,
-  [baseSepolia.id]: getChainInfo(baseSepolia.id)!,
-  [blastSepolia.id]: getChainInfo(blastSepolia.id)!,
-  [bscTestnet.id]: getChainInfo(bscTestnet.id)!,
-  [sepolia.id]: getChainInfo(sepolia.id)!,
-  [gnosisChiado.id]: getChainInfo(gnosisChiado.id)!,
-  [polygonAmoy.id]: getChainInfo(polygonAmoy.id)!,
-  [optimismSepolia.id]: getChainInfo(optimismSepolia.id)!,
-  [soneiumMinato.id]: getChainInfo(soneiumMinato.id)!,
-  [xaiTestnet.id]: getChainInfo(xaiTestnet.id)!,
-  [etherlinkTestnet.id]: getChainInfo(etherlinkTestnet.id)!,
-  [somniaTestnet.id]: getChainInfo(somniaTestnet.id)!,
-  [monadTestnet.id]: getChainInfo(monadTestnet.id)!,
-  [berachainBepolia.id]: getChainInfo(berachainBepolia.id)!,
-  [sonicTestnet.id]: getChainInfo(sonicTestnet.id)!,
-  [hyperliquidEvmTestnet.id]: getChainInfo(hyperliquidEvmTestnet.id)!,
-}
-
-export const mainnetChainsToTestnetChains: Record<number, Chain> = {
-  [arbitrum.id]: arbitrumSepolia,
-  [avalanche.id]: avalancheFuji,
-  [base.id]: baseSepolia,
-  [gnosis.id]: gnosisChiado,
-  [optimism.id]: optimismSepolia,
-  [polygon.id]: polygonAmoy,
-  [mainnet.id]: sepolia,
-  [xai.id]: xaiTestnet,
-  [soneium.id]: soneiumMinato,
-  [b3.id]: b3Sepolia,
-  [blast.id]: blastSepolia,
-  [bsc.id]: bscTestnet,
-  [arbitrumNova.id]: arbitrumSepolia,
-  [apeChain.id]: sepolia,
-  [etherlink.id]: etherlinkTestnet,
-  [somnia.id]: somniaTestnet,
-  [monad.id]: monadTestnet,
-  [berachain.id]: berachainBepolia,
-  [sonic.id]: sonicTestnet,
-  [hyperEvm.id]: hyperliquidEvmTestnet,
-}
-
-// Helper to get chain info
-export function getChainInfo(
-  chainId?: number,
-  options?: {
-    usePublicRpc?: boolean
-    sequenceProjectAccessKey?: string
-    sequenceNodeGatewayUrl?: string
-  },
-): Chain | null {
-  if (!chainId) return null
-  const foundChain =
-    getAllChains().find((chain: Chain) => chain.id === chainId) || null
-
-  if (!foundChain) return null
-
-  // Clone the chain object to avoid mutating the original viem chain objects
-  // This is important because we may modify rpcUrls and blockExplorers
-  const chainInfo: Chain = {
-    ...foundChain,
-    rpcUrls: {
-      default: { ...foundChain.rpcUrls.default },
-      public: foundChain.rpcUrls.public
-        ? { ...foundChain.rpcUrls.public }
-        : { ...foundChain.rpcUrls.default },
-    },
-    blockExplorers: foundChain.blockExplorers
-      ? { ...foundChain.blockExplorers }
-      : undefined,
-  }
-
-  // Use Sequence RPC by default. Only use public RPC when adding chains to user's wallet.
-  // When usePublicRpc is true, we keep the original viem RPC URLs (public)
-  if (
-    !options?.usePublicRpc &&
-    options?.sequenceProjectAccessKey &&
-    options?.sequenceNodeGatewayUrl
-  ) {
-    const rpcUrl = getRpcUrl(
-      chainId,
-      options.sequenceProjectAccessKey,
-      options.sequenceNodeGatewayUrl,
-    )
-    if (rpcUrl) {
-      chainInfo.rpcUrls = {
-        default: {
-          ...chainInfo.rpcUrls.default,
-          http: [rpcUrl],
-        },
-        public: {
-          ...chainInfo.rpcUrls.public,
-          http: [rpcUrl],
-        },
-      }
-    }
-  }
-
-  // Override explorer URLs for specific chains
-  if (chainId === katana.id) {
-    chainInfo.blockExplorers = {
-      default: {
-        name: "Katanascan",
-        url: "https://katanascan.com", // use katanascan instead of explorer.katanarpc.com
-      },
-    }
-  }
-
-  const name = getNormalizedChainName(chainId, chainInfo?.name || "")
-  const imageUrl = getChainImageUrl(chainId)
-
-  return {
-    ...chainInfo,
-    name,
-    imageUrl,
-  } as Chain
-}
-
-// Get testnet chain info from mainnet chain as input
-export function getTestnetChainInfo(
-  mainnetChain: Chain | number,
-): Chain | null {
-  let chainId = 0
-  if (typeof mainnetChain === "number" || typeof mainnetChain === "string") {
-    chainId = Number(mainnetChain)
-  } else {
-    chainId = mainnetChain.id
-  }
-  return mainnetChainsToTestnetChains[chainId] || null
-}
-
-// Chain order for sorting (in the desired display order)
-const CHAIN_ORDER: number[] = [
-  mainnet.id,
-  base.id,
-  arbitrum.id,
-  polygon.id,
-  katana.id,
-  bsc.id,
-  optimism.id,
-  avalanche.id,
-  arbitrumNova.id,
-  etherlink.id,
-  gnosis.id,
-  b3.id,
-  apeChain.id,
-  soneium.id,
-  somnia.id,
-  xai.id,
-  monad.id,
-  berachain.id,
-  hyperEvm.id,
-  sonic.id,
-]
-
-/**
- * Gets the normalized display name for a chain.
- * @param chainId - The chain ID
- * @param originalName - The original chain name from viem
- * @returns The normalized chain name
- */
-export function getNormalizedChainName(
-  chainId: number,
-  originalName: string,
-): string {
-  // Mapping of chain ID to normalized display name
-  const chainNameMap: Record<number, string> = {
-    [arbitrum.id]: "Arbitrum", // Rename from "Arbitrum One"
-    [bsc.id]: "BSC", // Rename from "BNB Smart Chain"
-    [optimism.id]: "Optimism", // Rename from "OP Mainnet"
-    [soneium.id]: "Soneium", // Rename from "Soneium Mainnet"
-    [xai.id]: "Xai", // Rename from "Xai Mainnet"
-  }
-
-  return chainNameMap?.[chainId] || originalName || ""
-}
-
-/**
- * Sorts chains by the predefined order, then alphabetically for chains not in the order.
- * @param chainList - The list of chains to sort
- * @returns The sorted list of chains
- */
-export function sortChainsByOrder(chainList: Chain[]): Chain[] {
-  return chainList.sort((a: Chain, b: Chain) => {
-    const aIndex = CHAIN_ORDER.indexOf(a.id)
-    const bIndex = CHAIN_ORDER.indexOf(b.id)
-
-    // If both chains are in the order, sort by their position
-    if (aIndex !== -1 && bIndex !== -1) {
-      return aIndex - bIndex
-    }
-
-    // If only one chain is in the order, prioritize it
-    if (aIndex !== -1) return -1
-    if (bIndex !== -1) return 1
-
-    // If neither chain is in the order, sort alphabetically
-    return a.name.localeCompare(b.name)
-  })
-}
-
-export async function getSupportedChains(config?: {
-  trailsApiUrl?: string
-  trailsApiKey?: string
-}): Promise<Chain[]> {
-  const sequenceChains = await getSupportedSequenceChains(config)
-
-  // Sort chains by predefined order
-  return sortChainsByOrder(sequenceChains)
-}
-
-/**
- * Get display name for a chain by ID.
- * @param chainId - The chain ID
- * @returns The chain display name, or "Chain {id}" for unknown chains
- */
-export function getChainName(chainId: number): string {
-  return getChainInfo(chainId)?.name ?? `Chain ${chainId}`
-}
-
-export function getIsTestnetChainId(chainId: number): boolean {
-  const testnetChainIds = Object.keys(supportedSequenceTestnetChains)
-  return testnetChainIds.includes(chainId.toString())
-}