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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshconnect/uwc-core",
-  "version": "0.7.5-snapshot.c90b3e8",
+  "version": "0.7.6",
   "description": "Core functionality for Universal Wallet Connector",
   "type": "module",
   "main": "dist/index.js",
@@ -16,10 +16,10 @@
     "src"
   ],
   "dependencies": {
-    "@meshconnect/uwc-wallet-connect-connector": "0.4.13-snapshot.c90b3e8",
-    "@meshconnect/uwc-injected-connector": "0.10.5-snapshot.c90b3e8",
-    "@meshconnect/uwc-ton-connector": "0.5.3-snapshot.c90b3e8",
-    "@meshconnect/uwc-types": "0.11.1-snapshot.c90b3e8"
+    "@meshconnect/uwc-injected-connector": "0.10.5",
+    "@meshconnect/uwc-ton-connector": "0.5.3",
+    "@meshconnect/uwc-types": "0.11.1",
+    "@meshconnect/uwc-wallet-connect-connector": "0.4.14"
   },
   "devDependencies": {
     "typescript": "^5.9.3"

package/src/index.ts

@@ -1,11 +1,3 @@
-export {
-  UniversalWalletConnector,
-  type UWCConfig,
-  type OperationOptions
-} from './universal-wallet-connector'
-export type {
-  UWCEventMap,
-  UWCEventName,
-  UWCEventListener,
-  UWCOperation
-} from './events'
+export * from './universal-wallet-connector'
+export * from './managers'
+export * from './services'

package/src/managers/event-manager.test.ts

@@ -71,74 +71,4 @@ describe('EventManager', () => {
     eventManager.clearAllListeners()
     expect(eventManager.getListenerCount()).toBe(0)
   })
-
-  describe('typed events', () => {
-    it('dispatches typed event data only to on() listeners of that event', () => {
-      const disconnected: unknown[] = []
-      const networkSwitched: unknown[] = []
-
-      eventManager.on('disconnected', data => disconnected.push(data))
-      eventManager.on('networkSwitched', data => networkSwitched.push(data))
-
-      eventManager.emit('disconnected', undefined)
-
-      expect(disconnected).toHaveLength(1)
-      expect(networkSwitched).toHaveLength(0)
-    })
-
-    it('cascades every typed event to the legacy change channel', () => {
-      let changeCount = 0
-      eventManager.subscribe(() => {
-        changeCount++
-      })
-
-      eventManager.emit('connectionUri', {
-        uri: 'wc://x',
-        connectionMode: 'walletConnect'
-      })
-      eventManager.emit('disconnected', undefined)
-
-      expect(changeCount).toBe(2)
-    })
-
-    it('off() removes a listener from the typed set', () => {
-      const calls: unknown[] = []
-      const listener = (d: unknown) => calls.push(d)
-      eventManager.on('ready', listener)
-      eventManager.off('ready', listener)
-      eventManager.emit('ready', undefined)
-      expect(calls).toHaveLength(0)
-    })
-
-    it('once() removes the listener after a single dispatch', () => {
-      let calls = 0
-      eventManager.once('ready', () => {
-        calls++
-      })
-      eventManager.emit('ready', undefined)
-      eventManager.emit('ready', undefined)
-      expect(calls).toBe(1)
-    })
-
-    it('a throwing listener does not stop other listeners', () => {
-      const calls: string[] = []
-      eventManager.on('ready', () => {
-        throw new Error('boom')
-      })
-      eventManager.on('ready', () => {
-        calls.push('second')
-      })
-      eventManager.emit('ready', undefined)
-      expect(calls).toEqual(['second'])
-    })
-
-    it('emit("change") does not recurse into itself', () => {
-      let count = 0
-      eventManager.on('change', () => {
-        count++
-      })
-      eventManager.emit('change', undefined)
-      expect(count).toBe(1)
-    })
-  })
 })

package/src/managers/event-manager.ts

@@ -1,93 +1,22 @@
-import type { UWCEventMap, UWCEventName, UWCEventListener } from '../events'
+type Listener = () => void
+type Unsubscribe = () => void
 
-type LegacyListener = () => void
-type UntypedListener = (data: unknown) => void
-
-/**
- * Typed event emitter used by UniversalWalletConnector.
- *
- * Each event has its own listener set. Emitting any typed event also
- * dispatches the legacy `change` event, so `subscribe()` callers keep
- * receiving a notification on every state change.
- */
 export class EventManager {
-  private listeners: Map<UWCEventName, Set<UntypedListener>> = new Map()
-
-  /** Subscribe to a typed event. Returns an unsubscribe function. */
-  on<K extends UWCEventName>(
-    event: K,
-    listener: UWCEventListener<K>
-  ): () => void {
-    let set = this.listeners.get(event)
-    if (!set) {
-      set = new Set()
-      this.listeners.set(event, set)
-    }
-    set.add(listener as UntypedListener)
-    return () => this.off(event, listener)
-  }
-
-  /** Subscribe once; the listener is removed after the first dispatch. */
-  once<K extends UWCEventName>(
-    event: K,
-    listener: UWCEventListener<K>
-  ): () => void {
-    const wrapper: UWCEventListener<K> = data => {
-      this.off(event, wrapper)
-      listener(data)
-    }
-    return this.on(event, wrapper)
-  }
-
-  off<K extends UWCEventName>(event: K, listener: UWCEventListener<K>): void {
-    const set = this.listeners.get(event)
-    set?.delete(listener as UntypedListener)
-  }
-
-  emit<K extends UWCEventName>(event: K, data: UWCEventMap[K]): void {
-    this.dispatch(event, data)
-    if (event !== 'change') {
-      this.dispatch('change', undefined as UWCEventMap['change'])
-    }
-  }
+  private listeners: Set<Listener> = new Set()
 
-  private dispatch<K extends UWCEventName>(
-    event: K,
-    data: UWCEventMap[K]
-  ): void {
-    const set = this.listeners.get(event)
-    if (!set || set.size === 0) return
-    // Clone to guard against mutation during dispatch.
-    for (const listener of [...set]) {
-      try {
-        listener(data)
-      } catch {
-        // A bad listener shouldn't break the rest of the dispatch chain.
-      }
+  subscribe(listener: Listener): Unsubscribe {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
     }
   }
 
-  // ---- legacy API (still used by the React ConnectionProvider) ----
-
-  /**
-   * @deprecated Prefer `on(eventName, listener)` for targeted updates.
-   * Subscribes to the catch-all `change` event.
-   */
-  subscribe(listener: LegacyListener): () => void {
-    return this.on('change', listener)
-  }
-
-  /** @deprecated Prefer `emit(eventName, data)`. Emits `change` with no payload. */
   notify(): void {
-    this.dispatch('change', undefined as UWCEventMap['change'])
+    this.listeners.forEach(listener => listener())
   }
 
   getListenerCount(): number {
-    let count = 0
-    for (const set of this.listeners.values()) {
-      count += set.size
-    }
-    return count
+    return this.listeners.size
   }
 
   clearAllListeners(): void {

package/src/services/connection-service.test.ts

@@ -249,12 +249,8 @@ describe('ConnectionService', () => {
       })
     })
 
-    it('emits connectionUri and change events when URI becomes available', async () => {
-      const uriListener = vi.fn()
-      const changeListener = vi.fn()
-      eventManager.on('connectionUri', uriListener)
-      eventManager.on('change', changeListener)
-
+    it('polls for URI and notifies eventManager when available', async () => {
+      const notifySpy = vi.spyOn(eventManager, 'notify')
       let connectResolve: (v: any) => void
 
       tonConnector.connect = vi.fn().mockReturnValue(
@@ -279,11 +275,7 @@ describe('ConnectionService', () => {
       // Wait for polling to detect URI
       await new Promise(r => setTimeout(r, 250))
 
-      expect(uriListener).toHaveBeenCalledWith({
-        uri: 'tc://some-uri',
-        connectionMode: 'tonConnect'
-      })
-      expect(changeListener).toHaveBeenCalled()
+      expect(notifySpy).toHaveBeenCalled()
 
       // Resolve the connection to let the test finish
       connectResolve!({

package/src/services/connection-service.ts

@@ -13,10 +13,6 @@ import type {
 import type { SessionManager } from '../managers/session-manager'
 import type { EventManager } from '../managers/event-manager'
 
-export interface ServiceOptions {
-  signal?: AbortSignal
-}
-
 export class ConnectionService {
   private activeConnector: Connector | null = null
 
@@ -32,13 +28,8 @@ export class ConnectionService {
   async connect(
     connectionMode: ConnectionMode,
     walletId: string,
-    networkId?: NetworkId,
-    options?: ServiceOptions
+    networkId?: NetworkId
   ): Promise<void> {
-    options?.signal?.throwIfAborted()
-
-    this.eventManager.emit('connecting', { connectionMode, walletId })
-
     // Find the wallet
     const wallet = this.findWallet(walletId)
 
@@ -68,12 +59,7 @@ export class ConnectionService {
         connectionMode === 'tonConnect' ||
         connectionMode === 'walletConnect'
       ) {
-        result = await this.connectWithURIPoll(
-          connector,
-          network,
-          provider,
-          connectionMode
-        )
+        result = await this.connectWithURIPoll(connector, network, provider)
       } else {
         throw new Error(`Unsupported connection mode: ${connectionMode}`)
       }
@@ -82,9 +68,6 @@ export class ConnectionService {
       throw error
     }
 
-    // If the caller aborted during the await, 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)
@@ -101,26 +84,20 @@ 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,
-    connectionMode: ConnectionMode
+    provider: SupportedProvider
   ): Promise<ConnectorResult> {
     const connectPromise = connector.connect(network, provider)
 
-    let emittedUri: string | undefined
     const pollForURI = setInterval(() => {
       const uri = this.getConnectionURI()
-      if (uri && uri !== emittedUri) {
-        emittedUri = uri
-        this.eventManager.emit('connectionUri', { uri, connectionMode })
+      if (uri) {
+        clearInterval(pollForURI)
+        this.eventManager.notify()
       }
     }, 100)
 
@@ -242,8 +219,7 @@ export class ConnectionService {
     return network
   }
 
-  async disconnect(options?: ServiceOptions): Promise<void> {
-    options?.signal?.throwIfAborted()
+  async disconnect(): Promise<void> {
     try {
       if (
         this.activeConnector &&
@@ -254,9 +230,6 @@ 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,7 +11,6 @@ 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
@@ -32,12 +31,7 @@ export class NetworkSwitchService {
     }
   }
 
-  async switchNetwork(
-    networkId: NetworkId,
-    options?: ServiceOptions
-  ): Promise<void> {
-    options?.signal?.throwIfAborted()
-
+  async switchNetwork(networkId: NetworkId): Promise<void> {
     // Check if there's an active connection
     const session = this.sessionManager.getSession()
     if (!session) {
@@ -110,10 +104,7 @@ export class NetworkSwitchService {
       // Set loading states
       this.isLoading = true
       this.isWaitingForUserApproval = requiresApproval
-      this.eventManager.emit('networkSwitching', {
-        isLoading: true,
-        isWaitingForUserApproval: requiresApproval
-      })
+      this.eventManager.notify()
 
       // Perform the network switch and get the new address
       // Pass the appropriate provider based on connection mode
@@ -138,8 +129,6 @@ 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 =>
@@ -155,19 +144,11 @@ 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.emit('networkSwitching', {
-        isLoading: false,
-        isWaitingForUserApproval: false
-      })
+      this.eventManager.notify()
     }
   }
 

package/src/services/signature-service.ts

@@ -8,7 +8,6 @@ import type {
   SignatureType
 } 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,15 +22,12 @@ 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,
-    options?: ServiceOptions
+    provider?: SupportedProvider
   ): Promise<SignatureType> {
-    options?.signal?.throwIfAborted()
     const session = this.sessionManager.getSession()
 
     if (!session.connectionMode) {
@@ -56,33 +52,29 @@ 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')
       }
-      signature = await connector.signMessage(
+      return await connector.signMessage(
         message,
         provider as
           | ExtensionInjectedProvider
           | IntegratedBrowserInjectedProvider
       )
     } else if (session.connectionMode === 'tonConnect') {
-      signature = await connector.signMessage(message)
+      return await connector.signMessage(message)
     } else if (session.connectionMode === 'walletConnect') {
       if (!provider) {
         throw new Error('Provider is required for WalletConnect connector')
       }
-      signature = await connector.signMessage(
+      return await connector.signMessage(
         message,
         provider as WalletConnectProvider
       )
     } else {
       // For other connectors that might not need the provider
-      signature = await connector.signMessage(message)
+      return await connector.signMessage(message)
     }
-
-    options?.signal?.throwIfAborted()
-    return signature
   }
 }

package/src/services/transaction-service.ts

@@ -9,7 +9,6 @@ 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
@@ -24,15 +23,12 @@ 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,
-    options?: ServiceOptions
+    provider?: SupportedProvider
   ): Promise<TransactionResult> {
-    options?.signal?.throwIfAborted()
     const session = this.sessionManager.getSession()
 
     if (!session.connectionMode) {
@@ -57,33 +53,29 @@ 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')
       }
-      result = await connector.sendTransaction(
+      return await connector.sendTransaction(
         request,
         provider as
           | ExtensionInjectedProvider
           | IntegratedBrowserInjectedProvider
       )
     } else if (session.connectionMode === 'tonConnect') {
-      result = await connector.sendTransaction(request)
+      return await connector.sendTransaction(request)
     } else if (session.connectionMode === 'walletConnect') {
       if (!provider) {
         throw new Error('Provider is required for WalletConnect connector')
       }
-      result = await connector.sendTransaction(
+      return await connector.sendTransaction(
         request,
         provider as WalletConnectProvider
       )
     } else {
       // For other connectors that might not need the provider
-      result = await connector.sendTransaction(request)
+      return await connector.sendTransaction(request)
     }
-
-    options?.signal?.throwIfAborted()
-    return result
   }
 }

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

@@ -6,7 +6,6 @@ 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(
@@ -18,11 +17,8 @@ export class WalletCapabilitiesService {
 
   async getWalletCapabilities(
     address: string,
-    activeNetwork?: Network,
-    options?: ServiceOptions
+    activeNetwork?: Network
   ): Promise<void> {
-    options?.signal?.throwIfAborted()
-
     let activeWalletCapabilities: Record<string, EVMCapabilities> = {}
     let activeNetworkWalletCapabilities: EVMCapabilities = {}
 
@@ -53,8 +49,6 @@ export class WalletCapabilitiesService {
         capabilities = {}
       }
 
-      options?.signal?.throwIfAborted()
-
       // keep only supported networks
       activeWalletCapabilities = Object.fromEntries(
         Object.entries(capabilities).filter(([networkId, _]) =>
@@ -77,13 +71,7 @@ export class WalletCapabilitiesService {
           activeNetworkWalletCapabilities: null
         })
       }
-
-      this.eventManager.emit('capabilitiesUpdated', {
-        capabilities: activeWalletCapabilities
-      })
-      this.eventManager.emit('sessionChanged', {
-        session: this.sessionManager.getSession()
-      })
+      this.eventManager.notify()
     }
   }
 }

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

@@ -29,11 +29,7 @@ const mockSessionManager = {
 
 const mockEventManager = {
   subscribe: vi.fn().mockReturnValue(() => {}),
-  notify: vi.fn(),
-  emit: vi.fn(),
-  on: vi.fn().mockReturnValue(() => {}),
-  off: vi.fn(),
-  once: vi.fn().mockReturnValue(() => {})
+  notify: vi.fn()
 }
 
 const mockConnectionService = {
@@ -121,7 +117,8 @@ describe('UniversalWalletConnector', () => {
   let mockWalletConnectConfig: WalletConnectConfig
 
   beforeEach(() => {
-    UniversalWalletConnector.resetInstance()
+    ;(UniversalWalletConnector as any).instanceCount = 0
+    ;(UniversalWalletConnector as any).hasWarnedAboutMultipleInstances = false
 
     mockNetworks = [
       {
@@ -405,87 +402,6 @@ 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()
     })
   })