@openocean.finance/widget 1.0.44 → 1.0.46

package/src/cross/adapters/LifiAdapter.ts

@@ -2,6 +2,7 @@ import { createConfig, getQuote, getStatus } from '@lifi/sdk'
 import { WalletAdapterProps } from '@solana/wallet-adapter-base'
 import { Connection, Transaction, VersionedTransaction } from '@solana/web3.js'
 import { WalletClient, formatUnits } from 'viem'
+import * as bitcoin from 'bitcoinjs-lib'
 
 import { CROSS_CHAIN_FEE_RECEIVER, ZERO_ADDRESS, Currency, SolanaToken, MAINNET_NETWORKS } from '../constants/index.js'
 
@@ -17,11 +18,25 @@ import {
   SwapStatus,
 } from './BaseSwapAdapter.js'
 
+type DynamicSignPsbtParams = {
+  allowedSighash: number[]
+  unsignedPsbtBase64: string
+  signature: Array<{
+    address: string
+    signingIndexes: number[]
+  }>
+}
+type TransactionRequest = {
+  to: string
+  value: string
+  data: string
+}
+
 export class LifiAdapter extends BaseSwapAdapter {
   constructor() {
     super()
     createConfig({
-      integrator: 'kyberswap',
+      integrator: 'openocean',
     })
   }
 
@@ -32,34 +47,57 @@ export class LifiAdapter extends BaseSwapAdapter {
     return 'https://storage.googleapis.com/ks-setting-1d682dca/aed3a971-48be-4c3c-9597-5ab78073fbf11745552578218.png'
   }
   getSupportedChains(): Chain[] {
-    return [NonEvmChain.Solana, ...MAINNET_NETWORKS]
+    return [NonEvmChain.Solana, NonEvmChain.Bitcoin, ...MAINNET_NETWORKS]
   }
 
   getSupportedTokens(_sourceChain: Chain, _destChain: Chain): Currency[] {
     return []
   }
 
+
+
   async getQuote(params: QuoteParams): Promise<NormalizedQuote> {
-    const r = await getQuote({
-      fromChain: params.fromChain === 1151111081099710 ? 'SOL' : +params.fromChain, // Arbitrum
-      fromToken:
-        params.fromChain === 1151111081099710
-          ? (params.fromToken as SolanaToken).id
-          : (params.fromToken as any).isNative
-            ? ZERO_ADDRESS
-            : (params.fromToken as any).wrapped.address,
+
+    let fromToken = (params.fromToken as any).isNative
+      ? ZERO_ADDRESS
+      : (params.fromToken as any).address
+    if (params.fromChain === 20000000000001 || params.fromChain === 1151111081099710) {
+      fromToken = (params.fromToken as any).address
+    }
+    let fromChain = params.fromChain === 1151111081099710 ? 'SOL' : +params.fromChain
+    if (params.fromChain === 20000000000001) {
+      fromChain = 'BTC'
+    }
+
+
+    let toToken = (params.toToken as any).isNative
+      ? ZERO_ADDRESS
+      : (params.toToken as any).address
+    if (params.toChain === 20000000000001 || params.toChain === 1151111081099710) {
+      toToken = (params.toToken as any).address
+    }
+    let toChain = params.toChain === 1151111081099710 ? 'SOL' : +params.toChain
+    if (params.toChain === 20000000000001) {
+      toChain = 'BTC'
+    }
+
+
+    let quoteParams = {
+      fromChain, // Arbitrum
+      fromToken,
       fromAmount: params.amount,
       fromAddress: params.sender === ZERO_ADDRESS ? CROSS_CHAIN_FEE_RECEIVER : params.sender,
-
-      toChain: params.toChain === 1151111081099710 ? 'SOL' : +params.toChain,
-      toToken:
-        params.toChain === 1151111081099710
-          ? (params.toToken as SolanaToken).id
-          : (params.toToken as any).isNative
-            ? ZERO_ADDRESS
-            : (params.toToken as any).wrapped.address,
+      toChain,
+      toToken,
       toAddress: params.recipient,
       fee: params.feeBps / 10_000,
+    }
+    const r = await getQuote(quoteParams).catch(error => {
+      if (error && error.cause && error.cause.responseBody && error.cause.responseBody.message) {
+        throw new Error(error.cause.responseBody.message)
+      } else {
+        throw error
+      }
     })
 
     //const inputUsd = Number(r.estimate.fromAmountUSD || '0')
@@ -74,6 +112,9 @@ export class LifiAdapter extends BaseSwapAdapter {
       ? Number(r.estimate.toAmountUSD)
       : params.tokenOutUsd * +formattedOutputAmount
 
+    const protocolFee: any = r.estimate.feeCosts?.reduce((acc: number, curr: any) => acc + Number(curr.amountUSD), 0) || 0
+    const gasFeeUsd = r.estimate.gasCosts.reduce((acc: number, curr: any) => acc + Number(curr.amountUSD), 0)
+
     return {
       quoteParams: params,
       outputAmount: BigInt(r.estimate.toAmount),
@@ -84,13 +125,13 @@ export class LifiAdapter extends BaseSwapAdapter {
       priceImpact: !inputUsd || !outputUsd ? NaN : ((inputUsd - outputUsd) * 100) / inputUsd,
       rate: +formattedOutputAmount / +formattedInputAmount,
 
-      gasFeeUsd: 0,
+      gasFeeUsd,
 
       timeEstimate: r.estimate.executionDuration,
       contractAddress: r.transactionRequest?.to || r.estimate.approvalAddress,
       rawQuote: r,
 
-      protocolFee: 0,
+      protocolFee,
       platformFeePercent: (params.feeBps * 100) / 10_000,
     }
   }
@@ -103,8 +144,177 @@ export class LifiAdapter extends BaseSwapAdapter {
     sendTransaction?: WalletAdapterProps['sendTransaction'],
     connection?: Connection,
   ): Promise<NormalizedTxResponse> {
+    if (quote.quoteParams.fromChain === NonEvmChain.Bitcoin) {
+      // Get user address
+      const account = (walletClient as any).account?.address || quote.quoteParams.sender
+      if (!account) throw new Error('WalletClient account is not defined')
+
+      const transactionRequest: TransactionRequest = quote.rawQuote.transactionRequest
+
+      if (!transactionRequest.data) {
+        throw new Error('TransactionRequest data is missing')
+      }
+
+      // Parse PSBT (may be base64 or hex)
+      let psbt: bitcoin.Psbt
+      try {
+        // Try to parse as base64
+        psbt = bitcoin.Psbt.fromBase64(transactionRequest.data, { network: bitcoin.networks.bitcoin })
+      } catch {
+        try {
+          // Try to parse as hex
+          psbt = bitcoin.Psbt.fromHex(transactionRequest.data, { network: bitcoin.networks.bitcoin })
+        } catch (error) {
+          throw new Error(`Failed to parse PSBT: ${error}`)
+        }
+      }
+
+      // Detect wallet type
+      const anyWindow = typeof window !== 'undefined' ? (window as any) : undefined
+      let connectorName: string | undefined
+      if (anyWindow?.okxwallet?.bitcoin) connectorName = 'OKX Wallet'
+      else if (anyWindow?.unisat) connectorName = 'Unisat'
+      else if (anyWindow?.BitcoinProvider) connectorName = 'Xverse'
+      else if (anyWindow?.phantom?.bitcoin) connectorName = 'Phantom'
+      else throw new Error('No Bitcoin wallet found')
+
+      // Extract inputs to sign from PSBT
+      const inputsToSign: any[] = []
+      for (let index = 0; index < psbt.data.inputs.length; index++) {
+        const input = psbt.data.inputs[index]
+        let inputAddress: string
+
+        if (input.witnessUtxo) {
+          // Extract address from witnessUtxo
+          inputAddress = bitcoin.address.fromOutputScript(input.witnessUtxo.script, bitcoin.networks.bitcoin)
+        } else if (input.nonWitnessUtxo) {
+          // Extract address from nonWitnessUtxo (needs output index, simplified here)
+          // Usually needs to be extracted from transaction, using account address as default here
+          inputAddress = account.toString()
+        } else {
+          inputAddress = account.toString()
+        }
+
+        // Only add inputs that belong to the current account
+        if (inputAddress === account.toString()) {
+          inputsToSign.push({
+            index,
+            address: inputAddress,
+          })
+        }
+      }
+
+      if (inputsToSign.length === 0) {
+        throw new Error('No inputs found to sign')
+      }
+
+      const psbtBase64 = psbt.toBase64()
+      const psbtHex = psbt.toHex()
+      let signedPsbtBase64: string
+
+      // Sign PSBT using wallet
+      switch (connectorName) {
+        case 'OKX Wallet': {
+          const signOptions = {
+            autoFinalized: false,
+            toSignInputs: inputsToSign.map((item) => ({
+              index: item.index,
+              address: item.address,
+              sighashTypes: [1], // SIGHASH_ALL
+            })),
+          }
+          const response = await anyWindow.okxwallet.bitcoin.signPsbt(psbtHex, signOptions)
+          signedPsbtBase64 = this.convertHexToBase64(this.extractSignedPsbt(response) || '')
+          break
+        }
+
+        case 'Unisat': {
+          const signOptions = {
+            autoFinalized: false,
+            toSignInputs: inputsToSign.map((item) => ({
+              index: item.index,
+              address: item.address,
+              sighashTypes: [1],
+            })),
+          }
+          const response = await anyWindow.unisat.signPsbt(psbtHex, signOptions)
+          signedPsbtBase64 = this.convertHexToBase64(this.extractSignedPsbt(response) || '')
+          break
+        }
+
+        case 'Xverse': {
+          const response = await anyWindow.BitcoinProvider.request('signPsbt', {
+            psbt: psbtHex,
+            finalize: false,
+            toSignInputs: inputsToSign.map((item) => ({
+              index: item.index,
+              address: item.address,
+            })),
+          })
+          signedPsbtBase64 = this.extractSignedPsbt(response) || ''
+          break
+        }
+
+        case 'Phantom': {
+          const phantom = anyWindow.phantom.bitcoin
+          if (!phantom?.signPSBT) throw new Error('Phantom wallet does not support signPSBT')
+
+          const response = await phantom.signPSBT(psbtBase64, {
+            autoFinalize: false,
+            inputsToSign: inputsToSign.map((item) => ({
+              index: item.index,
+              address: item.address,
+              sighashTypes: [1],
+            })),
+          })
+          signedPsbtBase64 = this.extractSignedPsbt(response) || ''
+          break
+        }
+
+        default:
+          throw new Error(`Unsupported wallet: ${connectorName}`)
+      }
+
+      if (!signedPsbtBase64) {
+        throw new Error('Failed to sign PSBT')
+      }
+
+      // Finalize PSBT and extract transaction
+      const signedPsbt = bitcoin.Psbt.fromBase64(signedPsbtBase64, { network: bitcoin.networks.bitcoin })
+      signedPsbt.finalizeAllInputs()
+      const rawTx = signedPsbt.extractTransaction().toHex()
+
+      // Broadcast transaction to mempool.space
+      const txHash = await fetch('https://mempool.space/api/tx', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'text/plain',
+        },
+        body: rawTx,
+      }).then((r) => r.text())
+
+      if (!txHash || txHash.startsWith('<')) {
+        throw new Error(`Failed to broadcast transaction: ${txHash}`)
+      }
+
+      return {
+        sender: quote.quoteParams.sender,
+        id: txHash,
+        sourceTxHash: txHash,
+        adapter: this.getName(),
+        sourceChain: quote.quoteParams.fromChain,
+        targetChain: quote.quoteParams.toChain,
+        inputAmount: quote.quoteParams.amount,
+        outputAmount: quote.outputAmount.toString(),
+        sourceToken: quote.quoteParams.fromToken,
+        targetToken: quote.quoteParams.toToken,
+        timestamp: new Date().getTime(),
+      }
+    }
+
+
     if (quote.quoteParams.fromChain === NonEvmChain.Solana) {
-      if (!connection || !sendTransaction) throw new Error('Connection is not defined for Solana swap')
+      if (!walletClient.sendTransaction) throw new Error('Connection is not defined for Solana swap')
       const txBuffer = Buffer.from(quote.rawQuote.transactionRequest.data, 'base64')
 
       // Try to deserialize as VersionedTransaction first
@@ -125,39 +335,39 @@ export class LifiAdapter extends BaseSwapAdapter {
       console.log('Transaction parsed successfully:', transaction)
 
       // Send through wallet adapter
-      const signature = await sendTransaction(transaction, connection)
+      const tx: any = await walletClient.sendTransaction(transaction)
+      const signature = tx.signature
+      // try {
+      //   const latestBlockhash = await connection.getLatestBlockhash()
 
-      try {
-        const latestBlockhash = await connection.getLatestBlockhash()
-
-        // Wait for confirmation with timeout
-        const confirmation = await Promise.race([
-          connection.confirmTransaction(
-            {
-              signature,
-              blockhash: latestBlockhash.blockhash,
-              lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
-            },
-            'confirmed',
-          ),
-          new Promise((_, reject) => setTimeout(() => reject(new Error('Transaction confirmation timeout')), 60000)),
-        ])
-
-        const confirmationResult = confirmation as { value: { err: any } }
-        if (confirmationResult.value.err) {
-          throw new Error(`Transaction failed: ${JSON.stringify(confirmationResult.value.err)}`)
-        }
+      //   // Wait for confirmation with timeout
+      //   const confirmation = await Promise.race([
+      //     connection.confirmTransaction(
+      //       {
+      //         signature,
+      //         blockhash: latestBlockhash.blockhash,
+      //         lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+      //       },
+      //       'confirmed',
+      //     ),
+      //     new Promise((_, reject) => setTimeout(() => reject(new Error('Transaction confirmation timeout')), 60000)),
+      //   ])
 
-        console.log('Transaction confirmed successfully!')
-      } catch (confirmError) {
-        console.error('Transaction confirmation failed:', confirmError)
+      //   const confirmationResult = confirmation as { value: { err: any } }
+      //   if (confirmationResult.value.err) {
+      //     throw new Error(`Transaction failed: ${JSON.stringify(confirmationResult.value.err)}`)
+      //   }
 
-        // Check if transaction actually succeeded despite timeout
-        const txStatus = await connection.getSignatureStatus(signature)
-        if (txStatus?.value?.confirmationStatus !== 'confirmed') {
-          throw new Error(`Transaction was not confirmed: ${confirmError.message}`)
-        }
-      }
+      //   console.log('Transaction confirmed successfully!')
+      // } catch (confirmError) {
+      //   console.error('Transaction confirmation failed:', confirmError)
+
+      //   // Check if transaction actually succeeded despite timeout
+      //   const txStatus = await connection.getSignatureStatus(signature)
+      //   if (txStatus?.value?.confirmationStatus !== 'confirmed') {
+      //     throw new Error(`Transaction was not confirmed: ${confirmError.message}`)
+      //   }
+      // }
       return {
         sender: quote.quoteParams.sender,
         id: signature,
@@ -211,4 +421,46 @@ export class LifiAdapter extends BaseSwapAdapter {
       status: res.status === 'DONE' ? 'Success' : res.status === 'FAILED' ? 'Failed' : 'Processing',
     }
   }
+
+  // Helper function: Create PSBT signature options
+  private createPsbtOptions(psbt: bitcoin.Psbt, request: DynamicSignPsbtParams) {
+    const psbtSignOptions: any = {
+      autoFinalized: false,
+    }
+    if (request.signature) {
+      const toSignInputs: any[] = []
+      for (const signature of request.signature) {
+        if (signature.signingIndexes?.length) {
+          for (const index of signature.signingIndexes) {
+            toSignInputs.push({
+              address: signature.address,
+              disableAddressValidation: (signature as any).disableAddressValidation,
+              index,
+              sighashTypes: request.allowedSighash,
+            })
+          }
+        }
+      }
+      psbtSignOptions.toSignInputs = toSignInputs
+    }
+    return psbtSignOptions
+  }
+
+  // Helper function: Convert hex to base64
+  private convertHexToBase64(hexString: string): string {
+    try {
+      const buffer = Buffer.from(hexString, 'hex')
+      return buffer.toString('base64')
+    } catch (error) {
+      // If conversion fails, it may already be base64
+      return hexString
+    }
+  }
+
+  // Helper function: Extract signed PSBT from wallet response
+  private extractSignedPsbt(response: any): string | null {
+    if (!response) return null
+    if (typeof response === 'string') return response
+    return response.signedPsbtHex || response.signedPsbtBase64 || response.signedPsbt || null
+  }
 }

package/src/cross/adapters/RelayAdapter.ts

@@ -25,7 +25,8 @@ import {
   sonic,
   unichain,
   zksync,
-  celo
+  celo,
+  monad
 } from 'viem/chains'
 import type { Currency } from '../constants/index.js'
 
@@ -104,7 +105,6 @@ const plasma = defineChain({
 const SolanaChainId = 792703809
 const BitcoinChainId = 8253038
 const BitcoinAddress = 'bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqmql8k8'
-const MonadChainId = 143
 
 const solanaChain = {
   id: SolanaChainId,
@@ -119,15 +119,6 @@ const bitcoinChain = {
   displayName: 'Bitcoin',
   vmType: 'bvm' as const,
 } as RelayChain
-
-
-const MonadChain = {
-  id: MonadChainId,
-  name: 'Monad',
-  displayName: 'Monad',
-  vmType: 'evm' as const,
-} as RelayChain
-
 export class RelayAdapter extends BaseSwapAdapter {
   constructor() {
     super()
@@ -155,9 +146,10 @@ export class RelayAdapter extends BaseSwapAdapter {
         hyperEvm,
         plasma,
         celo,
+        monad,
       ]
         .map(convertViemChainToRelayChain)
-        .concat(solanaChain as any, bitcoinChain as any, MonadChain as any),
+        .concat(solanaChain as any, bitcoinChain as any),
     })
   }
 

package/src/cross/adapters/index.ts

@@ -5,6 +5,6 @@ export * from './RelayAdapter.js'
 export * from './MayanAdapter.js'
 // export * from './SymbiosisAdapter.js'
 // export * from './DebridgeAdapter.js'
-// export * from './LifiAdapter.js'
+export * from './LifiAdapter.js'
 // export * from './KyberSwapAdapter.js'
 export * from './NearIntentsAdapter.js'

package/src/cross/crossChainQuote.ts

@@ -90,7 +90,7 @@ export async function getCrossChainQuote({
           quoteResults.push({ adapter, quote })
         }
       } catch (error) {
-        errorMsg = error instanceof Error ? error.message : 'Unknown error'
+        errorMsg = error instanceof Error || error?.message ? error.message : 'Unknown error'
         // Ignore individual adapter errors, continue getting quotes from other adapters
         console.warn(`Failed to get quote from ${adapter.getName()}:`, error)
       }
@@ -148,7 +148,65 @@ export async function getCrossChainQuote({
     }
   } catch (error) {
     console.error('Error getting cross-chain quote:', error)
-    throw error
+    let errors = [
+      {
+        message: 'Please connect your wallet first.',
+        conditions: [
+          'refundTo should not be empty',
+          'User is required',
+          'fromAddress" is missing'
+        ],
+      },
+      {
+        message: 'The input amount is too low.',
+        conditions: [
+          'Swap output amount is too small to cover fees required to execute swap',
+          'Amount is too low for bridge',
+          'Amount too small',
+          'Amount too low',
+        ],
+      },
+      {
+        message: 'Insufficient balance in your wallet.',
+        conditions: [
+          'Insufficient funds',
+          'Failed to get quote',
+          'Insufficient balance',
+        ],
+      },
+      {
+        message: 'Please enter valid recipient address.',
+        conditions: [
+          'recipient should not be empty',
+          'Recipient is required',
+          'Invalid toAddress:'
+        ],
+      },
+      {
+        message: 'Not supported token',
+        conditions: [
+          'not supported to token',
+          'not supported from token',
+          'no routes found',
+          'SDK version too old for monad and solana fast mctp route'
+        ],
+      },
+      {
+        message: 'There’s no routes available for the selected token pairs',
+        conditions: [
+          'No available quotes for the requested transfer',
+        ],
+      }
+    ]
+    if (error instanceof Error && error.message) {
+      const newError = errors.find(e => e.conditions.some(condition => error.message.indexOf(condition) !== -1))
+      if (newError) {
+        throw new Error(newError.message)
+      } else {
+        throw new Error(error.message)
+      }
+    }
+    throw new Error('Unknown error')
   }
 }
 

package/src/cross/factory.ts

@@ -3,7 +3,7 @@
 import {
   // AcrossAdapter,
   // DeBridgeAdapter,
-  // LifiAdapter,
+  LifiAdapter,
   MayanAdapter,
   RelayAdapter,
   NearIntentsAdapter,
@@ -22,7 +22,7 @@ export class CrossChainSwapFactory {
   private static mayanInstance: MayanAdapter
   // private static symbiosisInstance: SymbiosisAdapter
   // private static debridgeInstance: DeBridgeAdapter
-  // private static lifiInstance: LifiAdapter
+  private static lifiInstance: LifiAdapter
   // private static optimexInstance: OptimexAdapter
   // private static orbiterInstance: OrbiterAdapter
 
@@ -77,12 +77,12 @@ export class CrossChainSwapFactory {
   //   return CrossChainSwapFactory.debridgeInstance
   // }
 
-  // static getLifiInstance(): LifiAdapter {
-  //   if (!CrossChainSwapFactory.lifiInstance) {
-  //     CrossChainSwapFactory.lifiInstance = new LifiAdapter()
-  //   }
-  //   return CrossChainSwapFactory.lifiInstance
-  // }
+  static getLifiInstance(): LifiAdapter {
+    if (!CrossChainSwapFactory.lifiInstance) {
+      CrossChainSwapFactory.lifiInstance = new LifiAdapter()
+    }
+    return CrossChainSwapFactory.lifiInstance
+  }
 
   // static getOptimexAdapter(): OptimexAdapter {
   //   if (!CrossChainSwapFactory.optimexInstance) {
@@ -104,12 +104,13 @@ export class CrossChainSwapFactory {
       CrossChainSwapFactory.getMayanAdapter(),
       CrossChainSwapFactory.getRelayAdapter(),
       CrossChainSwapFactory.getNearIntentsAdapter(),
+      CrossChainSwapFactory.getLifiInstance(),
+
 
       // CrossChainSwapFactory.getAcrossAdapter(),
       // CrossChainSwapFactory.getXyFinanceAdapter(),
       // CrossChainSwapFactory.getSymbiosisAdapter(),
       // CrossChainSwapFactory.getDebridgeInstance(),
-      // CrossChainSwapFactory.getLifiInstance(),
       // CrossChainSwapFactory.getOptimexAdapter(),
       // CrossChainSwapFactory.getOrbiterAdapter(),
     ]
@@ -132,8 +133,8 @@ export class CrossChainSwapFactory {
       //   return CrossChainSwapFactory.getSymbiosisAdapter()
       // case 'debridge':
       //   return CrossChainSwapFactory.getDebridgeInstance()
-      // case 'lifi':
-      //   return CrossChainSwapFactory.getLifiInstance()
+      case 'lifi':
+        return CrossChainSwapFactory.getLifiInstance()
       // case 'optimex':
       //   return CrossChainSwapFactory.getOptimexAdapter()
       // case 'orbiter':

package/src/hooks/useSwapOnly.ts

@@ -1,6 +1,13 @@
 import { useSplitSubvariantStore } from '../stores/settings/useSplitSubvariantStore.js'
+import { useWidgetConfig } from '../providers/WidgetProvider/WidgetProvider.js'
+
 
 export const useSwapOnly = () => {
-  const state = useSplitSubvariantStore((state) => state.state)
-  return state === 'swap'
+  const { subvariant } = useWidgetConfig()
+  const [state, setState] = useSplitSubvariantStore((storeState) => [storeState.state, storeState.setState])
+  if (subvariant === 'swap' && state !== 'swap') {
+    setState('swap')
+    return true
+  }
+  return state === 'swap' || subvariant === 'swap'
 }

package/src/i18n/en.json

@@ -90,7 +90,7 @@
       "emptyTokenList": "We couldn't find tokens on {{chainName}} chain or you don't have any. Please search by contract address if your token doesn't appear or choose another chain.",
       "emptyTransactionHistory": "Transaction history is only stored locally and will be deleted if you clear your browser data.",
       "routeNotFound": "Reasons for that could be: low liquidity, amount selected is too low, gas costs are too high or there are no routes for the selected combination.",
-      "toAddressIsRequired": "The destination wallet address is required to proceed with the transfer."
+      "toAddressIsRequired": "Please enter valid recipient address"
     },
     "title": {
       "autoRefuel": "Get {{chainName}} gas",
@@ -123,7 +123,7 @@
       "deleteTransactionHistory": "Transaction history is only stored locally and can't be recovered if you delete it.",
       "fundsLossPrevention": "Always ensure smart contract accounts are properly set up on the destination chain and avoid direct transfers to exchanges to prevent fund loss.",
       "highValueLoss": "The value of the received tokens is significantly lower than the exchanged tokens and transaction cost.",
-      "insufficientFunds": "Insufficient balance.",
+      "insufficientFunds": "Insufficient balance in your wallet.",
       "insufficientGas": "You don't have enough gas to complete the transaction. You need to add at least:",
       "rateChanged": "The exchange rate has changed. By continuing the transaction, you'll accept the new rate.",
       "resetSettings": "This will reset your route priority, slippage, gas price, enabled bridges and exchanges.",
@@ -320,7 +320,9 @@
     "routePriority": "Route priority",
     "slippage": "Slippage Tolerance",
     "custom": "Custom",
-    "resetSettings": "You're using custom settings that can affect the number or sorting of available routes."
+    "resetSettings": "You're using custom settings that can affect the number or sorting of available routes.",
+    "dynamicMode": "Dynamic Mode",
+    "dynamicModeTooltip": "Automatically minimizes slippage to enhance the MEV protection through running simulations."
   },
   "sendToWallet": {
     "addBookmark": "Add bookmark",

package/src/i18n/ja.json

@@ -302,7 +302,9 @@
     "routePriority": "ルート優先度",
     "slippage": "",
     "custom": "カスタム設定",
-    "resetSettings": "利用可能なルートの数とソートに影響する可能性があるカスタム設定を使用しています。"
+    "resetSettings": "利用可能なルートの数とソートに影響する可能性があるカスタム設定を使用しています。",
+    "dynamicMode": "動的モード",
+    "dynamicModeTooltip": "シミュレーションを実行することで、MEV 保護を強化するためのスリッページを自動的に最小化します。"
   },
   "sendToWallet": {
     "addBookmark": "ブックマークに追加",