@openocean.finance/widget 1.0.28 → 1.0.30

package/src/hooks/useRoutes.ts

@@ -2,14 +2,17 @@ import { useAccount } from '@openocean.finance/wallet-management'
 import type { Route } from '@openocean.finance/widget-sdk'
 import { OpenOceanErrorCode } from '@openocean.finance/widget-sdk'
 import { useQuery, useQueryClient } from '@tanstack/react-query'
-import { parseUnits, formatUnits } from 'viem'
+import { parseUnits } from 'viem'
+import { useConfig } from 'wagmi'
+import { getWalletClient } from 'wagmi/actions'
+import { getCrossChainQuote } from '../cross/crossChainQuote.js'
 import { useWidgetConfig } from '../providers/WidgetProvider/WidgetProvider.js'
-import { DebridgeService } from '../services/DebridgeService.js'
 import { OpenOceanService } from '../services/OpenOceanService.js'
 import { useFieldValues } from '../stores/form/useFieldValues.js'
 import { useSetExecutableRoute } from '../stores/routes/useSetExecutableRoute.js'
 import { useSettings } from '../stores/settings/useSettings.js'
 import { defaultSlippage } from '../stores/settings/useSettingsStore.js'
+import { useServerErrorStore } from '../stores/useServerErrorStore.js'
 import { WidgetEvent } from '../types/events.js'
 import { getChainTypeFromAddress } from '../utils/chainType.js'
 import { useChain } from './useChain.js'
@@ -20,7 +23,6 @@ import { useIsBatchingSupported } from './useIsBatchingSupported.js'
 import { useSwapOnly } from './useSwapOnly.js'
 import { useToken } from './useToken.js'
 import { useWidgetEvents } from './useWidgetEvents.js'
-import { useServerErrorStore } from '../stores/useServerErrorStore.js'
 
 const refetchTime = 60_000
 
@@ -29,6 +31,8 @@ interface RoutesProps {
 }
 
 export const useRoutes = ({ observableRoute }: RoutesProps = {}) => {
+  const wagmiConfig = useConfig()
+
   const {
     subvariant,
     sdkConfig,
@@ -38,7 +42,7 @@ export const useRoutes = ({ observableRoute }: RoutesProps = {}) => {
     fee,
     feeConfig,
     useRelayerRoutes,
-    referrer
+    referrer,
   } = useWidgetConfig()
   const setExecutableRoute = useSetExecutableRoute()
   const queryClient = useQueryClient()
@@ -96,14 +100,18 @@ export const useRoutes = ({ observableRoute }: RoutesProps = {}) => {
   const contractCallQuoteEnabled: boolean =
     subvariant === 'custom' ? Boolean(contractCalls && account.address) : true
 
-  const toAddress = fromChainId === toChainId || (fromChain?.chainType === 'EVM' && toChain?.chainType === 'EVM') ? account.address : _toAddress
-  // When we bridge between ecosystems we need to be sure toAddress is set and has the same chainType as toChain
+  const toAddress =
+    fromChainId === toChainId ||
+    (fromChain?.chainType === 'EVM' && toChain?.chainType === 'EVM')
+      ? account.address
+      : _toAddress
+  // When bridging between ecosystems, we need to ensure toAddress is set and has the same chainType as toChain
   // If toAddress is set, it must have the same chainType as toChain
   const hasToAddressAndChainTypeSatisfied: boolean =
     !!toChain &&
     !!toAddress &&
     getChainTypeFromAddress(toAddress) === toChain.chainType
-  // We need to check for toAddress only if it is set
+  // We only need to check if toAddress is set
   const isToAddressSatisfied = toAddress
     ? hasToAddressAndChainTypeSatisfied
     : true
@@ -181,9 +189,7 @@ export const useRoutes = ({ observableRoute }: RoutesProps = {}) => {
         try {
           useServerErrorStore.getState().setError(null)
           const fromAmount = parseUnits(fromTokenAmount, fromToken!.decimals)
-          const formattedSlippage = slippage
-            ? (Number.parseFloat(slippage) / 100).toString()
-            : '0.01' // Default slippage 1%
+          const formattedSlippage = slippage ? slippage : '1' // Default slippage 1%
 
           let quoteResult: any // Initialize quoteResult
 
@@ -209,17 +215,29 @@ export const useRoutes = ({ observableRoute }: RoutesProps = {}) => {
                 chainId: toChainId,
               }
 
-              quoteResult = await DebridgeService.swapUThenCross({
-                fromMsg: fromMsg,
-                toMsg: toMsg,
+              const walletClient = await getWalletClient(wagmiConfig)
+
+              quoteResult = await getCrossChainQuote({
+                feeBps: 10,
+                fromMsg,
+                toMsg,
                 inAmount: fromAmount.toString(),
-                slippage_tolerance: formattedSlippage, // Debridge might use a different format/unit
+                slippage_tolerance: formattedSlippage,
                 account: account?.address || '',
-                receiver: toAddress, // Assuming receiver is the same as account for now
+                walletClient,
               })
+
+              // quoteResult = await DebridgeService.swapUThenCross({
+              //   fromMsg: fromMsg,
+              //   toMsg: toMsg,
+              //   inAmount: fromAmount.toString(),
+              //   slippage_tolerance: formattedSlippage, // Debridge might use a different format/unit
+              //   account: account?.address || '',
+              //   receiver: toAddress, // Assuming receiver is the same as account for now
+              // })
               // Add a flag or modify structure to indicate it's a Debridge route
               if (quoteResult) {
-                quoteResult.isDebridgeRoute = true
+                quoteResult.isBridge = true
               }
             } else {
               console.warn(
@@ -260,27 +278,29 @@ export const useRoutes = ({ observableRoute }: RoutesProps = {}) => {
             }
             // Ensure the structure is consistent or add a flag
             if (quoteResult) {
-              quoteResult.isDebridgeRoute = false
+              quoteResult.isBridge = false
             }
           }
-          const data = quoteResult && quoteResult.data || {}
+          const data = (quoteResult && quoteResult.data) || {}
           // minOutAmount calculation is now handled within DebridgeService or OpenOceanService
-          const isDebridge = data.isDebridgeRoute === true
-
-          let toAmountMin = '0';
+          const isBridge = quoteResult.isBridge
+          let toAmountMin = '0'
           if (data?.minOutAmount) {
-            toAmountMin = data.minOutAmount;
-          } else if (isDebridge) {
-            toAmountMin = '0';
+            toAmountMin = data.minOutAmount
+          } else if (isBridge) {
+            toAmountMin = '0'
           } else {
-            const amount = Number(data?.outAmount || 0);
-            const slippageValue = Number.parseFloat(slippage);
-            const minAmount = (amount * (100 - slippageValue)) / 100;
-            toAmountMin = minAmount.toFixed(20).replace(/\.?0+$/, '');
-            // 如果还是科学计数法，再强制转字符串
+            const amount = Number(data?.outAmount || 0)
+            const slippageValue = Number.parseFloat(slippage)
+            const minAmount = (amount * (100 - slippageValue)) / 100
+            toAmountMin = minAmount.toFixed(20).replace(/\.?0+$/, '')
+            // If still in scientific notation, force convert to string
             if (toAmountMin.includes('e') || toAmountMin.includes('E')) {
-              toAmountMin = minAmount.toLocaleString('fullwide', { useGrouping: false, maximumSignificantDigits: 21 });
-              toAmountMin = toAmountMin.replace(/\.?0+$/, '');
+              toAmountMin = minAmount.toLocaleString('fullwide', {
+                useGrouping: false,
+                maximumSignificantDigits: 21,
+              })
+              toAmountMin = toAmountMin.replace(/\.?0+$/, '')
             }
           }
           const route: Route = {
@@ -303,8 +323,8 @@ export const useRoutes = ({ observableRoute }: RoutesProps = {}) => {
             steps: [
               {
                 id: '1',
-                type: 'openocean',
-                tool: isDebridge ? 'debridge' : 'openocean',
+                type: isBridge ? 'bridge' : 'swap',
+                tool: isBridge ? 'bridge' : 'openocean',
                 transactionRequest: {
                   chainId: data?.chainId || fromChainId,
                   from: data?.from,
@@ -312,12 +332,12 @@ export const useRoutes = ({ observableRoute }: RoutesProps = {}) => {
                   to: data?.to,
                   value: data?.value || '0x0',
                   gasPrice: data?.gasPrice,
-                  type: isDebridge ? '0x0' : data?.dexId || '0x0',
+                  type: isBridge ? data?.quoteAdapterKey : data?.dexId || '0x0',
                 },
                 toolDetails: {
-                  key: isDebridge ? 'debridge' : 'openocean',
-                  name: isDebridge ? 'Debridge' : 'OpenOcean',
-                  logoURI: isDebridge
+                  key: isBridge ? data?.quoteAdapterKey : 'openocean',
+                  name: isBridge ? data?.quoteAdapterName : 'OpenOcean',
+                  logoURI: isBridge
                     ? 'https://s3.openocean.finance/static/debridge.svg'
                     : 'https://assets.coingecko.com/coins/images/17014/small/ooe_log.png',
                 },
@@ -335,13 +355,11 @@ export const useRoutes = ({ observableRoute }: RoutesProps = {}) => {
                   fromAmount: fromAmount.toString(),
                   toAmount: data?.outAmount || '0',
                   toAmountMin,
-                  approvalAddress:
-                    data?.approveContract ||
-                    (isDebridge
-                      ? data?.to
-                      : '0x6352a56caadC4F1E25CD6c75970Fa768A3304e64'),
-                  executionDuration: data?.executionDuration || Math.floor(Math.random() * 20) + 40,
-                  tool: isDebridge ? 'debridge' : 'openocean',
+                  approvalAddress: data?.approveContract || '0x0',
+                  executionDuration:
+                    data?.executionDuration ||
+                    Math.floor(Math.random() * 20) + 40,
+                  tool: isBridge ? 'bridge' : 'openocean',
                   feeCosts: data?.feeCosts || [
                     {
                       name: 'Gas Fee',
@@ -355,6 +373,7 @@ export const useRoutes = ({ observableRoute }: RoutesProps = {}) => {
                   ],
                 },
                 includedSteps: [],
+                quoteData: isBridge ? data : null,
               },
             ],
             ...(data as any),

package/src/hooks/useSettingMonitor.ts

@@ -27,7 +27,6 @@ export const useSettingMonitor = () => {
   const { tools } = useTools()
   const config = useWidgetConfig()
   const { setDefaultSettings, resetSettings } = useSettingsActions()
-
   const isSlippageChanged = config.slippage
     ? Number(slippage) !== config.slippage * 100
     : slippage !== defaultConfigurableSettings.slippage

package/src/hooks/useTokenPrice.ts

@@ -9,11 +9,13 @@ export const useTokenPrice = (chainId?: number, token?: TokenAmount) => {
       if (!chainId || !token?.address) {
         return undefined
       }
-      const prices = await OpenOceanService.getTokensPrice(chainId.toString(), [token.address])
+      const prices = await OpenOceanService.getTokensPrice(chainId.toString(), [
+        token.address,
+      ])
       return prices[token.address.toLowerCase()] || 0
     },
     enabled: !!chainId && !!token?.address,
-    refetchInterval: 60_000, // 每分钟更新一次价格
+    refetchInterval: 60_000, // Update price every minute
     staleTime: 60_000,
   })
 
@@ -21,4 +23,4 @@ export const useTokenPrice = (chainId?: number, token?: TokenAmount) => {
     price,
     isLoading,
   }
-} 
+}

package/src/services/ExecuteRoute.ts

@@ -8,6 +8,7 @@ import type {
 import { Connection, Transaction, VersionedTransaction } from '@solana/web3.js'
 import { ethers } from 'ethers'
 import { getPublicClient, getWalletClient } from 'wagmi/actions'
+import { bridgeExecuteSwap } from '../cross/crossChainQuote.js'
 import { useSettingsStore } from '../stores/settings/useSettingsStore.js'
 import { sendAndConfirmSolanaTransaction } from './SendAndConfirmSolanaTransaction.js'
 
@@ -123,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>
@@ -135,6 +251,7 @@ interface ExecuteRouteOptions {
 }
 
 interface ExtendedOpenOceanStep extends OpenOceanStep {
+  quoteData?: any
   execution?: {
     status: ExecutionStatus
     process: Process[]
@@ -172,7 +289,7 @@ 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))
@@ -301,22 +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
+      ].indexOf(step.action.fromToken.address) === -1 &&
+      step.estimate.approvalAddress !==
+        '0x0000000000000000000000000000000000000000'
     ) {
       let allowance = 0n
       try {
@@ -391,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',
-        }
+      // 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',
+          }
 
-        // 调用 swap_quote_mev 获取调整后的交易数据
-        const adjustedResponse = await swapQuoteMEV(response, { publicClient })
+          // Call swap_quote_mev to get adjusted transaction data
+          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')
+          // 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
@@ -485,121 +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
-    }
-    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 (error) {
-    return response
-  }
-}
-
 // Execute transaction
 async function executeSwap(
   route: ExtendedRoute,