@meshconnect/uwc-core 0.10.1 → 1.0.0

package/src/services/connection-service.ts

@@ -12,6 +12,11 @@ import type {
 } from '@meshconnect/uwc-types'
 import type { SessionManager } from '../managers/session-manager'
 import type { EventManager } from '../managers/event-manager'
+import { raceAbort } from '../utils/abort'
+
+export interface ServiceOptions {
+  signal?: AbortSignal
+}
 
 export class ConnectionService {
   private activeConnector: Connector | null = null
@@ -28,8 +33,11 @@ export class ConnectionService {
   async connect(
     connectionMode: ConnectionMode,
     walletId: string,
-    networkId?: NetworkId
+    networkId?: NetworkId,
+    options?: ServiceOptions
   ): Promise<void> {
+    options?.signal?.throwIfAborted()
+
     // Find the wallet
     const wallet = this.findWallet(walletId)
 
@@ -42,24 +50,44 @@ export class ConnectionService {
     // Get the appropriate connector
     const connector = this.getConnector(connectionMode)
 
+    // Emit AFTER validation so a thrown lookup/validation error doesn't leave
+    // listeners seeing a "connecting" state for an attempt that never started.
+    this.eventManager.emit('connecting', { connectionMode, walletId })
+
     // Store the active connector BEFORE starting connection
     // This allows getConnectionURI to work while connection is in progress
     this.activeConnector = connector
 
     let result
     try {
+      // Race the connector call against the AbortSignal so a mid-flight abort
+      // (e.g. user cancels the WalletConnect QR while the prompt is open)
+      // rejects the caller's await promptly. The underlying wallet prompt
+      // itself can't be cancelled, but the dapp UI is no longer blocked on it.
       if (connectionMode === 'injected') {
-        result = await connector.connect(
-          network,
-          provider as
-            | ExtensionInjectedProvider
-            | IntegratedBrowserInjectedProvider
+        result = await raceAbort(
+          connector.connect(
+            network,
+            provider as
+              | ExtensionInjectedProvider
+              | IntegratedBrowserInjectedProvider
+          ),
+          options?.signal
         )
       } else if (
         connectionMode === 'tonConnect' ||
         connectionMode === 'walletConnect'
       ) {
-        result = await this.connectWithURIPoll(connector, network, provider)
+        result = await raceAbort(
+          this.connectWithURIPoll(
+            connector,
+            network,
+            provider,
+            connectionMode,
+            options?.signal
+          ),
+          options?.signal
+        )
       } else {
         throw new Error(`Unsupported connection mode: ${connectionMode}`)
       }
@@ -68,6 +96,10 @@ export class ConnectionService {
       throw error
     }
 
+    // Belt-and-suspenders: if the signal fired between raceAbort resolving
+    // and this point, still bail before mutating session.
+    options?.signal?.throwIfAborted()
+
     // Filter available addresses to only include those for configured networks
     const filteredAvailableAddresses = result.availableAddresses.filter(addr =>
       this.networks.some(n => n.id === addr.networkId)
@@ -84,22 +116,29 @@ export class ConnectionService {
       ),
       availableAddresses: filteredAvailableAddresses
     })
+
+    const session = this.sessionManager.getSession()
+    this.eventManager.emit('connected', { session })
+    this.eventManager.emit('sessionChanged', { session })
   }
 
   private async connectWithURIPoll(
     connector: Connector,
     network: Network,
-    provider: SupportedProvider
+    provider: SupportedProvider,
+    connectionMode: ConnectionMode,
+    signal?: AbortSignal
   ): Promise<ConnectorResult> {
     const connectPromise = connector.connect(network, provider)
 
     let pollingStopped = false
+    let emittedUri: string | undefined
 
     const pollForURI = setInterval(() => {
       const uri = this.getConnectionURI()
-      if (uri) {
-        stopPolling()
-        this.eventManager.notify()
+      if (uri && uri !== emittedUri) {
+        emittedUri = uri
+        this.eventManager.emit('connectionUri', { uri, connectionMode })
       }
     }, 100)
 
@@ -119,8 +158,16 @@ export class ConnectionService {
       pollingStopped = true
       clearInterval(pollForURI)
       clearTimeout(watchdogTimeoutId)
+      signal?.removeEventListener('abort', stopPolling)
     }
 
+    // raceAbort unblocks the caller on abort, but the underlying connectPromise
+    // can stay pending (the wallet popup isn't cancellable). Without this the
+    // interval lives until the watchdog and — once a later connect re-sets
+    // activeConnector — emits the new session's URI tagged with this session's
+    // connectionMode.
+    signal?.addEventListener('abort', stopPolling, { once: true })
+
     try {
       return await connectPromise
     } finally {
@@ -234,7 +281,8 @@ export class ConnectionService {
     return network
   }
 
-  async disconnect(): Promise<void> {
+  async disconnect(options?: ServiceOptions): Promise<void> {
+    options?.signal?.throwIfAborted()
     try {
       if (
         this.activeConnector &&
@@ -245,6 +293,9 @@ export class ConnectionService {
     } finally {
       this.activeConnector = null
       this.sessionManager.clearSession()
+      const session = this.sessionManager.getSession()
+      this.eventManager.emit('disconnected', undefined)
+      this.eventManager.emit('sessionChanged', { session })
     }
   }
 

package/src/services/network-switch-service.ts

@@ -11,6 +11,7 @@ import type {
 } from '@meshconnect/uwc-types'
 import type { SessionManager } from '../managers/session-manager'
 import type { EventManager } from '../managers/event-manager'
+import type { ServiceOptions } from './connection-service'
 
 export class NetworkSwitchService {
   private isLoading = false
@@ -31,7 +32,12 @@ export class NetworkSwitchService {
     }
   }
 
-  async switchNetwork(networkId: NetworkId): Promise<void> {
+  async switchNetwork(
+    networkId: NetworkId,
+    options?: ServiceOptions
+  ): Promise<void> {
+    options?.signal?.throwIfAborted()
+
     // Check if there's an active connection
     const session = this.sessionManager.getSession()
     if (!session) {
@@ -104,7 +110,10 @@ export class NetworkSwitchService {
       // Set loading states
       this.isLoading = true
       this.isWaitingForUserApproval = requiresApproval
-      this.eventManager.notify()
+      this.eventManager.emit('networkSwitching', {
+        isLoading: true,
+        isWaitingForUserApproval: requiresApproval
+      })
 
       // Perform the network switch and get the new address
       // Pass the appropriate provider based on connection mode
@@ -129,6 +138,8 @@ export class NetworkSwitchService {
         result = await activeConnector.switchNetwork(network)
       }
 
+      options?.signal?.throwIfAborted()
+
       // Filter available addresses to only include those for configured networks
       const filteredAvailableAddresses = result.availableAddresses
         ? result.availableAddresses.filter(addr =>
@@ -144,11 +155,19 @@ export class NetworkSwitchService {
           availableAddresses: filteredAvailableAddresses
         })
       })
+
+      this.eventManager.emit('networkSwitched', { network })
+      this.eventManager.emit('sessionChanged', {
+        session: this.sessionManager.getSession()
+      })
     } finally {
       // Clear loading states
       this.isLoading = false
       this.isWaitingForUserApproval = false
-      this.eventManager.notify()
+      this.eventManager.emit('networkSwitching', {
+        isLoading: false,
+        isWaitingForUserApproval: false
+      })
     }
   }
 

package/src/services/signature-service.ts

@@ -9,6 +9,7 @@ import type {
   EIP712TypedData
 } from '@meshconnect/uwc-types'
 import type { SessionManager } from '../managers/session-manager'
+import type { ServiceOptions } from './connection-service'
 
 /**
  * Service for handling signature operations across different connector types
@@ -23,12 +24,15 @@ export class SignatureService {
    * Sign a message with the currently connected wallet
    * @param message The message to sign
    * @param provider The wallet provider to use for signing (required for injected connector)
+   * @param options Optional cancellation signal
    * @returns A promise that resolves to the signature
    */
   async signMessage(
     message: string,
-    provider?: SupportedProvider
+    provider?: SupportedProvider,
+    options?: ServiceOptions
   ): Promise<SignatureType> {
+    options?.signal?.throwIfAborted()
     const session = this.sessionManager.getSession()
 
     if (!session.connectionMode) {
@@ -53,30 +57,34 @@ export class SignatureService {
     }
 
     // Call the connector's signMessage method with the appropriate provider
+    let signature: SignatureType
     if (session.connectionMode === 'injected') {
       if (!provider) {
         throw new Error('Provider is required for injected connector')
       }
-      return await connector.signMessage(
+      signature = await connector.signMessage(
         message,
         provider as
           | ExtensionInjectedProvider
           | IntegratedBrowserInjectedProvider
       )
     } else if (session.connectionMode === 'tonConnect') {
-      return await connector.signMessage(message)
+      signature = await connector.signMessage(message)
     } else if (session.connectionMode === 'walletConnect') {
       if (!provider) {
         throw new Error('Provider is required for WalletConnect connector')
       }
-      return await connector.signMessage(
+      signature = await connector.signMessage(
         message,
         provider as WalletConnectProvider
       )
     } else {
       // For other connectors that might not need the provider
-      return await connector.signMessage(message)
+      signature = await connector.signMessage(message)
     }
+
+    options?.signal?.throwIfAborted()
+    return signature
   }
 
   /**

package/src/services/transaction-service.ts

@@ -9,6 +9,7 @@ import type {
   TransactionResult
 } from '@meshconnect/uwc-types'
 import type { SessionManager } from '../managers/session-manager'
+import type { ServiceOptions } from './connection-service'
 
 /**
  * Service for handling transaction operations across different connector types
@@ -23,12 +24,15 @@ export class TransactionService {
    * Send a transaction with the currently connected wallet
    * @param request The transaction request parameters
    * @param provider The wallet provider to use for sending (required for injected connector)
+   * @param options Optional cancellation signal
    * @returns A promise that resolves to the transaction result
    */
   async sendTransaction(
     request: TransactionRequest,
-    provider?: SupportedProvider
+    provider?: SupportedProvider,
+    options?: ServiceOptions
   ): Promise<TransactionResult> {
+    options?.signal?.throwIfAborted()
     const session = this.sessionManager.getSession()
 
     if (!session.connectionMode) {
@@ -53,29 +57,33 @@ export class TransactionService {
     }
 
     // Call the connector's sendTransaction method with the appropriate provider
+    let result: TransactionResult
     if (session.connectionMode === 'injected') {
       if (!provider) {
         throw new Error('Provider is required for injected connector')
       }
-      return await connector.sendTransaction(
+      result = await connector.sendTransaction(
         request,
         provider as
           | ExtensionInjectedProvider
           | IntegratedBrowserInjectedProvider
       )
     } else if (session.connectionMode === 'tonConnect') {
-      return await connector.sendTransaction(request)
+      result = await connector.sendTransaction(request)
     } else if (session.connectionMode === 'walletConnect') {
       if (!provider) {
         throw new Error('Provider is required for WalletConnect connector')
       }
-      return await connector.sendTransaction(
+      result = await connector.sendTransaction(
         request,
         provider as WalletConnectProvider
       )
     } else {
       // For other connectors that might not need the provider
-      return await connector.sendTransaction(request)
+      result = await connector.sendTransaction(request)
     }
+
+    options?.signal?.throwIfAborted()
+    return result
   }
 }

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

@@ -6,6 +6,7 @@ import type {
 } from '@meshconnect/uwc-types'
 import type { SessionManager } from '../managers/session-manager'
 import type { EventManager } from '../managers/event-manager'
+import type { ServiceOptions } from './connection-service'
 
 export class WalletCapabilitiesService {
   constructor(
@@ -17,8 +18,11 @@ export class WalletCapabilitiesService {
 
   async getWalletCapabilities(
     address: string,
-    activeNetwork?: Network
+    activeNetwork?: Network,
+    options?: ServiceOptions
   ): Promise<void> {
+    options?.signal?.throwIfAborted()
+
     let activeWalletCapabilities: Record<string, EVMCapabilities> = {}
     let activeNetworkWalletCapabilities: EVMCapabilities = {}
 
@@ -49,6 +53,8 @@ export class WalletCapabilitiesService {
         capabilities = {}
       }
 
+      options?.signal?.throwIfAborted()
+
       // keep only supported networks
       activeWalletCapabilities = Object.fromEntries(
         Object.entries(capabilities).filter(([networkId, _]) =>
@@ -71,7 +77,13 @@ export class WalletCapabilitiesService {
           activeNetworkWalletCapabilities: null
         })
       }
-      this.eventManager.notify()
+
+      this.eventManager.emit('capabilitiesUpdated', {
+        capabilities: activeWalletCapabilities
+      })
+      this.eventManager.emit('sessionChanged', {
+        session: this.sessionManager.getSession()
+      })
     }
   }
 }

package/src/universal-wallet-connector.test.ts

@@ -39,7 +39,11 @@ const mockSessionManager = {
 
 const mockEventManager = {
   subscribe: vi.fn().mockReturnValue(() => {}),
-  notify: vi.fn()
+  notify: vi.fn(),
+  emit: vi.fn(),
+  on: vi.fn().mockReturnValue(() => {}),
+  off: vi.fn(),
+  once: vi.fn().mockReturnValue(() => {})
 }
 
 const mockConnectionService = {
@@ -139,8 +143,7 @@ describe('UniversalWalletConnector', () => {
   let mockWalletConnectConfig: WalletConnectConfig
 
   beforeEach(() => {
-    ;(UniversalWalletConnector as any).instanceCount = 0
-    ;(UniversalWalletConnector as any).hasWarnedAboutMultipleInstances = false
+    UniversalWalletConnector.resetInstance()
 
     mockNetworks = [
       {
@@ -424,6 +427,87 @@ describe('UniversalWalletConnector', () => {
       expect(typeof connector.sendTransaction).toBe('function')
       expect(typeof connector.isConnectionModeAvailable).toBe('function')
       expect(typeof connector.getActiveWalletCapabilities).toBe('function')
+      expect(typeof connector.on).toBe('function')
+      expect(typeof connector.once).toBe('function')
+      expect(typeof connector.off).toBe('function')
+    })
+  })
+
+  describe('getInstance singleton factory', () => {
+    it('creates an instance on first call and reuses it afterwards', () => {
+      const a = UniversalWalletConnector.getInstance({
+        networks: mockNetworks,
+        wallets: mockWallets
+      })
+      const b = UniversalWalletConnector.getInstance({
+        networks: mockNetworks,
+        wallets: mockWallets
+      })
+      expect(a).toBe(b)
+    })
+
+    it('throws when called before any instance exists and no config is given', () => {
+      expect(() => UniversalWalletConnector.getInstance()).toThrow(
+        /getInstance.*before an instance existed/
+      )
+    })
+
+    it('resetInstance() clears the shared reference', () => {
+      const first = UniversalWalletConnector.getInstance({
+        networks: mockNetworks,
+        wallets: mockWallets
+      })
+      UniversalWalletConnector.resetInstance()
+      const second = UniversalWalletConnector.getInstance({
+        networks: mockNetworks,
+        wallets: mockWallets
+      })
+      expect(second).not.toBe(first)
+    })
+
+    it('adopts a `new`-constructed instance as the singleton', () => {
+      const created = new UniversalWalletConnector(mockNetworks, mockWallets)
+      expect(UniversalWalletConnector.getInstance()).toBe(created)
+    })
+  })
+
+  describe('config-object constructor', () => {
+    it('accepts the { networks, wallets, ... } form', () => {
+      const connector = new UniversalWalletConnector({
+        networks: mockNetworks,
+        wallets: mockWallets,
+        walletConnectConfig: mockWalletConnectConfig
+      })
+      expect(connector).toBeInstanceOf(UniversalWalletConnector)
+    })
+  })
+
+  describe('AbortSignal support', () => {
+    it('connect rejects immediately when signal is already aborted', async () => {
+      const connector = new UniversalWalletConnector(mockNetworks, mockWallets)
+      const controller = new AbortController()
+      controller.abort()
+
+      // ConnectionService.connect is mocked to return undefined by default,
+      // so the abort check is what surfaces the error.
+      mockConnectionService.connect = vi.fn().mockImplementation(
+        async (
+          _m: unknown,
+          _w: unknown,
+          _n: unknown,
+          options?: {
+            signal?: AbortSignal
+          }
+        ) => {
+          options?.signal?.throwIfAborted()
+        }
+      )
+
+      await expect(
+        connector.connect('injected', 'metamask', undefined, {
+          signal: controller.signal
+        })
+      ).rejects.toThrow()
     })
   })
 
@@ -460,6 +544,115 @@ describe('UniversalWalletConnector', () => {
       // Should complete without throwing
       expect(connector.isReady()).toBe(true)
     })
+
+    it('marks a Tron wallet installed when detected.uuid matches WalletMetadata.id (TronConnector path)', async () => {
+      // Mesh-owned TronConnector returns { uuid: TronWalletId } (e.g. "tronlink").
+      // The merge must match this directly against WalletMetadata.id, not just
+      // against the legacy `tron-${injectedId}` form. Regression guard for the
+      // post-rebase break in `applyDetectedWallet`.
+      const tronWallet: WalletMetadata = {
+        id: 'tronlink',
+        name: 'TronLink',
+        metadata: {},
+        extensionInjectedProvider: {
+          supportedNetworkIds: ['tron:728126428'] as const,
+          namespaceMetaData: {
+            tron: {
+              injectedId: 'tronWeb',
+              installed: false
+            }
+          },
+          requiresUserApprovalOnNamespaceSwitch: false
+        }
+      }
+
+      mockInjectedConnector.getAvailableWallets.mockImplementation(
+        async (namespace: string) =>
+          namespace === 'tron' ? [{ uuid: 'tronlink', name: 'TronLink' }] : []
+      )
+
+      new UniversalWalletConnector(mockNetworks, [tronWallet])
+      await new Promise(resolve => setTimeout(resolve, 0))
+
+      const tronMeta = tronWallet.extensionInjectedProvider!.namespaceMetaData
+        .tron as { installed?: boolean; detectedWallet?: { uuid: string } }
+      expect(tronMeta.installed).toBe(true)
+      expect(tronMeta.detectedWallet?.uuid).toBe('tronlink')
+    })
+
+    it('matches a catalog wallet (backend GUID id) via the canonical detected.injectedId (#174 path)', async () => {
+      // Mesh-owned TronConnector now reports the canonical `injectedId`
+      // directly on DetectedTronWalletInfo. Catalog-driven consumers (Link
+      // v1/v2) use a backend GUID as `WalletMetadata.id` — neither the id nor
+      // the legacy `tron-${injectedId}` uuid match. The canonical injectedId
+      // join key is the only thing that works for them.
+      const tronWallet: WalletMetadata = {
+        id: '7b3c2a6e-4f5a-4d6b-8e9f-1a2b3c4d5e6f',
+        name: 'TronLink',
+        metadata: {},
+        extensionInjectedProvider: {
+          supportedNetworkIds: ['tron:728126428'] as const,
+          namespaceMetaData: {
+            tron: {
+              injectedId: 'tronLink',
+              installed: false
+            }
+          },
+          requiresUserApprovalOnNamespaceSwitch: false
+        }
+      }
+
+      mockInjectedConnector.getAvailableWallets.mockImplementation(
+        async (namespace: string) =>
+          namespace === 'tron'
+            ? [{ uuid: 'tronlink', name: 'TronLink', injectedId: 'tronLink' }]
+            : []
+      )
+
+      new UniversalWalletConnector(mockNetworks, [tronWallet])
+      await new Promise(resolve => setTimeout(resolve, 0))
+
+      const tronMeta = tronWallet.extensionInjectedProvider!.namespaceMetaData
+        .tron as { installed?: boolean; detectedWallet?: { uuid: string } }
+      expect(tronMeta.installed).toBe(true)
+      expect(tronMeta.detectedWallet?.uuid).toBe('tronlink')
+    })
+
+    it('still matches the legacy `tron-${injectedId}` uuid form (window-global discovery)', async () => {
+      // Belt-and-suspenders: when the legacy bridge/window-global path
+      // produces `tron-tronlink`, the same code path must still match via
+      // the injectedId-derived key — both schemes coexist in production.
+      const tronWallet: WalletMetadata = {
+        id: 'tronlink-legacy',
+        name: 'TronLink',
+        metadata: {},
+        extensionInjectedProvider: {
+          supportedNetworkIds: ['tron:728126428'] as const,
+          namespaceMetaData: {
+            tron: {
+              injectedId: 'tronLink',
+              installed: false
+            }
+          },
+          requiresUserApprovalOnNamespaceSwitch: false
+        }
+      }
+
+      mockInjectedConnector.getAvailableWallets.mockImplementation(
+        async (namespace: string) =>
+          namespace === 'tron'
+            ? [{ uuid: 'tron-tronlink', name: 'TronLink' }]
+            : []
+      )
+
+      new UniversalWalletConnector(mockNetworks, [tronWallet])
+      await new Promise(resolve => setTimeout(resolve, 0))
+
+      const tronMeta = tronWallet.extensionInjectedProvider!.namespaceMetaData
+        .tron as { installed?: boolean; detectedWallet?: { uuid: string } }
+      expect(tronMeta.installed).toBe(true)
+      expect(tronMeta.detectedWallet?.uuid).toBe('tron-tronlink')
+    })
   })
 
   describe('signSolanaTransaction', () => {