0xtrails 0.4.2 → 0.5.0

package/src/chains.ts

@@ -35,10 +35,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,38 +85,62 @@ 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
   }
@@ -186,15 +206,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: {

package/src/config.ts

@@ -3,128 +3,45 @@ import {
   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
+  walletConnectProjectId?: string
+  slippageTolerance?: string
+  debug?: boolean
+  commitHash?: string
+}
+
+const globalConfig: TrailsConfig = {
+  trailsApiKey: PROD_SEQUENCE_PROJECT_ACCESS_KEY,
+  sequenceIndexerUrl: PROD_SEQUENCE_INDEXER_URL,
+  sequenceNodeGatewayUrl: PROD_SEQUENCE_NODE_GATEWAY_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
-}
-
-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 +58,30 @@ 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}`,
-  )
-}
-
+/**
+ * @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,13 @@ 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_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/index.ts

@@ -12,15 +12,8 @@ export {
   getAllChains,
   type Chain,
 } from "./chains.js"
-export {
-  getIndexerGatewayClient,
-  useIndexerGatewayClient,
-} from "./indexerClient.js"
-export type {
-  OriginCallParams,
-  QuoteProvider,
-  TrailsFee,
-} from "./intents.js"
+export { useIndexerGatewayClient } from "./indexerClient.js"
+export type { OriginCallParams, QuoteProvider, TrailsFee } from "./intents.js"
 export {
   calculateIntentAddress,
   calculateOriginAndDestinationIntentAddresses,
@@ -38,11 +31,7 @@ export {
   type OnDestinationTransactionFound,
   type OnReceiptUpdate,
 } from "./intentReceiptPoller.js"
-export {
-  prepareSend,
-  useQuote,
-  TradeType,
-} from "./prepareSend.js"
+export { prepareSend, useQuote, TradeType } from "./prepareSend.js"
 export type {
   UseQuoteReturn,
   UseQuoteProps,
@@ -88,35 +77,23 @@ export {
 } from "./tokens.js"
 export type { SupportedToken } from "./tokens.js"
 export { getTxTimeDiff } from "./transactions.js"
-export { useTrails } from "./trails.js"
-export type { WagmiAccount } from "./trails.js"
-export {
-  useCommitIntent,
-  useExecuteIntent,
-} from "./mutations.js"
+export { useCommitIntent, useExecuteIntent } from "./mutations.js"
 export type { Mode } from "./mode.js"
 export { TRAILS_ROUTER_PLACEHOLDER_AMOUNT } from "./trailsRouter.js"
 export { getERC20TransferData } from "./encoders.js"
+// Config functions - getters are deprecated, use TrailsProvider context instead
 export {
-  declareSequenceEnv,
-  getSequenceProjectAccessKey,
-  getTrailsApiUrl,
-  getSequenceIndexerUrl,
-  getSequenceEnv,
-  setSequenceProjectAccessKey,
-  setTrailsApiUrl,
-  setSequenceIndexerUrl,
-  setSequenceNodeGatewayUrl,
-  getSequenceNodeGatewayUrl,
-  setSequenceEnv,
-  setWalletConnectProjectId,
-  getWalletConnectProjectId,
-  setSlippageTolerance,
+  getConfig,
   getSlippageTolerance,
-  setDebug,
   getDebug,
+  getCommitHash,
 } from "./config.js"
 export * from "./widget/index.js"
+export { TrailsProvider } from "./widget/providers/TrailsProvider.js"
+export type {
+  TrailsConfig,
+  SequenceEnv,
+} from "./widget/providers/TrailsProvider.js"
 export { logger, getMinLogLevel } from "./logger.js"
 export {
   getTrailsClient,

package/src/indexerClient.ts

@@ -1,11 +1,3 @@
-import { useConfig } from "@0xsequence/hooks"
-import { SequenceIndexerGateway } from "@0xsequence/indexer"
-import { useMemo } from "react"
-import {
-  getSequenceIndexerUrl,
-  getSequenceProjectAccessKey,
-  getSequenceEnv,
-} from "./config.js"
 import {
   arbitrum,
   base,
@@ -34,24 +26,53 @@ export type IndexerGatewayConfig = {
 
 /**
  * Get the indexer URL for a specific chain slug
- * Dynamically determines the environment prefix
+ * Dynamically determines the environment prefix by parsing the base indexer URL
+ * @param chainSlug - The chain slug (e.g., "arbitrum", "base")
+ * @param baseIndexerUrl - Optional base indexer URL. If not provided, uses getConfig("sequenceIndexerUrl")
+ * @returns The chain-specific indexer URL with appropriate environment prefix
  */
-export function getIndexerUrlFromChainSlug(chainSlug: string): string {
-  const env = getSequenceEnv()
-  let envPrefix = ""
+export function getIndexerUrlFromChainSlug(
+  chainSlug: string,
+  baseIndexerUrl: string,
+): string {
+  // Parse the URL to detect if it's a dev environment
+  // Check if the URL contains "dev" (e.g., "dev-indexer.sequence.app")
+  const isDev = baseIndexerUrl?.includes("dev")
+
+  // Extract the domain from the URL
+  // e.g., "https://indexer.sequence.app" -> "indexer.sequence.app"
+  // or "https://dev-indexer.sequence.app" -> "dev-indexer.sequence.app"
+  const urlObj = new URL(baseIndexerUrl)
+  const hostname = urlObj.hostname
 
-  if (env === "dev") {
-    envPrefix = "dev-"
+  // Construct the chain-specific indexer URL
+  // If dev environment: "dev-indexer.sequence.app" -> "dev-{chainSlug}-indexer.sequence.app"
+  // If prod environment: "indexer.sequence.app" -> "{chainSlug}-indexer.sequence.app"
+  let chainHostname: string
+  if (isDev) {
+    // Replace "dev-indexer" with "dev-{chainSlug}-indexer"
+    chainHostname = hostname.replace(
+      /^dev-indexer\./,
+      `dev-${chainSlug}-indexer.`,
+    )
+  } else {
+    // Replace "indexer" with "{chainSlug}-indexer"
+    chainHostname = hostname.replace(/^indexer\./, `${chainSlug}-indexer.`)
   }
 
-  return `https://${envPrefix}${chainSlug}-indexer.sequence.app`
+  return `${urlObj.protocol}//${chainHostname}`
 }
 
 /**
  * Get the chain-specific indexer URL by chain ID
  * Returns the appropriate indexer URL based on the current environment
+ * @param chainId - The chain ID
+ * @param baseIndexerUrl - Optional base indexer URL. If not provided, uses getConfig("sequenceIndexerUrl")
  */
-export function getChainIndexerUrl(chainId: number): string | undefined {
+export function getChainIndexerUrl(
+  chainId: number,
+  baseIndexerUrl: string,
+): string | undefined {
   const chainIdToSlug: Record<number, string> = {
     [arbitrum.id]: "arbitrum",
     [base.id]: "base",
@@ -78,37 +99,7 @@ export function getChainIndexerUrl(chainId: number): string | undefined {
     return undefined
   }
 
-  return getIndexerUrlFromChainSlug(chainSlug)
-}
-
-export function getIndexerGatewayClient({
-  indexerGatewayUrl = getSequenceIndexerUrl(),
-  projectAccessKey = getSequenceProjectAccessKey(),
-  jwt,
-}: IndexerGatewayConfig): SequenceIndexerGateway {
-  return new SequenceIndexerGateway(
-    indexerGatewayUrl as string,
-    projectAccessKey,
-    jwt,
-  )
+  return getIndexerUrlFromChainSlug(chainSlug, baseIndexerUrl)
 }
 
-export const useIndexerGatewayClient = (config?: IndexerGatewayConfig) => {
-  const { projectAccessKey, jwt, env } = useConfig()
-
-  const indexerGatewayClient = useMemo(() => {
-    return getIndexerGatewayClient({
-      indexerGatewayUrl:
-        getSequenceIndexerUrl() ??
-        config?.indexerGatewayUrl ??
-        env.indexerGatewayUrl,
-      projectAccessKey:
-        config?.projectAccessKey ??
-        getSequenceProjectAccessKey() ??
-        projectAccessKey,
-      jwt: config?.jwt ?? jwt,
-    })
-  }, [projectAccessKey, jwt, env.indexerGatewayUrl, config])
-
-  return indexerGatewayClient
-}
+export { useIndexerGatewayClient } from "@0xsequence/hooks"

package/src/intents.ts

@@ -52,7 +52,6 @@ import {
   trackIntentCommitCompleted,
   trackIntentCommitError,
 } from "./analytics.js"
-import { getQueryParam } from "./queryParams.js"
 import { getFullErrorMessage } from "./error.js"
 import { GAS_BUFFER, getFeeData } from "./estimate.js"
 import { getERC20TransferData } from "./encoders.js"
@@ -135,27 +134,11 @@ export type SendOriginCallTxArgs = {
   maxPriorityFeePerGas?: bigint // Optional: EIP-1559 max priority fee per gas
 }
 
-export async function getLocalClientIfEnabled(
-  trailsClient: TrailsApi,
-): Promise<TrailsApi> {
-  const localApiIntent = getQueryParam("localapiintent") === "true"
-  if (localApiIntent) {
-    // for testing local api changes
-    const { getTrailsClient } = await import("./trailsClient.js")
-    trailsClient = getTrailsClient({
-      hostname: "http://localhost:4422",
-    })
-  }
-  return trailsClient
-}
-
 export async function quoteIntent(
   trailsClient: TrailsApi,
   args: QuoteIntentRequest,
   additionalTrackingProps: Record<string, string> = {},
 ): Promise<{ intent: Intent; gasFeeOptions?: GasFeeOptions }> {
-  trailsClient = await getLocalClientIfEnabled(trailsClient)
-
   // Track intent quote request
   trackIntentQuoteRequested({
     originChainId: args.originChainId || 0,
@@ -351,8 +334,6 @@ export async function commitIntent(
   intent: Intent,
   additionalTrackingProps: Record<string, string> = {},
 ): Promise<CommitIntentResponse> {
-  trailsClient = await getLocalClientIfEnabled(trailsClient)
-
   logger.console.log("[trails-sdk] commitIntent inputs:", {
     intentId: intent.intentId,
     ownerAddress: intent.ownerAddress,
@@ -461,8 +442,6 @@ export async function executeIntent(
   depositTransactionHash?: string,
   depositSignature?: DepositSignature,
 ) {
-  trailsClient = await getLocalClientIfEnabled(trailsClient)
-
   logger.console.log("[trails-sdk] executeIntent inputs:", {
     intentId,
     depositTransactionHash,