@meshconnect/uwc-core 0.7.5-snapshot.c90b3e8 → 0.7.6

package/src/universal-wallet-connector.ts

@@ -16,10 +16,8 @@ import type {
   TransactionResult,
   NetworkRpcMap,
   EVMCapabilities,
-  SignatureType,
-  WalletError
+  SignatureType
 } from '@meshconnect/uwc-types'
-import { WalletConnectorError } from '@meshconnect/uwc-types'
 import { InjectedConnector } from '@meshconnect/uwc-injected-connector'
 import { WalletConnectConnector } from '@meshconnect/uwc-wallet-connect-connector'
 import { TonConnectConnector } from '@meshconnect/uwc-ton-connector'
@@ -31,28 +29,8 @@ import { SignatureService } from './services/signature-service'
 import { TransactionService } from './services/transaction-service'
 import { WalletCapabilitiesService } from './services/wallet-capabilities-service'
 import { createNetworkRpcMap } from './utils/network-rpc-utils'
-import type { UWCEventName, UWCEventListener, UWCOperation } from './events'
-
-/**
- * Configuration object form of the UniversalWalletConnector constructor.
- * Prefer this over the positional constructor in new code.
- */
-export interface UWCConfig {
-  networks: Network[]
-  wallets?: WalletMetadata[]
-  usingIntegratedBrowser?: boolean
-  walletConnectConfig?: WalletConnectConfig
-  tonConnectConfig?: TonConnectConfig
-}
-
-/** Common options for user-initiated async operations. */
-export interface OperationOptions {
-  /** Abort the operation if the signal fires. State mutations are skipped after abort. */
-  signal?: AbortSignal
-}
 
 export class UniversalWalletConnector {
-  private static instance: UniversalWalletConnector | null = null
   private static instanceCount = 0
   private static hasWarnedAboutMultipleInstances = false
 
@@ -70,78 +48,17 @@ export class UniversalWalletConnector {
   private detectionComplete = false
   private networkRpcMap: NetworkRpcMap
 
-  /**
-   * Recommended entry point: returns the shared instance, creating it on the
-   * first call. Subsequent calls ignore the `config` argument — use
-   * `resetInstance()` first if you need to reinitialise (e.g. in tests).
-   */
-  static getInstance(config?: UWCConfig): UniversalWalletConnector {
-    if (UniversalWalletConnector.instance) {
-      return UniversalWalletConnector.instance
-    }
-    if (!config) {
-      throw new Error(
-        'UniversalWalletConnector.getInstance() was called before an instance existed. Pass a config on the first call.'
-      )
-    }
-    return new UniversalWalletConnector(config)
-  }
-
-  /** Clear the shared instance reference. Primarily for tests and full-logout flows. */
-  static resetInstance(): void {
-    UniversalWalletConnector.instance = null
-    UniversalWalletConnector.instanceCount = 0
-    UniversalWalletConnector.hasWarnedAboutMultipleInstances = false
-  }
-
-  constructor(config: UWCConfig)
   constructor(
     networks: Network[],
-    wallets?: WalletMetadata[],
-    usingIntegratedBrowser?: boolean,
-    walletConnectConfig?: WalletConnectConfig,
-    tonConnectConfig?: TonConnectConfig
-  )
-  constructor(
-    networksOrConfig: Network[] | UWCConfig,
     wallets: WalletMetadata[] = [],
     usingIntegratedBrowser = false,
     walletConnectConfig?: WalletConnectConfig,
     tonConnectConfig?: TonConnectConfig
   ) {
-    if (!networksOrConfig) {
-      throw new Error(
-        'Universal Wallet Connector must be initialized with at least one network'
-      )
-    }
-
-    let config: UWCConfig
-    if (Array.isArray(networksOrConfig)) {
-      config = {
-        networks: networksOrConfig,
-        wallets,
-        usingIntegratedBrowser
-      }
-      if (walletConnectConfig) {
-        config.walletConnectConfig = walletConnectConfig
-      }
-      if (tonConnectConfig) {
-        config.tonConnectConfig = tonConnectConfig
-      }
-    } else {
-      config = networksOrConfig
-    }
-
-    const {
-      networks,
-      wallets: configuredWallets = [],
-      usingIntegratedBrowser: configuredUsingIntegratedBrowser = false,
-      walletConnectConfig: configuredWalletConnectConfig,
-      tonConnectConfig: configuredTonConnectConfig
-    } = config
-
-    // Track instance creation and warn on duplicates
+    // Track instance creation
     UniversalWalletConnector.instanceCount++
+
+    // Warn about multiple instances
     if (
       UniversalWalletConnector.instanceCount > 1 &&
       !UniversalWalletConnector.hasWarnedAboutMultipleInstances
@@ -151,7 +68,7 @@ export class UniversalWalletConnector {
         `⚠️ 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. ' +
-          'Use UniversalWalletConnector.getInstance(config) instead of `new` to guarantee a single instance. ' +
+          '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
@@ -162,14 +79,14 @@ export class UniversalWalletConnector {
         'Universal Wallet Connector must be initialized with at least one network'
       )
     }
-    if (!configuredWallets) {
+    if (!wallets) {
       throw new Error(
         'Universal Wallet Connector must be initialized with at least one wallet'
       )
     }
 
-    this.wallets = configuredWallets
-    this.usingIntegratedBrowser = configuredUsingIntegratedBrowser
+    this.wallets = wallets
+    this.usingIntegratedBrowser = usingIntegratedBrowser
 
     // Create RPC map from networks
     this.networkRpcMap = createNetworkRpcMap(networks)
@@ -179,25 +96,22 @@ export class UniversalWalletConnector {
     this.injectedConnector = new InjectedConnector(
       this.networkRpcMap,
       this.wallets,
-      configuredTonConnectConfig
+      tonConnectConfig
     )
     this.connectors.set('injected', this.injectedConnector)
 
-    if (configuredTonConnectConfig) {
+    if (tonConnectConfig) {
       this.connectors.set(
         'tonConnect',
-        new TonConnectConnector(configuredTonConnectConfig)
+        new TonConnectConnector(tonConnectConfig)
       )
     }
 
     // Only add WalletConnect connector if config is provided
-    if (configuredWalletConnectConfig) {
+    if (walletConnectConfig) {
       this.connectors.set(
         'walletConnect',
-        new WalletConnectConnector(
-          configuredWalletConnectConfig,
-          this.networkRpcMap
-        )
+        new WalletConnectConnector(walletConnectConfig, this.networkRpcMap)
       )
     }
 
@@ -208,14 +122,14 @@ export class UniversalWalletConnector {
       this.wallets,
       this.sessionManager,
       this.connectors,
-      configuredUsingIntegratedBrowser,
+      usingIntegratedBrowser,
       this.eventManager
     )
     this.networkSwitchService = new NetworkSwitchService(
       networks,
       this.sessionManager,
       this.connectors,
-      configuredUsingIntegratedBrowser,
+      usingIntegratedBrowser,
       this.eventManager
     )
     this.signatureService = new SignatureService(
@@ -233,12 +147,6 @@ export class UniversalWalletConnector {
       this.eventManager
     )
 
-    // Register as the shared instance so getInstance() works
-    // (only set if no instance exists, to avoid overwriting an earlier one)
-    if (!UniversalWalletConnector.instance) {
-      UniversalWalletConnector.instance = this
-    }
-
     // Initialize detected wallets after services are created
     this.initializeDetectedWallets()
   }
@@ -263,35 +171,151 @@ export class UniversalWalletConnector {
         }
       })
 
-      // Run every namespace × connector detection concurrently.
-      // The namespace loop used to be sequential and `await`-ed each call,
-      // which meant a 100ms EIP-6963 native timeout + any bridge polling
-      // added up. With Promise.all the total time is the slowest single
-      // call, not the sum.
-      const detectionTasks: Promise<void>[] = []
+      // Check available wallets for each namespace across all connectors
       for (const namespace of namespaces) {
         for (const [, connector] of this.connectors) {
-          if (typeof connector.getAvailableWallets !== 'function') continue
-          detectionTasks.push(
-            Promise.resolve()
-              .then(() =>
-                connector.getAvailableWallets!(
-                  namespace as Namespace,
-                  this.wallets
-                )
+          // Check if connector supports getAvailableWallets
+          if (typeof connector.getAvailableWallets === 'function') {
+            try {
+              const detectedWallets = await connector.getAvailableWallets(
+                namespace as Namespace,
+                this.wallets
               )
-              .then(detected => {
-                for (const d of detected) {
-                  this.applyDetectedWallet(namespace as Namespace, d)
+
+              // 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 if (namespace === 'tron') {
+                  // For Tron, match by injectedId path prefix
+                  const tronDetected = detected as DetectedTronWalletInfo
+                  wallet = this.wallets.find(w => {
+                    const provider = this.usingIntegratedBrowser
+                      ? w.integratedBrowserInjectedProvider
+                      : w.extensionInjectedProvider
+                    const injectedId =
+                      provider?.namespaceMetaData?.tron?.injectedId
+                    return (
+                      injectedId &&
+                      tronDetected.uuid ===
+                        `tron-${injectedId}`.toLowerCase().replace(/\./g, '-')
+                    )
+                  })
+                } else if (namespace === 'tvm') {
+                  // For TON, match by jsBridgeKey
+                  const tonDetected = detected as DetectedTonWalletInfo
+                  wallet = this.wallets.find(w => {
+                    const provider = this.usingIntegratedBrowser
+                      ? w.integratedBrowserInjectedProvider
+                      : w.extensionInjectedProvider
+                    return (
+                      provider?.namespaceMetaData?.tvm?.jsBridgeKey ===
+                      tonDetected.jsBridgeKey
+                    )
+                  })
+                } 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
+                      }
+                    } else if (namespace === 'tron') {
+                      const tronMetadata = nsMetadata as {
+                        installed?: boolean
+                        detectedWallet?: DetectedTronWalletInfo
+                      }
+                      tronMetadata.installed = true
+                      const tronDetected = detected as DetectedTronWalletInfo
+                      tronMetadata.detectedWallet = {
+                        uuid: tronDetected.uuid,
+                        name: tronDetected.name
+                      }
+                    } else if (namespace === 'tvm') {
+                      const tonMetadata = nsMetadata as {
+                        installed?: boolean
+                        detectedWallet?: DetectedTonWalletInfo
+                      }
+                      tonMetadata.installed = true
+                      const tonDetected = detected as DetectedTonWalletInfo
+                      tonMetadata.detectedWallet = {
+                        uuid: tonDetected.uuid,
+                        name: tonDetected.name,
+                        icon: tonDetected.icon,
+                        jsBridgeKey: tonDetected.jsBridgeKey
+                      }
+                    }
+                  }
                 }
               })
-              .catch(() => {
-                // Silently handle errors for individual connector/namespace combinations
-              })
-          )
+            } catch {
+              // Silently handle errors for individual connector/namespace combinations
+            }
+          }
         }
       }
-      await Promise.all(detectionTasks)
 
       // Notify the connection service to update its internal wallets reference
       this.connectionService.updateWallets(this.wallets)
@@ -299,131 +323,12 @@ export class UniversalWalletConnector {
       // Mark detection as complete
       this.detectionComplete = true
 
-      this.eventManager.emit('walletsDetected', { wallets: this.wallets })
-      this.eventManager.emit('ready', undefined)
-    } catch (error) {
+      // Notify listeners about the update
+      this.eventManager.notify()
+    } catch {
+      // Silently handle error during initialization
       this.detectionComplete = true
-      this.emitError(error, 'initialize')
-      this.eventManager.emit('ready', undefined)
-    }
-  }
-
-  /**
-   * Merge a single detected wallet (from one namespace × connector run) into
-   * the configured wallet metadata. Factored out so detection tasks can run
-   * in parallel without racing on the merge logic.
-   */
-  private applyDetectedWallet(
-    namespace: Namespace,
-    detected: {
-      uuid: string
-      name: string
-      icon?: string
-      rdns?: string
-      features?: string[]
-      jsBridgeKey?: string
-    }
-  ): void {
-    let wallet: WalletMetadata | undefined
-
-    const pickProvider = (w: WalletMetadata) =>
-      this.usingIntegratedBrowser
-        ? w.integratedBrowserInjectedProvider
-        : w.extensionInjectedProvider
-
-    if (namespace === 'eip155') {
-      wallet = this.wallets.find(
-        w =>
-          pickProvider(
-            w
-          )?.namespaceMetaData?.eip155?.eip155Name?.toLowerCase() ===
-          detected.name.toLowerCase()
-      )
-    } else if (namespace === 'solana') {
-      wallet = this.wallets.find(
-        w =>
-          pickProvider(
-            w
-          )?.namespaceMetaData?.solana?.walletStandardName?.toLowerCase() ===
-          detected.name.toLowerCase()
-      )
-    } else if (namespace === 'tron') {
-      const tronDetected = detected as DetectedTronWalletInfo
-      wallet = this.wallets.find(w => {
-        const injectedId = pickProvider(w)?.namespaceMetaData?.tron?.injectedId
-        return (
-          injectedId &&
-          tronDetected.uuid ===
-            `tron-${injectedId}`.toLowerCase().replace(/\./g, '-')
-        )
-      })
-    } else if (namespace === 'tvm') {
-      const tonDetected = detected as DetectedTonWalletInfo
-      wallet = this.wallets.find(
-        w =>
-          pickProvider(w)?.namespaceMetaData?.tvm?.jsBridgeKey ===
-          tonDetected.jsBridgeKey
-      )
-    } else {
-      wallet = this.wallets.find(
-        w => w.name.toLowerCase() === detected.name.toLowerCase()
-      )
-    }
-
-    if (!wallet) return
-
-    const provider = pickProvider(wallet)
-    if (!provider?.namespaceMetaData) return
-
-    const nsMetadata = provider.namespaceMetaData[namespace]
-    if (!nsMetadata) return
-
-    if (namespace === 'eip155') {
-      const m = nsMetadata as {
-        installed?: boolean
-        detectedWallet?: DetectedEIP6963WalletInfo
-      }
-      const d = detected as DetectedEIP6963WalletInfo
-      m.installed = true
-      m.detectedWallet = {
-        uuid: d.uuid,
-        name: d.name,
-        icon: d.icon,
-        rdns: d.rdns
-      }
-    } else if (namespace === 'solana') {
-      const m = nsMetadata as {
-        installed?: boolean
-        detectedWallet?: DetectedSolanaWalletInfo
-      }
-      const d = detected as DetectedSolanaWalletInfo
-      m.installed = true
-      m.detectedWallet = {
-        uuid: d.uuid,
-        name: d.name,
-        features: d.features
-      }
-    } else if (namespace === 'tron') {
-      const m = nsMetadata as {
-        installed?: boolean
-        detectedWallet?: DetectedTronWalletInfo
-      }
-      const d = detected as DetectedTronWalletInfo
-      m.installed = true
-      m.detectedWallet = { uuid: d.uuid, name: d.name }
-    } else if (namespace === 'tvm') {
-      const m = nsMetadata as {
-        installed?: boolean
-        detectedWallet?: DetectedTonWalletInfo
-      }
-      const d = detected as DetectedTonWalletInfo
-      m.installed = true
-      m.detectedWallet = {
-        uuid: d.uuid,
-        name: d.name,
-        icon: d.icon,
-        jsBridgeKey: d.jsBridgeKey
-      }
+      this.eventManager.notify()
     }
   }
 
@@ -435,32 +340,6 @@ export class UniversalWalletConnector {
     return this.detectionComplete
   }
 
-  // ---- Event subscription ----
-
-  /** Subscribe to a typed event. Returns an unsubscribe function. */
-  on<K extends UWCEventName>(
-    event: K,
-    listener: UWCEventListener<K>
-  ): () => void {
-    return this.eventManager.on(event, listener)
-  }
-
-  /** Subscribe once; the listener is removed after the first dispatch. */
-  once<K extends UWCEventName>(
-    event: K,
-    listener: UWCEventListener<K>
-  ): () => void {
-    return this.eventManager.once(event, listener)
-  }
-
-  off<K extends UWCEventName>(event: K, listener: UWCEventListener<K>): void {
-    this.eventManager.off(event, listener)
-  }
-
-  /**
-   * @deprecated Prefer `on(eventName, listener)` for targeted updates.
-   * Subscribes to the catch-all `change` event.
-   */
   subscribe(listener: () => void): () => void {
     return this.eventManager.subscribe(listener)
   }
@@ -482,45 +361,24 @@ export class UniversalWalletConnector {
   async connect(
     connectionMode: ConnectionMode,
     walletId: string,
-    networkId?: NetworkId,
-    options?: OperationOptions
+    networkId?: NetworkId
   ): Promise<void> {
-    try {
-      await this.connectionService.connect(
-        connectionMode,
-        walletId,
-        networkId,
-        options
-      )
-    } catch (error) {
-      this.emitError(error, 'connect')
-      throw error
-    }
+    await this.connectionService.connect(connectionMode, walletId, networkId)
+    this.eventManager.notify()
   }
 
   getConnectionURI(): string | undefined {
     return this.connectionService.getConnectionURI()
   }
 
-  async disconnect(options?: OperationOptions): Promise<void> {
-    try {
-      await this.connectionService.disconnect(options)
-    } catch (error) {
-      this.emitError(error, 'disconnect')
-      throw error
-    }
+  async disconnect(): Promise<void> {
+    await this.connectionService.disconnect()
+    this.eventManager.notify()
   }
 
-  async switchNetwork(
-    networkId: NetworkId,
-    options?: OperationOptions
-  ): Promise<void> {
-    try {
-      await this.networkSwitchService.switchNetwork(networkId, options)
-    } catch (error) {
-      this.emitError(error, 'switchNetwork')
-      throw error
-    }
+  async switchNetwork(networkId: NetworkId): Promise<void> {
+    await this.networkSwitchService.switchNetwork(networkId)
+    this.eventManager.notify()
   }
 
   getNetworkSwitchLoadingState() {
@@ -530,13 +388,9 @@ export class UniversalWalletConnector {
   /**
    * Sign a message with the connected wallet
    * @param message The message to sign
-   * @param options Optional cancellation signal
    * @returns A promise that resolves to the signature
    */
-  async signMessage(
-    message: string,
-    options?: OperationOptions
-  ): Promise<SignatureType> {
+  async signMessage(message: string): Promise<SignatureType> {
     const session = this.sessionManager.getSession()
 
     if (!session.activeWallet) {
@@ -547,43 +401,32 @@ export class UniversalWalletConnector {
       throw new Error('No active connection')
     }
 
-    try {
-      // 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
-      } else if (session.connectionMode === 'tonConnect') {
-        return await this.signatureService.signMessage(
-          message,
-          undefined,
-          options
-        )
-      }
-
-      if (!provider) {
-        throw new Error('No provider available for the active wallet')
-      }
+    // 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
+    } else if (session.connectionMode === 'tonConnect') {
+      return await this.signatureService.signMessage(message)
+    }
 
-      return await this.signatureService.signMessage(message, provider, options)
-    } catch (error) {
-      this.emitError(error, 'signMessage')
-      throw error
+    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
-   * @param options Optional cancellation signal
    * @returns A promise that resolves to the transaction result
    */
   async sendTransaction(
-    request: TransactionRequest,
-    options?: OperationOptions
+    request: TransactionRequest
   ): Promise<TransactionResult> {
     const session = this.sessionManager.getSession()
 
@@ -595,60 +438,39 @@ export class UniversalWalletConnector {
       throw new Error('No active connection')
     }
 
-    try {
-      // 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
-      } else if (session.connectionMode === 'tonConnect') {
-        return await this.transactionService.sendTransaction(
-          request,
-          undefined,
-          options
-        )
-      }
-
-      if (!provider) {
-        throw new Error('No provider available for the active wallet')
-      }
+    // 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
+    } else if (session.connectionMode === 'tonConnect') {
+      return await this.transactionService.sendTransaction(request)
+    }
 
-      return await this.transactionService.sendTransaction(
-        request,
-        provider,
-        options
-      )
-    } catch (error) {
-      this.emitError(error, 'sendTransaction')
-      throw error
+    if (!provider) {
+      throw new Error('No provider available for the active wallet')
     }
+
+    return await this.transactionService.sendTransaction(request, provider)
   }
 
   /**
    * Fetch wallet capabilities for the connected wallet
    * @param address The wallet address to fetch capabilities for
    * @param activeNetwork Optional network to set as the active network for capabilities
-   * @param options Optional cancellation signal
    * @returns A promise that resolves when capabilities are fetched and updated
    */
   async getWalletCapabilities(
     address: string,
-    activeNetwork?: Network,
-    options?: OperationOptions
+    activeNetwork?: Network
   ): Promise<void> {
-    try {
-      return await this.walletCapabilitiesService.getWalletCapabilities(
-        address,
-        activeNetwork,
-        options
-      )
-    } catch (error) {
-      this.emitError(error, 'getWalletCapabilities')
-      throw error
-    }
+    return await this.walletCapabilitiesService.getWalletCapabilities(
+      address,
+      activeNetwork
+    )
   }
 
   /**
@@ -710,17 +532,4 @@ export class UniversalWalletConnector {
     const session = this.sessionManager.getSession()
     return session.activeWalletCapabilities
   }
-
-  // ---- private helpers ----
-
-  private emitError(error: unknown, operation: UWCOperation): void {
-    const walletError: WalletError =
-      error instanceof WalletConnectorError
-        ? { type: error.type, message: error.message }
-        : {
-            type: 'unknown',
-            message: error instanceof Error ? error.message : String(error)
-          }
-    this.eventManager.emit('error', { error: walletError, operation })
-  }
 }