@openocean.finance/widget 1.0.43 → 1.0.44

package/src/services/ExecuteRoute.ts

@@ -12,7 +12,16 @@ import { getPublicClient, getWalletClient } from 'wagmi/actions'
 import { bridgeExecuteSwap } from '../cross/crossChainQuote.js'
 import { useSettingsStore } from '../stores/settings/useSettingsStore.js'
 import { sendAndConfirmSolanaTransaction } from './SendAndConfirmSolanaTransaction.js'
-
+import { adaptBitcoinWallet } from '@relayprotocol/relay-bitcoin-wallet-adapter'
+import * as bitcoin from 'bitcoinjs-lib';
+type DynamicSignPsbtParams = {
+  allowedSighash: number[];
+  unsignedPsbtBase64: string;
+  signature: Array<{
+    address: string;
+    signingIndexes: number[];
+  }>;
+};
 const OpenOceanABI = [
   {
     inputs: [
@@ -164,24 +173,24 @@ async function swapQuoteMEV(
     const inAmount = response?.inAmount
     const inTokenDecimals = response?.inToken?.decimals || 18
     const inTokenPrice = Number(response?.inToken?.priceUSD || 0)
-    const amount = decimals2Amount(inAmount, inTokenDecimals) * inTokenPrice
+    const amount = decimals2Amount(inAmount as string, inTokenDecimals) * inTokenPrice
     if (amount < 1) {
       return response
     }
-    const { publicClient } = options
+    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
+      OPENOCEAN_CONTRACT?.interface?.getFunction('swap')?.selector
     ) {
       return response
     }
     const oldCallData = OPENOCEAN_CONTRACT.interface.decodeFunctionData(
       'swap',
-      response?.data
+      response?.data as any
     )
     const callData = [...oldCallData]
     callData[1] = [...oldCallData[1]]
@@ -291,44 +300,53 @@ async function executeSolanaSwap(
 
     const { transactionRequest, type, quoteData } = step || {}
     if ((type as any) === 'bridge') {
-      const adaptedWallet: any = adaptSolanaWallet(
-        options.account.address?.toString() ||
-          '1nc1nerator11111111111111111111111111111111',
-        792703809, //chain id that Relay uses to identify solana
-        connection,
-        async (transaction) => {
-          try {
-            // Ensure transaction is properly formatted
-            if (
-              transaction instanceof VersionedTransaction ||
-              transaction instanceof Transaction
-            ) {
-              const connector = options.account.connector as any
-              if (typeof connector.signTransaction !== 'function') {
-                throw new Error('Wallet does not support transaction signing')
-              }
-              // Sign transaction
-              const signature = await connector.signTransaction(transaction)
-              const serializedTransaction = signature.serialize({
-                verifySignatures: false,
-                requireAllSignatures: false,
-              })
-              const txid = await connection.sendRawTransaction(
-                serializedTransaction,
-                {
-                  skipPreflight: true,
-                }
-              )
-              return { signature: txid }
+      // Define signAndSendTransaction function
+      const signAndSendTransaction = async (transaction: Transaction | VersionedTransaction) => {
+        try {
+          // Ensure transaction is properly formatted
+          if (
+            transaction instanceof VersionedTransaction ||
+            transaction instanceof Transaction
+          ) {
+            const connector = options.account.connector as any
+            if (typeof connector.signTransaction !== 'function') {
+              throw new Error('Wallet does not support transaction signing')
             }
 
-            throw new Error('Invalid transaction type')
-          } catch (error) {
-            console.error('Transaction sending failed:', error)
-            throw error
+            // Sign transaction
+            const signature = await connector.signTransaction(transaction)
+            const serializedTransaction = signature.serialize({
+              verifySignatures: false,
+              requireAllSignatures: false,
+            })
+            const txid = await connection.sendRawTransaction(
+              serializedTransaction,
+              {
+                skipPreflight: true,
+              }
+            )
+            return { signature: txid }
           }
+
+          throw new Error('Invalid transaction type')
+        } catch (error) {
+          console.error('Transaction sending failed:', error)
+          throw error
         }
+      }
+
+      const adaptedWallet: any = adaptSolanaWallet(
+        options.account.address?.toString() ||
+        '1nc1nerator11111111111111111111111111111111',
+        792703809, //chain id that Relay uses to identify solana
+        connection,
+        signAndSendTransaction
       )
+
+      // Expose connection and sendTransaction method for adapters to use
+      adaptedWallet.connection = connection
+      adaptedWallet.sendTransaction = signAndSendTransaction
+
       const signedTx = await bridgeExecuteSwap({
         quoteData: quoteData,
         walletClient: adaptedWallet,
@@ -352,7 +370,7 @@ async function executeSolanaSwap(
       const txData: any = transactionRequest?.data || ''
       const dexId = transactionRequest?.type || 0
       if (step.action.fromChainId === step.action.toChainId) {
-        if (dexId === 6 || dexId === 7 || dexId === 9) {
+        if (dexId === 6 || dexId === 7 || dexId === 9 || dexId === 10) {
           transaction = VersionedTransaction.deserialize(
             hexToUint8Array(txData)
           )
@@ -415,15 +433,15 @@ async function executeSolanaSwap(
     process.error =
       error instanceof Error
         ? {
-            code: 'EXECUTION_ERROR',
-            message: error.message,
-            htmlMessage: error.message,
-          }
+          code: 'EXECUTION_ERROR',
+          message: error.message,
+          htmlMessage: error.message,
+        }
         : {
-            code: 'UNKNOWN_ERROR',
-            message: 'Unknown error occurred',
-            htmlMessage: 'Unknown error occurred',
-          }
+          code: 'UNKNOWN_ERROR',
+          message: 'Unknown error occurred',
+          htmlMessage: 'Unknown error occurred',
+        }
     step.execution!.status = 'FAILED'
     options.updateRouteHook?.(route)
     throw error
@@ -439,7 +457,6 @@ 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) {
@@ -460,8 +477,7 @@ async function executeEvmSwap(
     )
     const currentChainId = await walletClient.getChainId()
     const targetChainId = step.action.fromChainId
-
-    if (currentChainId != targetChainId) {
+    if (currentChainId != targetChainId && targetChainId != 20000000000001) {
       try {
         // Try to switch to target chain
         await walletClient.switchChain({ id: targetChainId })
@@ -508,7 +524,7 @@ async function executeEvmSwap(
         '0x0000000000000000000000000000000000001010',
       ].indexOf(step.action.fromToken.address) === -1 &&
       step.estimate.approvalAddress !==
-        '0x0000000000000000000000000000000000000000'
+      '0x0000000000000000000000000000000000000000'
     ) {
       let allowance = 0n
       try {
@@ -546,14 +562,14 @@ async function executeEvmSwap(
         BigInt(step.action.fromAmount) +
         BigInt(
           route?.prependedOperatingExpenseCost ||
-            route?.data?.prependedOperatingExpenseCost ||
-            '0'
+          route?.data?.prependedOperatingExpenseCost ||
+          '0'
         )
       if (allowance < BigInt(amount)) {
         const approvalAmount = options.infiniteApproval
           ? BigInt(
-              '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
-            )
+            '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+          )
           : BigInt(amount)
 
         const hash = await walletClient.writeContract({
@@ -590,7 +606,7 @@ async function executeEvmSwap(
         quoteData: quoteData,
         walletClient: walletClient,
       })
-      hash = result.sourceTxHash
+      hash = result?.sourceTxHash || ''
     } else {
       const txRequest = {
         chain: publicClient.chain,
@@ -672,21 +688,252 @@ async function executeEvmSwap(
     process.error =
       error instanceof Error
         ? {
-            code: 'EXECUTION_ERROR',
-            message: error.message,
-            htmlMessage: error.message,
-          }
+          code: 'EXECUTION_ERROR',
+          message: error.message,
+          htmlMessage: error.message,
+        }
         : {
-            code: 'UNKNOWN_ERROR',
-            message: 'Unknown error occurred',
-            htmlMessage: 'Unknown error occurred',
-          }
+          code: 'UNKNOWN_ERROR',
+          message: 'Unknown error occurred',
+          htmlMessage: 'Unknown error occurred',
+        }
     step.execution!.status = 'FAILED'
     options.updateRouteHook?.(route)
     throw error
   }
 }
+function detectBtcWallet() {
+  const anyWindow = typeof window !== 'undefined' ? (window as any) : undefined
+  if (anyWindow.okxwallet?.bitcoin && anyWindow.okxwallet?.bitcoin?.signPsbt) return 'okx';
+  if (anyWindow.unisat && anyWindow.unisat?.signPsbt) return 'unisat';
+  if (anyWindow.BitcoinProvider && anyWindow.BitcoinProvider.request) return 'xverse';
+  return null;
+}
+
+// Get wallet type from connected account
+function getConnectedBtcWallet(account: Account): string | null {
+  if (!account.connector) return null;
+
+  const connectorId = (account.connector as any).id?.toLowerCase() || '';
+  const connectorName = (account.connector as any).name?.toLowerCase() || '';
+
+  // Match by connector ID or name
+  if (connectorId.includes('okx') || connectorId.includes('com.okex.wallet')) {
+    return 'okx';
+  }
+  if (connectorId.includes('unisat')) {
+    return 'unisat';
+  }
+  if (connectorId.includes('xverse') || connectorId.includes('XverseProviders')) {
+    return 'xverse';
+  }
+  if (connectorId.includes('phantom') || connectorName.includes('phantom')) {
+    return 'phantom';
+  }
+  if (connectorId.includes('leather') || connectorName.includes('leather')) {
+    return 'leather';
+  }
+  if (connectorId.includes('onekey') || connectorName.includes('onekey')) {
+    return 'onekey';
+  }
+
+  // Fallback to detection if connector doesn't match
+  return detectBtcWallet();
+}
+
+const createPsbtOptions = (_: any, request: any) => {
+  var _a;
+  const psbtSignOptions: any = {
+    autoFinalized: false,
+  };
+  if (request.signature) {
+    // validatePsbt(psbt, request.allowedSighash, request.signature);
+
+    const toSignInputs = [];
+    for (const signature of request.signature) {
+      if ((_a = signature.signingIndexes) === null || _a === void 0 ? void 0 : _a.length) {
+        for (const index of signature.signingIndexes) {
+          toSignInputs.push({
+            address: signature.address,
+            disableAddressValidation: signature.disableAddressValidation,
+            index,
+            sighashTypes: request.allowedSighash,
+          });
+        }
+      }
+    }
+    psbtSignOptions.toSignInputs = toSignInputs;
+  }
+  return psbtSignOptions;
+};
+
+// Helper function to convert hex response to base64
+function convertHexToBase64(hexString: string): string {
+  try {
+    const buffer = Buffer.from(hexString, 'hex');
+    return buffer.toString('base64');
+  } catch (error) {
+    // If conversion fails, it might already be base64
+    return hexString;
+  }
+}
 
+// Helper function to extract signed PSBT from wallet response
+function extractSignedPsbt(response: any): string | null {
+  if (!response) return null;
+  if (typeof response === 'string') return response;
+  return response.signedPsbtHex || response.signedPsbtBase64 || response.signedPsbt || null;
+}
+
+async function executeBitcoinSwap(
+  step: ExtendedOpenOceanStep,
+  options: ExecuteRouteOptions,
+  process: Process,
+  route: ExtendedRoute
+): Promise<void> {
+  try {
+
+    const { quoteData } = step || {}
+
+    const adaptedWallet: any = adaptBitcoinWallet(
+      options.account.address?.toString() || '',
+      async (_: any, __: any, dynamicParams: DynamicSignPsbtParams) => {
+        const psbtFromBase64 = bitcoin.Psbt.fromBase64(dynamicParams.unsignedPsbtBase64);
+        const psbtHex = psbtFromBase64.toHex();
+        const walletType = detectBtcWallet();
+        const anyWindow = typeof window !== 'undefined' ? (window as any) : undefined
+        switch (walletType) {
+          case 'okx': {
+            const response = await anyWindow.okxwallet?.bitcoin?.signPsbt(
+              psbtHex,
+              createPsbtOptions(psbtFromBase64, dynamicParams)
+            );
+            const signedPsbt = extractSignedPsbt(response);
+            if (!signedPsbt) {
+              throw new Error('Missing psbt response from OKX wallet');
+            }
+            return convertHexToBase64(signedPsbt);
+          }
+
+          case 'unisat': {
+            const response = await anyWindow.unisat?.signPsbt(
+              psbtHex,
+              createPsbtOptions(psbtFromBase64, dynamicParams)
+            );
+            const signedPsbt = extractSignedPsbt(response);
+            if (!signedPsbt) {
+              throw new Error('Missing psbt response from Unisat wallet');
+            }
+            return convertHexToBase64(signedPsbt);
+          }
+
+          case 'xverse': {
+            const response = await anyWindow.BitcoinProvider?.request('signPsbt', {
+              psbt: psbtHex,
+              finalize: true,
+            });
+            const signedPsbt = extractSignedPsbt(response);
+            if (!signedPsbt) {
+              throw new Error('Missing psbt response from Xverse wallet');
+            }
+            return convertHexToBase64(signedPsbt);
+          }
+
+          default:
+            throw new Error(`Unsupported wallet: ${walletType}`);
+        }
+      }
+    );
+    adaptedWallet.sendTransaction = async (params: { recipient: string; amount: string | number }) => {
+      const walletType = detectBtcWallet();
+      const anyWindow = typeof window !== 'undefined' ? (window as any) : undefined
+
+      // Convert amount to satoshis (BTC amount * 100000000)
+      const amountInSatoshis = Number(params.amount)
+      switch (walletType) {
+        case 'okx': {
+          // OKX wallet sendBitcoin method
+          if (anyWindow.okxwallet?.bitcoin?.sendBitcoin) {
+            const txid = await anyWindow.okxwallet.bitcoin.sendBitcoin(
+              params.recipient,
+              amountInSatoshis
+            );
+            return txid;
+          }
+          throw new Error('OKX wallet does not support sendBitcoin');
+        }
+
+        case 'unisat': {
+          // Unisat wallet sendBitcoin method
+          if (anyWindow.unisat?.sendBitcoin) {
+            const txid = await anyWindow.unisat.sendBitcoin(
+              params.recipient,
+              amountInSatoshis
+            );
+            return txid;
+          }
+          throw new Error('Unisat wallet does not support sendBitcoin');
+        }
+
+        case 'xverse': {
+          // Xverse wallet sendBitcoin method
+          if (anyWindow.BitcoinProvider?.request) {
+            const response = await anyWindow.BitcoinProvider.request('sendBitcoin', {
+              address: params.recipient,
+              amount: amountInSatoshis,
+            });
+            return response.txid || response;
+          }
+          throw new Error('Xverse wallet does not support sendBitcoin');
+        }
+
+        default:
+          throw new Error(`Unsupported wallet: ${walletType}`);
+      }
+    }
+
+    const signedTx = await bridgeExecuteSwap({
+      quoteData: quoteData,
+      walletClient: adaptedWallet,
+    });
+
+    if (!signedTx) {
+      throw new Error('Failed to sign transaction')
+    }
+    const hash = signedTx.sourceTxHash
+
+    process.status = 'DONE'
+    process.doneAt = Date.now()
+    process.txHash = hash
+    process.message = 'Transaction confirmed'
+    options.updateRouteHook?.(route)
+
+    // process.status = 'PENDING'
+    // process.txHash = hash
+    // process.message = 'Transaction pending'
+    // options.updateRouteHook?.(route)
+
+
+  } catch (error) {
+    console.error('Bitcoin swap execution failed:', error)
+    process.status = 'FAILED'
+    process.error =
+      error instanceof Error || (error && (error as any)?.message)
+        ? {
+          code: 'EXECUTION_ERROR',
+          message: error instanceof Error ? error.message : 'Unknown error occurred',
+          htmlMessage: error instanceof Error ? error.message : 'Unknown error occurred',
+        }
+        : {
+          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,
@@ -730,6 +977,10 @@ async function executeSwap(
       const currentStep = route.steps[0]
       if (currentStep.action?.fromChainId === 1151111081099710) {
         await executeSolanaSwap(currentStep, options, process, updatedRoute)
+      } else if (currentStep.action?.fromChainId === 20000000000001) {
+        await executeBitcoinSwap(currentStep, options, process, updatedRoute)
+      } else if (currentStep.action?.fromChainId === 20000000000001) {
+        await executeBitcoinSwap(currentStep, options, process, updatedRoute)
       } else {
         await executeEvmSwap(currentStep, options, process, updatedRoute)
       }

package/src/services/OpenOceanService.ts

@@ -17,6 +17,8 @@ export class OpenOceanService {
   // Chain ID to OpenOcean chain name mapping
   private static readonly CHAIN_ID_MAP: Record<string | number, string> = {
     1151111081099710: 'solana', // Solana mainnet
+    20000000000001: 'bitcoin', // Bitcoin mainnet
+    20000000000006: 'near', // Near mainnet
   }
 
   // Get OpenOcean supported chain name
@@ -125,7 +127,21 @@ export class OpenOceanService {
     const response = await fetch(`${this.API_V4_URL}/${chainName}/tokenList`)
     const data = await response.json()
     if (data.code !== 200) {
-      throw new Error('Failed to fetch token list')
+      if (chain === '20000000000001') {
+        data.data = [
+          {
+            address: 'bitcoin',
+            symbol: 'BTC',
+            decimals: 8,
+            isNative: true,
+            name: 'Bitcoin',
+            icon: 'https://assets.coingecko.com/coins/images/1/standard/bitcoin.png',
+            usd: '109559',
+          }
+        ]
+      } else {
+        throw new Error('Failed to fetch token list')
+      }
     }
     return data.data.map((token: OpenOceanToken) => {
       let address = token.address
@@ -159,7 +175,7 @@ export class OpenOceanService {
   }
 
   static async getGasPrice(chain: string) {
-    if (!chain || chain === '1151111081099710') {
+    if (!chain || chain === '1151111081099710' || chain === '20000000000001') {
       return {
         data: {
           gasPrice: '1000000000000000000',
@@ -177,7 +193,7 @@ export class OpenOceanService {
     // 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_V4_URL}/${chainName}/getTokenInfo?tokenAddress=${tokenAddress}`)
     const data = await response.json()
     if (!data || !data.address || !data.symbol || !data.decimals) {
@@ -204,22 +220,30 @@ export class OpenOceanService {
    * @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)
+    let chainName = this.getChainName(chain)
+    if (chain === '20000000000001') {
+      tokenAddresses = ['0x2260fac5e5542a773aa44fbcfedf7c193bc2c599']
+      chainName = '1'
+    }
+
     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
+        if (chain === '20000000000001') {
+          acc.bitcoin = token.usd
+        } else {
+          acc[token.address.toLowerCase()] = token.usd
+        }
       }
       return acc
     }, {})
-
     return prices
   }
 }

package/src/stores/bookmarks/createBookmarkStore.ts

@@ -20,40 +20,40 @@ export const createBookmarksStore = ({
         selectedBookmark: toAddress,
         bookmarks: [],
         recentWallets: [],
-        getBookmark: (address) =>
-          (get() as any).bookmarks.find((bookmark) => bookmark.address === address),
-        addBookmark: (bookmark) => {
-          set((state) => ({
+        getBookmark: (address: string) =>
+          (get() as any).bookmarks.find((bookmark: any) => bookmark.address === address),
+        addBookmark: (bookmark: any) => {
+          set((state: any) => ({
             bookmarks: [bookmark, ...state.bookmarks],
           }))
         },
-        removeBookmark: (address) => {
-          set((state) => ({
+        removeBookmark: (address: string) => {
+          set((state: any) => ({
             bookmarks: state.bookmarks.filter(
-              (storedBookmark) => storedBookmark.address !== address
+              (storedBookmark: any) => storedBookmark.address !== address
             ),
           }))
         },
         getSelectedBookmark: () => (get() as any).selectedBookmark,
-        setSelectedBookmark: (bookmark) => {
-          set((_state) => ({
+        setSelectedBookmark: (bookmark: any) => {
+          set((_state: any) => ({
             selectedBookmark: bookmark,
           }))
         },
-        addRecentWallet: (bookmark) => {
-          set((state) => ({
+        addRecentWallet: (bookmark: any) => {
+          set((state: any) => ({
             recentWallets: [
               bookmark,
               ...state.recentWallets.filter(
-                (recentWallet) => recentWallet.address !== bookmark.address
+                (recentWallet: any) => recentWallet.address !== bookmark.address
               ),
             ].slice(0, recentWalletsLimit),
           }))
         },
-        removeRecentWallet: (address) => {
-          set((state) => ({
+        removeRecentWallet: (address: string) => {
+          set((state: any) => ({
             recentWallets: state.recentWallets.filter(
-              (storedRecent) => storedRecent.address !== address
+              (storedRecent: any) => storedRecent.address !== address
             ),
           }))
         },

package/src/utils/chainType.ts

@@ -2,11 +2,34 @@ import { isUTXOAddress } from '@bigmi/core'
 import { ChainId, ChainType, isSVMAddress } from '@openocean.finance/widget-sdk'
 import { isAddress as isEVMAddress } from 'viem'
 
-const chainTypeAddressValidation = {
+const isNearAddress = (address: string) => {
+  if (!address) {
+    return false
+  }
+
+  // Implicit accounts are 64-char hex strings
+  const isImplicitAccount = /^[0-9a-f]{64}$/i.test(address)
+  if (isImplicitAccount) {
+    return true
+  }
+
+  // Named accounts must be lowercase and end with a TLD (e.g. .near, .testnet, custom subdomain)
+  const isNamedAccount =
+    /^[a-z0-9_-]+(\.[a-z0-9_-]+)*(\.near|\.testnet|\.chain|\.btc)?$/.test(
+      address
+    )
+  return isNamedAccount
+}
+
+const chainTypeAddressValidation: Record<
+  ChainType,
+  (address: string) => boolean
+> = {
   [ChainType.EVM]: isEVMAddress,
   [ChainType.SVM]: isSVMAddress,
   [ChainType.UTXO]: isUTXOAddress,
   [ChainType.MVM]: () => false,
+  [ChainType.NVM]: isNearAddress,
 }
 
 export const getChainTypeFromAddress = (
@@ -26,4 +49,5 @@ export const defaultChainIdsByType = {
   [ChainType.SVM]: ChainId.SOL,
   [ChainType.UTXO]: ChainId.BTC,
   [ChainType.MVM]: ChainId.SUI,
+  [ChainType.NVM]: ChainId.NEAR,
 }

package/src/utils/getPriceImpact.ts

@@ -28,9 +28,9 @@ export const getPriceImpact = ({
   if (!fromTokenPrice || !toTokenPrice) {
     return 0
   }
-  console.log('fromTokenPrice', fromTokenPrice)
-  console.log('toTokenPrice', toTokenPrice)
-  console.log('fromTokenPrice / toTokenPrice', fromTokenPrice / toTokenPrice)
+  // console.log('fromTokenPrice', fromTokenPrice)
+  // console.log('toTokenPrice', toTokenPrice)
+  // console.log('fromTokenPrice / toTokenPrice', fromTokenPrice / toTokenPrice)
   const priceImpact = toTokenPrice / fromTokenPrice - 1
 
   return priceImpact