0xtrails 0.6.6 → 0.7.0

package/src/relaySdk.ts

@@ -1,703 +0,0 @@
-import {
-  convertViemChainToRelayChain,
-  createClient,
-  getClient,
-  MAINNET_RELAY_API,
-} from "@reservoir0x/relay-sdk"
-import type { WalletClient } from "viem"
-import {
-  arbitrum,
-  avalanche,
-  base,
-  berachain,
-  blast,
-  opBNB,
-  bsc,
-  bob,
-  boba,
-  celo,
-  corn,
-  cronos,
-  cyber,
-  degen,
-  mainnet,
-  flowMainnet,
-  forma,
-  funkiMainnet,
-  gnosis,
-  gravity,
-  hemi,
-  hychain,
-  ink,
-  linea,
-  lisk,
-  manta,
-  mantle,
-  metis,
-  mint,
-  mode,
-  morph,
-  optimism,
-  plume,
-  polygon,
-  polygonZkEvm,
-  ronin,
-  redstone,
-  sanko,
-  scroll,
-  sei,
-  shape,
-  soneium,
-  sonic,
-  story,
-  superposition,
-  superseed,
-  swellchain,
-  taiko,
-  tron,
-  unichain,
-  worldchain,
-  xai,
-  zeroG,
-  zircuit,
-  zksync,
-  zora,
-  katana,
-  abstract,
-  ancient8,
-  apeChain,
-  arbitrumNova,
-  arenaz,
-  b3,
-} from "viem/chains"
-import { somnia } from "./customChains.js"
-import { logger } from "./logger.js"
-
-export type Chain = any
-export type RelayQuote = any
-export type RelayExecuteResult = any
-export type RelayProgressData = any
-
-// Source: https://docs.relay.link/resources/supported-chains
-export const relaySupportedChains: Record<number, Chain> = {
-  [abstract.id]: abstract,
-  [ancient8.id]: ancient8,
-  [apeChain.id]: apeChain,
-  [arbitrum.id]: arbitrum,
-  [arbitrumNova.id]: arbitrumNova,
-  [arenaz.id]: arenaz,
-  [avalanche.id]: avalanche,
-  [b3.id]: b3,
-  [base.id]: base,
-  [berachain.id]: berachain,
-  [blast.id]: blast,
-  [bsc.id]: bsc,
-  [opBNB.id]: opBNB,
-  [bob.id]: bob,
-  [boba.id]: boba,
-  [celo.id]: celo,
-  [corn.id]: corn,
-  [cronos.id]: cronos,
-  [cyber.id]: cyber,
-  [degen.id]: degen,
-  [mainnet.id]: mainnet,
-  [flowMainnet.id]: flowMainnet,
-  [forma.id]: forma,
-  [funkiMainnet.id]: funkiMainnet,
-  [gnosis.id]: gnosis,
-  [gravity.id]: gravity,
-  [hemi.id]: hemi,
-  [hychain.id]: hychain,
-  [ink.id]: ink,
-  [linea.id]: linea,
-  [lisk.id]: lisk,
-  [manta.id]: manta,
-  [mantle.id]: mantle,
-  [metis.id]: metis,
-  [mint.id]: mint,
-  [mode.id]: mode,
-  [morph.id]: morph,
-  [optimism.id]: optimism,
-  [plume.id]: plume,
-  [polygon.id]: polygon,
-  [polygonZkEvm.id]: polygonZkEvm,
-  [ronin.id]: ronin,
-  [redstone.id]: redstone,
-  [sanko.id]: sanko,
-  [scroll.id]: scroll,
-  [sei.id]: sei,
-  [shape.id]: shape,
-  [soneium.id]: soneium,
-  [sonic.id]: sonic,
-  [story.id]: story,
-  [superposition.id]: superposition,
-  [superseed.id]: superseed,
-  [swellchain.id]: swellchain,
-  [taiko.id]: taiko,
-  [tron.id]: tron,
-  [unichain.id]: unichain,
-  [worldchain.id]: worldchain,
-  [xai.id]: xai,
-  [zeroG.id]: zeroG,
-  [zircuit.id]: zircuit,
-  [zksync.id]: zksync,
-  [zora.id]: zora,
-  [katana.id]: katana,
-  [somnia.id]: somnia,
-}
-
-getRelaySupportedChains().then((relayChains) => {
-  createClient({
-    baseApiUrl: MAINNET_RELAY_API,
-    source: "Trails",
-    chains: relayChains.map((chain: Chain) =>
-      convertViemChainToRelayChain(chain),
-    ),
-  })
-})
-
-export enum RelayTradeType {
-  EXACT_INPUT = "EXACT_INPUT",
-  EXACT_OUTPUT = "EXACT_OUTPUT",
-}
-
-export interface RelayQuoteOptions {
-  wallet: WalletClient
-  chainId: number
-  toChainId?: number
-  amount: string
-  currency: string
-  toCurrency?: string
-  tradeType?: RelayTradeType
-  txs: Array<{
-    to: string
-    value: string
-    data: string
-  }>
-  recipient?: string
-  slippageTolerance?: string
-}
-
-export interface RelayExecuteOptions {
-  quote: RelayQuote
-  wallet: WalletClient
-  onProgress?: (data: RelayProgressData) => void
-}
-
-/**
- * Get a quote for a relay transaction
- */
-export async function getRelaySDKQuote(
-  options: RelayQuoteOptions,
-): Promise<RelayQuote> {
-  try {
-    const client = getClient()
-    if (!client) {
-      throw new Error("Relay client not available")
-    }
-
-    logger.console.log("[trails-sdk] getRelaySDKQuote", options)
-
-    const quote = await client.actions.getQuote({
-      wallet: options.wallet,
-      chainId: options.chainId,
-      toChainId: options.toChainId || options.chainId,
-      amount: options.amount,
-      currency: options.currency,
-      toCurrency: options.toCurrency || options.currency,
-      tradeType: options.tradeType || RelayTradeType.EXACT_OUTPUT,
-      txs: options.txs,
-      user: options.wallet.account!.address,
-      recipient: options.recipient || options.wallet.account!.address,
-      options: {
-        slippageTolerance: options.slippageTolerance
-          ? Math.round(Number(options.slippageTolerance) * 100 * 100).toString()
-          : undefined,
-      },
-    })
-
-    return quote
-  } catch (error) {
-    logger.console.error("[trails-sdk] Error getting relay quote:", error)
-    throw error
-  }
-}
-
-/**
- * Execute a relay transaction
- */
-export async function relaySDKExecute(
-  options: RelayExecuteOptions,
-): Promise<RelayExecuteResult> {
-  try {
-    const client = getClient()
-    if (!client) {
-      throw new Error("Relay client not available")
-    }
-
-    logger.console.log(
-      "[trails-sdk] relaysdkclient",
-      client.chains,
-      options.quote,
-    )
-
-    const result = await client.actions.execute({
-      quote: options.quote,
-      wallet: options.wallet,
-      onProgress:
-        options.onProgress ||
-        ((data) => {
-          logger.console.log("[trails-sdk] Relay progress:", data)
-        }),
-    })
-
-    return result
-  } catch (error) {
-    logger.console.error(
-      "[trails-sdk] Error executing relay transaction:",
-      error,
-    )
-    throw error
-  }
-}
-
-/**
- * Helper function to create a simple relay transaction for a contract call
- */
-export async function createSimpleRelayTransaction(
-  wallet: WalletClient,
-  contractAddress: string,
-  callData: string,
-  value: string,
-  chainId: number,
-  currency: string = "0x0000000000000000000000000000000000000000", // ETH
-): Promise<RelayQuote> {
-  const options: RelayQuoteOptions = {
-    wallet,
-    chainId,
-    amount: value,
-    currency,
-    txs: [
-      {
-        to: contractAddress,
-        value,
-        data: callData,
-      },
-    ],
-  }
-
-  return await getRelaySDKQuote(options)
-}
-
-/**
- * Helper function to execute a simple relay transaction
- */
-export async function executeSimpleRelayTransaction(
-  quote: RelayQuote,
-  wallet: WalletClient,
-  onProgress?: RelayExecuteOptions["onProgress"],
-): Promise<RelayExecuteResult> {
-  return await relaySDKExecute({
-    quote,
-    wallet,
-    onProgress,
-  })
-}
-
-export function getTxHashFromRelayResult(result: RelayExecuteResult): string {
-  let txHash =
-    result?.data?.steps?.[result?.data?.steps?.length - 1]?.items?.[0]
-      ?.txHashes?.[0]?.txHash
-
-  if (!txHash) {
-    txHash =
-      result?.data?.steps?.[result?.data?.steps?.length - 1]?.items?.[0]
-        ?.internalTxHashes?.[0]?.txHash
-  }
-
-  if (!txHash) {
-    throw new Error("No transaction hash found in relay result")
-  }
-
-  return txHash
-}
-
-export async function getRelaySupportedChains(): Promise<Chain[]> {
-  return Object.values(relaySupportedChains)
-}
-
-export async function isChainSupported(chainId: number): Promise<boolean> {
-  return Object.keys(relaySupportedChains).includes(chainId.toString())
-}
-
-export interface RelayToken {
-  id: string
-  symbol: string
-  name: string
-  contractAddress: string
-  decimals: number
-  chainId: number
-  chainName: string
-  imageUrl: string
-}
-
-export async function getRelaySupportedTokens(): Promise<RelayToken[]> {
-  try {
-    const relayChains = await fetchRelayChains()
-
-    const tokens: RelayToken[] = []
-
-    relayChains.forEach((chain) => {
-      if (!chain.disabled) {
-        // Add native currency
-        tokens.push({
-          id: chain.currency.id || `${chain.currency.symbol}-${chain.name}`,
-          symbol: chain.currency.symbol,
-          name: chain.currency.name,
-          contractAddress: chain.currency.address,
-          decimals: chain.currency.decimals,
-          chainId: chain.id,
-          chainName: chain.displayName || chain.name,
-          imageUrl: "", // Native currencies typically don't have logoURI
-        })
-
-        // Add featured tokens
-        chain.featuredTokens.forEach((token) => {
-          tokens.push({
-            id: token.id || `${token.symbol}-${chain.name}`,
-            symbol: token.symbol,
-            name: token.name,
-            contractAddress: token.address,
-            decimals: token.decimals,
-            chainId: chain.id,
-            chainName: chain.displayName || chain.name,
-            imageUrl: token.metadata?.logoURI || "",
-          })
-        })
-
-        // Add ERC20 currencies
-        chain.erc20Currencies.forEach((token) => {
-          tokens.push({
-            id: token.id || `${token.symbol}-${chain.name}`,
-            symbol: token.symbol,
-            name: token.name,
-            contractAddress: token.address,
-            decimals: token.decimals,
-            chainId: chain.id,
-            chainName: chain.displayName || chain.name,
-            imageUrl: token.metadata?.logoURI || "",
-          })
-        })
-
-        // Add solver currencies (fallback for chains that might not have featuredTokens/erc20Currencies)
-        chain.solverCurrencies.forEach((token) => {
-          tokens.push({
-            id: token.id || `${token.symbol}-${chain.name}`,
-            symbol: token.symbol,
-            name: token.name,
-            contractAddress: token.address,
-            decimals: token.decimals,
-            chainId: chain.id,
-            chainName: chain.displayName || chain.name,
-            imageUrl: token.metadata?.logoURI || "",
-          })
-        })
-      }
-    })
-
-    // Remove duplicates by chainId and contractAddress
-    const uniqueTokens = tokens.filter(
-      (token, index, self) =>
-        index ===
-        self.findIndex(
-          (t) =>
-            t.chainId === token.chainId &&
-            t.contractAddress.toLowerCase() ===
-              token.contractAddress.toLowerCase(),
-        ),
-    )
-
-    logger.console.log(
-      `[trails-sdk] Fetched ${uniqueTokens.length} unique tokens from Relay API`,
-    )
-
-    return uniqueTokens
-  } catch (error) {
-    logger.console.error(
-      "[trails-sdk] Error fetching Relay supported tokens:",
-      error,
-    )
-    return []
-  }
-}
-
-// Types for Relay API response
-interface RelayApiToken {
-  id: string
-  symbol: string
-  name: string
-  address: string
-  decimals: number
-  metadata?: {
-    logoURI?: string
-  }
-  supportsBridging?: boolean
-  withdrawalFee?: number
-  depositFee?: number
-  surgeEnabled?: boolean
-  supportsPermit?: boolean
-}
-
-interface RelayChain {
-  id: number
-  name: string
-  displayName: string
-  disabled: boolean
-  currency: {
-    id: string
-    symbol: string
-    name: string
-    address: string
-    decimals: number
-    supportsBridging: boolean
-  }
-  featuredTokens: RelayApiToken[]
-  erc20Currencies: RelayApiToken[]
-  solverCurrencies: RelayApiToken[]
-}
-
-interface RelayChainsResponse {
-  chains: RelayChain[]
-}
-
-// Cache for chains data
-let cachedChains: RelayChain[] | null = null
-let cacheTimestamp: number = 0
-const CACHE_DURATION = 5 * 60 * 1000 // 5 minutes
-
-async function fetchRelayChains(): Promise<RelayChain[]> {
-  const now = Date.now()
-
-  // Return cached data if still valid
-  if (cachedChains && now - cacheTimestamp < CACHE_DURATION) {
-    return cachedChains
-  }
-
-  try {
-    const response = await fetch("https://api.relay.link/chains")
-    if (!response.ok) {
-      throw new Error(`Failed to fetch chains: ${response.status}`)
-    }
-
-    const data: RelayChainsResponse = await response.json()
-    cachedChains = data.chains
-    cacheTimestamp = now
-
-    return data.chains
-  } catch (error) {
-    logger.console.error("[trails-sdk] Error fetching Relay chains:", error)
-    // Return cached data if available, even if expired
-    if (cachedChains) {
-      return cachedChains
-    }
-    throw error
-  }
-}
-
-export type GetIsRouteSupportedOptions = {
-  originChainId: number
-  destinationChainId: number
-  amount: string
-  originToken: string
-  destinationToken: string
-}
-
-export async function getIsRouteSupported({
-  originChainId,
-  destinationChainId,
-  amount,
-  originToken,
-  destinationToken,
-}: GetIsRouteSupportedOptions): Promise<boolean> {
-  try {
-    // Fetch supported chains from Relay API
-    const chains = await fetchRelayChains()
-
-    // Check if both chains are supported and not disabled
-    const originChain = chains.find((chain) => chain.id === originChainId)
-    const destinationChain = chains.find(
-      (chain) => chain.id === destinationChainId,
-    )
-
-    if (
-      !originChain ||
-      !destinationChain ||
-      originChain.disabled ||
-      destinationChain.disabled
-    ) {
-      return false
-    }
-
-    // Check if destination token is supported on destination chain
-    const isDestinationTokenSupported = destinationChain.solverCurrencies.some(
-      (currency) =>
-        currency.address.toLowerCase() === destinationToken.toLowerCase(),
-    )
-
-    if (!isDestinationTokenSupported) {
-      return false
-    }
-
-    // If we have a client available, try to get a quote to verify the route
-    const client = getClient()
-    if (client) {
-      try {
-        const sender = "0x1111111111111111111111111111111111111111"
-
-        const quote = await client.actions.getQuote({
-          chainId: originChainId,
-          toChainId: destinationChainId,
-          amount: amount,
-          currency: originToken,
-          toCurrency: destinationToken,
-          tradeType: "EXACT_OUTPUT",
-          txs: [],
-          user: sender,
-          recipient: sender,
-        })
-
-        return quote.steps.length > 0
-      } catch (error) {
-        logger.console.warn(
-          "[trails-sdk] Quote check failed, falling back to chain/token validation:",
-          error,
-        )
-        // If quote fails, we still return true if chains and tokens are supported
-        return true
-      }
-    }
-
-    // If no client available, return true if chains and tokens are supported
-    return true
-  } catch (error) {
-    logger.console.error("[trails-sdk] Error checking route support:", error)
-    return false
-  }
-}
-
-interface RelayStatusResponse {
-  status: string
-  inTxHashes: string[]
-  txHashes: string[]
-  time: number
-  originChainId: number
-  destinationChainId: number
-}
-
-/**
- * Fetch the status of a relay request by request ID
- */
-export async function fetchRelayRequestStatus(
-  requestId: string,
-): Promise<RelayStatusResponse> {
-  try {
-    const response = await fetch(
-      `https://api.relay.link/intents/status/v2?requestId=${requestId}`,
-    )
-
-    if (!response.ok) {
-      throw new Error(
-        `Failed to fetch relay status: ${response.status} ${response.statusText}`,
-      )
-    }
-
-    const data = await response.json()
-    return data as RelayStatusResponse
-  } catch (error) {
-    logger.console.error(
-      "[trails-sdk] Error fetching relay request status:",
-      error,
-    )
-    throw error
-  }
-}
-
-/**
- * Wait for relay destination transaction to complete and return the last transaction hash
- */
-export async function waitForRelayDestinationTx(
-  quoteProviderRequestId: string,
-): Promise<string> {
-  const maxWaitTime = 5 * 60 * 1000 // 5 minutes
-  const pollInterval = 5000 // 5 seconds
-  const startTime = Date.now()
-
-  const sleep = (ms: number): Promise<void> =>
-    new Promise((resolve) => setTimeout(resolve, ms))
-
-  while (Date.now() - startTime < maxWaitTime) {
-    try {
-      const status = await fetchRelayRequestStatus(quoteProviderRequestId)
-      if (!status) {
-        throw new Error("No status found")
-      }
-
-      if (
-        status.inTxHashes &&
-        status.inTxHashes.length > 0 &&
-        status.originChainId === status.destinationChainId
-      ) {
-        return status.inTxHashes[status.inTxHashes.length - 1]!
-      }
-
-      logger.console.log("[trails-sdk] Relay status check:", {
-        requestId: quoteProviderRequestId,
-        status: status.status,
-        txHashesCount: status.txHashes?.length || 0,
-      })
-
-      // Check if we have transaction hashes
-      if (status.txHashes && status.txHashes.length > 0) {
-        // Return the last transaction hash in the array
-        const lastTxHash = status.txHashes[status.txHashes.length - 1]
-        if (lastTxHash) {
-          logger.console.log(
-            "[trails-sdk] Relay transaction completed:",
-            lastTxHash,
-          )
-          return lastTxHash
-        }
-      }
-
-      // If status is failed or error, throw an error
-      if (status.status === "failed" || status.status === "error") {
-        throw new Error(
-          `Relay transaction failed with status: ${status.status}`,
-        )
-      }
-
-      // Wait before next poll
-      await sleep(pollInterval)
-    } catch (error) {
-      // If it's a fetch error (like 404), continue polling as the request might not be indexed yet
-      if (
-        error instanceof Error &&
-        (error.message.includes("Failed to fetch relay status") ||
-          error.message.includes("No status found"))
-      ) {
-        logger.console.warn(
-          "[trails-sdk] Relay status not yet available, continuing to poll...",
-        )
-        await sleep(pollInterval)
-        continue
-      }
-
-      // For other errors, rethrow
-      throw error
-    }
-  }
-
-  throw new Error(
-    `Timeout waiting for relay transaction after ${maxWaitTime / 1000} seconds`,
-  )
-}