@openocean.finance/widget 1.0.26 → 1.0.28

package/dist/esm/stores/form/useFieldController.d.ts

@@ -6,6 +6,6 @@ export declare const useFieldController: ({ name }: UseFieldControllerProps) =>
     onChange: (newValue: string | number | undefined) => void;
     onBlur: () => void;
     name: keyof import("./types.js").DefaultValues;
-    value: string | number | ContractCall[];
+    value: string | number | import("@openocean.finance/widget-types").ContractCall[];
 };
 export {};

package/dist/esm/stores/routes/useExecutingRoutesIds.d.ts

@@ -1 +1 @@
-export declare const useExecutingRoutesIds: () => any[];
+export declare const useExecutingRoutesIds: () => string[];

package/dist/esm/stores/routes/useSetExecutableRoute.d.ts

@@ -1 +1 @@
-export declare const useSetExecutableRoute: () => (route: Route, observableRouteIds?: string[]) => void;
+export declare const useSetExecutableRoute: () => (route: import("@openocean.finance/widget-types").Route, observableRouteIds?: string[]) => void;

package/dist/esm/stores/routes/utils.d.ts

@@ -1,8 +1,8 @@
 import type { Process, RouteExtended } from '@openocean.finance/widget-sdk';
-export declare const isRouteDone: (route: RouteExtended) => any;
-export declare const isRoutePartiallyDone: (route: RouteExtended) => any;
-export declare const isRouteRefunded: (route: RouteExtended) => any;
-export declare const isRouteFailed: (route: RouteExtended) => any;
-export declare const isRouteActive: (route?: RouteExtended) => any;
+export declare const isRouteDone: (route: RouteExtended) => boolean;
+export declare const isRoutePartiallyDone: (route: RouteExtended) => boolean;
+export declare const isRouteRefunded: (route: RouteExtended) => boolean;
+export declare const isRouteFailed: (route: RouteExtended) => boolean;
+export declare const isRouteActive: (route?: RouteExtended) => boolean;
 export declare const getUpdatedProcess: (currentRoute: RouteExtended, updatedRoute: RouteExtended) => Process | undefined;
-export declare const getSourceTxHash: (route?: RouteExtended) => any;
+export declare const getSourceTxHash: (route?: RouteExtended) => string;

package/dist/esm/utils/chainType.d.ts

@@ -1,8 +1,8 @@
-import { ChainType } from '@openocean.finance/widget-sdk';
+import { ChainId, ChainType } from '@openocean.finance/widget-sdk';
 export declare const getChainTypeFromAddress: (address: string) => ChainType | undefined;
 export declare const defaultChainIdsByType: {
-    [ChainType.EVM]: any;
-    [ChainType.SVM]: any;
-    [ChainType.UTXO]: any;
-    [ChainType.MVM]: any;
+    EVM: ChainId;
+    SVM: ChainId;
+    UTXO: ChainId;
+    MVM: ChainId;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openocean.finance/widget",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "description": "Openocean Widget for cross-chain bridging and swapping. It will drive your multi-chain strategy and attract new users from everywhere.",
   "type": "module",
   "main": "./dist/esm/index.js",

package/src/config/version.ts

@@ -1,2 +1,2 @@
 export const name = '@openocean.finance/widget'
-export const version = '1.0.26'
+export const version = '1.0.28'

package/src/services/ExecuteRoute.ts

@@ -6,116 +6,115 @@ import type {
   Route,
 } from '@openocean.finance/widget-sdk'
 import { Connection, Transaction, VersionedTransaction } from '@solana/web3.js'
-import type { Config } from 'wagmi'
+import { ethers } from 'ethers'
 import { getPublicClient, getWalletClient } from 'wagmi/actions'
-import { sendAndConfirmSolanaTransaction } from './SendAndConfirmSolanaTransaction.js'
 import { useSettingsStore } from '../stores/settings/useSettingsStore.js'
-import { ethers } from 'ethers'
+import { sendAndConfirmSolanaTransaction } from './SendAndConfirmSolanaTransaction.js'
 
 const OpenOceanABI = [
   {
-      "inputs": [
+    inputs: [
+      {
+        internalType: 'contract IOpenOceanCaller',
+        name: 'caller',
+        type: 'address',
+      },
+      {
+        components: [
           {
-              "internalType": "contract IOpenOceanCaller",
-              "name": "caller",
-              "type": "address"
+            internalType: 'contract IERC20',
+            name: 'srcToken',
+            type: 'address',
           },
           {
-              "components": [
-                  {
-                      "internalType": "contract IERC20",
-                      "name": "srcToken",
-                      "type": "address"
-                  },
-                  {
-                      "internalType": "contract IERC20",
-                      "name": "dstToken",
-                      "type": "address"
-                  },
-                  {
-                      "internalType": "address",
-                      "name": "srcReceiver",
-                      "type": "address"
-                  },
-                  {
-                      "internalType": "address",
-                      "name": "dstReceiver",
-                      "type": "address"
-                  },
-                  {
-                      "internalType": "uint256",
-                      "name": "amount",
-                      "type": "uint256"
-                  },
-                  {
-                      "internalType": "uint256",
-                      "name": "minReturnAmount",
-                      "type": "uint256"
-                  },
-                  {
-                      "internalType": "uint256",
-                      "name": "guaranteedAmount",
-                      "type": "uint256"
-                  },
-                  {
-                      "internalType": "uint256",
-                      "name": "flags",
-                      "type": "uint256"
-                  },
-                  {
-                      "internalType": "address",
-                      "name": "referrer",
-                      "type": "address"
-                  },
-                  {
-                      "internalType": "bytes",
-                      "name": "permit",
-                      "type": "bytes"
-                  }
-              ],
-              "internalType": "struct OpenOceanExchange.SwapDescription",
-              "name": "desc",
-              "type": "tuple"
+            internalType: 'contract IERC20',
+            name: 'dstToken',
+            type: 'address',
           },
           {
-              "components": [
-                  {
-                      "internalType": "uint256",
-                      "name": "target",
-                      "type": "uint256"
-                  },
-                  {
-                      "internalType": "uint256",
-                      "name": "gasLimit",
-                      "type": "uint256"
-                  },
-                  {
-                      "internalType": "uint256",
-                      "name": "value",
-                      "type": "uint256"
-                  },
-                  {
-                      "internalType": "bytes",
-                      "name": "data",
-                      "type": "bytes"
-                  }
-              ],
-              "internalType": "struct IOpenOceanCaller.CallDescription[]",
-              "name": "calls",
-              "type": "tuple[]"
-          }
-      ],
-      "name": "swap",
-      "outputs": [
+            internalType: 'address',
+            name: 'srcReceiver',
+            type: 'address',
+          },
           {
-              "internalType": "uint256",
-              "name": "returnAmount",
-              "type": "uint256"
-          }
-      ],
-      "stateMutability": "payable",
-      "type": "function"
-  }
+            internalType: 'address',
+            name: 'dstReceiver',
+            type: 'address',
+          },
+          {
+            internalType: 'uint256',
+            name: 'amount',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'minReturnAmount',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'guaranteedAmount',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'flags',
+            type: 'uint256',
+          },
+          {
+            internalType: 'address',
+            name: 'referrer',
+            type: 'address',
+          },
+          {
+            internalType: 'bytes',
+            name: 'permit',
+            type: 'bytes',
+          },
+        ],
+        internalType: 'struct OpenOceanExchange.SwapDescription',
+        name: 'desc',
+        type: 'tuple',
+      },
+      {
+        components: [
+          {
+            internalType: 'uint256',
+            name: 'target',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'gasLimit',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'value',
+            type: 'uint256',
+          },
+          {
+            internalType: 'bytes',
+            name: 'data',
+            type: 'bytes',
+          },
+        ],
+        internalType: 'struct IOpenOceanCaller.CallDescription[]',
+        name: 'calls',
+        type: 'tuple[]',
+      },
+    ],
+    name: 'swap',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: 'returnAmount',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'payable',
+    type: 'function',
+  },
 ]
 
 // Add helper function for handling hexadecimal conversion
@@ -147,8 +146,9 @@ interface ExtendedOpenOceanStep extends OpenOceanStep {
 
 interface ExtendedRoute extends Route {
   steps: ExtendedOpenOceanStep[]
-  data: {
-    prependedOperatingExpenseCost: string
+  prependedOperatingExpenseCost?: string
+  data?: {
+    prependedOperatingExpenseCost?: string
   }
 }
 
@@ -178,10 +178,12 @@ async function executeSolanaSwap(
         transaction = Transaction.from(hexToUint8Array(txData))
       }
     } else {
-      transaction = VersionedTransaction.deserialize(hexToUint8Array(txData.slice(2)))
+      transaction = VersionedTransaction.deserialize(
+        hexToUint8Array(txData.slice(2))
+      )
 
-      const { blockhash } = await connection.getLatestBlockhash();
-      transaction.message.recentBlockhash = blockhash;
+      const { blockhash } = await connection.getLatestBlockhash()
+      transaction.message.recentBlockhash = blockhash
     }
 
     // Check signTransaction method exists
@@ -254,7 +256,7 @@ async function executeEvmSwap(
 ): Promise<void> {
   try {
     let walletClient = await getWalletClient(options.wagmiConfig)
-    
+
     // Check if wallet is connected
     if (!walletClient) {
       if (options.account?.connector && options.onDisconnect) {
@@ -265,18 +267,18 @@ async function executeEvmSwap(
       }
       throw new Error('Please connect wallet first')
     }
-    
+
     // Check if current chain matches target chain
     const currentChainId = walletClient.chain.id
     const targetChainId = step.action.fromChainId
-    
+
     if (currentChainId !== targetChainId) {
       try {
         // Try to switch to target chain
         await walletClient.switchChain({ id: targetChainId })
-        
+
         // Get updated walletClient after chain switch
-        walletClient = await getWalletClient(options.wagmiConfig) as any
+        walletClient = (await getWalletClient(options.wagmiConfig)) as any
         if (!walletClient || walletClient.chain.id !== targetChainId) {
           throw new Error('Failed to switch chain')
         }
@@ -311,7 +313,10 @@ async function executeEvmSwap(
 
     // Check token approval
     if (
-      ['0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000001010'].indexOf(step.action.fromToken.address) === -1
+      [
+        '0x0000000000000000000000000000000000000000',
+        '0x0000000000000000000000000000000000001010',
+      ].indexOf(step.action.fromToken.address) === -1
     ) {
       let allowance = 0n
       try {
@@ -347,7 +352,11 @@ async function executeEvmSwap(
 
       const amount =
         BigInt(step.action.fromAmount) +
-        BigInt(route?.data?.prependedOperatingExpenseCost || '0')
+        BigInt(
+          route?.prependedOperatingExpenseCost ||
+            route?.data?.prependedOperatingExpenseCost ||
+            '0'
+        )
       if (allowance < BigInt(amount)) {
         const approvalAmount = options.infiniteApproval
           ? BigInt(
@@ -402,20 +411,20 @@ async function executeEvmSwap(
           data: transactionRequest?.data,
           from: walletClient.account.address,
           to: transactionRequest?.to,
-          value: transactionRequest?.value || '0'
-        };
-        
+          value: transactionRequest?.value || '0',
+        }
+
         // 调用 swap_quote_mev 获取调整后的交易数据
-        const adjustedResponse = await swapQuoteMEV(response, { publicClient });
-        
+        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');
+          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);
+        console.error('Failed to apply MEV protection:', error)
         // 错误时继续使用原始交易请求
       }
     }
@@ -483,110 +492,111 @@ async function executeEvmSwap(
  * @returns 实际金额
  */
 function decimals2Amount(amount: string | number, decimals = 18): number {
-  return Number(amount) / Math.pow(10, decimals);
+  return Number(amount) / Math.pow(10, decimals)
 }
 
 /**
  * 交易响应类型
  */
 interface SwapResponse {
-  inAmount?: string;
+  inAmount?: string
   inToken?: {
-    decimals?: number;
-    price?: string | number;
-    priceUSD?: string | number;
-    address?: string;
-  };
-  data?: string;
-  from?: string;
-  to?: string;
-  value?: string;
-  minOutAmount?: string;
+    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, 
+  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;
+    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;
+      return response
     }
-    const { publicClient } = options;
+    const { publicClient } = options
     const OPENOCEAN_CONTRACT = new ethers.Contract(
-      "0x6352a56caadC4F1E25CD6c75970Fa768A3304e64",
+      '0x6352a56caadC4F1E25CD6c75970Fa768A3304e64',
       OpenOceanABI
-    );
+    )
     if (
-      ethers.hexlify(ethers.getBytes(response?.data || "0x").slice(0, 4)) !==
-      OPENOCEAN_CONTRACT.interface.getFunction("swap").selector
+      ethers.hexlify(ethers.getBytes(response?.data || '0x').slice(0, 4)) !==
+      OPENOCEAN_CONTRACT.interface.getFunction('swap').selector
     ) {
-      return response;
+      return response
     }
-    let oldCallData = OPENOCEAN_CONTRACT.interface.decodeFunctionData(
-      "swap",
+    const 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(
+    )
+    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 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",
+            'swap',
             callData
           ) as `0x${string}`,
           value: BigInt(response?.value || '0'),
-        };
+        }
         try {
-          await publicClient.estimateGas(params);
-          return mockMinOutAmount;
+          await publicClient.estimateGas(params)
+          return mockMinOutAmount
         } catch (error) {
-          console.error('Failed to estimate gas:', error);
-          return undefined;
+          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));
-    
+      .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;
+      return response
     }
-    callData[1][5] = finalMinOutAmount;
+    callData[1][5] = finalMinOutAmount
     const finalCallData = OPENOCEAN_CONTRACT.interface.encodeFunctionData(
-      "swap",
+      'swap',
       callData
-    );
-    response.minOutAmount = finalMinOutAmount.toString();
-    response.data = finalCallData;
-    return response;
+    )
+    response.minOutAmount = finalMinOutAmount.toString()
+    response.data = finalCallData
+    return response
   } catch (error) {
-    return response;
+    return response
   }
 }
 

package/src/services/OpenOceanService.ts

@@ -33,6 +33,15 @@ export class OpenOceanService {
       : `${this.API_V4_URL}/${chainId}`
   }
 
+  private static getSolanaAddress(chain: string, tokenAddress: string): string {
+    if (chain === '1151111081099710' && tokenAddress === 'So11111111111111111111111111111111111111112') {
+      return '11111111111111111111111111111111'
+    } else if (chain === '1151111081099710' && tokenAddress === '11111111111111111111111111111111') {
+      return 'So11111111111111111111111111111111111111112'
+    }
+    return tokenAddress
+  }
+
   static async getQuote(params: {
     chain: string
     inTokenAddress: string
@@ -94,9 +103,9 @@ export class OpenOceanService {
     const queryParams = new URLSearchParams({
       quoteType: 'swap',
       inTokenSymbol: params.inTokenSymbol,
-      inTokenAddress: params.inTokenAddress,
+      inTokenAddress: this.getSolanaAddress(params.chain, params.inTokenAddress),
       outTokenSymbol: params.outTokenSymbol,
-      outTokenAddress: params.outTokenAddress,
+      outTokenAddress: this.getSolanaAddress(params.chain, params.outTokenAddress),
       amountDecimals: params.amount,
       account: params.account,
       slippage,
@@ -105,9 +114,9 @@ export class OpenOceanService {
       enabledDexIds: params.enabledDexIds || '',
       ...referrer,
     })
-    const isV1Api = Object.keys(this.CHAIN_ID_MAP).includes(params.chain.toString())
-    const swapEndpoint = isV1Api ? 'swap-quote' : 'swap'
-    const response = await fetch(`${apiUrl}/${swapEndpoint}?${queryParams.toString()}`)
+    // const isV1Api = Object.keys(this.CHAIN_ID_MAP).includes(params.chain.toString())
+    // const swapEndpoint = isV1Api ? 'swap-quote' : 'swap'
+    const response = await fetch(`${apiUrl}/swap?${queryParams.toString()}`)
     return response.json()
   }