0xtrails/src/config.ts

SDK for Trails

import {
  PROD_SEQUENCE_INDEXER_URL,
  PROD_SEQUENCE_API_URL,
  DEFAULT_WALLETCONNECT_PROJECT_ID,
  DEFAULT_SLIPPAGE_TOLERANCE,
  PROD_SEQUENCE_PROJECT_ACCESS_KEY,
  DEV_SEQUENCE_INDEXER_URL,
  DEV_SEQUENCE_API_URL,
  DEV_SEQUENCE_PROJECT_ACCESS_KEY,
  DEFAULT_SEQUENCE_ENV,
  PROD_SEQUENCE_NODE_GATEWAY_URL,
  DEV_SEQUENCE_NODE_GATEWAY_URL,
} from "./constants.js"
import { getQueryParam } from "./queryParams.js"

type SequenceEnv = "prod" | "dev" | "local" | "cors-anywhere"

export const globalConfig: {
  sequenceProjectAccessKey: string
  sequenceIndexerUrl: string
  sequenceNodeGatewayUrl: string
  sequenceApiUrl: string
  sequenceEnv: SequenceEnv
  walletConnectProjectId: string
  slippageTolerance: string
  debug: boolean
  commitHash: string | undefined
} = {
  commitHash: declareCommitHash(),
  sequenceProjectAccessKey: declareSequenceProjectAccessKey(),
  sequenceIndexerUrl: declareSequenceIndexerUrl(),
  sequenceNodeGatewayUrl: declareSequenceNodeGatewayUrl(),
  sequenceApiUrl: declareSequenceApiUrl(),
  sequenceEnv: declareSequenceEnv(),
  walletConnectProjectId: DEFAULT_WALLETCONNECT_PROJECT_ID,
  slippageTolerance: DEFAULT_SLIPPAGE_TOLERANCE,
  debug: false,
}

export function declareSequenceEnv(): SequenceEnv {
  // Check for Vite development environment with HMR
  if (typeof window !== "undefined" && (import.meta as any)?.hot) {
    return "local"
  }
  if (typeof process !== "undefined") {
    if (getEnvVar("ENV") === "local") {
      return "local"
    }
    if (getEnvVar("ENV") === "development" || getEnvVar("ENV") === "dev") {
      return "dev"
    }
    if (
      getEnvVar("CF_PAGES_BRANCH") === "master" ||
      getEnvVar("CF_PAGES_BRANCH") === "main" ||
      getEnvVar("ENV") === "production" ||
      getEnvVar("ENV") === "prod"
    ) {
      return "prod"
    }
  }

  return DEFAULT_SEQUENCE_ENV
}

export function declareSequenceIndexerUrl() {
  if (declareSequenceEnv() === "prod") {
    return PROD_SEQUENCE_INDEXER_URL
  }
  return DEV_SEQUENCE_INDEXER_URL
}

export function declareSequenceApiUrl() {
  if (declareSequenceEnv() === "prod") {
    return PROD_SEQUENCE_API_URL
  }
  if (declareSequenceEnv() === "local") {
    return getEnvVar("TEST_API_URL") || DEV_SEQUENCE_API_URL
  }
  return DEV_SEQUENCE_API_URL
}

export function declareSequenceNodeGatewayUrl() {
  if (declareSequenceEnv() === "prod") {
    return PROD_SEQUENCE_NODE_GATEWAY_URL
  }
  return DEV_SEQUENCE_NODE_GATEWAY_URL
}

export function declareSequenceProjectAccessKey() {
  if (declareSequenceEnv() === "prod") {
    return PROD_SEQUENCE_PROJECT_ACCESS_KEY
  }
  return DEV_SEQUENCE_PROJECT_ACCESS_KEY
}

export function declareCommitHash() {
  const cfPagesCommitHash = getEnvVar("CF_PAGES_COMMIT_SHA")
  const viteCommitHash = getEnvVar("VITE_COMMIT_SHA")
  if (cfPagesCommitHash) {
    console.log(`Commit hash from CF_PAGES_COMMIT_SHA: ${cfPagesCommitHash}`)
  }
  if (viteCommitHash) {
    console.log(`Commit hash from VITE_COMMIT_SHA: ${viteCommitHash}`)
  }
  return cfPagesCommitHash || viteCommitHash
}

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 setSequenceApiUrl(sequenceApiUrl: string) {
  globalConfig.sequenceApiUrl = sequenceApiUrl
}

export function getSequenceApiUrl() {
  return globalConfig.sequenceApiUrl
}

export function setSequenceEnv(sequenceEnv: SequenceEnv) {
  globalConfig.sequenceEnv = sequenceEnv

  if (sequenceEnv === "prod") {
    setSequenceIndexerUrl(PROD_SEQUENCE_INDEXER_URL)
    setSequenceApiUrl(PROD_SEQUENCE_API_URL)
    setSequenceNodeGatewayUrl(PROD_SEQUENCE_NODE_GATEWAY_URL)
  }

  if (sequenceEnv === "local") {
    if (getEnvVar("API_URL")) {
      setSequenceApiUrl(getEnvVar("API_URL"))
    }
  }

  if (sequenceEnv === "dev") {
    setSequenceIndexerUrl(DEV_SEQUENCE_INDEXER_URL)
    setSequenceApiUrl(DEV_SEQUENCE_API_URL)
    setSequenceNodeGatewayUrl(DEV_SEQUENCE_NODE_GATEWAY_URL)
  }
}

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
}

/**
 * Get current slippage tolerance
 * @returns Slippage tolerance as decimal string (e.g., "0.05" for 5%, "0.001" for 0.1%)
 */
export function getSlippageTolerance() {
  return globalConfig.slippageTolerance
}

export function setDebug(debug: boolean) {
  globalConfig.debug = debug
}

export function getDebug() {
  return globalConfig.debug || getQueryParam("debug") === "true"
}

export function setCommitHash(commitHash: string) {
  globalConfig.commitHash = commitHash
  console.log(`Commit hash manually set to: ${commitHash}`)
}

export function getCommitHash() {
  return globalConfig.commitHash
}

export function getAccountIntentTransactionHistory() {
  return FeatureFlags.accountIntentTransactionHistory
}

export function getSameChainSwapDifferentIntentAddresses() {
  return FeatureFlags.sameChainSwapDifferentIntentAddresses
}

export const FeatureFlags = {
  accountIntentTransactionHistory: false,
  sameChainSwapDifferentIntentAddresses: false,
}

export function getEnvVar(name: string) {
  if (typeof process !== "undefined") {
    return process?.env?.[name]
  }
  if ((import.meta as any)?.env) {
    return (import.meta as any).env[name]
  }
  if ((import.meta as any).env[`VITE_${name}`]) {
    return (import.meta as any).env[`VITE_${name}`]
  }
  return undefined
}