@openocean.finance/widget 1.0.27 → 1.0.29

package/src/services/ExecuteRoute.ts

@@ -6,116 +6,116 @@ import type {
   Route,
 } from '@openocean.finance/widget-sdk'
 import { Connection, Transaction, VersionedTransaction } from '@solana/web3.js'
-import type { Config } from 'wagmi'
+import { ethers } from 'ethers'
 import { getPublicClient, getWalletClient } from 'wagmi/actions'
-import { sendAndConfirmSolanaTransaction } from './SendAndConfirmSolanaTransaction.js'
+import { bridgeExecuteSwap } from '../cross/crossChainQuote.js'
 import { useSettingsStore } from '../stores/settings/useSettingsStore.js'
-import { ethers } from 'ethers'
+import { sendAndConfirmSolanaTransaction } from './SendAndConfirmSolanaTransaction.js'
 
 const OpenOceanABI = [
   {
-      "inputs": [
+    inputs: [
+      {
+        internalType: 'contract IOpenOceanCaller',
+        name: 'caller',
+        type: 'address',
+      },
+      {
+        components: [
           {
-              "internalType": "contract IOpenOceanCaller",
-              "name": "caller",
-              "type": "address"
+            internalType: 'contract IERC20',
+            name: 'srcToken',
+            type: 'address',
           },
           {
-              "components": [
-                  {
-                      "internalType": "contract IERC20",
-                      "name": "srcToken",
-                      "type": "address"
-                  },
-                  {
-                      "internalType": "contract IERC20",
-                      "name": "dstToken",
-                      "type": "address"
-                  },
-                  {
-                      "internalType": "address",
-                      "name": "srcReceiver",
-                      "type": "address"
-                  },
-                  {
-                      "internalType": "address",
-                      "name": "dstReceiver",
-                      "type": "address"
-                  },
-                  {
-                      "internalType": "uint256",
-                      "name": "amount",
-                      "type": "uint256"
-                  },
-                  {
-                      "internalType": "uint256",
-                      "name": "minReturnAmount",
-                      "type": "uint256"
-                  },
-                  {
-                      "internalType": "uint256",
-                      "name": "guaranteedAmount",
-                      "type": "uint256"
-                  },
-                  {
-                      "internalType": "uint256",
-                      "name": "flags",
-                      "type": "uint256"
-                  },
-                  {
-                      "internalType": "address",
-                      "name": "referrer",
-                      "type": "address"
-                  },
-                  {
-                      "internalType": "bytes",
-                      "name": "permit",
-                      "type": "bytes"
-                  }
-              ],
-              "internalType": "struct OpenOceanExchange.SwapDescription",
-              "name": "desc",
-              "type": "tuple"
+            internalType: 'contract IERC20',
+            name: 'dstToken',
+            type: 'address',
           },
           {
-              "components": [
-                  {
-                      "internalType": "uint256",
-                      "name": "target",
-                      "type": "uint256"
-                  },
-                  {
-                      "internalType": "uint256",
-                      "name": "gasLimit",
-                      "type": "uint256"
-                  },
-                  {
-                      "internalType": "uint256",
-                      "name": "value",
-                      "type": "uint256"
-                  },
-                  {
-                      "internalType": "bytes",
-                      "name": "data",
-                      "type": "bytes"
-                  }
-              ],
-              "internalType": "struct IOpenOceanCaller.CallDescription[]",
-              "name": "calls",
-              "type": "tuple[]"
-          }
-      ],
-      "name": "swap",
-      "outputs": [
+            internalType: 'address',
+            name: 'srcReceiver',
+            type: 'address',
+          },
           {
-              "internalType": "uint256",
-              "name": "returnAmount",
-              "type": "uint256"
-          }
-      ],
-      "stateMutability": "payable",
-      "type": "function"
-  }
+            internalType: 'address',
+            name: 'dstReceiver',
+            type: 'address',
+          },
+          {
+            internalType: 'uint256',
+            name: 'amount',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'minReturnAmount',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'guaranteedAmount',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'flags',
+            type: 'uint256',
+          },
+          {
+            internalType: 'address',
+            name: 'referrer',
+            type: 'address',
+          },
+          {
+            internalType: 'bytes',
+            name: 'permit',
+            type: 'bytes',
+          },
+        ],
+        internalType: 'struct OpenOceanExchange.SwapDescription',
+        name: 'desc',
+        type: 'tuple',
+      },
+      {
+        components: [
+          {
+            internalType: 'uint256',
+            name: 'target',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'gasLimit',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'value',
+            type: 'uint256',
+          },
+          {
+            internalType: 'bytes',
+            name: 'data',
+            type: 'bytes',
+          },
+        ],
+        internalType: 'struct IOpenOceanCaller.CallDescription[]',
+        name: 'calls',
+        type: 'tuple[]',
+      },
+    ],
+    name: 'swap',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: 'returnAmount',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'payable',
+    type: 'function',
+  },
 ]
 
 // Add helper function for handling hexadecimal conversion
@@ -124,6 +124,121 @@ function hexToUint8Array(hexString: string): Uint8Array {
   return new Uint8Array(pairs.map((s) => Number.parseInt(s, 16)))
 }
 
+/**
+ * Convert amount with precision to actual amount
+ * @param amount Amount with precision
+ * @param decimals Precision
+ * @returns Actual amount
+ */
+function decimals2Amount(amount: string | number, decimals = 18): number {
+  return Number(amount) / 10 ** decimals
+}
+
+/**
+ * Swap response type
+ */
+interface SwapResponse {
+  inAmount?: string
+  inToken?: {
+    decimals?: number
+    price?: string | number
+    priceUSD?: string | number
+    address?: string
+  }
+  data?: string
+  from?: string
+  to?: string
+  value?: string
+  minOutAmount?: string
+}
+
+/**
+ * Adjust transaction parameters based on dynamic slippage to provide MEV protection
+ */
+async function swapQuoteMEV(
+  response: SwapResponse,
+  options?: { publicClient?: any }
+): Promise<SwapResponse> {
+  try {
+    const inAmount = response?.inAmount
+    const inTokenDecimals = response?.inToken?.decimals || 18
+    const inTokenPrice = Number(response?.inToken?.priceUSD || 0)
+    const amount = decimals2Amount(inAmount, inTokenDecimals) * inTokenPrice
+    if (amount < 1) {
+      return response
+    }
+    const { publicClient } = options
+    const OPENOCEAN_CONTRACT = new ethers.Contract(
+      '0x6352a56caadC4F1E25CD6c75970Fa768A3304e64',
+      OpenOceanABI
+    )
+    if (
+      ethers.hexlify(ethers.getBytes(response?.data || '0x').slice(0, 4)) !==
+      OPENOCEAN_CONTRACT.interface.getFunction('swap').selector
+    ) {
+      return response
+    }
+    const oldCallData = OPENOCEAN_CONTRACT.interface.decodeFunctionData(
+      'swap',
+      response?.data
+    )
+    const callData = [...oldCallData]
+    callData[1] = [...oldCallData[1]]
+    const minOutAmount = BigInt(callData[1][5] || 0)
+    const outAmount = BigInt(callData[1][6] || 0)
+    const slippageAmount = outAmount - minOutAmount
+
+    const minOutAmounts = await Promise.all(
+      [1, 2, 3].map(async (i) => {
+        const mockMinOutAmount =
+          minOutAmount + (slippageAmount / 4n) * BigInt(i)
+        callData[1][5] = mockMinOutAmount
+        const params = {
+          from: response?.from as `0x${string}`,
+          to: response?.to as `0x${string}`,
+          data: OPENOCEAN_CONTRACT.interface.encodeFunctionData(
+            'swap',
+            callData
+          ) as `0x${string}`,
+          value: BigInt(response?.value || '0'),
+        }
+        try {
+          await publicClient.estimateGas(params)
+          return mockMinOutAmount
+        } catch (error) {
+          console.error('Failed to estimate gas:', error)
+          return undefined
+        }
+      })
+    )
+    let [min1, min2] = minOutAmounts
+      .filter((value) => value !== undefined)
+      .sort((a, b) => (BigInt(b || 0) > BigInt(a || 0) ? 1 : -1))
+      .slice(0, 2)
+    min1 = min1 ?? minOutAmount
+    min2 = min2 ?? minOutAmount
+
+    const randomFactor = BigInt(Math.floor(Math.random() * 10000))
+    const minOutAmountDiff = BigInt(min1 || 0) - BigInt(min2 || 0)
+    const finalMinOutAmount =
+      BigInt(min2 || 0) + (minOutAmountDiff * randomFactor) / BigInt(10000)
+
+    if (finalMinOutAmount < minOutAmount) {
+      return response
+    }
+    callData[1][5] = finalMinOutAmount
+    const finalCallData = OPENOCEAN_CONTRACT.interface.encodeFunctionData(
+      'swap',
+      callData
+    )
+    response.minOutAmount = finalMinOutAmount.toString()
+    response.data = finalCallData
+    return response
+  } catch {
+    return response
+  }
+}
+
 interface ExecuteRouteOptions {
   updateRouteHook?: (route: Route) => void
   acceptExchangeRateUpdateHook?: (params: any) => Promise<boolean>
@@ -136,6 +251,7 @@ interface ExecuteRouteOptions {
 }
 
 interface ExtendedOpenOceanStep extends OpenOceanStep {
+  quoteData?: any
   execution?: {
     status: ExecutionStatus
     process: Process[]
@@ -147,8 +263,9 @@ interface ExtendedOpenOceanStep extends OpenOceanStep {
 
 interface ExtendedRoute extends Route {
   steps: ExtendedOpenOceanStep[]
-  data: {
-    prependedOperatingExpenseCost: string
+  prependedOperatingExpenseCost?: string
+  data?: {
+    prependedOperatingExpenseCost?: string
   }
 }
 
@@ -172,16 +289,18 @@ async function executeSolanaSwap(
     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) {
+      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)))
+      transaction = VersionedTransaction.deserialize(
+        hexToUint8Array(txData.slice(2))
+      )
 
-      const { blockhash } = await connection.getLatestBlockhash();
-      transaction.message.recentBlockhash = blockhash;
+      const { blockhash } = await connection.getLatestBlockhash()
+      transaction.message.recentBlockhash = blockhash
     }
 
     // Check signTransaction method exists
@@ -254,7 +373,7 @@ async function executeEvmSwap(
 ): Promise<void> {
   try {
     let walletClient = await getWalletClient(options.wagmiConfig)
-    
+
     // Check if wallet is connected
     if (!walletClient) {
       if (options.account?.connector && options.onDisconnect) {
@@ -265,18 +384,18 @@ async function executeEvmSwap(
       }
       throw new Error('Please connect wallet first')
     }
-    
+
     // Check if current chain matches target chain
     const currentChainId = walletClient.chain.id
     const targetChainId = step.action.fromChainId
-    
+
     if (currentChainId !== targetChainId) {
       try {
         // Try to switch to target chain
         await walletClient.switchChain({ id: targetChainId })
-        
+
         // Get updated walletClient after chain switch
-        walletClient = await getWalletClient(options.wagmiConfig) as any
+        walletClient = (await getWalletClient(options.wagmiConfig)) as any
         if (!walletClient || walletClient.chain.id !== targetChainId) {
           throw new Error('Failed to switch chain')
         }
@@ -299,19 +418,23 @@ async function executeEvmSwap(
       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)
-
+    // 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 (
-      ['0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000001010'].indexOf(step.action.fromToken.address) === -1
+      [
+        '0x0000000000000000000000000000000000000000',
+        '0x0000000000000000000000000000000000001010',
+      ].indexOf(step.action.fromToken.address) === -1 &&
+      step.estimate.approvalAddress !==
+        '0x0000000000000000000000000000000000000000'
     ) {
       let allowance = 0n
       try {
@@ -347,7 +470,11 @@ async function executeEvmSwap(
 
       const amount =
         BigInt(step.action.fromAmount) +
-        BigInt(route?.data?.prependedOperatingExpenseCost || '0')
+        BigInt(
+          route?.prependedOperatingExpenseCost ||
+            route?.data?.prependedOperatingExpenseCost ||
+            '0'
+        )
       if (allowance < BigInt(amount)) {
         const approvalAmount = options.infiniteApproval
           ? BigInt(
@@ -382,58 +509,68 @@ async function executeEvmSwap(
       }
     }
 
-    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,
-    }
+    const { transactionRequest, type, quoteData } = step || {}
+    let hash: any = ''
+    if ((type as any) === 'bridge') {
+      const result = await bridgeExecuteSwap({
+        quoteData: quoteData,
+        walletClient: walletClient,
+      })
+      hash = result.sourceTxHash
+    } else {
+      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,
+      }
 
-    // 在这里根据useSettingsStore 中的 dynamicSlippage 参数来判断是否调用下面的函数 swap_quote_mev
-    const { dynamicSlippage } = useSettingsStore.getState()
-    if (dynamicSlippage) {
-      try {
-        // 构建 response 对象
-        const response = {
-          inAmount: step.action.fromAmount || '0',
-          inToken: step.action.fromToken,
-          data: transactionRequest?.data,
-          from: walletClient.account.address,
-          to: transactionRequest?.to,
-          value: transactionRequest?.value || '0'
-        };
-        
-        // 调用 swap_quote_mev 获取调整后的交易数据
-        const adjustedResponse = await swapQuoteMEV(response, { publicClient });
-        
-        // 如果 swap_quote_mev 返回了修改后的数据，更新交易请求
-        if (adjustedResponse && adjustedResponse.data !== response.data) {
-          txRequest.data = adjustedResponse.data as `0x${string}`;
-          txRequest.value = BigInt(adjustedResponse.value || '0');
-          console.log('Applied MEV protection with dynamic slippage');
+      // Check if dynamicSlippage is enabled in useSettingsStore to determine whether to call swap_quote_mev
+      const { dynamicSlippage } = useSettingsStore.getState()
+      if (dynamicSlippage) {
+        try {
+          // Build response object
+          const response = {
+            inAmount: step.action.fromAmount || '0',
+            inToken: step.action.fromToken,
+            data: transactionRequest?.data,
+            from: walletClient.account.address,
+            to: transactionRequest?.to,
+            value: transactionRequest?.value || '0',
+          }
+
+          // Call swap_quote_mev to get adjusted transaction data
+          const adjustedResponse = await swapQuoteMEV(response, {
+            publicClient,
+          })
+
+          // If swap_quote_mev returns modified data, update transaction request
+          if (adjustedResponse && adjustedResponse.data !== response.data) {
+            txRequest.data = adjustedResponse.data as `0x${string}`
+            txRequest.value = BigInt(adjustedResponse.value || '0')
+            // Applied MEV protection with dynamic slippage
+          }
+        } catch (error) {
+          console.error('Failed to apply MEV protection:', error)
+          // Continue with original transaction request on error
         }
-      } catch (error) {
-        console.error('Failed to apply MEV protection:', error);
-        // 错误时继续使用原始交易请求
       }
-    }
 
-    // Estimate gas
-    const estimatedGas = await publicClient.estimateGas(txRequest)
-    console.log('estimatedGas', estimatedGas)
+      // Estimate gas
+      const estimatedGas = await publicClient.estimateGas(txRequest)
 
-    // Add estimated gas to transaction request (using 2x the estimated value to ensure transaction success)
-    const finalTxRequest = {
-      ...txRequest,
-      gas: estimatedGas * 2n,
-    }
+      // 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,
-      kzg: undefined,
-    })
+      hash = await walletClient.sendTransaction({
+        ...finalTxRequest,
+        kzg: undefined,
+      })
+    }
 
     process.status = 'PENDING'
     process.txHash = hash
@@ -476,120 +613,6 @@ async function executeEvmSwap(
   }
 }
 
-/**
- * 将带精度的金额转换为实际金额
- * @param amount 带精度的金额
- * @param decimals 精度
- * @returns 实际金额
- */
-function decimals2Amount(amount: string | number, decimals = 18): number {
-  return Number(amount) / Math.pow(10, decimals);
-}
-
-/**
- * 交易响应类型
- */
-interface SwapResponse {
-  inAmount?: string;
-  inToken?: {
-    decimals?: number;
-    price?: string | number;
-    priceUSD?: string | number;
-    address?: string;
-  };
-  data?: string;
-  from?: string;
-  to?: string;
-  value?: string;
-  minOutAmount?: string;
-}
-
-/**
- * 根据动态滑点调整交易参数，提供 MEV 保护
- */
-async function swapQuoteMEV(
-  response: SwapResponse, 
-  options?: { publicClient?: any }
-): Promise<SwapResponse> {
-  try {
-    const inAmount = response?.inAmount;
-    const inTokenDecimals = response?.inToken?.decimals || 18;
-    const inTokenPrice = Number(response?.inToken?.priceUSD || 0);
-    const amount = decimals2Amount(inAmount, inTokenDecimals) * inTokenPrice;
-    if (amount < 1) {
-      return response;
-    }
-    const { publicClient } = options;
-    const OPENOCEAN_CONTRACT = new ethers.Contract(
-      "0x6352a56caadC4F1E25CD6c75970Fa768A3304e64",
-      OpenOceanABI
-    );
-    if (
-      ethers.hexlify(ethers.getBytes(response?.data || "0x").slice(0, 4)) !==
-      OPENOCEAN_CONTRACT.interface.getFunction("swap").selector
-    ) {
-      return response;
-    }
-    let oldCallData = OPENOCEAN_CONTRACT.interface.decodeFunctionData(
-      "swap",
-      response?.data
-    );
-    let callData = [...oldCallData];
-    callData[1] = [...oldCallData[1]];
-    const minOutAmount = BigInt(callData[1][5] || 0);
-    const outAmount = BigInt(callData[1][6] || 0);
-    const slippageAmount = outAmount - minOutAmount;
-
-    let minOutAmounts = await Promise.all(
-      [1, 2, 3].map(async (i) => {
-        const mockMinOutAmount = minOutAmount + (slippageAmount / 4n) * BigInt(i);
-        callData[1][5] = mockMinOutAmount;
-        const params = {
-          from: response?.from as `0x${string}`,
-          to: response?.to as `0x${string}`,
-          data: OPENOCEAN_CONTRACT.interface.encodeFunctionData(
-            "swap",
-            callData
-          ) as `0x${string}`,
-          value: BigInt(response?.value || '0'),
-        };
-        try {
-          await publicClient.estimateGas(params);
-          return mockMinOutAmount;
-        } catch (error) {
-          console.error('Failed to estimate gas:', error);
-          return undefined;
-        }
-      })
-    );
-    let [min1, min2] = minOutAmounts
-      .filter((value) => value !== undefined)
-      .sort((a, b) => (BigInt(b || 0) > BigInt(a || 0) ? 1 : -1))
-      .slice(0, 2);
-    min1 = min1 ?? minOutAmount;
-    min2 = min2 ?? minOutAmount;
-
-    const randomFactor = BigInt(Math.floor(Math.random() * 10000));
-    const minOutAmountDiff = BigInt(min1 || 0) - BigInt(min2 || 0);
-    const finalMinOutAmount = BigInt(min2 || 0) + 
-      (minOutAmountDiff * randomFactor / BigInt(10000));
-    
-    if (finalMinOutAmount < minOutAmount) {
-      return response;
-    }
-    callData[1][5] = finalMinOutAmount;
-    const finalCallData = OPENOCEAN_CONTRACT.interface.encodeFunctionData(
-      "swap",
-      callData
-    );
-    response.minOutAmount = finalMinOutAmount.toString();
-    response.data = finalCallData;
-    return response;
-  } catch (error) {
-    return response;
-  }
-}
-
 // Execute transaction
 async function executeSwap(
   route: ExtendedRoute,