0xtrails 0.4.3 → 0.6.0

package/src/chains.ts

@@ -1,5 +1,7 @@
 import { useQuery } from "@tanstack/react-query"
-import type { Chain as ViemChain } from "viem"
+import type { Chain as ViemChain, PublicClient } from "viem"
+import { createPublicClient, http } from "viem"
+import { getConfig } from "./config.js"
 
 import {
   arbitrum,
@@ -35,10 +37,6 @@ import {
 } from "viem/chains"
 import { getRelaySupportedChains } from "./relaySdk.js"
 import { getLifiSupportedChains } from "./lifi.js"
-import {
-  getSequenceProjectAccessKey,
-  getSequenceNodeGatewayUrl,
-} from "./config.js"
 import type { QuoteProvider } from "./intents.js"
 import { somnia } from "./customChains.js"
 
@@ -89,44 +87,103 @@ export function getAllChains(): Chain[] {
   ]
 }
 
-function getSequenceRpcUrlFromSlug(chainSlug: string): string {
-  return `${getSequenceNodeGatewayUrl()}/${chainSlug}`
+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(): Record<number, string> {
+function getSequenceRpcUrls(
+  sequenceNodeGatewayUrl: string,
+): Record<number, string> {
   return {
-    [arbitrum.id]: getSequenceRpcUrlFromSlug("arbitrum"),
-    [base.id]: getSequenceRpcUrlFromSlug("base"),
-    [mainnet.id]: getSequenceRpcUrlFromSlug("mainnet"),
-    [optimism.id]: getSequenceRpcUrlFromSlug("optimism"),
-    [gnosis.id]: getSequenceRpcUrlFromSlug("gnosis"),
-    [polygon.id]: getSequenceRpcUrlFromSlug("polygon"),
-    [soneium.id]: getSequenceRpcUrlFromSlug("soneium"),
-    [somnia.id]: getSequenceRpcUrlFromSlug("somnia"),
-    [xai.id]: getSequenceRpcUrlFromSlug("xai"),
-    [apeChain.id]: getSequenceRpcUrlFromSlug("apechain"),
-    [arbitrumNova.id]: getSequenceRpcUrlFromSlug("arbitrum-nova"),
-    [avalanche.id]: getSequenceRpcUrlFromSlug("avalanche"),
-    [b3.id]: getSequenceRpcUrlFromSlug("b3"),
-    [blast.id]: getSequenceRpcUrlFromSlug("blast"),
-    [bsc.id]: getSequenceRpcUrlFromSlug("bsc"),
-    [katana.id]: getSequenceRpcUrlFromSlug("katana"),
-    [etherlink.id]: getSequenceRpcUrlFromSlug("etherlink"),
+    [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,
+    ),
   }
 }
 
 export const getRpcUrl = (
   chainId: number,
-  sequenceProjectAccessKey: string = getSequenceProjectAccessKey(),
+  sequenceProjectAccessKey: string,
+  sequenceNodeGatewayUrl: string,
 ): string | null => {
-  const sequenceRpcUrls = getSequenceRpcUrls()
+  const sequenceRpcUrls = getSequenceRpcUrls(sequenceNodeGatewayUrl)
   if (!sequenceRpcUrls[chainId]) {
     return null
   }
   return `${sequenceRpcUrls[chainId]}/${sequenceProjectAccessKey}`
 }
 
+/**
+ * Get HTTP transport 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 get the transport for
+ * @returns Viem HTTP transport configured with Sequence RPC URL if available
+ */
+export function getHttpTransport(chainId: number) {
+  const config = getConfig()
+  const trailsApiKey = config.trailsApiKey
+  const sequenceNodeGatewayUrl = config.sequenceNodeGatewayUrl
+
+  if (trailsApiKey && sequenceNodeGatewayUrl) {
+    const rpcUrl = getRpcUrl(chainId, trailsApiKey, sequenceNodeGatewayUrl)
+    if (rpcUrl) {
+      return http(rpcUrl)
+    }
+  }
+
+  // Fallback to default http() if Sequence RPC URL is not available
+  return http()
+}
+
+/**
+ * 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 chain - The chain to create the public client for
+ * @returns Viem PublicClient configured with Sequence RPC URL if available
+ */
+export function getPublicRpcClient(chain: Chain): PublicClient {
+  return createPublicClient({
+    chain,
+    transport: getHttpTransport(chain.id),
+  })
+}
+
 export const supportedSequenceChains: Record<number, Chain> = {
   [apeChain.id]: getChainInfo(apeChain.id)!,
   [arbitrum.id]: getChainInfo(arbitrum.id)!,
@@ -186,15 +243,28 @@ export const mainnetChainsToTestnetChains: Record<number, Chain> = {
 // Helper to get chain info
 export function getChainInfo(
   chainId?: number,
-  options?: { usePublicRpc?: boolean },
+  options?: {
+    usePublicRpc?: boolean
+    sequenceProjectAccessKey?: string
+    sequenceNodeGatewayUrl?: string
+  },
 ): Chain | null {
   if (!chainId) return null
   const chainInfo =
     getAllChains().find((chain: Chain) => chain.id === chainId) || null
 
   // Use Sequence RPC by default. We'll want to use public RPC when adding chains to user's metamask wallet.
-  if (chainInfo && !options?.usePublicRpc) {
-    const rpcUrl = getRpcUrl(chainId)
+  if (
+    chainInfo &&
+    !options?.usePublicRpc &&
+    options?.sequenceProjectAccessKey &&
+    options?.sequenceNodeGatewayUrl
+  ) {
+    const rpcUrl = getRpcUrl(
+      chainId,
+      options.sequenceProjectAccessKey,
+      options.sequenceNodeGatewayUrl,
+    )
     if (rpcUrl) {
       chainInfo.rpcUrls = {
         default: {
@@ -247,30 +317,67 @@ export async function getSupportedSequenceChains(): Promise<Chain[]> {
   return Object.values(supportedSequenceChains)
 }
 
-export async function getSupportedSequenceTestnetChains(): Promise<Chain[]> {
-  return Object.values(supportedSequenceTestnetChains)
+// Chain order for sorting (in the desired display order)
+const CHAIN_ORDER = [
+  1, // Ethereum
+  8453, // Base
+  42161, // Arbitrum
+  137, // Polygon
+  747474, // Katana
+  56, // BNB Smart Chain
+  10, // Optimism
+  43114, // Avalanche
+  42170, // Arbitrum Nova
+  42793, // Etherlink
+  100, // Gnosis
+  8333, // B3
+  33139, // Ape Chain
+  1868, // Soneium
+  5031, // Somnia
+  660279, // Xai
+]
+
+// Mapping of chain ID to normalized display name
+const CHAIN_NAME_MAP: Record<number, string> = {
+  [arbitrum.id]: "Arbitrum", // Rename from "Arbitrum One"
+  [optimism.id]: "Optimism", // Rename from "OP Mainnet"
+  [soneium.id]: "Soneium", // Rename from "Soneium Mainnet"
+  [xai.id]: "Xai", // Rename from "Xai Mainnet"
 }
 
-// Priority chains that should appear first in the list
-const PRIORITY_CHAIN_IDS = [1, 8453, 42161, 10, 137]
+/**
+ * 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 {
+  return CHAIN_NAME_MAP[chainId] || originalName
+}
 
-// Sort function for chains with priority order and then by name
-function sortChains(chainList: Chain[]): Chain[] {
+/**
+ * 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, b) => {
-    // 1. Priority chains first (1, 8453, 42161, 10, 137)
-    const aPriority = PRIORITY_CHAIN_IDS.indexOf(a.id)
-    const bPriority = PRIORITY_CHAIN_IDS.indexOf(b.id)
+    const aIndex = CHAIN_ORDER.indexOf(a.id)
+    const bIndex = CHAIN_ORDER.indexOf(b.id)
 
-    // If both are priority chains, sort by priority order
-    if (aPriority !== -1 && bPriority !== -1) {
-      return aPriority - bPriority
+    // If both chains are in the order, sort by their position
+    if (aIndex !== -1 && bIndex !== -1) {
+      return aIndex - bIndex
     }
 
-    // If only one is a priority chain, prioritize it
-    if (aPriority !== -1) return -1
-    if (bPriority !== -1) return 1
+    // If only one chain is in the order, prioritize it
+    if (aIndex !== -1) return -1
+    if (bIndex !== -1) return 1
 
-    // 2. Sort by chain name alphabetically
+    // If neither chain is in the order, sort alphabetically
     return a.name.localeCompare(b.name)
   })
 }
@@ -312,10 +419,8 @@ export async function getSupportedChains({
     (chain, index, self) => index === self.findIndex((c) => c.id === chain.id),
   )
 
-  const sortedChains = sortChains(uniqueChains)
-
-  // Sort chains by priority and then by name
-  return sortedChains
+  // Sort chains by predefined order
+  return sortChainsByOrder(uniqueChains)
 }
 
 export function useSupportedChains({
@@ -345,21 +450,3 @@ export function getIsTestnetChainId(chainId: number): boolean {
   const testnetChainIds = Object.keys(supportedSequenceTestnetChains)
   return testnetChainIds.includes(chainId.toString())
 }
-
-// Get chain color for UI styling
-export function getChainColor(chainId: number): string {
-  switch (chainId) {
-    case 1:
-      return "bg-gray-100 text-gray-800 dark:bg-gray-700 dark:text-gray-200" // More gray-blue for Ethereum
-    case 8453:
-      return "bg-blue-100 text-blue-800 dark:bg-blue-900 dark:text-blue-200" // Blue for Base
-    case 42161:
-      return "bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-200"
-    case 137:
-      return "bg-purple-100 text-purple-800 dark:bg-purple-900 dark:text-purple-200"
-    case 10:
-      return "bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-200"
-    default:
-      return "bg-gray-100 text-gray-800 dark:bg-gray-700 dark:text-gray-200"
-  }
-}

package/src/config.ts

@@ -1,130 +1,57 @@
 import {
   PROD_SEQUENCE_INDEXER_URL,
+  PROD_SEQUENCE_METADATA_URL,
   DEFAULT_WALLETCONNECT_PROJECT_ID,
   DEFAULT_SLIPPAGE_TOLERANCE,
-  PROD_SEQUENCE_PROJECT_ACCESS_KEY,
-  DEV_SEQUENCE_INDEXER_URL,
-  DEV_TRAILS_API_URL,
-  DEV_SEQUENCE_PROJECT_ACCESS_KEY,
-  DEFAULT_SEQUENCE_ENV,
   PROD_SEQUENCE_NODE_GATEWAY_URL,
-  DEV_SEQUENCE_NODE_GATEWAY_URL,
   PROD_TRAILS_API_URL,
-  LOCAL_TRAILS_API_URL,
 } from "./constants.js"
 import { getQueryParam } from "./queryParams.js"
 import { logger } from "./logger.js"
 
-export type SequenceEnv = "prod" | "dev" | "local" | "cors-anywhere"
-
-export const globalConfig: {
-  sequenceProjectAccessKey: string
-  sequenceIndexerUrl: string
-  sequenceNodeGatewayUrl: string
-  trailsApiUrl: string
-  sequenceEnv: SequenceEnv
-  walletConnectProjectId: string
-  slippageTolerance: string
-  debug: boolean
-  commitHash: string | undefined
-} = {
-  commitHash: declareCommitHash(),
-  sequenceEnv: declareSequenceEnv(),
-  sequenceProjectAccessKey: declareSequenceProjectAccessKey(),
-  sequenceIndexerUrl: declareSequenceIndexerUrl(),
-  sequenceNodeGatewayUrl: declareSequenceNodeGatewayUrl(),
-  trailsApiUrl: declareTrailsApiUrl(),
+export interface TrailsConfig {
+  trailsApiKey: string
+  trailsApiUrl?: string
+  sequenceIndexerUrl?: string
+  sequenceNodeGatewayUrl?: string
+  sequenceMetadataUrl?: string
+  walletConnectProjectId?: string
+  slippageTolerance?: string
+  debug?: boolean
+  commitHash?: string
+}
+
+const globalConfig: TrailsConfig = {
+  trailsApiKey: "",
+  sequenceIndexerUrl: PROD_SEQUENCE_INDEXER_URL,
+  sequenceNodeGatewayUrl: PROD_SEQUENCE_NODE_GATEWAY_URL,
+  sequenceMetadataUrl: PROD_SEQUENCE_METADATA_URL,
+  trailsApiUrl: PROD_TRAILS_API_URL,
   walletConnectProjectId: DEFAULT_WALLETCONNECT_PROJECT_ID,
   slippageTolerance: DEFAULT_SLIPPAGE_TOLERANCE,
   debug: false,
+  commitHash: declareCommitHash(),
 }
 
-export function declareSequenceEnv(): SequenceEnv {
-  // Check for Vite development environment with HMR
-  if (typeof window !== "undefined" && (import.meta as any)?.hot) {
-    return "local"
-  }
-
-  // Check explicit ENV variable first
-  const explicitEnv = getEnvVar("ENV")
-  if (explicitEnv === "local") {
-    return "local"
-  }
-  if (explicitEnv === "development" || explicitEnv === "dev") {
-    return "dev"
-  }
-  if (explicitEnv === "production" || explicitEnv === "prod") {
-    return "prod"
-  }
-
-  // Special handling for Cloudflare Pages branches
-  const cfPagesBranch = getEnvVar("CF_PAGES_BRANCH")
-  if (cfPagesBranch) {
-    // If running on Cloudflare Pages, all branches except "production" default to dev
-    if (cfPagesBranch === "prod" || cfPagesBranch === "production") {
-      return "prod"
-    }
-    // Preview mode and other branches default to dev
-    return "dev"
-  }
-
-  // If we're in a browser/Cloudflare environment but no explicit env is set,
-  // check if we have dev environment variables set (indicating non-prod)
-  // This helps with Cloudflare Workers preview mode
-  if (typeof window !== "undefined" || typeof process === "undefined") {
-    // In browser/Cloudflare Workers context, if no explicit prod indicators,
-    // default to dev for safety (unless explicitly set to prod)
-    // This prevents accidental prod usage in preview/staging environments
-    return "dev"
-  }
-
-  return DEFAULT_SEQUENCE_ENV
-}
-
-export function declareSequenceIndexerUrl() {
-  if (declareSequenceEnv() === "prod") {
-    return PROD_SEQUENCE_INDEXER_URL
-  }
-  return DEV_SEQUENCE_INDEXER_URL
-}
-
-export function declareTrailsApiUrl() {
-  if (declareSequenceEnv() === "prod") {
-    return PROD_TRAILS_API_URL
-  }
-  if (declareSequenceEnv() === "local") {
-    return LOCAL_TRAILS_API_URL
-  }
-  return DEV_TRAILS_API_URL
-}
-
-export function declareSequenceNodeGatewayUrl() {
-  if (declareSequenceEnv() === "prod") {
-    return PROD_SEQUENCE_NODE_GATEWAY_URL
-  }
-  return DEV_SEQUENCE_NODE_GATEWAY_URL
+/**
+ * Updates the global config with new values
+ * This is a temporary solution to sync config from TrailsProvider
+ */
+export function updateGlobalConfig(updates: Partial<TrailsConfig>) {
+  Object.assign(globalConfig, updates)
 }
 
-export function declareSequenceProjectAccessKey() {
-  // Check for explicit env var override first (works in all environments)
-  const envVarKey =
-    getEnvVar("SEQUENCE_PROJECT_ACCESS_KEY") ||
-    getEnvVar("PROJECT_ACCESS_KEY") ||
-    getEnvVar("VITE_SEQUENCE_PROJECT_ACCESS_KEY") ||
-    getEnvVar("VITE_PROJECT_ACCESS_KEY")
-  if (envVarKey) {
-    return envVarKey
-  }
-
-  // Use dev/prod keys based on environment
-  const sequenceEnv = declareSequenceEnv()
-  if (sequenceEnv === "prod") {
-    return PROD_SEQUENCE_PROJECT_ACCESS_KEY
-  }
-
-  return DEV_SEQUENCE_PROJECT_ACCESS_KEY
+// DEPRECATED: Use TrailsProvider context instead
+// This is kept only for backward compatibility during migration
+export function getConfig<T extends keyof TrailsConfig | undefined = undefined>(
+  propName?: T,
+): T extends undefined ? Readonly<TrailsConfig> : TrailsConfig[NonNullable<T>] {
+  // console.warn(
+  //   "[trails-sdk] getConfig is deprecated. Use TrailsProvider context with useTrails() hook instead.",
+  //   propName,
+  // )
+  return (propName ? globalConfig[propName] : globalConfig) as any
 }
-
 export function declareCommitHash() {
   const cfPagesCommitHash = getEnvVar("CF_PAGES_COMMIT_SHA")
   const viteCommitHash = getEnvVar("VITE_COMMIT_SHA")
@@ -141,121 +68,38 @@ export function declareCommitHash() {
   return cfPagesCommitHash || viteCommitHash
 }
 
-export function getSequenceConfig() {
-  return globalConfig
-}
-
-export function getSequenceProjectAccessKey() {
-  return globalConfig.sequenceProjectAccessKey
-}
-
-export function setSequenceProjectAccessKey(sequenceProjectAccessKey: string) {
-  globalConfig.sequenceProjectAccessKey = sequenceProjectAccessKey
-}
-
-export function setSequenceIndexerUrl(sequenceIndexerUrl: string) {
-  globalConfig.sequenceIndexerUrl = sequenceIndexerUrl
-}
-
-export function getSequenceIndexerUrl() {
-  return globalConfig.sequenceIndexerUrl
-}
-
-export function setSequenceNodeGatewayUrl(sequenceNodeGatewayUrl: string) {
-  globalConfig.sequenceNodeGatewayUrl = sequenceNodeGatewayUrl
-}
-
-export function getSequenceNodeGatewayUrl() {
-  return globalConfig.sequenceNodeGatewayUrl
-}
-
-export function setTrailsApiUrl(trailsApiUrl: string) {
-  globalConfig.trailsApiUrl = trailsApiUrl
-}
-
-export function getTrailsApiUrl() {
-  return globalConfig.trailsApiUrl
-}
-
-export function setSequenceEnv(sequenceEnv: SequenceEnv) {
-  globalConfig.sequenceEnv = sequenceEnv
-
-  if (sequenceEnv === "prod") {
-    setSequenceIndexerUrl(PROD_SEQUENCE_INDEXER_URL)
-    setTrailsApiUrl(PROD_TRAILS_API_URL)
-    setSequenceNodeGatewayUrl(PROD_SEQUENCE_NODE_GATEWAY_URL)
-    setSequenceProjectAccessKey(PROD_SEQUENCE_PROJECT_ACCESS_KEY)
-  }
-
-  if (sequenceEnv === "local") {
-    if (getEnvVar("TRAILS_API_URL")) {
-      setTrailsApiUrl(getEnvVar("TRAILS_API_URL"))
-    }
-  }
-
-  if (sequenceEnv === "dev") {
-    setSequenceIndexerUrl(DEV_SEQUENCE_INDEXER_URL)
-    setTrailsApiUrl(DEV_TRAILS_API_URL)
-    setSequenceNodeGatewayUrl(DEV_SEQUENCE_NODE_GATEWAY_URL)
-    setSequenceProjectAccessKey(DEV_SEQUENCE_PROJECT_ACCESS_KEY)
-  }
-}
-
-export function getSequenceEnv() {
-  return globalConfig.sequenceEnv
-}
-
-export function setWalletConnectProjectId(walletConnectProjectId: string) {
-  globalConfig.walletConnectProjectId = walletConnectProjectId
-}
-
-export function getWalletConnectProjectId() {
-  return globalConfig.walletConnectProjectId
-}
-
-/**
- * Set slippage tolerance for swaps
- * @param slippageTolerance - Slippage tolerance as decimal string (e.g., "0.05" for 5%, "0.001" for 0.1%)
- */
-export function setSlippageTolerance(slippageTolerance: string) {
-  globalConfig.slippageTolerance = slippageTolerance
-}
+// DEPRECATED: These getter functions are kept for backward compatibility
+// New code should use TrailsProvider context with useTrails() hook
 
 /**
- * Get current slippage tolerance
- * @returns Slippage tolerance as decimal string (e.g., "0.05" for 5%, "0.001" for 0.1%)
+ * @deprecated Use TrailsProvider context instead
  */
 export function getSlippageTolerance() {
   return globalConfig.slippageTolerance
 }
 
-export function setDebug(debug: boolean) {
-  globalConfig.debug = debug
-}
-
+/**
+ * @deprecated Use TrailsProvider context instead
+ */
 export function getDebug() {
   return globalConfig.debug || getQueryParam("debug") === "true"
 }
 
-export function setCommitHash(commitHash: string) {
-  globalConfig.commitHash = commitHash
-  logger.console.log(
-    `[trails-sdk][config] commit hash manually set to: ${commitHash}`,
-  )
+/**
+ * Sets the global debug mode for backward compatibility with getDebug()
+ * This is called by TrailsProvider to sync the debug state
+ */
+export function setGlobalDebug(debug: boolean) {
+  globalConfig.debug = debug
 }
 
+/**
+ * @deprecated Use TrailsProvider context instead
+ */
 export function getCommitHash() {
   return globalConfig.commitHash
 }
 
-export function getAccountIntentTransactionHistory() {
-  return FeatureFlags.accountIntentTransactionHistory
-}
-
-export const FeatureFlags = {
-  accountIntentTransactionHistory: false,
-}
-
 export function getEnvVar(name: string) {
   // In Vite/browser environments, check import.meta.env first
   // This is where Vite injects environment variables at build time

package/src/constants.ts

@@ -27,22 +27,10 @@ export const TRAILS_INTENT_ENTRYPOINT_ADDRESS: Address.Address =
 export const ATTESATION_SIGNER_ADDRESS: Address.Address =
   "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
 
-export const DEFAULT_SEQUENCE_ENV = "prod"
-
 export const PROD_SEQUENCE_NODE_GATEWAY_URL = "https://nodes.sequence.app"
 export const PROD_SEQUENCE_INDEXER_URL = "https://indexer.sequence.app"
+export const PROD_SEQUENCE_METADATA_URL = "https://metadata.sequence.app"
 export const PROD_TRAILS_API_URL = "https://trails-api.sequence.app"
-export const DEV_SEQUENCE_NODE_GATEWAY_URL = "https://dev-nodes.sequence.app"
-export const DEV_SEQUENCE_INDEXER_URL = "https://dev-indexer.sequence.app"
-export const DEV_TRAILS_API_URL = "https://dev-trails-api.sequence-dev.app"
-
-export const LOCAL_TRAILS_API_URL = "http://localhost:4422"
-
-// This is used for Sequence Indexer and API
-export const PROD_SEQUENCE_PROJECT_ACCESS_KEY =
-  "AQAAAAAAAKhGHJc3N5V2AWqfJ1v9xZ2u0nA"
-export const DEV_SEQUENCE_PROJECT_ACCESS_KEY =
-  "AQAAAAAAAAaq1E41OU0QxifQgrVBMgfqg7k"
 
 export const DATABEAT_SERVER = "https://databeat.sequence.app"
 export const DATABEAT_KEY =

package/src/contractUtils.ts

@@ -1,12 +1,12 @@
-import { createPublicClient, http } from "viem"
-import { getChainInfo } from "./chains.js"
+import { getChainInfo, getPublicRpcClient } from "./chains.js"
 import { logger } from "./logger.js"
 
 export async function getIsContract(address: `0x${string}`, chainId: number) {
-  const client = createPublicClient({
-    chain: getChainInfo(chainId)!,
-    transport: http(),
-  })
+  const chainInfo = getChainInfo(chainId)
+  if (!chainInfo) {
+    throw new Error(`Chain ${chainId} not found`)
+  }
+  const client = getPublicRpcClient(chainInfo)
 
   const code = await client.getCode({ address })
   const isNonZero = isNonZeroHexString(code)

package/src/estimate.ts

@@ -1,5 +1,5 @@
-import { type PublicClient, formatUnits, createPublicClient, http } from "viem"
-import { getChainInfo } from "./chains.js"
+import { type PublicClient, formatUnits } from "viem"
+import { getChainInfo, getPublicRpcClient } from "./chains.js"
 import { logger } from "./logger.js"
 
 // Default minimum gas limit for deposit transactions
@@ -360,10 +360,7 @@ export async function getDefaultGasCostEstimate(
       try {
         const chain = getChainInfo(chainId)
         if (chain) {
-          const publicClient = createPublicClient({
-            chain,
-            transport: http(),
-          })
+          const publicClient = getPublicRpcClient(chain)
 
           // Try to estimate gas if we have transaction details
           let gasLimit = DEFAULT_MIN_GASLIMIT