@openocean.finance/widget 1.0.32 → 1.0.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openocean.finance/widget",
-  "version": "1.0.32",
+  "version": "1.0.34",
   "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",
@@ -58,6 +58,7 @@
     "@solana/wallet-adapter-base": "^0.9.24",
     "@solana/web3.js": "^1.98.0",
     "@tanstack/react-virtual": "^3.13.4",
+    "@reservoir0x/relay-solana-wallet-adapter": "^2.0.5",
     "ethers": "^6.13.5",
     "i18next": "^24.2.3",
     "microdiff": "^1.5.0",

package/src/config/version.ts

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

package/src/cross/adapters/RelayAdapter.ts

@@ -92,8 +92,8 @@ export class RelayAdapter extends BaseSwapAdapter {
     return 'https://storage.googleapis.com/ks-setting-1d682dca/84e906bb-eaeb-45d3-a64c-2aa9c84eb3ea1747759080942.png'
   }
   getSupportedChains(): Chain[] {
-    // return [NonEvmChain.Solana, ...MAINNET_NETWORKS]
-    return [...MAINNET_NETWORKS]
+    return [NonEvmChain.Solana, ...MAINNET_NETWORKS]
+    // return [...MAINNET_NETWORKS]
   }
 
   getSupportedTokens(_sourceChain: Chain, _destChain: Chain): Currency[] {

package/src/hooks/useRouteExecution.ts

@@ -10,7 +10,7 @@ import type {
 import { updateRouteExecution } from '@openocean.finance/widget-sdk'
 import { useMutation, useQueryClient } from '@tanstack/react-query'
 import { useCallback, useEffect, useRef } from 'react'
-import { useConfig } from 'wagmi'
+import { useConfig, useWalletClient } from 'wagmi'
 import { shallow } from 'zustand/shallow'
 import { executeRoute } from '../services/ExecuteRoute.js'
 import {
@@ -26,7 +26,6 @@ import {
 import { WidgetEvent } from '../types/events.js'
 import { useAvailableChains } from './useAvailableChains.js'
 import { useWidgetEvents } from './useWidgetEvents.js'
-
 interface RouteExecutionProps {
   routeId: string
   executeInBackground?: boolean
@@ -46,6 +45,7 @@ export const useRouteExecution = ({
   const wagmiConfig = useConfig()
   const disconnect = useAccountDisconnect()
   const { openWalletMenu } = useWalletMenu()
+  const solanaWallet = useWalletClient()
   // const { wallet: solanaWallet } = useWallet()
   const resumedAfterMount = useRef(false)
   const emitter = useWidgetEvents()
@@ -150,7 +150,7 @@ export const useRouteExecution = ({
         wagmiConfig,
         onDisconnect: disconnect,
         onOpenWalletMenu: openWalletMenu,
-        // solanaWallet: solanaWallet?.adapter,
+        solanaWallet: solanaWallet,
       })
     },
     onMutate: () => {

package/src/services/ExecuteRoute.ts

@@ -5,6 +5,7 @@ import type {
   Process,
   Route,
 } from '@openocean.finance/widget-sdk'
+import { adaptSolanaWallet } from '@reservoir0x/relay-solana-wallet-adapter'
 import { Connection, Transaction, VersionedTransaction } from '@solana/web3.js'
 import { ethers } from 'ethers'
 import { getPublicClient, getWalletClient } from 'wagmi/actions'
@@ -275,8 +276,7 @@ async function executeSolanaSwap(
   step: ExtendedOpenOceanStep,
   options: ExecuteRouteOptions,
   process: Process,
-  route: ExtendedRoute,
-  solanaWallet?: any
+  route: ExtendedRoute
 ): Promise<void> {
   try {
     // Check wallet connection status
@@ -288,17 +288,66 @@ async function executeSolanaSwap(
     const connection = new Connection(
       'https://burned-practical-bird.solana-mainnet.quiknode.pro/33f4786133c252415e194b29ee69ffc7671480ab'
     )
+
     const { transactionRequest, type, quoteData } = step || {}
     if ((type as any) === 'bridge') {
-      const result = await bridgeExecuteSwap({
+      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 }
+            }
+
+            throw new Error('Invalid transaction type')
+          } catch (error) {
+            console.error('Transaction sending failed:', error)
+            throw error
+          }
+        }
+      )
+      const signedTx = await bridgeExecuteSwap({
         quoteData: quoteData,
-        walletClient: solanaWallet,
+        walletClient: adaptedWallet,
       })
-      const hash = result.sourceTxHash
-      process.status = 'PENDING'
+      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 pending'
+      process.message = 'Transaction confirmed'
       options.updateRouteHook?.(route)
+
+      // process.status = 'PENDING'
+      // process.txHash = hash
+      // process.message = 'Transaction pending'
+      // options.updateRouteHook?.(route)
     } else {
       const txData: any = transactionRequest?.data || ''
       const dexId = transactionRequest?.type || 0
@@ -633,8 +682,7 @@ async function executeEvmSwap(
 // Execute transaction
 async function executeSwap(
   route: ExtendedRoute,
-  options: ExecuteRouteOptions,
-  solanaWallet?: any
+  options: ExecuteRouteOptions
 ): Promise<Route> {
   const updatedRoute = { ...route }
 
@@ -673,13 +721,7 @@ async function executeSwap(
       // Execute different transaction logic based on chain type
       const currentStep = route.steps[0]
       if (currentStep.action?.fromChainId === 1151111081099710) {
-        await executeSolanaSwap(
-          currentStep,
-          options,
-          process,
-          updatedRoute,
-          solanaWallet
-        )
+        await executeSolanaSwap(currentStep, options, process, updatedRoute)
       } else {
         await executeEvmSwap(currentStep, options, process, updatedRoute)
       }
@@ -711,6 +753,5 @@ export async function executeRoute(
   if (!options.account.isConnected) {
     throw new Error('Wallet not connected')
   }
-
-  return executeSwap(route as ExtendedRoute, options, options.solanaWallet)
+  return executeSwap(route as ExtendedRoute, options)
 }

package/src/services/SendAndConfirmSolanaTransaction.ts

@@ -1,37 +1,40 @@
 /**
  * Solana Transaction Sending Service
- * 
+ *
  * This module handles sending and confirming transactions on Solana blockchain
  */
 
-import { BlockhashWithExpiryBlockHeight, Connection } from "@solana/web3.js";
+import type {
+  BlockhashWithExpiryBlockHeight,
+  Connection,
+} from '@solana/web3.js'
 
 /**
  * Delay execution helper
  * @param ms Delay time in milliseconds
  */
 const delay = (ms: number): Promise<void> =>
-  new Promise((resolve) => setTimeout(resolve, ms));
+  new Promise((resolve) => setTimeout(resolve, ms))
 
 /**
  * Transaction sending and confirmation parameters interface
  */
 interface SolanaTransactionParams {
   /** Solana RPC connection instance */
-  connection: Connection;
+  connection: Connection
   /** Serialized transaction data */
-  serializedTransaction: Buffer;
+  serializedTransaction: Buffer
   /** Blockhash with expiry block height */
-  blockhashWithExpiryBlockHeight?: BlockhashWithExpiryBlockHeight;
+  blockhashWithExpiryBlockHeight?: BlockhashWithExpiryBlockHeight
   /** Transaction process object */
-  process?: any;
+  process?: any
   /** Route update callback function */
-  updateRouteHook?: (route: any) => void;
+  updateRouteHook?: (route: any) => void
 }
 
 /**
  * Send raw transaction to Solana network
- * 
+ *
  * @param connection Solana RPC connection instance
  * @param serializedTransaction Serialized transaction data
  * @param process Transaction process object
@@ -39,44 +42,40 @@ interface SolanaTransactionParams {
  * @returns Transaction hash
  */
 async function sendSolanaTransaction(
-  connection: Connection, 
+  connection: Connection,
   serializedTransaction: Buffer,
   process: any,
   updateRouteHook?: (route: any) => void
 ): Promise<string> {
   try {
     // Send transaction to network
-    const txid = await connection.sendRawTransaction(
-      serializedTransaction,
-      {
-        skipPreflight: true,
-      }
-    );
-    console.log('Transaction sent:', txid);
-
+    const txid = await connection.sendRawTransaction(serializedTransaction, {
+      skipPreflight: true,
+    })
     // Update transaction status to pending
     if (process && updateRouteHook) {
-      process.status = 'PENDING';
-      process.txHash = txid;
-      process.message = 'Transaction pending';
-      updateRouteHook(process.route);
+      process.status = 'PENDING'
+      process.txHash = txid
+      process.message = 'Transaction pending'
+      updateRouteHook(process.route)
     }
 
-    return txid;
+    return txid
   } catch (error) {
-    console.error('Failed to send transaction:', error);
+    console.error('Failed to send transaction:', error)
     if (process && updateRouteHook) {
-      process.status = 'FAILED';
-      process.message = error instanceof Error ? error.message : 'Failed to send transaction';
-      updateRouteHook(process.route);
+      process.status = 'FAILED'
+      process.message =
+        error instanceof Error ? error.message : 'Failed to send transaction'
+      updateRouteHook(process.route)
     }
-    throw error;
+    throw error
   }
 }
 
 /**
  * Confirm Solana transaction status
- * 
+ *
  * @param connection Solana RPC connection instance
  * @param txid Transaction hash
  * @param process Transaction process object
@@ -89,59 +88,59 @@ async function confirmSolanaTransaction(
   txid: string,
   process: any,
   updateRouteHook?: (route: any) => void,
-  maxRetries: number = 30
+  maxRetries = 30
 ): Promise<boolean> {
-  let retries = 0;
-  
+  let retries = 0
+
   while (retries < maxRetries) {
     try {
       // Get latest blockhash
-      const latestBlockhash = await connection.getLatestBlockhash();
-      
+      const latestBlockhash = await connection.getLatestBlockhash()
+
       // Confirm transaction status
       const confirmation = await connection.confirmTransaction({
         signature: txid,
         blockhash: latestBlockhash.blockhash,
-        lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
-      });
+        lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+      })
 
       // Check if transaction failed
       if (confirmation.value.err) {
         if (process && updateRouteHook) {
-          process.status = 'FAILED';
-          process.message = 'Transaction failed on chain';
-          updateRouteHook(process.route);
+          process.status = 'FAILED'
+          process.message = 'Transaction failed on chain'
+          updateRouteHook(process.route)
         }
-        return false;
+        return false
       }
 
       // Transaction confirmed successfully
       if (process && updateRouteHook) {
-        process.status = 'DONE';
-        process.doneAt = Date.now();
-        process.message = 'Transaction confirmed';
-        updateRouteHook(process.route);
+        process.status = 'DONE'
+        process.doneAt = Date.now()
+        process.message = 'Transaction confirmed'
+        updateRouteHook(process.route)
       }
-      return true;
+      return true
     } catch (error) {
-      console.warn('Confirmation attempt failed:', error);
-      await delay(2000); // Wait 2 seconds before retrying
-      retries++;
+      console.warn('Confirmation attempt failed:', error)
+      await delay(2000) // Wait 2 seconds before retrying
+      retries++
     }
   }
 
   // Exceeded maximum retry attempts
   if (process && updateRouteHook) {
-    process.status = 'FAILED';
-    process.message = 'Transaction confirmation timeout';
-    updateRouteHook(process.route);
+    process.status = 'FAILED'
+    process.message = 'Transaction confirmation timeout'
+    updateRouteHook(process.route)
   }
-  throw new Error('Transaction confirmation timeout');
+  throw new Error('Transaction confirmation timeout')
 }
 
 /**
  * Send and wait for Solana transaction confirmation
- * 
+ *
  * @param params Transaction parameters
  * @returns Transaction response and hash
  */
@@ -149,32 +148,42 @@ export async function sendAndConfirmSolanaTransaction({
   connection,
   serializedTransaction,
   process,
-  updateRouteHook
+  updateRouteHook,
 }: SolanaTransactionParams): Promise<any> {
   try {
     // Send transaction and get transaction hash
-    const txid = await sendSolanaTransaction(connection, serializedTransaction, process, updateRouteHook);
-    
+    const txid = await sendSolanaTransaction(
+      connection,
+      serializedTransaction,
+      process,
+      updateRouteHook
+    )
+
     // Wait for transaction confirmation
-    const success = await confirmSolanaTransaction(connection, txid, process, updateRouteHook);
-    
+    const success = await confirmSolanaTransaction(
+      connection,
+      txid,
+      process,
+      updateRouteHook
+    )
+
     if (!success) {
-      throw new Error('Transaction failed during confirmation');
+      throw new Error('Transaction failed during confirmation')
     }
 
     // Get transaction details
     const response = await connection.getTransaction(txid, {
-      commitment: "confirmed",
-      maxSupportedTransactionVersion: 0
-    });
+      commitment: 'confirmed',
+      maxSupportedTransactionVersion: 0,
+    })
 
     if (!response) {
-      throw new Error('Failed to fetch transaction details');
+      throw new Error('Failed to fetch transaction details')
     }
 
-    return { response, txid };
+    return { response, txid }
   } catch (error) {
-    console.error('Transaction failed:', error);
-    throw error;
+    console.error('Transaction failed:', error)
+    throw error
   }
-}
+}