@meshconnect/uwc-wallet-connect-connector 0.2.0 → 0.2.2

package/src/services/transaction-service.ts

@@ -1,39 +1,30 @@
-import { ethers } from 'ethers'
-import { Buffer } from 'buffer'
-import {
-  Connection,
-  PublicKey,
-  Transaction,
-  VersionedTransaction
-} from '@solana/web3.js'
 import type {
   TransactionRequest,
   TransactionResult,
-  EVMNativeTransferRequest,
-  EVMContractCallRequest,
-  SolanaNativeTransferRequest,
-  NetworkId,
+  EthereumTransactionRequest,
+  SolanaTransactionRequest,
   NetworkRpcMap
 } from '@meshconnect/uwc-types'
-import type SignClient from '@walletconnect/sign-client'
 import { WalletConnectClient } from './walletconnect-client'
 import { ConnectionService } from './connection-service'
-import { getChainIdFromNetworkId } from '../utils/account-utils'
-import { parseError } from '../utils/error-utils'
-import { getSolanaTransaction } from '../utils/solana-transactions'
-import type { SessionTypes } from '@walletconnect/types'
-import base58 from 'bs58'
-import { standardizeSignature } from '../utils/encoding-utils'
+import { EthereumTransactionService } from './ethereum/ethereum-transaction-service'
+import { SolanaTransactionService } from './solana/solana-transaction-service'
 
 /**
  * Service for handling transactions in WalletConnect
  */
 export class TransactionService {
+  private ethereumService: EthereumTransactionService
+  private solanaService: SolanaTransactionService
+
   constructor(
     private walletConnectClient: WalletConnectClient,
     private connectionService: ConnectionService,
-    private networkRpcMap: NetworkRpcMap = {}
-  ) {}
+    networkRpcMap: NetworkRpcMap = {}
+  ) {
+    this.ethereumService = new EthereumTransactionService()
+    this.solanaService = new SolanaTransactionService(networkRpcMap)
+  }
 
   /**
    * Send a transaction with the connected wallet
@@ -63,18 +54,17 @@ export class TransactionService {
     const namespace = activeNetwork.id.split(':')[0]
 
     if (namespace === 'eip155') {
-      return this.sendEthereumTransaction(
+      return this.ethereumService.sendTransaction(
         client,
         session,
-        request,
-        activeNetwork.id,
-        activeAddress
+        request as EthereumTransactionRequest,
+        activeNetwork.id
       )
     } else if (namespace === 'solana') {
-      return this.sendSolanaTransaction(
+      return this.solanaService.sendTransaction(
         client,
         session,
-        request as SolanaNativeTransferRequest,
+        request as SolanaTransactionRequest,
         activeNetwork.id,
         activeAddress
       )
@@ -82,316 +72,4 @@ export class TransactionService {
       throw new Error(`Unsupported namespace: ${namespace}`)
     }
   }
-
-  /**
-   * Send an Ethereum transaction
-   */
-  private async sendEthereumTransaction(
-    client: SignClient,
-    session: SessionTypes.Struct,
-    request: TransactionRequest,
-    activeNetworkId: string,
-    activeAddress: string
-  ): Promise<string> {
-    try {
-      // Handle different types of EVM transactions
-      if ('contractAddress' in request && 'abi' in request) {
-        // Contract call
-        return await this.sendContractCall(
-          client,
-          session,
-          request as EVMContractCallRequest,
-          activeNetworkId,
-          activeAddress
-        )
-      } else if ('calls' in request) {
-        // Batch transaction - not yet supported
-        throw new Error(
-          'Batch transactions are not yet supported for WalletConnect'
-        )
-      } else if ('amount' in request && typeof request.amount === 'bigint') {
-        // Native transfer
-        return await this.sendNativeTransfer(
-          client,
-          session,
-          request as EVMNativeTransferRequest,
-          activeNetworkId,
-          activeAddress
-        )
-      } else {
-        throw new Error('Invalid transaction request type')
-      }
-    } catch (error) {
-      throw parseError(error)
-    }
-  }
-
-  /**
-   * Send a Solana transaction
-   */
-  private async sendSolanaTransaction(
-    client: SignClient,
-    session: SessionTypes.Struct,
-    request: SolanaNativeTransferRequest,
-    activeNetworkId: string,
-    activeAddress: string
-  ): Promise<string> {
-    try {
-      // Verify the from address matches active address
-      if (request.from !== activeAddress) {
-        throw new Error('From address does not match connected wallet')
-      }
-
-      // Blockhash is required
-      if (!request.blockhash) {
-        throw new Error('Blockhash is required for Solana transactions')
-      }
-
-      // Create the transaction using the utility function
-      let transaction: Transaction | VersionedTransaction =
-        getSolanaTransaction(request)
-
-      // Serialize the transaction for WalletConnect
-      const serializedTransaction = transaction
-        .serialize({
-          verifySignatures: false
-        })
-        .toString('base64')
-
-      // Get the chain ID (e.g., "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp" for mainnet)
-      const chainId = activeNetworkId
-
-      try {
-        // First try signAndSendTransaction (preferred method)
-        const result = await client.request({
-          topic: session.topic,
-          chainId,
-          request: {
-            method: 'solana_signAndSendTransaction',
-            params: {
-              transaction: serializedTransaction
-            }
-          }
-        })
-
-        // WalletConnect returns the signature directly for Solana
-        return result as string
-      } catch (signAndSendError: unknown) {
-        const errorMessage =
-          signAndSendError instanceof Error
-            ? signAndSendError.message
-            : String(signAndSendError)
-        // If signAndSendTransaction is not supported, fallback to signTransaction
-        if (
-          errorMessage.includes('solana_signAndSendTransaction') ||
-          errorMessage.includes('Missing or invalid')
-        ) {
-          // Sign the transaction only
-          const result: { transaction: string } | { signature: string } =
-            await client.request({
-              topic: session.topic,
-              chainId,
-              request: {
-                method: 'solana_signTransaction',
-                params: {
-                  transaction: serializedTransaction
-                }
-              }
-            })
-
-          if ('signature' in result) {
-            const decoded = base58.decode(result.signature)
-            transaction.addSignature(
-              new PublicKey(request.from),
-              Buffer.from(decoded) as Buffer & Uint8Array
-            )
-          }
-
-          if ('transaction' in result) {
-            const decodedTransaction = Buffer.from(result.transaction, 'base64')
-
-            if (transaction instanceof VersionedTransaction) {
-              transaction = VersionedTransaction.deserialize(
-                new Uint8Array(decodedTransaction)
-              )
-            } else {
-              transaction = Transaction.from(decodedTransaction)
-            }
-          }
-
-          // Get RPC URL from the network RPC map or fall back to public endpoint
-          const rpcUrl =
-            this.networkRpcMap[activeNetworkId as NetworkId] ||
-            'https://api.mainnet-beta.solana.com'
-          const connection = new Connection(rpcUrl)
-          const rawSignature = await connection.sendRawTransaction(
-            transaction.serialize(),
-            {
-              skipPreflight: false,
-              maxRetries: 3,
-              preflightCommitment: 'confirmed'
-            }
-          )
-
-          return standardizeSignature(rawSignature)
-        }
-
-        // If it's a different error, throw it
-        throw signAndSendError
-      }
-    } catch (error) {
-      throw parseError(error)
-    }
-  }
-
-  /**
-   * Send native token transfer (ETH, BNB, MATIC, etc.)
-   */
-  private async sendNativeTransfer(
-    client: SignClient,
-    session: SessionTypes.Struct,
-    request: EVMNativeTransferRequest,
-    activeNetworkId: string,
-    activeAddress: string
-  ): Promise<string> {
-    try {
-      // Use the active network chainId
-      const chainId = getChainIdFromNetworkId(activeNetworkId as NetworkId)
-
-      // Build transaction using ethers
-      const tx: ethers.TransactionRequest = {
-        from: request.from || activeAddress,
-        to: request.to,
-        value: request.amount
-      }
-
-      // Add gas configuration if provided
-      if (request.gasConfig?.gasLimit) {
-        tx.gasLimit = BigInt(Math.floor(request.gasConfig.gasLimit))
-      }
-      if (request.gasConfig?.maxFeePerGas) {
-        tx.maxFeePerGas = BigInt(Math.floor(request.gasConfig.maxFeePerGas))
-      }
-      if (request.gasConfig?.maxPriorityFeePerGas) {
-        tx.maxPriorityFeePerGas = BigInt(
-          Math.floor(request.gasConfig.maxPriorityFeePerGas)
-        )
-      }
-
-      // Convert to hex format for WalletConnect
-      const txParams: Record<string, string> = {
-        from: tx.from as string,
-        to: tx.to as string,
-        value: '0x' + (tx.value ? BigInt(tx.value).toString(16) : '0'),
-        data: '0x' // Empty data for native transfers
-      }
-
-      // Add gas params if present
-      if (tx.gasLimit) {
-        txParams['gasLimit'] = '0x' + tx.gasLimit.toString(16)
-      }
-      if (tx.maxFeePerGas) {
-        txParams['maxFeePerGas'] = '0x' + tx.maxFeePerGas.toString(16)
-      }
-      if (tx.maxPriorityFeePerGas) {
-        txParams['maxPriorityFeePerGas'] =
-          '0x' + tx.maxPriorityFeePerGas.toString(16)
-      }
-
-      const hash = await client.request({
-        topic: session.topic,
-        chainId: `eip155:${chainId}`,
-        request: {
-          method: 'eth_sendTransaction',
-          params: [txParams]
-        }
-      })
-
-      return hash as string
-    } catch (error) {
-      throw parseError(error)
-    }
-  }
-
-  /**
-   * Send smart contract transaction (including ERC-20 transfers)
-   */
-  private async sendContractCall(
-    client: SignClient,
-    session: SessionTypes.Struct,
-    request: EVMContractCallRequest,
-    activeNetworkId: string,
-    activeAddress: string
-  ): Promise<string> {
-    try {
-      // Use the active network chainId
-      const chainId = getChainIdFromNetworkId(activeNetworkId as NetworkId)
-
-      // Encode the contract call data using ethers
-      const iface = new ethers.Interface(request.abi)
-      const data = iface.encodeFunctionData(request.functionName, request.args)
-
-      // Build transaction using ethers
-      const tx: ethers.TransactionRequest = {
-        from: request.from || activeAddress,
-        to: request.contractAddress,
-        data
-      }
-
-      // Add value for payable functions
-      if (request.value) {
-        tx.value = BigInt(request.value)
-      }
-
-      // Add gas configuration if provided
-      if (request.gasConfig?.gasLimit) {
-        tx.gasLimit = BigInt(Math.floor(request.gasConfig.gasLimit))
-      }
-      if (request.gasConfig?.maxFeePerGas) {
-        tx.maxFeePerGas = BigInt(Math.floor(request.gasConfig.maxFeePerGas))
-      }
-      if (request.gasConfig?.maxPriorityFeePerGas) {
-        tx.maxPriorityFeePerGas = BigInt(
-          Math.floor(request.gasConfig.maxPriorityFeePerGas)
-        )
-      }
-
-      // Convert to hex format for WalletConnect
-      const txParams: Record<string, string> = {
-        from: tx.from as string,
-        to: tx.to as string,
-        data: tx.data as string
-      }
-
-      // Add value if present
-      if (tx.value) {
-        txParams['value'] = '0x' + BigInt(tx.value).toString(16)
-      }
-
-      // Add gas params if present
-      if (tx.gasLimit) {
-        txParams['gasLimit'] = '0x' + tx.gasLimit.toString(16)
-      }
-      if (tx.maxFeePerGas) {
-        txParams['maxFeePerGas'] = '0x' + tx.maxFeePerGas.toString(16)
-      }
-      if (tx.maxPriorityFeePerGas) {
-        txParams['maxPriorityFeePerGas'] =
-          '0x' + tx.maxPriorityFeePerGas.toString(16)
-      }
-
-      const hash = await client.request({
-        topic: session.topic,
-        chainId: `eip155:${chainId}`,
-        request: {
-          method: 'eth_sendTransaction',
-          params: [txParams]
-        }
-      })
-
-      return hash as string
-    } catch (error) {
-      throw parseError(error)
-    }
-  }
 }

package/src/utils/account-utils.ts

@@ -113,4 +113,4 @@ export function extractAccountsFromNamespaces(
   })
 
   return accounts
-}
+}

package/src/utils/solana-transactions.ts

@@ -1,24 +0,0 @@
-import type { SolanaNativeTransferRequest } from '@meshconnect/uwc-types'
-import {
-  PublicKey,
-  SystemProgram,
-  Transaction,
-  VersionedTransaction
-} from '@solana/web3.js'
-
-export function getSolanaTransaction(params: SolanaNativeTransferRequest) {
-  if (!params.blockhash) {
-    throw new Error('Blockhash is required for Solana transactions')
-  }
-
-  const transaction: Transaction | VersionedTransaction = new Transaction().add(
-    SystemProgram.transfer({
-      fromPubkey: new PublicKey(params.from),
-      toPubkey: new PublicKey(params.to),
-      lamports: Number(params.amount)
-    })
-  )
-  transaction.recentBlockhash = params.blockhash
-  transaction.feePayer = new PublicKey(params.from)
-  return transaction
-}