@meshconnect/uwc-wallet-connect-connector 0.2.0

package/src/services/signature-service.ts

@@ -0,0 +1,128 @@
+import { WalletConnectClient } from './walletconnect-client'
+import { ConnectionService } from './connection-service'
+import { findAccountInNamespaces, parseAccount } from '../utils/account-utils'
+import { base58Encode } from '../utils/encoding-utils'
+import { parseError } from '../utils/error-utils'
+
+/**
+ * Service for handling message signing in WalletConnect
+ */
+export class SignatureService {
+  constructor(
+    private walletConnectClient: WalletConnectClient,
+    private connectionService: ConnectionService
+  ) {}
+
+  /**
+   * Sign a message with the connected wallet
+   */
+  async signMessage(message: string): Promise<string> {
+    try {
+      const session = this.connectionService.getSession()
+      if (!session) {
+        throw new Error('No active session. Please connect first.')
+      }
+
+      const activeNetwork = this.connectionService.getActiveNetwork()
+      const activeAddress = this.connectionService.getActiveAddress()
+
+      if (!activeNetwork) {
+        throw new Error('No active network. Please connect first.')
+      }
+
+      if (!activeAddress) {
+        throw new Error('No active address. Please connect first.')
+      }
+
+      const client = await this.walletConnectClient.getClient()
+
+      // Find the account that matches the active network and address
+      const targetAccount = findAccountInNamespaces(
+        session.namespaces,
+        activeNetwork.id,
+        activeAddress
+      )
+
+      if (!targetAccount) {
+        throw new Error(
+          `No account found for network ${activeNetwork.id} and address ${activeAddress}`
+        )
+      }
+
+      const {
+        namespace: accountNamespace,
+        chainId,
+        address
+      } = parseAccount(targetAccount)
+
+      // Determine the signing method based on namespace
+      let method: string
+      let params: unknown[] | unknown
+
+      switch (accountNamespace) {
+        case 'eip155':
+          method = 'personal_sign'
+          // For personal_sign: [message, address]
+          params = [message, address]
+          break
+
+        case 'solana': {
+          method = 'solana_signMessage'
+          // For Solana: message needs to be base58 encoded
+          const base58Message = base58Encode(message)
+
+          // For Solana, params is an object, not an array
+          params = {
+            message: base58Message,
+            pubkey: address
+          }
+          break
+        }
+
+        case 'bip122':
+          method = 'signMessage'
+          params = [
+            {
+              message,
+              address
+            }
+          ]
+          break
+
+        case 'tron':
+          method = 'tron_signMessage'
+          params = [
+            {
+              message,
+              address
+            }
+          ]
+          break
+
+        default:
+          throw new Error(
+            `Signing not supported for namespace: ${accountNamespace}`
+          )
+      }
+      // Make the signing request
+      const result = await client.request({
+        topic: session.topic,
+        chainId: `${accountNamespace}:${chainId}`,
+        request: {
+          method,
+          params
+        }
+      })
+
+      // Handle different response formats
+      if (accountNamespace === 'solana') {
+        // Solana returns an object with a signature property
+        return (result as { signature: string }).signature
+      }
+
+      return result as string
+    } catch (error) {
+      throw parseError(error)
+    }
+  }
+}

package/src/services/transaction-service.ts

@@ -0,0 +1,397 @@
+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,
+  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'
+
+/**
+ * Service for handling transactions in WalletConnect
+ */
+export class TransactionService {
+  constructor(
+    private walletConnectClient: WalletConnectClient,
+    private connectionService: ConnectionService,
+    private networkRpcMap: NetworkRpcMap = {}
+  ) {}
+
+  /**
+   * Send a transaction with the connected wallet
+   */
+  async sendTransaction(
+    request: TransactionRequest
+  ): Promise<TransactionResult> {
+    const session = this.connectionService.getSession()
+    if (!session) {
+      throw new Error('No active session. Please connect first.')
+    }
+
+    const activeNetwork = this.connectionService.getActiveNetwork()
+    const activeAddress = this.connectionService.getActiveAddress()
+
+    if (!activeNetwork) {
+      throw new Error('No active network. Please connect first.')
+    }
+
+    if (!activeAddress) {
+      throw new Error('No active address. Please connect first.')
+    }
+
+    const client = await this.walletConnectClient.getClient()
+
+    // Determine namespace from network ID
+    const namespace = activeNetwork.id.split(':')[0]
+
+    if (namespace === 'eip155') {
+      return this.sendEthereumTransaction(
+        client,
+        session,
+        request,
+        activeNetwork.id,
+        activeAddress
+      )
+    } else if (namespace === 'solana') {
+      return this.sendSolanaTransaction(
+        client,
+        session,
+        request as SolanaNativeTransferRequest,
+        activeNetwork.id,
+        activeAddress
+      )
+    } else {
+      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/services/walletconnect-client.ts

@@ -0,0 +1,103 @@
+import SignClient from '@walletconnect/sign-client'
+import type { WalletConnectConfig } from '@meshconnect/uwc-types'
+
+/**
+ * Service for managing WalletConnect client instance
+ */
+export class WalletConnectClient {
+  private client: SignClient | null = null
+  private initPromise: Promise<SignClient> | null = null
+
+  constructor(private config: WalletConnectConfig) {}
+
+  /**
+   * Initialize or get the WalletConnect client
+   */
+  async getClient(): Promise<SignClient> {
+    // If already initialized, return the client
+    if (this.client) {
+      return this.client
+    }
+
+    // If initialization is in progress, wait for it
+    if (this.initPromise) {
+      return this.initPromise
+    }
+
+    // Start initialization
+    this.initPromise = this.initClient()
+    this.client = await this.initPromise
+    this.initPromise = null
+
+    return this.client
+  }
+
+  /**
+   * Initialize the WalletConnect client
+   */
+  private async initClient(): Promise<SignClient> {
+    if (!this.config.projectId) {
+      throw new Error('WalletConnect projectId is required')
+    }
+
+    let url = this.config.metadata?.url || ''
+    if (!url && typeof globalThis !== 'undefined') {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const global = globalThis as any
+      if (global.location?.origin) {
+        url = global.location.origin
+      }
+    }
+
+    const metadata = {
+      name: this.config.metadata?.name || 'Universal Wallet Connector',
+      description: this.config.metadata?.description || 'Connect your wallet',
+      url,
+      icons: this.config.metadata?.icons || []
+    }
+
+    const client = await SignClient.init({
+      projectId: this.config.projectId,
+      metadata
+    })
+
+    return client
+  }
+
+  /**
+   * Disconnect all sessions
+   */
+  async disconnectAll(): Promise<void> {
+    const client = await this.getClient()
+    const sessions = client.session.getAll()
+
+    for (const session of sessions) {
+      try {
+        await client.disconnect({
+          topic: session.topic,
+          reason: {
+            code: 6000,
+            message: 'User disconnected'
+          }
+        })
+      } catch {
+        // Silently ignore disconnect errors
+      }
+    }
+  }
+
+  /**
+   * Disconnect a specific session
+   */
+  async disconnect(topic: string): Promise<void> {
+    const client = await this.getClient()
+
+    await client.disconnect({
+      topic,
+      reason: {
+        code: 6000,
+        message: 'User disconnected'
+      }
+    })
+  }
+}