@meshconnect/uwc-injected-connector 0.2.0

package/src/services/ethereum-transaction-service.ts

@@ -0,0 +1,196 @@
+import { ethers } from 'ethers'
+import type { EthereumProvider } from '../eip6963-discovery'
+import type {
+  EVMGasConfig,
+  EVMNativeTransferRequest,
+  EVMContractCallRequest,
+  EVMBatchTransactionRequest,
+  EVMCapabilities,
+  BatchTransactionResult
+} from '@meshconnect/uwc-types'
+import { parseError } from '../utils/error-utils'
+
+/**
+ * Service for handling Ethereum/EVM transaction operations
+ */
+export class EthereumTransactionService {
+  /**
+   * Send native token transfer (ETH, BNB, MATIC, etc.)
+   */
+  async sendNativeTransfer(
+    provider: EthereumProvider,
+    request: EVMNativeTransferRequest
+  ): Promise<string> {
+    try {
+      // Get current chain ID
+      const chainIdHex = await provider.request({
+        method: 'eth_chainId'
+      })
+      const chainId = parseInt(chainIdHex, 16)
+
+      // Create ethers provider and signer
+      const ethersProvider = new ethers.BrowserProvider(provider)
+      const signer = await ethersProvider.getSigner(request.from)
+
+      // Verify network hasn't changed
+      const network = await ethersProvider.getNetwork()
+      if (Number(network.chainId) !== chainId) {
+        throw new Error('Network changed during transaction setup')
+      }
+
+      // Build transaction
+      const tx = await signer.sendTransaction({
+        to: request.to,
+        value: request.amount,
+        ...this.formatGasConfig(request.gasConfig)
+      })
+
+      // Wait for confirmation
+      const receipt = await tx.wait()
+      return receipt ? receipt.hash : ''
+    } catch (error) {
+      parseError(error)
+    }
+  }
+
+  /**
+   * Send smart contract transaction (including ERC-20 transfers)
+   */
+  async sendContractCall(
+    provider: EthereumProvider,
+    request: EVMContractCallRequest
+  ): Promise<string> {
+    try {
+      // Get current chain ID
+      const chainIdHex = await provider.request({
+        method: 'eth_chainId'
+      })
+      const chainId = parseInt(chainIdHex, 16)
+
+      // Create ethers provider and signer
+      const ethersProvider = new ethers.BrowserProvider(provider)
+      const signer = await ethersProvider.getSigner(request.from)
+
+      // Verify network hasn't changed
+      const network = await ethersProvider.getNetwork()
+      if (Number(network.chainId) !== chainId) {
+        throw new Error('Network changed during transaction setup')
+      }
+
+      // Create contract instance
+      const contract = new ethers.Contract(
+        request.contractAddress,
+        request.abi,
+        signer
+      )
+
+      // Build transaction options
+      const txOptions: ethers.Overrides = {
+        ...this.formatGasConfig(request.gasConfig)
+      }
+
+      // Add value for payable functions
+      if (request.value) {
+        txOptions.value = request.value
+      }
+
+      // Call the contract function
+      const contractFunction = contract[request.functionName]
+      if (!contractFunction) {
+        throw new Error(
+          `Function ${request.functionName} not found in contract`
+        )
+      }
+      const tx = await contractFunction(...request.args, txOptions)
+
+      // Wait for confirmation
+      const receipt = await tx.wait()
+      return receipt ? receipt.hash : ''
+    } catch (error) {
+      parseError(error)
+    }
+  }
+
+  /**
+   * Send batch of transactions (EIP-5792)
+   */
+  async sendBatch(
+    provider: EthereumProvider,
+    request: EVMBatchTransactionRequest
+  ): Promise<string> {
+    try {
+      const ethersProvider = new ethers.BrowserProvider(provider)
+
+      // Send batch transaction
+      const response: { id: string } = await ethersProvider.send(
+        'wallet_sendCalls',
+        [request]
+      )
+
+      // Poll for completion
+      let result: BatchTransactionResult
+      do {
+        result = await ethersProvider.send('wallet_getCallsStatus', [
+          response.id
+        ])
+
+        // Wait 1 second if still pending
+        if (result.status === 100) {
+          await new Promise(resolve => setTimeout(resolve, 1000))
+        }
+      } while (result.status === 100)
+
+      // Check if successful
+      if (result.status !== 200) {
+        throw new Error('Batch transaction failed')
+      }
+
+      // Return first transaction hash
+      const firstReceipt = result.receipts.find(r => r)
+      if (!firstReceipt) {
+        throw new Error('No transaction receipt found')
+      }
+
+      return firstReceipt.transactionHash
+    } catch (error) {
+      parseError(error)
+    }
+  }
+
+  /**
+   * Get wallet capabilities (EIP-5792 support)
+   */
+  async getCapabilities(
+    provider: EthereumProvider,
+    from: string,
+    chainId: string
+  ): Promise<EVMCapabilities> {
+    const ethersProvider = new ethers.BrowserProvider(provider)
+    const capabilities = await ethersProvider.send('wallet_getCapabilities', [
+      from,
+      [chainId]
+    ])
+    return capabilities[chainId] || {}
+  }
+
+  /**
+   * Helper to format gas configuration for ethers
+   */
+  private formatGasConfig(gasConfig?: EVMGasConfig): ethers.Overrides {
+    const txOptions: ethers.Overrides = {}
+
+    if (gasConfig?.gasLimit) {
+      txOptions.gasLimit = BigInt(Math.floor(gasConfig.gasLimit))
+    }
+    if (gasConfig?.maxFeePerGas) {
+      txOptions.maxFeePerGas = BigInt(Math.floor(gasConfig.maxFeePerGas))
+    }
+    if (gasConfig?.maxPriorityFeePerGas) {
+      txOptions.maxPriorityFeePerGas = BigInt(
+        Math.floor(gasConfig.maxPriorityFeePerGas)
+      )
+    }
+
+    return txOptions
+  }
+}

package/src/services/ethereum-wallet-service.ts

@@ -0,0 +1,161 @@
+import type { NetworkId, AvailableAddress } from '@meshconnect/uwc-types'
+import type {
+  EthereumProvider,
+  DetectedWallet as EIP6963DetectedWallet
+} from '../eip6963-discovery'
+import { getAvailableWallets as getEIP6963Wallets } from '../eip6963-discovery'
+
+/**
+ * Service for managing Ethereum wallet connections
+ */
+export class EthereumWalletService {
+  private detectedWallets: EIP6963DetectedWallet[] = []
+  private connectedProvider: EthereumProvider | null = null
+  private account: string | null = null
+
+  /**
+   * Initialize wallet discovery
+   */
+  async initializeDiscovery(): Promise<void> {
+    this.detectedWallets = await getEIP6963Wallets()
+  }
+
+  /**
+   * Get detected wallets
+   */
+  getDetectedWallets(): EIP6963DetectedWallet[] {
+    return this.detectedWallets
+  }
+
+  /**
+   * Find wallet by UUID
+   */
+  findWalletByUuid(uuid: string): EIP6963DetectedWallet | undefined {
+    return this.detectedWallets.find(w => w.uuid === uuid)
+  }
+
+  /**
+   * Check if a wallet is already connected without requesting access
+   */
+  async checkExistingConnection(
+    provider: EthereumProvider
+  ): Promise<string[] | null> {
+    try {
+      // Try eth_accounts which doesn't prompt user
+      const accounts = await provider.request({
+        method: 'eth_accounts'
+      })
+      return accounts && accounts.length > 0 ? accounts : null
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Connect to wallet
+   */
+  async connect(provider: EthereumProvider): Promise<string> {
+    const accounts = await provider.request({
+      method: 'eth_requestAccounts'
+    })
+
+    if (!accounts || accounts.length === 0) {
+      throw new Error('No accounts returned from wallet')
+    }
+
+    const address = accounts[0]
+    this.connectedProvider = provider
+    this.account = address
+
+    // Request chain ID to ensure we're connected
+    await provider.request({
+      method: 'eth_chainId'
+    })
+
+    return address
+  }
+
+  /**
+   * Switch network
+   */
+  async switchNetwork(networkId: string): Promise<void> {
+    if (!this.connectedProvider) {
+      throw new Error('No Ethereum wallet connected')
+    }
+
+    // Extract chain ID from network.id (format: "eip155:1")
+    const chainIdParts = networkId.split(':')
+    if (chainIdParts.length !== 2 || !chainIdParts[1]) {
+      throw new Error(`Invalid network ID format: ${networkId}`)
+    }
+    const chainId = chainIdParts[1]
+    const chainIdHex = `0x${parseInt(chainId, 10).toString(16)}`
+
+    // Try to switch to the requested chain
+    try {
+      await this.connectedProvider.request({
+        method: 'wallet_switchEthereumChain',
+        params: [{ chainId: chainIdHex }]
+      })
+    } catch (switchError: unknown) {
+      // This error code indicates that the chain has not been added to the wallet
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      if ((switchError as any).code === 4902) {
+        throw new Error(`Chain ${networkId} is not added to the wallet`)
+      }
+      throw switchError
+    }
+  }
+
+  /**
+   * Build available addresses for all supported networks
+   */
+  buildAvailableAddresses(
+    supportedNetworkIds: string[],
+    address: string
+  ): AvailableAddress[] {
+    const addresses: AvailableAddress[] = []
+    supportedNetworkIds.forEach(networkId => {
+      if (networkId.startsWith('eip155:')) {
+        addresses.push({
+          address,
+          networkId: networkId as NetworkId
+        })
+      }
+    })
+    return addresses
+  }
+
+  /**
+   * Set connection state
+   */
+  setConnectionState(
+    provider: EthereumProvider | null,
+    account: string | null
+  ): void {
+    this.connectedProvider = provider
+    this.account = account
+  }
+
+  /**
+   * Get current account
+   */
+  getAccount(): string | null {
+    return this.account
+  }
+
+  /**
+   * Get connected provider
+   */
+  getConnectedProvider(): EthereumProvider | null {
+    return this.connectedProvider
+  }
+
+  /**
+   * Disconnect (clear state only)
+   */
+  disconnect(): void {
+    this.connectedProvider = null
+    this.account = null
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,7 @@
+export { StorageService } from './storage-service'
+export { EthereumWalletService } from './ethereum-wallet-service'
+export { SolanaWalletService } from './solana-wallet-service'
+export { ConnectionManager } from './connection-manager'
+export { SignatureService } from './signature-service'
+export { TransactionService } from './transaction-service'
+export { EthereumTransactionService } from './ethereum-transaction-service'

package/src/services/signature-service.ts

@@ -0,0 +1,84 @@
+import type { EthereumProvider } from '../eip6963-discovery'
+import type { WalletAdapter } from '@solana/wallet-adapter-base'
+import bs58 from 'bs58'
+import { parseError } from '../utils/error-utils'
+
+/**
+ * Service for handling message signing operations for injected wallets
+ */
+export class SignatureService {
+  /**
+   * Sign a message with an Ethereum wallet
+   */
+  async signEthereumMessage(
+    message: string,
+    address: string,
+    provider: EthereumProvider
+  ): Promise<string> {
+    if (!provider) {
+      throw new Error('Provider is required for Ethereum message signing')
+    }
+
+    if (!message) {
+      throw new Error('Message is required for signing')
+    }
+
+    if (!address) {
+      throw new Error('Address is required for signing')
+    }
+
+    try {
+      // Use personal_sign for Ethereum
+      const signature = await provider.request({
+        method: 'personal_sign',
+        params: [message, address]
+      })
+
+      return signature
+    } catch (error) {
+      parseError(error)
+    }
+  }
+
+  /**
+   * Sign a message with a Solana wallet
+   */
+  async signSolanaMessage(
+    message: string,
+    adapter: WalletAdapter
+  ): Promise<string> {
+    if (!adapter) {
+      throw new Error('Adapter is required for Solana message signing')
+    }
+
+    if (!message) {
+      throw new Error('Message is required for signing')
+    }
+
+    // Check if adapter supports signMessage
+    const signingAdapter = adapter as WalletAdapter & {
+      signMessage?: (message: Uint8Array) => Promise<Uint8Array>
+    }
+
+    if (!signingAdapter.signMessage) {
+      throw new Error('Solana adapter does not support message signing')
+    }
+
+    try {
+      // Convert message to Uint8Array for Solana
+      const encoder = new TextEncoder()
+      const messageBytes = encoder.encode(message)
+
+      // Sign the message
+      const signedMessage = await signingAdapter.signMessage(messageBytes)
+
+      // Encode signature using base58 for Solana (standard encoding for Solana)
+      // The signature is returned as a Uint8Array, encode it to base58 string
+      const signatureBase58 = bs58.encode(signedMessage)
+
+      return signatureBase58
+    } catch (error) {
+      parseError(error)
+    }
+  }
+}

package/src/services/solana-transaction-service.ts

@@ -0,0 +1,68 @@
+import {
+  PublicKey,
+  SystemProgram,
+  Transaction,
+  Connection
+} from '@solana/web3.js'
+import type { WalletAdapter } from '@solana/wallet-adapter-base'
+import type { SolanaNativeTransferRequest, NetworkRpcMap, NetworkId } from '@meshconnect/uwc-types'
+import { parseError } from '../utils/error-utils'
+
+/**
+ * Service for handling Solana transaction operations
+ */
+export class SolanaTransactionService {
+  private networkRpcMap: NetworkRpcMap
+
+  constructor(networkRpcMap: NetworkRpcMap = {}) {
+    this.networkRpcMap = networkRpcMap
+  }
+
+  /**
+   * Send native SOL transfer
+   */
+  async sendNativeTransfer(
+    adapter: WalletAdapter,
+    request: SolanaNativeTransferRequest,
+    networkId?: NetworkId
+  ): Promise<string> {
+    try {
+      if (!adapter.publicKey) {
+        throw new Error('Wallet not connected')
+      }
+
+      // Verify the from address matches connected wallet
+      if (adapter.publicKey.toBase58() !== request.from) {
+        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 transaction
+      const transaction = new Transaction().add(
+        SystemProgram.transfer({
+          fromPubkey: new PublicKey(request.from),
+          toPubkey: new PublicKey(request.to),
+          lamports: Number(request.amount)
+        })
+      )
+
+      transaction.recentBlockhash = request.blockhash
+      transaction.feePayer = adapter.publicKey
+
+      // Get RPC URL from the network RPC map or fall back to public endpoint
+      const rpcUrl = networkId && this.networkRpcMap[networkId] 
+        ? this.networkRpcMap[networkId] 
+        : 'https://api.mainnet-beta.solana.com'
+      const connection = new Connection(rpcUrl)
+
+      const signature = await adapter.sendTransaction(transaction, connection)
+      return signature
+    } catch (error) {
+      parseError(error)
+    }
+  }
+}

package/src/services/solana-wallet-service.ts

@@ -0,0 +1,161 @@
+import type { NetworkId, AvailableAddress } from '@meshconnect/uwc-types'
+import type { WalletAdapter } from '@solana/wallet-adapter-base'
+import {
+  getSolanaWallets,
+  type WalletStandardInfo
+} from '../wallet-standard-discovery'
+import { StorageService } from './storage-service'
+
+/**
+ * Service for managing Solana wallet connections
+ */
+export class SolanaWalletService {
+  private detectedWallets: WalletStandardInfo[] = []
+  private connectedAdapter: WalletAdapter | null = null
+  private account: string | null = null
+  private storageService: StorageService
+
+  constructor(storageService: StorageService) {
+    this.storageService = storageService
+  }
+
+  /**
+   * Initialize wallet discovery
+   */
+  initializeDiscovery(): void {
+    this.detectedWallets = getSolanaWallets()
+  }
+
+  /**
+   * Get detected wallets
+   */
+  getDetectedWallets(): WalletStandardInfo[] {
+    return this.detectedWallets
+  }
+
+  /**
+   * Find wallet by UUID
+   */
+  findWalletByUuid(uuid: string): WalletStandardInfo | undefined {
+    return this.detectedWallets.find(w => w.uuid === uuid)
+  }
+
+  /**
+   * Check if a Solana wallet is already connected
+   */
+  async checkExistingConnection(
+    adapter: WalletAdapter,
+    walletUuid: string
+  ): Promise<string | null> {
+    try {
+      // Check if adapter has a publicKey (means it's connected)
+      if (adapter.publicKey) {
+        return adapter.publicKey.toBase58()
+      }
+
+      // If this wallet was previously connected, try to reconnect
+      // This should work without prompting for wallets that support it
+      if (this.storageService.wasSolanaWalletPreviouslyConnected(walletUuid)) {
+        if (
+          'connecting' in adapter &&
+          !adapter.connecting &&
+          'connect' in adapter
+        ) {
+          try {
+            // Type assertion needed because TypeScript can't narrow the type properly
+            await adapter.connect()
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const publicKey = (adapter as any).publicKey
+            if (publicKey && 'toBase58' in publicKey) {
+              return publicKey.toBase58()
+            }
+          } catch {
+            // Silent fail - wallet requires user interaction or doesn't support silent reconnect
+          }
+        }
+      }
+      return null
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Connect to wallet
+   */
+  async connect(adapter: WalletAdapter, walletUuid: string): Promise<string> {
+    // Connect to the Solana wallet
+    await adapter.connect()
+
+    if (!adapter.publicKey) {
+      throw new Error('No public key returned from wallet')
+    }
+
+    const address = adapter.publicKey.toBase58()
+    this.connectedAdapter = adapter
+    this.account = address
+
+    // Store this wallet as connected
+    this.storageService.storeSolanaWalletUUID(walletUuid)
+
+    return address
+  }
+
+  /**
+   * Build available addresses for all supported networks
+   */
+  buildAvailableAddresses(
+    supportedNetworkIds: string[],
+    address: string
+  ): AvailableAddress[] {
+    const addresses: AvailableAddress[] = []
+    supportedNetworkIds.forEach(networkId => {
+      if (networkId.startsWith('solana:')) {
+        addresses.push({
+          address,
+          networkId: networkId as NetworkId
+        })
+      }
+    })
+    return addresses
+  }
+
+  /**
+   * Set connection state
+   */
+  setConnectionState(
+    adapter: WalletAdapter | null,
+    account: string | null,
+    walletUuid?: string
+  ): void {
+    this.connectedAdapter = adapter
+    this.account = account
+
+    // Store wallet UUID if provided and connected
+    if (adapter && account && walletUuid) {
+      this.storageService.storeSolanaWalletUUID(walletUuid)
+    }
+  }
+
+  /**
+   * Get current account
+   */
+  getAccount(): string | null {
+    return this.account
+  }
+
+  /**
+   * Get connected adapter
+   */
+  getConnectedAdapter(): WalletAdapter | null {
+    return this.connectedAdapter
+  }
+
+  /**
+   * Disconnect (clear state only, don't actually disconnect from wallet)
+   */
+  disconnect(): void {
+    this.connectedAdapter = null
+    this.account = null
+  }
+}