@openocean.finance/widget 1.0.4 → 1.0.8

package/src/hooks/usePriceImpact.ts

@@ -0,0 +1,18 @@
+import type { RouteExtended } from '@openocean.finance/widget-sdk'
+import { getPriceImpact } from '../utils/getPriceImpact.js'
+
+export const usePriceImpact = (route?: RouteExtended) => {
+  let priceImpact = 0
+  if (route) {
+    priceImpact = getPriceImpact({
+      fromAmount: BigInt(route?.fromAmount),
+      toAmount: BigInt(route?.toAmount),
+      fromToken: route?.fromToken,
+      toToken: route?.toToken,
+    })
+  }
+
+  return {
+    priceImpact,
+  }
+}

package/src/hooks/useRoutes.ts

@@ -2,7 +2,7 @@ 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 } from 'viem'
+import { parseUnits, formatUnits } from 'viem'
 import { useWidgetConfig } from '../providers/WidgetProvider/WidgetProvider.js'
 import { DebridgeService } from '../services/DebridgeService.js'
 import { OpenOceanService } from '../services/OpenOceanService.js'
@@ -37,6 +37,7 @@ export const useRoutes = ({ observableRoute }: RoutesProps = {}) => {
     fee,
     feeConfig,
     useRelayerRoutes,
+    referrer
   } = useWidgetConfig()
   const setExecutableRoute = useSetExecutableRoute()
   const queryClient = useQueryClient()
@@ -94,7 +95,7 @@ export const useRoutes = ({ observableRoute }: RoutesProps = {}) => {
   const contractCallQuoteEnabled: boolean =
     subvariant === 'custom' ? Boolean(contractCalls && account.address) : true
 
-  const toAddress = fromChainId === toChainId ? account.address : _toAddress
+  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
   // If toAddress is set, it must have the same chainType as toChain
   const hasToAddressAndChainTypeSatisfied: boolean =
@@ -238,6 +239,8 @@ export const useRoutes = ({ observableRoute }: RoutesProps = {}) => {
                 slippage: formattedSlippage, // OpenOcean expects slippage like '100' for 1%
                 gasPrice: gasPrice || '10', // Consider chain-specific defaults
                 enabledDexIds: fromChainId === 1151111081099710 ? '6' : '', // Example for Solana specific dex
+                referrer: referrer?.address || '',
+                referrerFee: referrer?.fee || '',
               })
             } else {
               // Use getQuote if account is not connected (view mode)
@@ -262,6 +265,23 @@ export const useRoutes = ({ observableRoute }: RoutesProps = {}) => {
           // minOutAmount calculation is now handled within DebridgeService or OpenOceanService
           const isDebridge = data.isDebridgeRoute === true
 
+          let toAmountMin = '0';
+          if (data?.minOutAmount) {
+            toAmountMin = data.minOutAmount;
+          } else if (isDebridge) {
+            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+$/, '');
+            // 如果还是科学计数法，再强制转字符串
+            if (toAmountMin.includes('e') || toAmountMin.includes('E')) {
+              debugger;
+              toAmountMin = minAmount.toLocaleString('fullwide', { useGrouping: false, maximumSignificantDigits: 21 });
+              toAmountMin = toAmountMin.replace(/\.?0+$/, '');
+            }
+          }
           const route: Route = {
             id: data?.orderId || Date.now().toString(),
             fromChainId: fromChainId,
@@ -272,15 +292,7 @@ export const useRoutes = ({ observableRoute }: RoutesProps = {}) => {
             toChainId: toChainId,
             toAmountUSD: data?.toTokenUSD || '0',
             toAmount: data?.outAmount || '0',
-            toAmountMin:
-              data?.minOutAmount ||
-              (isDebridge
-                ? '0'
-                : Math.floor(
-                    (Number(data?.outAmount || 0) *
-                      (100 - Number.parseFloat(slippage))) /
-                      100
-                  ).toString()),
+            toAmountMin,
             toToken: toToken!,
             toAddress: toAddress || '',
             insurance: {
@@ -321,15 +333,7 @@ export const useRoutes = ({ observableRoute }: RoutesProps = {}) => {
                 estimate: {
                   fromAmount: fromAmount.toString(),
                   toAmount: data?.outAmount || '0',
-                  toAmountMin:
-                    data?.minOutAmount ||
-                    (isDebridge
-                      ? '0'
-                      : Math.floor(
-                          (Number(data?.outAmount || 0) *
-                            (100 - Number.parseFloat(slippage))) /
-                            100
-                        ).toString()),
+                  toAmountMin,
                   approvalAddress:
                     data?.approveContract ||
                     (isDebridge

package/src/hooks/useTokenPrice.ts

@@ -10,7 +10,7 @@ export const useTokenPrice = (chainId?: number, token?: TokenAmount) => {
         return undefined
       }
       const prices = await OpenOceanService.getTokensPrice(chainId.toString(), [token.address])
-      return prices[token.address.toLowerCase()]
+      return prices[token.address.toLowerCase()] || 0
     },
     enabled: !!chainId && !!token?.address,
     refetchInterval: 60_000, // 每分钟更新一次价格

package/src/pages/MainPage/MainPage.tsx

@@ -13,10 +13,10 @@ import { useHeader } from '../../hooks/useHeader.js'
 import { useRoutes } from '../../hooks/useRoutes.js'
 // import { useWideVariant } from '../../hooks/useWideVariant.js'
 import { useWidgetConfig } from '../../providers/WidgetProvider/WidgetProvider.js'
+import { useSplitSubvariantStore } from '../../stores/settings/useSplitSubvariantStore.js'
 import { HiddenUI } from '../../types/widget.js'
 import { MainWarningMessages } from './MainWarningMessages.js'
 import { ReviewButton } from './ReviewButton.js'
-import { useSplitSubvariantStore } from '../../stores/settings/useSplitSubvariantStore.js'
 
 export const MainPage: React.FC = () => {
   const { t } = useTranslation()

package/src/pages/MainPage/MainWarningMessages.tsx

@@ -1,7 +1,6 @@
 import type { BoxProps } from '@mui/material'
 import type { Route } from '@openocean.finance/widget-sdk'
 import { WarningMessages } from '../../components/Messages/WarningMessages.js'
-import { useRoutes } from '../../hooks/useRoutes.js'
 
 interface MainWarningMessagesProps extends BoxProps {
   route?: Route
@@ -10,8 +9,7 @@ interface MainWarningMessagesProps extends BoxProps {
 export const MainWarningMessages: React.FC<MainWarningMessagesProps> = (
   props
 ) => {
-  const { routes } = useRoutes()
-  const currentRoute = routes?.[0]
+  const currentRoute = props.route
 
   return <WarningMessages route={currentRoute} {...props} />
 }

package/src/pages/MainPage/ReviewButton.tsx

@@ -1,7 +1,10 @@
 import { useTranslation } from 'react-i18next'
 import { useNavigate } from 'react-router-dom'
 import { BaseTransactionButton } from '../../components/BaseTransactionButton/BaseTransactionButton.js'
-import { useMessageQueue } from '../../components/Messages/useMessageQueue.js'
+import {
+  useMessageQueue,
+  useStorePriceImpactAcknowledged,
+} from '../../components/Messages/useMessageQueue.js'
 import { useRoutes } from '../../hooks/useRoutes.js'
 import { useToAddressRequirements } from '../../hooks/useToAddressRequirements.js'
 import { useWidgetEvents } from '../../hooks/useWidgetEvents.js'
@@ -21,7 +24,20 @@ export const ReviewButton: React.FC = () => {
 
   const currentRoute = routes?.[0]
 
-  const { hasMessages } = useMessageQueue(currentRoute, {})
+  const { messages } = useMessageQueue(currentRoute)
+  const priceImpactAcknowledged = useStorePriceImpactAcknowledged(
+    (state) => state.priceImpactAcknowledged
+  )
+
+  let hasMessages = messages.length > 0
+  if (messages.length > 0) {
+    const message: any = messages.find(
+      (message) => message.id === 'PRICE_IMPACT_HIGH'
+    )
+    if (message && priceImpactAcknowledged) {
+      hasMessages = false
+    }
+  }
 
   const handleClick = async () => {
     if (!currentRoute) {

package/src/pages/SettingsPage/DynamicSlippageSettings.tsx

@@ -0,0 +1,54 @@
+import { Box, styled, Switch, Typography, Tooltip } from '@mui/material'
+import { useTranslation } from 'react-i18next'
+import { useSettings } from '../../stores/settings/useSettings.js'
+import { useSettingsActions } from '../../stores/settings/useSettingsActions.js'
+import { Card } from '../../components/Card/Card.js'
+import { CardRowContainer, CardTitleContainer, CardValue } from '../../components/Card/CardButton.style.js'
+import { InfoOutlined } from '@mui/icons-material'
+
+const StyledSwitch = styled(Switch)(({ theme }) => ({
+  padding: 8,
+  '& .MuiSwitch-track': {
+    backgroundColor: '#666',
+    opacity: 1,
+    borderRadius: 20,
+  },
+  '& .MuiSwitch-thumb': {
+    backgroundColor: theme.palette.common.white,
+  },
+  '& .Mui-checked+.MuiSwitch-track': {
+    backgroundColor: theme.palette.primary.main,
+    opacity: 1,
+  },
+}))
+
+export const DynamicSlippageSettings: React.FC = () => {
+  const { t } = useTranslation()
+  const { dynamicSlippage } = useSettings(['dynamicSlippage'])
+  const { setValue } = useSettingsActions()
+
+  const handleToggle = () => {
+    setValue('dynamicSlippage', !dynamicSlippage)
+  }
+
+  return (
+    <Card sx={{ p: 1, mb: 1 }}>
+      <CardRowContainer sx={{ padding: '0 0 0 8px' }}>
+        <CardTitleContainer>
+          <CardValue>
+            {t('translation:settings.dynamicMode', 'Dynamic Mode')}
+            <Tooltip title={t('translation:settings.dynamicModeTooltip', 'Automatically minimizes slippage to enhance the MEV protection through running simulations.')}>
+              <InfoOutlined fontSize="small" sx={{ ml: 0.5, verticalAlign: 'middle', fontSize: '16px', opacity: 0.7 }} />
+            </Tooltip>
+          </CardValue>
+        </CardTitleContainer>
+        <StyledSwitch
+          checked={!!dynamicSlippage}
+          onChange={handleToggle}
+          name="dynamicSlippage"
+          inputProps={{ 'aria-label': 'dynamic slippage toggle' }}
+        />
+      </CardRowContainer>
+    </Card>
+  )
+} 

package/src/pages/SettingsPage/SettingsPage.tsx

@@ -5,10 +5,11 @@ import { ResetSettingsButton } from './ResetSettingsButton.js'
 import { SettingsList } from './SettingsCard/SettingCard.style.js'
 import { SettingsCardAccordion } from './SettingsCard/SettingsAccordian.js'
 import { SlippageSettings } from './SlippageSettings/SlippageSettings.js'
+import { DynamicSlippageSettings } from './DynamicSlippageSettings.js'
 
 export const SettingsPage = () => {
   const { t } = useTranslation()
-  useHeader(t('header.settings'))
+  useHeader(t('translation:header.settings', 'Settings'))
 
   return (
     <PageContainer bottomGutters>
@@ -18,6 +19,7 @@ export const SettingsPage = () => {
           {/* <LanguageSetting /> */}
           {/* <RoutePrioritySettings /> */}
           {/* <GasPriceSettings /> */}
+          <DynamicSlippageSettings />
           <SlippageSettings />
           {/* <BridgeAndExchangeSettings type="Bridges" />
           <BridgeAndExchangeSettings type="Exchanges" /> */}

package/src/pages/SettingsPage/SlippageSettings/SlippageSettings.tsx

@@ -107,7 +107,7 @@ export const SlippageSettings: React.FC = () => {
           {slippage ? `${slippage}%` : t('button.auto')}
         </BadgedValue>
       }
-      // icon={<Percent />}
+      icon={null}
       title={t('settings.slippage')}
     >
       <Box

package/src/pages/TransactionPage/StartTransactionButton.tsx

@@ -1,5 +1,8 @@
 import { BaseTransactionButton } from '../../components/BaseTransactionButton/BaseTransactionButton.js'
-import { useMessageQueue } from '../../components/Messages/useMessageQueue.js'
+import {
+  useMessageQueue,
+  useStorePriceImpactAcknowledged,
+} from '../../components/Messages/useMessageQueue.js'
 import type { StartTransactionButtonProps } from './types.js'
 
 export const StartTransactionButton: React.FC<StartTransactionButtonProps> = ({
@@ -8,8 +11,20 @@ export const StartTransactionButton: React.FC<StartTransactionButtonProps> = ({
   text,
   loading,
 }) => {
-  const { hasMessages, isLoading } = useMessageQueue(route, true)
+  const { messages, isLoading } = useMessageQueue(route)
+  const priceImpactAcknowledged = useStorePriceImpactAcknowledged(
+    (state) => state.priceImpactAcknowledged
+  )
 
+  let hasMessages = messages.length > 0
+  if (messages.length > 0) {
+    const message: any = messages.find(
+      (message) => message.id === 'PRICE_IMPACT_HIGH'
+    )
+    if (message && priceImpactAcknowledged) {
+      hasMessages = false
+    }
+  }
   return (
     <BaseTransactionButton
       onClick={onClick}

package/src/services/ExecuteRoute.ts

@@ -9,6 +9,114 @@ import { Connection, Transaction, VersionedTransaction } from '@solana/web3.js'
 import type { Config } from 'wagmi'
 import { getPublicClient, getWalletClient } from 'wagmi/actions'
 import { sendAndConfirmSolanaTransaction } from './SendAndConfirmSolanaTransaction.js'
+import { useSettingsStore } from '../stores/settings/useSettingsStore.js'
+import { ethers } from 'ethers'
+
+const OpenOceanABI = [
+  {
+      "inputs": [
+          {
+              "internalType": "contract IOpenOceanCaller",
+              "name": "caller",
+              "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"
+          },
+          {
+              "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
 function hexToUint8Array(hexString: string): Uint8Array {
@@ -145,7 +253,7 @@ async function executeEvmSwap(
   route: ExtendedRoute
 ): Promise<void> {
   try {
-    const walletClient = await getWalletClient(options.wagmiConfig)
+    let walletClient = await getWalletClient(options.wagmiConfig)
     
     // Check if wallet is connected
     if (!walletClient) {
@@ -168,8 +276,8 @@ async function executeEvmSwap(
         await walletClient.switchChain({ id: targetChainId })
         
         // Get updated walletClient after chain switch
-        const updatedWalletClient = await getWalletClient(options.wagmiConfig)
-        if (!updatedWalletClient || updatedWalletClient.chain.id !== targetChainId) {
+        walletClient = await getWalletClient(options.wagmiConfig)
+        if (!walletClient || walletClient.chain.id !== targetChainId) {
           throw new Error('Failed to switch chain')
         }
       } catch (error) {
@@ -203,8 +311,7 @@ async function executeEvmSwap(
 
     // Check token approval
     if (
-      step.action.fromToken.address !==
-      '0x0000000000000000000000000000000000000000'
+      ['0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000001010'].indexOf(step.action.fromToken.address) === -1
     ) {
       let allowance = 0n
       try {
@@ -249,6 +356,8 @@ async function executeEvmSwap(
           : BigInt(amount)
 
         const hash = await walletClient.writeContract({
+          chain: walletClient.chain,
+          account: walletClient.account,
           address: step.action.fromToken.address as `0x${string}`,
           abi: [
             {
@@ -282,6 +391,35 @@ async function executeEvmSwap(
       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');
+        }
+      } catch (error) {
+        console.error('Failed to apply MEV protection:', error);
+        // 错误时继续使用原始交易请求
+      }
+    }
+
     // Estimate gas
     const estimatedGas = await publicClient.estimateGas(txRequest)
     console.log('estimatedGas', estimatedGas)
@@ -292,7 +430,10 @@ async function executeEvmSwap(
       gas: estimatedGas * 2n,
     }
 
-    const hash = await walletClient.sendTransaction(finalTxRequest)
+    const hash = await walletClient.sendTransaction({
+      ...finalTxRequest,
+      kzg: undefined,
+    })
 
     process.status = 'PENDING'
     process.txHash = hash
@@ -335,6 +476,120 @@ 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,

package/src/services/OpenOceanService.ts

@@ -77,7 +77,9 @@ export class OpenOceanService {
     gasPrice?: string
     disabledDexIds?: string
     enabledDexIds?: string
-    referrer?: string
+    referrer?: string,
+    referrerFee?: string,
+    referrerFeeShare?: string
   }) {
     const apiUrl = this.getApiUrl(params.chain)
     const slippage = (Number(params.slippage || '1') * 10000).toString()
@@ -94,6 +96,8 @@ export class OpenOceanService {
       disabledDexIds: params.disabledDexIds || '',
       enabledDexIds: params.enabledDexIds || '',
       referrer: params.referrer || '0x3487ef9f9b36547e43268b8f0e2349a226c70b53',
+      referrerFee: (Number(params.referrerFee || '0') * 100).toString(),
+      referrerFeeShare: params.referrerFeeShare || '1500',
     })
     const isV1Api = Object.keys(this.CHAIN_ID_MAP).includes(params.chain.toString())
     const swapEndpoint = isV1Api ? 'swap-quote' : 'swap'

package/src/stores/settings/types.ts

@@ -25,6 +25,7 @@ export interface SettingsProps {
   routePriority?: Order
   enabledAutoRefuel: boolean
   slippage?: string
+  dynamicSlippage?: boolean
   disabledBridges: string[]
   enabledBridges: string[]
   _enabledBridges: Record<string, boolean>

package/src/stores/settings/useSettingsStore.ts

@@ -9,17 +9,19 @@ export const defaultSlippage = '1'
 
 export const defaultConfigurableSettings: Pick<
   SettingsState,
-  'routePriority' | 'slippage' | 'gasPrice'
+  'routePriority' | 'slippage' | 'gasPrice' | 'dynamicSlippage'
 > = {
   routePriority: 'CHEAPEST',
   slippage: defaultSlippage,
   gasPrice: 'normal',
+  dynamicSlippage: false,
 }
 
 export const defaultSettings: SettingsProps = {
   appearance: 'auto',
   gasPrice: 'normal',
   enabledAutoRefuel: true,
+  dynamicSlippage: false,
   disabledBridges: [],
   disabledExchanges: [],
   enabledBridges: [],