@openocean.finance/widget 1.0.0

package/src/services/ExecuteRoute.ts

@@ -0,0 +1,385 @@
+import type { ExecutionStatus, LiFiStep, Process, Route } from '@lifi/sdk'
+import type { Account } from '@openocean.finance/wallet-management'
+import { Connection, Transaction, VersionedTransaction } from '@solana/web3.js'
+import type { Config } from 'wagmi'
+import { getPublicClient, getWalletClient } from 'wagmi/actions'
+import { sendAndConfirmSolanaTransaction } from './SendAndConfirmSolanaTransaction.js'
+
+// Add helper function for handling hexadecimal conversion
+function hexToUint8Array(hexString: string): Uint8Array {
+  const pairs = hexString.match(/[\dA-F]{2}/gi) || []
+  return new Uint8Array(pairs.map((s) => Number.parseInt(s, 16)))
+}
+
+interface ExecuteRouteOptions {
+  updateRouteHook?: (route: Route) => void
+  acceptExchangeRateUpdateHook?: (params: any) => Promise<boolean>
+  infiniteApproval?: boolean
+  executeInBackground?: boolean
+  account: Account
+  wagmiConfig: Config
+  onDisconnect?: (account: Account) => Promise<void>
+  onOpenWalletMenu?: () => void
+}
+
+interface ExtendedLiFiStep extends LiFiStep {
+  execution?: {
+    status: ExecutionStatus
+    process: Process[]
+  }
+  toolData?: {
+    data: string
+  }
+}
+
+interface ExtendedRoute extends Route {
+  steps: ExtendedLiFiStep[]
+  data: {
+    prependedOperatingExpenseCost: string
+  }
+}
+
+// Execute Solana transaction
+async function executeSolanaSwap(
+  step: ExtendedLiFiStep,
+  options: ExecuteRouteOptions,
+  process: Process,
+  route: ExtendedRoute
+): Promise<void> {
+  try {
+    // Check wallet connection status
+    if (!options.account || !options.account.connector) {
+      throw new Error('Wallet not connected or connector not initialized')
+    }
+
+    let transaction: any = ''
+    let connection: any = null
+    const txData: any = step.transactionRequest?.data || ''
+    const dexId = step.transactionRequest?.type || 0
+    if (step.action.fromChainId === step.action.toChainId) {
+      if (dexId == 6 || dexId == 7 || dexId == 9) {
+        transaction = VersionedTransaction.deserialize(hexToUint8Array(txData))
+      } else {
+        transaction = Transaction.from(hexToUint8Array(txData))
+      }
+    } else {
+      transaction = VersionedTransaction.deserialize(hexToUint8Array(txData.slice(2)))
+      // Create connection instance
+      connection = new Connection(
+        'https://burned-practical-bird.solana-mainnet.quiknode.pro/33f4786133c252415e194b29ee69ffc7671480ab'
+      )
+      const { blockhash } = await connection.getLatestBlockhash();
+      transaction.message.recentBlockhash = blockhash;
+    }
+
+    // Check signTransaction method exists
+    const connector = options.account.connector as any
+    if (typeof connector.signTransaction !== 'function') {
+      throw new Error('Wallet does not support transaction signing')
+    }
+
+    // Sign transaction
+    const signedTx = await connector.signTransaction(transaction)
+    if (!signedTx) {
+      throw new Error('Failed to sign transaction')
+    }
+
+
+    // Serialize signed transaction
+    const serializedTransaction = signedTx.serialize({
+      verifySignatures: false,
+      requireAllSignatures: false,
+    })
+
+    // Use improved transaction sender
+    await sendAndConfirmSolanaTransaction({
+      connection,
+      serializedTransaction,
+      process,
+      updateRouteHook: (updatedProcess) => {
+        // Update process status
+        Object.assign(process, updatedProcess)
+
+        // Update step execution status
+        if (process.status === 'DONE') {
+          step.execution!.status = 'DONE'
+        } else if (process.status === 'FAILED') {
+          step.execution!.status = 'FAILED'
+        } else {
+          step.execution!.status = 'PENDING'
+        }
+
+        // Call original updateRouteHook
+        options.updateRouteHook?.(route)
+      },
+    })
+  } catch (error) {
+    console.error('Solana swap execution failed:', error)
+    process.status = 'FAILED'
+    process.error =
+      error instanceof Error
+        ? {
+            code: 'EXECUTION_ERROR',
+            message: error.message,
+            htmlMessage: error.message,
+          }
+        : {
+            code: 'UNKNOWN_ERROR',
+            message: 'Unknown error occurred',
+            htmlMessage: 'Unknown error occurred',
+          }
+    step.execution!.status = 'FAILED'
+    options.updateRouteHook?.(route)
+    throw error
+  }
+}
+
+// Execute EVM transaction
+async function executeEvmSwap(
+  step: ExtendedLiFiStep,
+  options: ExecuteRouteOptions,
+  process: Process,
+  route: ExtendedRoute
+): Promise<void> {
+  try {
+    const walletClient = await getWalletClient(options.wagmiConfig)
+    if (!walletClient) {
+      // If disconnect callback exists, disconnect the current connection first
+      if (options.account?.connector && options.onDisconnect) {
+        await options.onDisconnect(options.account)
+      }
+      // Open wallet menu to let user reconnect
+      if (options.onOpenWalletMenu) {
+        options.onOpenWalletMenu()
+      }
+      throw new Error('Please connect wallet first')
+    }
+
+    const publicClient = getPublicClient(options.wagmiConfig)
+    if (!publicClient) {
+      // If disconnect callback exists, disconnect the current connection first
+      if (options.account?.connector && options.onDisconnect) {
+        await options.onDisconnect(options.account)
+      }
+      // Open wallet menu to let user reconnect
+      if (options.onOpenWalletMenu) {
+        options.onOpenWalletMenu()
+      }
+      throw new Error('Public client not found')
+    }
+
+    console.log('Current Chain:', publicClient.chain?.id, publicClient.chain?.name);
+    console.log('Token Address:', step.action.fromToken.address);
+    console.log('Token Chain ID:', step.action.fromToken.chainId);
+    console.log('Owner Address:', walletClient.account.address);
+    console.log('Spender Address:', step.estimate.approvalAddress);
+
+    // Check token approval
+    if (
+      step.action.fromToken.address !==
+      '0x0000000000000000000000000000000000000000'
+    ) {
+      let allowance: bigint = 0n;
+      try {
+          allowance = (await publicClient.readContract({
+          address: step.action.fromToken.address as `0x${string}`,
+          abi: [
+            {
+              constant: true,
+              inputs: [
+                { name: 'owner', type: 'address' },
+                { name: 'spender', type: 'address' },
+              ],
+              name: 'allowance',
+              outputs: [{ name: '', type: 'uint256' }],
+              type: 'function',
+            },
+          ],
+          functionName: 'allowance',
+          args: [
+            walletClient.account.address,
+            step.estimate.approvalAddress as `0x${string}`,
+          ],
+        })) as bigint;
+      } catch (error) {
+        console.error("Failed to read allowance:", error);
+        // Log additional context
+        console.error("Context - Step:", JSON.stringify(step, null, 2));
+        console.error("Context - Route:", JSON.stringify(route, null, 2));
+        console.error("Context - Public Client Chain:", publicClient.chain);
+        // Re-throw the error or handle it appropriately
+        // throw new Error(`Failed to read allowance for token ${step.action.fromToken.address}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+
+      const amount = BigInt(step.action.fromAmount) + BigInt(route?.data?.prependedOperatingExpenseCost || '0');
+      if (allowance < BigInt(amount)) {
+        const approvalAmount = options.infiniteApproval
+          ? BigInt(
+              '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+            )
+          : BigInt(amount)
+
+        const hash = await walletClient.writeContract({
+          address: step.action.fromToken.address as `0x${string}`,
+          abi: [
+            {
+              constant: false,
+              inputs: [
+                { name: 'spender', type: 'address' },
+                { name: 'amount', type: 'uint256' },
+              ],
+              name: 'approve',
+              outputs: [{ name: '', type: 'bool' }],
+              type: 'function',
+            },
+          ],
+          functionName: 'approve',
+          args: [
+            step.estimate.approvalAddress as `0x${string}`,
+            approvalAmount,
+          ],
+        })
+
+        await publicClient.waitForTransactionReceipt({ hash })
+      }
+    }
+
+    const { transactionRequest } = step || {}
+    const txRequest = {
+      chain: publicClient.chain,
+      to: transactionRequest?.to as `0x${string}`,
+      data: (transactionRequest?.data as `0x${string}`) || '0x',
+      value: BigInt(transactionRequest?.value || '0x0'),
+      account: walletClient.account.address,
+    }
+
+    // Estimate gas
+    const estimatedGas = await publicClient.estimateGas(txRequest)
+    console.log('estimatedGas', estimatedGas)
+
+    // Add estimated gas to transaction request (using 2x the estimated value to ensure transaction success)
+    const finalTxRequest = {
+      ...txRequest,
+      gas: estimatedGas * 2n,
+    }
+
+    const hash = await walletClient.sendTransaction(finalTxRequest)
+
+    process.status = 'PENDING'
+    process.txHash = hash
+    process.message = 'Transaction pending'
+    options.updateRouteHook?.(route)
+
+    const receipt = await publicClient.waitForTransactionReceipt({ hash })
+
+    process.status = receipt.status === 'success' ? 'DONE' : 'FAILED'
+    process.doneAt = Date.now()
+    process.message =
+      receipt.status === 'success'
+        ? 'Transaction confirmed'
+        : 'Transaction failed'
+
+    step.execution!.status = receipt.status === 'success' ? 'DONE' : 'FAILED'
+    options.updateRouteHook?.(route)
+
+    if (receipt.status !== 'success') {
+      throw new Error('Transaction failed')
+    }
+  } catch (error) {
+    console.error('EVM swap execution failed:', error)
+    process.status = 'FAILED'
+    process.error =
+      error instanceof Error
+        ? {
+            code: 'EXECUTION_ERROR',
+            message: error.message,
+            htmlMessage: error.message,
+          }
+        : {
+            code: 'UNKNOWN_ERROR',
+            message: 'Unknown error occurred',
+            htmlMessage: 'Unknown error occurred',
+          }
+    step.execution!.status = 'FAILED'
+    options.updateRouteHook?.(route)
+    throw error
+  }
+}
+
+// Execute transaction
+async function executeSwap(
+  route: ExtendedRoute,
+  options: ExecuteRouteOptions
+): Promise<Route> {
+  const updatedRoute = { ...route }
+
+  try {
+    // Execute transactions for each step
+    for (const step of updatedRoute.steps) {
+      // Update status to start execution
+      const process: Process = {
+        type: 'SWAP',
+        status: 'STARTED',
+        startedAt: Date.now(),
+        message: 'Preparing swap transaction',
+        txHash: '',
+      }
+
+      step.execution = {
+        status: 'PENDING',
+        process: [process],
+      }
+
+      options.updateRouteHook?.(updatedRoute)
+
+      // Check wallet connection status
+      if (!options.account || !options.account.connector) {
+        // If connector exists but not connected, disconnect first
+        if (options.account?.connector && options.onDisconnect) {
+          await options.onDisconnect(options.account)
+        }
+        // Open wallet menu
+        if (options.onOpenWalletMenu) {
+          options.onOpenWalletMenu()
+        }
+        throw new Error('Please connect wallet first')
+      }
+
+      // Execute different transaction logic based on chain type
+      const currentStep = route.steps[0]
+      if (currentStep.action?.fromChainId === 1151111081099710) {
+        await executeSolanaSwap(currentStep, options, process, updatedRoute)
+      } else {
+        await executeEvmSwap(currentStep, options, process, updatedRoute)
+      }
+    }
+
+    return updatedRoute
+  } catch (error: unknown) {
+    console.error('Swap execution failed:', error)
+    updatedRoute.steps.forEach((step) => {
+      if (step.execution?.status === 'PENDING') {
+        step.execution.status = 'FAILED'
+        step.execution.process[0].status = 'FAILED'
+        step.execution.process[0].message =
+          error instanceof Error ? error.message : 'Transaction failed'
+      }
+    })
+
+    options.updateRouteHook?.(updatedRoute)
+    throw error
+  }
+}
+
+// Export main function
+export async function executeRoute(
+  route: Route,
+  options: ExecuteRouteOptions
+): Promise<Route> {
+  // Check wallet connection status
+  if (!options.account.isConnected) {
+    throw new Error('Wallet not connected')
+  }
+
+  return executeSwap(route as ExtendedRoute, options)
+}

package/src/services/OpenOceanService.ts

@@ -0,0 +1,207 @@
+interface OpenOceanToken {
+  address: string
+  symbol: string
+  decimals: number
+  name: string
+  icon?: string
+  usd?: string
+  chainId?: number
+}
+
+export class OpenOceanService {
+  private static readonly API_V1_URL = 'https://ethapi.openocean.finance/v1'
+  private static readonly API_V2_URL = 'https://ethapi.openocean.finance/v2'
+  private static readonly API_V3_URL = 'https://open-api.openocean.finance/v3'
+
+  // Chain ID to OpenOcean chain name mapping
+  private static readonly CHAIN_ID_MAP: Record<string | number, string> = {
+    1151111081099710: 'solana', // Solana mainnet
+  }
+
+  // Get OpenOcean supported chain name
+  private static getChainName(chainId: string | number): string {
+    return this.CHAIN_ID_MAP[chainId] || chainId.toString()
+  }
+
+  // Get API URL based on chain ID
+  private static getApiUrl(chainId: string | number): string {
+    // If chainId exists in CHAIN_ID_MAP, use V1 API
+    const chainName = this.getChainName(chainId)
+    return Object.keys(this.CHAIN_ID_MAP).includes(chainId.toString())
+      ? `${this.API_V1_URL}/${chainName}`
+      : `${this.API_V2_URL}/${chainId}`
+  }
+
+  static async getQuote(params: {
+    chain: string
+    inTokenAddress: string
+    inTokenSymbol: string
+    outTokenAddress: string
+    outTokenSymbol: string
+    amount: string
+    slippage?: string
+    gasPrice?: string
+    disabledDexIds?: string
+    enabledDexIds?: string
+    referrer?: string
+  }) {
+    const apiUrl = this.getApiUrl(params.chain)
+    const slippage = (Number(params.slippage || '1') * 10000).toString()
+    const queryParams = new URLSearchParams({
+      quoteType: 'quote',
+      inTokenSymbol: params.inTokenSymbol,
+      inTokenAddress: params.inTokenAddress,
+      outTokenSymbol: params.outTokenSymbol,
+      outTokenAddress: params.outTokenAddress,
+      amount: params.amount,
+      slippage,
+      gasPrice: params.gasPrice || '',
+      disabledDexIds: params.disabledDexIds || '',
+      enabledDexIds: params.enabledDexIds || '',
+      referrer: params.referrer || '0x3487ef9f9b36547e43268b8f0e2349a226c70b53',
+    })
+
+    const response = await fetch(`${apiUrl}/quote?${queryParams.toString()}`)
+    return response.json()
+  }
+
+  static async getSwapQuote(params: {
+    chain: string
+    inTokenAddress: string
+    inTokenSymbol: string
+    outTokenAddress: string
+    outTokenSymbol: string
+    amount: string
+    account: string
+    slippage?: string
+    gasPrice?: string
+    disabledDexIds?: string
+    enabledDexIds?: string
+    referrer?: string
+  }) {
+    const apiUrl = this.getApiUrl(params.chain)
+    const slippage = (Number(params.slippage || '1') * 10000).toString()
+    const queryParams = new URLSearchParams({
+      quoteType: 'swap',
+      inTokenSymbol: params.inTokenSymbol,
+      inTokenAddress: params.inTokenAddress,
+      outTokenSymbol: params.outTokenSymbol,
+      outTokenAddress: params.outTokenAddress,
+      amount: params.amount,
+      account: params.account,
+      slippage,
+      gasPrice: params.gasPrice || '',
+      disabledDexIds: params.disabledDexIds || '',
+      enabledDexIds: params.enabledDexIds || '',
+      referrer: params.referrer || '0x3487ef9f9b36547e43268b8f0e2349a226c70b53',
+    })
+    const isV1Api = Object.keys(this.CHAIN_ID_MAP).includes(params.chain.toString())
+    const swapEndpoint = isV1Api ? 'swap-quote' : 'swap'
+    const response = await fetch(`${apiUrl}/${swapEndpoint}?${queryParams.toString()}`)
+    return response.json()
+  }
+
+  static async getTokenList(chain: string) {
+    const chainName = this.getChainName(chain)
+    const response = await fetch(`${this.API_V3_URL}/${chainName}/tokenList`)
+    const data = await response.json()
+    if (data.code !== 200) {
+      throw new Error('Failed to fetch token list')
+    }
+    return data.data.map((token: OpenOceanToken) => {
+      let address = token.address
+      // Convert Solana native token address
+      if (chain === '1151111081099710' && address === 'So11111111111111111111111111111111111111112') {
+        address = '11111111111111111111111111111111'
+      }
+      // Convert Base chain native token address
+      if (address === '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE') {
+        address = '0x0000000000000000000000000000000000000000'
+      }
+      return {
+        address,
+        symbol: token.symbol,
+        decimals: token.decimals,
+        name: token.name,
+        logoURI: token.icon,
+        priceUSD: token.usd,
+        chainId: Number(chain),
+        amount: 0n,
+        featured: false,
+        popular: false
+      }
+    })
+  }
+
+  static async getDexList(chain: string) {
+    const apiUrl = this.getApiUrl(chain)
+    const response = await fetch(`${apiUrl}/dexList`)
+    return response.json()
+  }
+
+  static async getGasPrice(chain: string) {
+    if (!chain || chain === '1151111081099710') {
+      return {
+        data: {
+          gasPrice: '1000000000000000000',
+        },
+      }
+    }
+    // const apiUrl = this.getApiUrl(chain)
+    const response = await fetch(`${this.API_V2_URL}/${chain}/gas-price`)
+    const data = await response.json()
+    return data
+  }
+
+  static async getTokenInfo(chain: string, tokenAddress: string) {
+    const chainName = this.getChainName(chain)
+    // Check if the address is valid
+    if (!tokenAddress || (!/^0x[a-fA-F0-9]{40}$/.test(tokenAddress) && !/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(tokenAddress))) {
+      throw new Error('Invalid token address')
+    }
+    const response = await fetch(`${this.API_V3_URL}/${chainName}/getTokenInfo?tokenAddress=${tokenAddress}`)
+    const data = await response.json()
+    if (!data || !data.address || !data.symbol || !data.decimals) {
+      throw new Error('Failed to fetch token info')
+    }
+    return {
+      address: data.address,
+      symbol: data.symbol,
+      decimals: data.decimals,
+      name: data.name,
+      logoURI: data.icon,
+      priceUSD: data.usd,
+      chainId: Number(chain),
+      amount: 0n,
+      featured: false,
+      popular: false
+    }
+  }
+
+  /**
+   * Get prices for specified tokens
+   * @param chain chain name, e.g. 'arbitrum'
+   * @param tokenAddresses array of token addresses
+   * @returns Promise<Record<string, string>> returns an object where key is token address and value is price
+   */
+  static async getTokensPrice(chain: string, tokenAddresses: string[]): Promise<Record<string, string>> {
+    const chainName = this.getChainName(chain)
+    const tokenAddressesStr = tokenAddresses.join(',')
+    const response = await fetch(`${this.API_V3_URL}/${chainName}/designated_tokenList?tokens=${tokenAddressesStr}`)
+    const data = await response.json()
+    
+    if (data.code !== 200) {
+      throw new Error('Failed to fetch token prices')
+    }
+
+    const prices = data.data.reduce((acc: Record<string, string>, token: OpenOceanToken) => {
+      if (token.address && token.usd) {
+        acc[token.address.toLowerCase()] = token.usd
+      }
+      return acc
+    }, {})
+
+    return prices
+  }
+}
+