@openocean.finance/widget 1.0.43 → 1.0.45

package/src/services/ExecuteRoute.ts

@@ -12,7 +12,17 @@ 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 +174,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 +301,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 +371,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 +434,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 +458,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 +478,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,11 +525,11 @@ async function executeEvmSwap(
         '0x0000000000000000000000000000000000001010',
       ].indexOf(step.action.fromToken.address) === -1 &&
       step.estimate.approvalAddress !==
-        '0x0000000000000000000000000000000000000000'
+      '0x0000000000000000000000000000000000000000'
     ) {
       let allowance = 0n
       try {
-        allowance = (await publicClient.readContract({
+        allowance = (await (publicClient as any).readContract({
           address: step.action.fromToken.address as `0x${string}`,
           abi: [
             {
@@ -546,14 +563,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 +607,7 @@ async function executeEvmSwap(
         quoteData: quoteData,
         walletClient: walletClient,
       })
-      hash = result.sourceTxHash
+      hash = result?.sourceTxHash || ''
     } else {
       const txRequest = {
         chain: publicClient.chain,
@@ -672,21 +689,364 @@ 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
   }
 }
 
+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;
+}
+
+
+// BTC 主网
+const network = bitcoin.networks.bitcoin;
+
+export async function sendBTCWithPhantom(sender: string, recipient: string, amount: number) {
+  const phantom = (window as any).phantom?.bitcoin;
+  if (!phantom) throw new Error("Phantom Bitcoin provider not found");
+  // 1. 获取 UTXO（这里使用 mempool.space API，你也可以换自己的）
+  const utxos = await fetch(
+    `https://mempool.space/api/address/${sender}/utxo`
+  ).then((r) => r.json());
+
+  if (!utxos.length) throw new Error("No UTXO available");
+
+  // ====== 费用参数 ======
+  // amount / fee 单位都按 satoshi 处理，调用方需要保证一致
+  const fee = 5000; // 手续费（可以根据当前网络费率动态调整）
+  const required = BigInt(amount + fee);
+
+  // 2. 简单的累加选币：从小到大选 UTXO，直到覆盖 amount + fee
+  const sortedUtxos = [...utxos].sort(
+    (a: any, b: any) => Number(a.value) - Number(b.value)
+  );
+
+  const selectedUtxos: any[] = [];
+  let totalInput = 0n;
+
+  for (const utxo of sortedUtxos) {
+    selectedUtxos.push(utxo);
+    totalInput += BigInt(utxo.value);
+    if (totalInput >= required) break;
+  }
+
+  if (totalInput < required) {
+    throw new Error("Insufficient balance: UTXOs do not cover amount + fee");
+  }
+
+  const changeValue = totalInput - required;
+
+  // 可选：避免输出过小（dust），这里简单判断 >0 即可，如需更严格可改成 > 546
+  if (changeValue <= 0n) {
+    throw new Error("UTXOs too small to cover amount and fee with change");
+  }
+
+  // 3. 构造 PSBT（多输入）
+  const psbt = new bitcoin.Psbt({ network });
+
+  selectedUtxos.forEach((utxo) => {
+    psbt.addInput({
+      hash: utxo.txid,
+      index: utxo.vout,
+      witnessUtxo: {
+        // bitcoinjs-lib 期望 bigint，这里将 mempool 返回的 number 转成 bigint
+        value: BigInt(utxo.value),
+        script: bitcoin.address.toOutputScript(sender, network),
+      },
+    });
+  });
+
+  // 目标地址 output
+  psbt.addOutput({
+    address: recipient,
+    value: BigInt(amount),
+  });
+
+  // 找零 output
+  psbt.addOutput({
+    address: sender,
+    value: changeValue,
+  });
+
+  // 4. 调用 Phantom.signPSBT
+  const psbtBase64 = psbt.toBase64();
+
+  const signOptions = {
+    autoFinalized: false,
+    toSignInputs: selectedUtxos.map((_, index) => ({
+      address: sender,
+      index,
+      // SIGHASH_ALL (0x01) 通常足够，如有需要可根据业务调整
+      sighashTypes: [0, 1], // 保持和原来一致
+    })),
+  };
+
+  const signed = await phantom.signPSBT(psbtBase64, signOptions);
+
+  // Phantom 返回 Base64
+  const signedPsbt = bitcoin.Psbt.fromBase64(signed);
+
+  // 5. Finalize + 提取原始交易
+  signedPsbt.finalizeAllInputs();
+  const rawTx = signedPsbt.extractTransaction().toHex();
+
+  // 6. 广播 Raw TX
+  const txid = await fetch("https://mempool.space/api/tx", {
+    method: "POST",
+    body: rawTx,
+  }).then((r) => r.text());
+
+  console.log("Broadcasted TXID:", txid);
+  return txid;
+}
+
+
+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 connector = options.account.connector;
+        const anyWindow = typeof window !== 'undefined' ? (window as any) : undefined
+        switch (connector?.name) {
+          case 'OKX Wallet': {
+            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);
+          }
+
+          case 'Phantom': {
+            const phantom = anyWindow.phantom?.bitcoin;
+            if (!phantom?.signPSBT) throw new Error('Phantom wallet does not support signPSBT');
+
+            const inputsToSign = [];
+            console.log("Phantom options = ", JSON.stringify(createPsbtOptions(psbtFromBase64, dynamicParams)));
+            console.log("psbtHex = ", psbtHex);
+            console.log("psbtBase64 = ", psbtFromBase64.toBase64());
+
+            debugger
+            for (const sig of dynamicParams.signature || []) {
+              for (const index of sig.signingIndexes || []) {
+                inputsToSign.push({
+                  index,
+                  address: sig.address,
+                  sighashTypes: dynamicParams.allowedSighash,
+                });
+              }
+            }
+            debugger
+
+            const response = await phantom.signPSBT(
+              psbtFromBase64.toBase64(),   // ✅ Phantom only accepts base64
+              {
+                autoFinalize: false,              // ✅ correct name
+                inputsToSign,                     // ✅ correct name
+              }
+            );
+
+            const signedPsbt = extractSignedPsbt(response);
+            if (!signedPsbt) throw new Error('Missing psbt response from Phantom wallet');
+
+            return signedPsbt; // already base64
+          }
+
+
+          default:
+            throw new Error(`Unsupported wallet: ${connector.name}`);
+        }
+      }
+    );
+    adaptedWallet.sendTransaction = async (params: { recipient: string; amount: string | number }) => {
+      const connector = options.account.connector;
+      const anyWindow = typeof window !== 'undefined' ? (window as any) : undefined
+
+      // Convert amount to satoshis (BTC amount * 100000000)
+      const amountInSatoshis = Number(params.amount)
+      switch (connector?.name) {
+        case 'OKX Wallet': {
+          // 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');
+        }
+
+        case 'Phantom': {
+          // Phantom wallet sendBitcoin method
+          const txid = await sendBTCWithPhantom(
+            options.account.address?.toString() || '',
+            params.recipient,
+            amountInSatoshis
+          );
+          return txid;
+        }
+
+        default:
+          throw new Error(`Unsupported wallet: ${connector?.name}`);
+      }
+    }
+
+    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)
+    debugger
+    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 +1090,8 @@ 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 {
         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
   }
 }