@meshconnect/uwc-core 2.5.16 → 2.7.0

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

@@ -12,7 +12,10 @@ import type {
   ConnectionMode,
   Connector
 } from '@meshconnect/uwc-types'
-import { NoCommonNetworkError } from '@meshconnect/uwc-types'
+import {
+  NoCommonNetworkError,
+  WalletNotAuthorizedError
+} from '@meshconnect/uwc-types'
 import type { WalletLifecycleEvent } from '@meshconnect/uwc-types'
 
 describe('ConnectionService', () => {
@@ -211,6 +214,115 @@ describe('ConnectionService', () => {
       expect(connectionService['activeConnector']).toBe(mockConnector)
     })
 
+    // ONC-1975: silentOnly is a promise never to open wallet UI.
+    it('forwards silentOnly to the injected connector', async () => {
+      const provider = { supportedNetworkIds: ['eip155:1'] }
+      wallets[0].extensionInjectedProvider = provider as any
+      mockConnector.connect = vi.fn().mockResolvedValue({
+        networkId: 'eip155:1',
+        address: '0x1234',
+        availableAddresses: [{ address: '0x1234', networkId: 'eip155:1' }]
+      })
+
+      await connectionService.connect('injected', 'metamask', 'eip155:1', {
+        silentOnly: true
+      })
+
+      expect(mockConnector.connect).toHaveBeenCalledWith(
+        networks[0],
+        provider,
+        {
+          silentOnly: true
+        }
+      )
+    })
+
+    it('tags the connect funnel with silentOnly, so a silent restore is not counted as a tap', async () => {
+      const provider = { supportedNetworkIds: ['eip155:1'] }
+      wallets[0].extensionInjectedProvider = provider as any
+      mockConnector.connect = vi.fn().mockResolvedValue({
+        networkId: 'eip155:1',
+        address: '0x1234',
+        availableAddresses: [{ address: '0x1234', networkId: 'eip155:1' }]
+      })
+      const awaiting = vi.fn()
+      const succeeded = vi.fn()
+      eventManager.on('awaitingWallet', awaiting)
+      eventManager.on('walletSucceeded', succeeded)
+
+      await connectionService.connect('injected', 'metamask', 'eip155:1', {
+        silentOnly: true
+      })
+      await connectionService.connect('injected', 'metamask', 'eip155:1')
+
+      expect(awaiting.mock.calls.map(([e]) => e.silentOnly)).toEqual([
+        true,
+        false
+      ])
+      expect(succeeded.mock.calls.map(([e]) => e.silentOnly)).toEqual([
+        true,
+        false
+      ])
+    })
+
+    it('passes no connect options when neither silentOnly nor requiredAddresses is set', async () => {
+      const provider = { supportedNetworkIds: ['eip155:1'] }
+      wallets[0].extensionInjectedProvider = provider as any
+      mockConnector.connect = vi.fn().mockResolvedValue({
+        networkId: 'eip155:1',
+        address: '0x1234',
+        availableAddresses: [{ address: '0x1234', networkId: 'eip155:1' }]
+      })
+
+      await connectionService.connect('injected', 'metamask', 'eip155:1', {
+        silentOnly: false
+      })
+
+      expect(mockConnector.connect).toHaveBeenCalledWith(
+        networks[0],
+        provider,
+        undefined
+      )
+    })
+
+    it('rejects silentOnly for a non-injected mode before the attempt starts', async () => {
+      const walletConnectConnector: Connector = {
+        connect: vi.fn(),
+        disconnect: vi.fn(),
+        signMessage: vi.fn(),
+        sendTransaction: vi.fn(),
+        switchNetwork: vi.fn()
+      }
+      connectors.set('walletConnect', walletConnectConnector)
+      wallets[0].walletConnectProvider = {
+        supportedNetworkIds: ['eip155:1']
+      } as any
+      const connectingListener = vi.fn()
+      const awaiting = vi.fn()
+      eventManager.on('connecting', connectingListener)
+      eventManager.on('awaitingWallet', awaiting)
+
+      await expect(
+        connectionService.connect('walletConnect', 'metamask', 'eip155:1', {
+          silentOnly: true
+        })
+      ).rejects.toThrow(
+        "silentOnly is not supported for connection mode 'walletConnect'"
+      )
+      // A caller bug, not the expected `not_authorized` miss.
+      await expect(
+        connectionService.connect('walletConnect', 'metamask', 'eip155:1', {
+          silentOnly: true
+        })
+      ).rejects.not.toBeInstanceOf(WalletNotAuthorizedError)
+
+      // A validation failure: never reaches the wallet, never enters the funnel.
+      expect(walletConnectConnector.connect).not.toHaveBeenCalled()
+      expect(connectingListener).not.toHaveBeenCalled()
+      expect(awaiting).not.toHaveBeenCalled()
+      expect(connectionService['activeConnector']).toBeNull()
+    })
+
     it('does not emit "connecting" when validation throws (unknown wallet)', async () => {
       const connectingListener = vi.fn()
       eventManager.on('connecting', connectingListener)

package/src/services/connection-service.ts

@@ -26,6 +26,11 @@ export interface ServiceOptions {
    * Forwarded verbatim to the connector; see `ConnectorConnectOptions`.
    */
   requiredAddresses?: readonly string[]
+  /**
+   * Connect only if the wallet already trusts this origin (connect only).
+   * Injected mode only; see `ConnectorConnectOptions.silentOnly`.
+   */
+  silentOnly?: boolean
 }
 
 /** Sibling-namespace live-account re-read poll: absorbs the lag while a wallet
@@ -101,6 +106,17 @@ export class ConnectionService {
     const provider = this.getProviderForMode(wallet, connectionMode)
     const network = this.validateAndDetermineNetwork(networkId, provider)
     const connector = this.getConnector(connectionMode)
+    // A silent-only connect is a promise never to open wallet UI. Only the
+    // injected connector can keep it — WalletConnect / TON Connect always hand
+    // off to the wallet — so refuse the rest here, as a validation failure:
+    // before `connecting`, so the attempt never enters the hand-off funnel.
+    // A plain Error, not `WalletNotAuthorizedError`: that classifies as the
+    // expected `not_authorized` miss, which would hide this caller bug.
+    if (options?.silentOnly && connectionMode !== 'injected') {
+      throw new Error(
+        `silentOnly is not supported for connection mode '${connectionMode}'`
+      )
+    }
     const connectAttemptId = generateId()
 
     // Supersede any prior in-flight attempt: abort it so its URI poll and
@@ -157,7 +173,10 @@ export class ConnectionService {
           walletId,
           namespace: network.namespace,
           chainId: network.id,
-          connectAttemptId
+          connectAttemptId,
+          // Lets telemetry tell a silent restore from a tapped connect: both
+          // succeed the same way, and only a miss carries a distinct failureKind.
+          silentOnly: options?.silentOnly === true
         },
         async handoffId => {
           // Publish this attempt's routing for the connector's step sink.
@@ -170,7 +189,8 @@ export class ConnectionService {
               provider,
               signal,
               connectAttemptId,
-              options?.requiredAddresses
+              options?.requiredAddresses,
+              options?.silentOnly
             )
           } finally {
             // Retract ONLY if we are still the published attempt. An
@@ -261,7 +281,8 @@ export class ConnectionService {
     provider: SupportedProvider,
     signal: AbortSignal,
     connectAttemptId: string,
-    requiredAddresses?: readonly string[]
+    requiredAddresses?: readonly string[],
+    silentOnly?: boolean
   ): Promise<ConnectorResult> {
     // Race the connector call against the AbortSignal so a mid-flight abort
     // (e.g. user cancels the WalletConnect QR while the prompt is open)
@@ -274,7 +295,12 @@ export class ConnectionService {
           provider as
             | ExtensionInjectedProvider
             | IntegratedBrowserInjectedProvider,
-          requiredAddresses ? { requiredAddresses } : undefined
+          requiredAddresses || silentOnly
+            ? {
+                ...(requiredAddresses ? { requiredAddresses } : {}),
+                ...(silentOnly ? { silentOnly } : {})
+              }
+            : undefined
         ),
         signal
       )

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

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach, vi } from 'vitest'
 import { TransactionService } from './transaction-service'
 import { SessionManager } from '../managers/session-manager'
 import { EventManager } from '../managers/event-manager'
+import { WalletConnectorError } from '../../../types/src'
 import type {
   ConnectionMode,
   Connector,
@@ -211,6 +212,30 @@ describe('TransactionService.sendTransaction', () => {
     expect(events).toEqual(['awaitingWallet', 'walletRejected'])
   })
 
+  it("carries the wallet's own reason onto walletFailed and the thrown error", async () => {
+    connectSession()
+    const failures: { error: { providerReason?: string } }[] = []
+    eventManager.on('walletFailed', d => failures.push(d))
+    vi.mocked(mockConnector.sendTransaction!).mockRejectedValueOnce(
+      new WalletConnectorError({
+        type: 'unknown',
+        message: 'An unknown RPC error occurred.',
+        providerReason: 'cancelled'
+      })
+    )
+
+    const error = await transactionService
+      .sendTransaction(request)
+      .catch((e: unknown) => e)
+
+    expect(error).toMatchObject({ providerReason: 'cancelled' })
+    expect(events).toEqual(['awaitingWallet', 'walletFailed'])
+    expect(failures[0]?.error).toMatchObject({
+      type: 'unknown',
+      providerReason: 'cancelled'
+    })
+  })
+
   it('tonConnect enters the funnel with the connector resolving its own provider', async () => {
     connectors.set('tonConnect', mockConnector)
     connectSession('tonConnect', walletWithoutProviders)

package/src/universal-wallet-connector.ts

@@ -130,6 +130,13 @@ export interface ConnectOptions extends OperationOptions {
    * constraint.
    */
   requiredAddresses?: readonly string[]
+  /**
+   * Connect only if the wallet already trusts this origin; never prompt.
+   * Forwarded to the connector as {@link ConnectorConnectOptions.silentOnly}
+   * — see there for the semantics. `'injected'` mode only: any other mode
+   * rejects with a plain `Error` before reaching the wallet.
+   */
+  silentOnly?: boolean
 }
 
 export class UniversalWalletConnector {
@@ -473,8 +480,9 @@ export class UniversalWalletConnector {
       UniversalWalletConnector.instance = this
     }
 
-    // Initialize detected wallets after services are created
-    this.initializeDetectedWallets()
+    // Initialize detected wallets after services are created. Fire-and-forget on
+    // purpose (a constructor can't await); the method catches everything itself.
+    void this.initializeDetectedWallets()
   }
 
   /**

package/src/utils/to-wallet-error.test.ts

@@ -1,7 +1,8 @@
 import { describe, it, expect } from 'vitest'
 import {
   WalletConnectorError,
-  NoCommonNetworkError
+  NoCommonNetworkError,
+  WalletNotAuthorizedError
 } from '@meshconnect/uwc-types'
 import {
   classifyError,
@@ -38,6 +39,15 @@ describe('classifyError', () => {
     })
   })
 
+  it('classifies WalletNotAuthorizedError as not_authorized/connector (ONC-1975)', () => {
+    // A silent-only connect that found no authorization. Expected, not a
+    // fault, so it gets its own kind that failure rates can exclude.
+    expect(classifyError(new WalletNotAuthorizedError())).toEqual({
+      failureKind: 'not_authorized',
+      source: 'connector'
+    })
+  })
+
   it('classifies -32002 (request already pending) as provider_error', () => {
     // Delta B: the double-fire race. A provider-level error, not a user reject.
     expect(classifyError({ code: -32002, message: 'already pending' })).toEqual(
@@ -203,6 +213,24 @@ describe('toWalletError', () => {
     })
   })
 
+  it('carries the provider reason of a connector error', () => {
+    const err = new WalletConnectorError({
+      type: 'unknown',
+      message: 'An unknown RPC error occurred.',
+      providerReason: 'cancelled'
+    })
+    expect(toWalletError(err)).toEqual({
+      type: 'unknown',
+      message: 'An unknown RPC error occurred.',
+      providerReason: 'cancelled'
+    })
+  })
+
+  it('omits providerReason when the connector error has none', () => {
+    const err = new WalletConnectorError({ type: 'unknown', message: 'x' })
+    expect(toWalletError(err)).not.toHaveProperty('providerReason')
+  })
+
   it('bounds an over-long non-connector message (shared safeErrorMessage cap)', () => {
     const err = new Error('x'.repeat(10_000))
     expect(toWalletError(err).message).toHaveLength(500)

package/src/utils/to-wallet-error.ts

@@ -1,6 +1,7 @@
 import {
   WalletConnectorError,
   NoCommonNetworkError,
+  WalletNotAuthorizedError,
   safeErrorMessage,
   type WalletError,
   type FailureKind,
@@ -26,7 +27,13 @@ const MAX_ERROR_CODE_LENGTH = 64
 export function toWalletError(error: unknown): WalletError {
   try {
     if (error instanceof WalletConnectorError) {
-      return { type: error.type, message: error.message }
+      return {
+        type: error.type,
+        message: error.message,
+        ...(error.providerReason
+          ? { providerReason: error.providerReason }
+          : {})
+      }
     }
     return { type: 'unknown', message: safeErrorMessage(error) }
   } catch {
@@ -101,6 +108,10 @@ function classifyErrorUnguarded(error: unknown): {
   let failureKind: FailureKind = 'unknown'
   if (isUserRejection(error)) {
     failureKind = 'user_rejected'
+  } else if (error instanceof WalletNotAuthorizedError) {
+    // A silent-only connect stopped because the wallet hasn't authorized this
+    // origin. Nothing was shown to the user, so it is expected, not a fault.
+    failureKind = 'not_authorized'
   } else if (error instanceof NoCommonNetworkError) {
     // The wallet and configured networks don't overlap — the #1 prod connection
     // failure. Carries its own CAIP-2 id lists; the caller forwards them.

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated from package.json by scripts/generate-version.mjs — do not edit.
-export const UWC_CORE_VERSION = '2.5.16'
+export const UWC_CORE_VERSION = '2.7.0'