@meshconnect/uwc-core 2.5.16-snapshot.da6ba82 → 2.6.0

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/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,24 +213,6 @@ 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,13 +27,7 @@ const MAX_ERROR_CODE_LENGTH = 64
 export function toWalletError(error: unknown): WalletError {
   try {
     if (error instanceof WalletConnectorError) {
-      return {
-        type: error.type,
-        message: error.message,
-        ...(error.providerReason
-          ? { providerReason: error.providerReason }
-          : {})
-      }
+      return { type: error.type, message: error.message }
     }
     return { type: 'unknown', message: safeErrorMessage(error) }
   } catch {
@@ -107,6 +102,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.6.0'