@meshconnect/uwc-core 0.2.0

package/src/universal-wallet-connector.ts

@@ -0,0 +1,426 @@
+import type {
+  UniversalWalletConnectorState,
+  Network,
+  WalletMetadata,
+  NetworkId,
+  ConnectionMode,
+  WalletConnectConfig,
+  Connector,
+  Namespace,
+  DetectedEIP6963WalletInfo,
+  DetectedSolanaWalletInfo,
+  TransactionRequest,
+  TransactionResult,
+  NetworkRpcMap
+} from '@meshconnect/uwc-types'
+import { InjectedConnector } from '@meshconnect/uwc-injected-connector'
+import { WalletConnectConnector } from '@meshconnect/uwc-wallet-connect-connector'
+import { SessionManager } from './managers/session-manager'
+import { EventManager } from './managers/event-manager'
+import { ConnectionService } from './services/connection-service'
+import { NetworkSwitchService } from './services/network-switch-service'
+import { SignatureService } from './services/signature-service'
+import { TransactionService } from './services/transaction-service'
+import { createNetworkRpcMap } from './utils/network-rpc-utils'
+
+export class UniversalWalletConnector {
+  private static instanceCount = 0
+  private static hasWarnedAboutMultipleInstances = false
+
+  private sessionManager: SessionManager
+  private eventManager: EventManager
+  private connectionService: ConnectionService
+  private networkSwitchService: NetworkSwitchService
+  private signatureService: SignatureService
+  private transactionService: TransactionService
+  private connectors: Map<ConnectionMode, Connector>
+  private injectedConnector: InjectedConnector
+  private wallets: WalletMetadata[]
+  private usingIntegratedBrowser: boolean
+  private detectionComplete = false
+  private networkRpcMap: NetworkRpcMap
+
+  constructor(
+    networks: Network[],
+    wallets: WalletMetadata[] = [],
+    usingIntegratedBrowser = false,
+    walletConnectConfig?: WalletConnectConfig
+  ) {
+    // Track instance creation
+    UniversalWalletConnector.instanceCount++
+
+    // Warn about multiple instances
+    if (
+      UniversalWalletConnector.instanceCount > 1 &&
+      !UniversalWalletConnector.hasWarnedAboutMultipleInstances
+    ) {
+      // eslint-disable-next-line no-console
+      console.error(
+        `⚠️ WARNING: Multiple instances of UniversalWalletConnector detected (${UniversalWalletConnector.instanceCount} instances). ` +
+          'This can lead to state inconsistencies and unexpected behavior. ' +
+          'Please ensure you create only one instance and reuse it throughout your application. ' +
+          'Consider using a singleton pattern or a context provider. ' +
+          'You can ignore this warning if you are using React Strict Mode, which intentionally mounts components twice in development to help identify side effects.'
+      )
+      UniversalWalletConnector.hasWarnedAboutMultipleInstances = true
+    }
+
+    if (!networks || networks.length === 0) {
+      throw new Error(
+        'Universal Wallet Connector must be initialized with at least one network'
+      )
+    }
+    if (!wallets || wallets.length === 0) {
+      throw new Error(
+        'Universal Wallet Connector must be initialized with at least one wallet'
+      )
+    }
+
+    this.wallets = wallets
+    this.usingIntegratedBrowser = usingIntegratedBrowser
+
+    // Create RPC map from networks
+    this.networkRpcMap = createNetworkRpcMap(networks)
+
+    // Initialize connectors with RPC map
+    this.connectors = new Map()
+    this.injectedConnector = new InjectedConnector(this.networkRpcMap)
+    this.connectors.set('injected', this.injectedConnector)
+
+    // Only add WalletConnect connector if config is provided
+    if (walletConnectConfig) {
+      this.connectors.set(
+        'walletConnect',
+        new WalletConnectConnector(walletConnectConfig, this.networkRpcMap)
+      )
+    }
+
+    this.sessionManager = new SessionManager()
+    this.eventManager = new EventManager()
+    this.connectionService = new ConnectionService(
+      networks,
+      this.wallets,
+      this.sessionManager,
+      this.connectors,
+      usingIntegratedBrowser,
+      this.eventManager
+    )
+    this.networkSwitchService = new NetworkSwitchService(
+      networks,
+      this.sessionManager,
+      this.connectors,
+      usingIntegratedBrowser,
+      this.eventManager
+    )
+    this.signatureService = new SignatureService(
+      this.sessionManager,
+      this.connectors
+    )
+    this.transactionService = new TransactionService(
+      this.sessionManager,
+      this.connectors
+    )
+
+    // Initialize detected wallets after services are created
+    this.initializeDetectedWallets()
+  }
+
+  /**
+   * Discovers available wallets and updates the wallet metadata
+   */
+  private async initializeDetectedWallets(): Promise<void> {
+    try {
+      // Collect all unique namespaces from all wallets
+      const namespaces = new Set<string>()
+
+      this.wallets.forEach(wallet => {
+        const provider = this.usingIntegratedBrowser
+          ? wallet.integratedBrowserInjectedProvider
+          : wallet.extensionInjectedProvider
+
+        if (provider?.namespaceMetaData) {
+          Object.keys(provider.namespaceMetaData).forEach(ns => {
+            namespaces.add(ns)
+          })
+        }
+      })
+
+      // Check available wallets for each namespace across all connectors
+      for (const namespace of namespaces) {
+        for (const [, connector] of this.connectors) {
+          // Check if connector supports getAvailableWallets
+          if (typeof connector.getAvailableWallets === 'function') {
+            try {
+              const detectedWallets = await connector.getAvailableWallets(
+                namespace as Namespace
+              )
+
+              // Update wallets with detected information
+              detectedWallets.forEach(detected => {
+                // Find matching wallet based on namespace-specific naming
+                let wallet: WalletMetadata | undefined
+
+                if (namespace === 'eip155') {
+                  // For EIP155, match by eip155Name
+                  wallet = this.wallets.find(w => {
+                    const provider = this.usingIntegratedBrowser
+                      ? w.integratedBrowserInjectedProvider
+                      : w.extensionInjectedProvider
+                    return (
+                      provider?.namespaceMetaData?.eip155?.eip155Name?.toLowerCase() ===
+                      detected.name.toLowerCase()
+                    )
+                  })
+                } else if (namespace === 'solana') {
+                  // For Solana, match by walletStandardName
+                  wallet = this.wallets.find(w => {
+                    const provider = this.usingIntegratedBrowser
+                      ? w.integratedBrowserInjectedProvider
+                      : w.extensionInjectedProvider
+                    return (
+                      provider?.namespaceMetaData?.solana?.walletStandardName?.toLowerCase() ===
+                      detected.name.toLowerCase()
+                    )
+                  })
+                } else {
+                  // For other namespaces, fall back to wallet name
+                  wallet = this.wallets.find(
+                    w => w.name.toLowerCase() === detected.name.toLowerCase()
+                  )
+                }
+
+                if (wallet) {
+                  // Determine which provider to update based on usingIntegratedBrowser
+                  const provider = this.usingIntegratedBrowser
+                    ? wallet.integratedBrowserInjectedProvider
+                    : wallet.extensionInjectedProvider
+
+                  // Update the appropriate namespace metadata
+                  if (provider?.namespaceMetaData) {
+                    const nsMetadata =
+                      provider.namespaceMetaData[namespace as Namespace]
+                    if (nsMetadata && namespace === 'eip155') {
+                      // For EIP155, we have specific fields
+                      const eip155Metadata = nsMetadata as {
+                        installed?: boolean
+                        detectedWallet?: DetectedEIP6963WalletInfo
+                      }
+                      eip155Metadata.installed = true
+                      const eip155Detected =
+                        detected as DetectedEIP6963WalletInfo
+                      eip155Metadata.detectedWallet = {
+                        uuid: eip155Detected.uuid,
+                        name: eip155Detected.name,
+                        icon: eip155Detected.icon,
+                        rdns: eip155Detected.rdns
+                      }
+                    } else if (namespace === 'solana') {
+                      // For Solana, we have different fields
+                      const solanaMetadata = nsMetadata as {
+                        installed?: boolean
+                        detectedWallet?: DetectedSolanaWalletInfo
+                      }
+                      solanaMetadata.installed = true
+                      const solanaDetected =
+                        detected as DetectedSolanaWalletInfo
+                      solanaMetadata.detectedWallet = {
+                        uuid: solanaDetected.uuid,
+                        name: solanaDetected.name,
+                        features: solanaDetected.features
+                      }
+                    }
+                    // For other namespaces, we could add different handling if needed
+                  }
+                }
+              })
+            } catch {
+              // Silently handle errors for individual connector/namespace combinations
+            }
+          }
+        }
+      }
+
+      // Notify the connection service to update its internal wallets reference
+      this.connectionService.updateWallets(this.wallets)
+
+      // Mark detection as complete
+      this.detectionComplete = true
+
+      // Notify listeners about the update
+      this.eventManager.notify()
+    } catch {
+      // Silently handle error during initialization
+      this.detectionComplete = true
+      this.eventManager.notify()
+    }
+  }
+
+  getSession() {
+    return this.sessionManager.getSession()
+  }
+
+  isReady() {
+    return this.detectionComplete
+  }
+
+  subscribe(listener: () => void): () => void {
+    return this.eventManager.subscribe(listener)
+  }
+
+  getState(): UniversalWalletConnectorState {
+    return {
+      session: this.sessionManager.getSession()
+    }
+  }
+
+  getWallets(): WalletMetadata[] {
+    return this.connectionService.getWallets()
+  }
+
+  getNetworks(): Network[] {
+    return this.connectionService.getNetworks()
+  }
+
+  async connect(
+    connectionMode: ConnectionMode,
+    walletId: string,
+    networkId?: NetworkId
+  ): Promise<void> {
+    await this.connectionService.connect(connectionMode, walletId, networkId)
+    this.eventManager.notify()
+  }
+
+  getConnectionURI(): string | undefined {
+    return this.connectionService.getConnectionURI()
+  }
+
+  async disconnect(): Promise<void> {
+    await this.connectionService.disconnect()
+    this.eventManager.notify()
+  }
+
+  async switchNetwork(networkId: NetworkId): Promise<void> {
+    await this.networkSwitchService.switchNetwork(networkId)
+    this.eventManager.notify()
+  }
+
+  getNetworkSwitchLoadingState() {
+    return this.networkSwitchService.getLoadingState()
+  }
+
+  /**
+   * Sign a message with the connected wallet
+   * @param message The message to sign
+   * @returns A promise that resolves to the signature
+   */
+  async signMessage(message: string): Promise<string> {
+    const session = this.sessionManager.getSession()
+
+    if (!session.activeWallet) {
+      throw new Error('No active wallet')
+    }
+
+    if (!session.connectionMode) {
+      throw new Error('No active connection')
+    }
+
+    // Get the provider from the active wallet based on connection mode
+    let provider
+    if (session.connectionMode === 'injected') {
+      provider = this.usingIntegratedBrowser
+        ? session.activeWallet.integratedBrowserInjectedProvider
+        : session.activeWallet.extensionInjectedProvider
+    } else if (session.connectionMode === 'walletConnect') {
+      provider = session.activeWallet.walletConnectProvider
+    }
+
+    if (!provider) {
+      throw new Error('No provider available for the active wallet')
+    }
+
+    return await this.signatureService.signMessage(message, provider)
+  }
+
+  /**
+   * Send a transaction with the connected wallet
+   * @param request The transaction request parameters
+   * @returns A promise that resolves to the transaction result
+   */
+  async sendTransaction(
+    request: TransactionRequest
+  ): Promise<TransactionResult> {
+    const session = this.sessionManager.getSession()
+
+    if (!session.activeWallet) {
+      throw new Error('No active wallet')
+    }
+
+    if (!session.connectionMode) {
+      throw new Error('No active connection')
+    }
+
+    // Get the provider from the active wallet based on connection mode
+    let provider
+    if (session.connectionMode === 'injected') {
+      provider = this.usingIntegratedBrowser
+        ? session.activeWallet.integratedBrowserInjectedProvider
+        : session.activeWallet.extensionInjectedProvider
+    } else if (session.connectionMode === 'walletConnect') {
+      provider = session.activeWallet.walletConnectProvider
+    }
+
+    if (!provider) {
+      throw new Error('No provider available for the active wallet')
+    }
+
+    return await this.transactionService.sendTransaction(request, provider)
+  }
+
+  /**
+   * Check if a connection mode is available for a specific wallet
+   * @param connectionMode The connection mode to check
+   * @param walletId The wallet ID to check availability for
+   * @returns True if the connection mode is available, false otherwise
+   */
+  isConnectionModeAvailable(
+    connectionMode: ConnectionMode,
+    walletId: string
+  ): boolean {
+    // Find the wallet
+    const wallet = this.wallets.find(w => w.id === walletId)
+    if (!wallet) {
+      return false
+    }
+
+    if (connectionMode === 'walletConnect') {
+      // WalletConnect is available if the connector exists and wallet has WalletConnect provider
+      return (
+        this.connectors.has('walletConnect') &&
+        wallet.walletConnectProvider !== undefined
+      )
+    }
+
+    if (connectionMode === 'injected') {
+      // Check the appropriate provider based on browser type
+      const provider = this.usingIntegratedBrowser
+        ? wallet.integratedBrowserInjectedProvider
+        : wallet.extensionInjectedProvider
+
+      if (!provider) {
+        return false
+      }
+
+      // Check if at least one namespace is installed
+      const hasInstalledNamespace = provider.namespaceMetaData
+        ? Object.values(provider.namespaceMetaData).some(
+            namespace => namespace?.installed === true
+          )
+        : false
+
+      // Injected is available if provider exists and wallet is installed
+      return hasInstalledNamespace
+    }
+
+    return false
+  }
+}

package/src/utils/network-rpc-utils.ts

@@ -0,0 +1,27 @@
+import type { Network, NetworkId, NetworkRpcMap } from '@meshconnect/uwc-types'
+
+/**
+ * Extract RPC URLs from networks array and create a mapping
+ */
+export function createNetworkRpcMap(networks: Network[]): NetworkRpcMap {
+  const rpcMap: NetworkRpcMap = {}
+
+  for (const network of networks) {
+    if (network.rpcUrls?.default?.http?.[0]) {
+      // Use the first HTTP RPC URL as the default
+      rpcMap[network.id] = network.rpcUrls.default.http[0]
+    }
+  }
+
+  return rpcMap
+}
+
+/**
+ * Get RPC URL for a specific network from the map
+ */
+export function getRpcUrlForNetwork(
+  rpcMap: NetworkRpcMap,
+  networkId: NetworkId
+): string | undefined {
+  return rpcMap[networkId]
+}