@meshconnect/uwc-core 2.5.16 → 2.7.0-snapshot.c392d3d

package/src/services/connection-service.ts

@@ -18,6 +18,11 @@ import { raceAbort } from '../utils/abort'
 import { generateId } from '../utils/id'
 import { instrumentHandoff } from '../observability/instrument-handoff'
 import { attachLifecycle } from '../observability/lifecycle-bridge'
+import {
+  DEFAULT_NAMESPACE_PRIORITY,
+  type NetworkSelection,
+  pickAutoNetwork
+} from './network-selection'
 
 export interface ServiceOptions {
   signal?: AbortSignal
@@ -26,6 +31,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
@@ -82,7 +92,9 @@ export class ConnectionService {
     private usingIntegratedBrowser: boolean,
     private eventManager: EventManager,
     // Observational wallet-response deadline for the handoff timeout marker.
-    private walletResponseTimeoutMs: number
+    private walletResponseTimeoutMs: number,
+    /** Namespace preference for an auto-picked connect network — see `pickAutoNetwork`. */
+    private preferredNamespaces: readonly Namespace[] = DEFAULT_NAMESPACE_PRIORITY
   ) {}
 
   async connect(
@@ -99,8 +111,20 @@ export class ConnectionService {
     // connect() would spuriously abort (MFS-602).
     const wallet = this.findWallet(walletId)
     const provider = this.getProviderForMode(wallet, connectionMode)
-    const network = this.validateAndDetermineNetwork(networkId, provider)
+    const { network, selection: networkSelection } =
+      this.validateAndDetermineNetwork(networkId, provider, connectionMode)
     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 +181,11 @@ 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,
+          networkSelection
         },
         async handoffId => {
           // Publish this attempt's routing for the connector's step sink.
@@ -170,7 +198,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 +290,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 +304,12 @@ export class ConnectionService {
           provider as
             | ExtensionInjectedProvider
             | IntegratedBrowserInjectedProvider,
-          requiredAddresses ? { requiredAddresses } : undefined
+          requiredAddresses || silentOnly
+            ? {
+                ...(requiredAddresses ? { requiredAddresses } : {}),
+                ...(silentOnly ? { silentOnly } : {})
+              }
+            : undefined
         ),
         signal
       )
@@ -921,9 +956,11 @@ export class ConnectionService {
 
   private validateAndDetermineNetwork(
     networkId: NetworkId | undefined,
-    provider: SupportedProvider
-  ): Network {
+    provider: SupportedProvider,
+    connectionMode: ConnectionMode
+  ): { network: Network; selection: NetworkSelection } {
     let targetNetworkId: NetworkId
+    let selection: NetworkSelection = 'explicit'
 
     if (networkId) {
       // Check if networkId is in the configured networks
@@ -942,11 +979,16 @@ export class ConnectionService {
 
       targetNetworkId = networkId
     } else {
-      // Use the first supported network that exists in both wallet and configured networks
-      const supportedNetwork = provider.supportedNetworkIds.find(id =>
-        this.networks.some(n => n.id === id)
+      // No network named: prefer a namespace detection found installed (injected
+      // only), ranked by `preferredNamespaces`; otherwise the first supported
+      // network that is also configured (catalog order).
+      const picked = pickAutoNetwork(
+        provider,
+        this.networks,
+        connectionMode,
+        this.preferredNamespaces
       )
-      if (!supportedNetwork) {
+      if (!picked) {
         // The #1 production connection failure. Throw a typed, self-describing
         // error carrying both CAIP-2 id lists (non-PII) so telemetry can tell a
         // metadata gap from a client-config mistake — see NoCommonNetworkError.
@@ -955,7 +997,8 @@ export class ConnectionService {
           this.networks.map(n => n.id)
         )
       }
-      targetNetworkId = supportedNetwork
+      targetNetworkId = picked.networkId
+      selection = picked.selection
     }
 
     // Find and return the network object
@@ -965,7 +1008,7 @@ export class ConnectionService {
         `Network ${targetNetworkId} not found in configured networks`
       )
     }
-    return network
+    return { network, selection }
   }
 
   async disconnect(options?: ServiceOptions): Promise<void> {

package/src/services/index.ts

@@ -1,3 +1,4 @@
 export * from './connection-service'
+export * from './network-selection'
 export * from './signature-service'
 export * from './transaction-service'

package/src/services/network-selection.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it } from 'vitest'
+import type { Network, SupportedProvider } from '@meshconnect/uwc-types'
+import {
+  DEFAULT_NAMESPACE_PRIORITY,
+  pickAutoNetwork
+} from './network-selection'
+
+const network = (id: string, namespace: Network['namespace']): Network =>
+  ({
+    id,
+    internalId: 0,
+    name: id,
+    namespace,
+    logoUrl: '',
+    networkType: 'evm',
+    nativeCurrency: { name: '', symbol: '', decimals: 18 }
+  }) as Network
+
+const NETWORKS = [
+  network('eip155:1', 'eip155'),
+  network('eip155:81457', 'eip155'),
+  network('solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp', 'solana'),
+  network('tron:0x2b6653dc', 'tron'),
+  network('tvm:-239', 'tvm')
+]
+
+/** An injected provider whose namespaces carry detection's `installed` flag. */
+const injected = (
+  supportedNetworkIds: string[],
+  installed: Partial<Record<'eip155' | 'solana' | 'tron' | 'tvm', boolean>>
+): SupportedProvider =>
+  ({
+    supportedNetworkIds,
+    namespaceMetaData: {
+      eip155: { eip155Name: 'W', installed: installed.eip155 },
+      solana: { walletStandardName: 'W', installed: installed.solana },
+      tron: { injectedId: 'w.tron', installed: installed.tron },
+      tvm: { jsBridgeKey: 'w', installed: installed.tvm }
+    }
+  }) as unknown as SupportedProvider
+
+describe('pickAutoNetwork', () => {
+  it('skips an undetected first network (Trust mobile: Tron first, not injected)', () => {
+    const provider = injected(
+      [
+        'tron:0x2b6653dc',
+        'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+        'eip155:1'
+      ],
+      { eip155: true, solana: true, tron: false, tvm: true }
+    )
+    expect(
+      pickAutoNetwork(
+        provider,
+        NETWORKS,
+        'injected',
+        DEFAULT_NAMESPACE_PRIORITY
+      )
+    ).toEqual({ networkId: 'eip155:1', selection: 'detected' })
+  })
+
+  it('keeps catalog order within a namespace', () => {
+    const provider = injected(['eip155:81457', 'eip155:1'], { eip155: true })
+    expect(
+      pickAutoNetwork(
+        provider,
+        NETWORKS,
+        'injected',
+        DEFAULT_NAMESPACE_PRIORITY
+      )?.networkId
+    ).toBe('eip155:81457')
+  })
+
+  it('honours a caller-supplied namespace preference', () => {
+    const provider = injected(
+      ['eip155:1', 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'],
+      { eip155: true, solana: true }
+    )
+    expect(
+      pickAutoNetwork(provider, NETWORKS, 'injected', ['solana', 'eip155'])
+    ).toEqual({
+      networkId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+      selection: 'detected'
+    })
+  })
+
+  it('ranks a namespace missing from the preference list last', () => {
+    const provider = injected(['tvm:-239', 'tron:0x2b6653dc'], {
+      tvm: true,
+      tron: true
+    })
+    expect(
+      pickAutoNetwork(provider, NETWORKS, 'injected', ['tron'])?.networkId
+    ).toBe('tron:0x2b6653dc')
+  })
+
+  it('falls back to catalog order when nothing was detected (e.g. before detection)', () => {
+    const provider = injected(['tron:0x2b6653dc', 'eip155:1'], {})
+    expect(
+      pickAutoNetwork(
+        provider,
+        NETWORKS,
+        'injected',
+        DEFAULT_NAMESPACE_PRIORITY
+      )
+    ).toEqual({ networkId: 'tron:0x2b6653dc', selection: 'catalogOrder' })
+  })
+
+  it('leaves non-injected modes on catalog order even with installed flags', () => {
+    const provider = injected(['tron:0x2b6653dc', 'eip155:1'], {
+      eip155: true
+    })
+    expect(
+      pickAutoNetwork(
+        provider,
+        NETWORKS,
+        'walletConnect',
+        DEFAULT_NAMESPACE_PRIORITY
+      )
+    ).toEqual({ networkId: 'tron:0x2b6653dc', selection: 'catalogOrder' })
+  })
+
+  it('ignores supported networks that are not configured', () => {
+    const provider = injected(
+      ['eip155:999', 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'],
+      {
+        eip155: true,
+        solana: true
+      }
+    )
+    expect(
+      pickAutoNetwork(
+        provider,
+        NETWORKS,
+        'injected',
+        DEFAULT_NAMESPACE_PRIORITY
+      )?.networkId
+    ).toBe('solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp')
+  })
+
+  it('returns undefined when no supported network is configured', () => {
+    const provider = injected(['eip155:999'], { eip155: true })
+    expect(
+      pickAutoNetwork(
+        provider,
+        NETWORKS,
+        'injected',
+        DEFAULT_NAMESPACE_PRIORITY
+      )
+    ).toBeUndefined()
+  })
+})

package/src/services/network-selection.ts

@@ -0,0 +1,86 @@
+import type {
+  ConnectionMode,
+  Namespace,
+  Network,
+  NetworkId,
+  SupportedProvider
+} from '@meshconnect/uwc-types'
+
+/**
+ * Default namespace preference for an auto-picked connect network (no
+ * `networkId` passed): EVM first, then Solana, Tron, TON, Bitcoin. A caller
+ * policy, not a correctness rule — override it with `UWCConfig.preferredNamespaces`.
+ * Same order as the namespace unions used across the connectors.
+ */
+export const DEFAULT_NAMESPACE_PRIORITY: readonly Namespace[] = [
+  'eip155',
+  'solana',
+  'tron',
+  'tvm',
+  'bip122'
+]
+
+/**
+ * How the connect network was chosen, surfaced on the hand-off telemetry:
+ * - `explicit` — the caller passed a `networkId`.
+ * - `detected` — auto-picked among namespaces whose injected provider was
+ *   detected, ranked by the namespace preference, catalog order breaking ties.
+ * - `catalogOrder` — legacy pick: the first configured network in the wallet's
+ *   `supportedNetworkIds` (non-injected modes, or nothing detected yet).
+ */
+export type NetworkSelection = 'explicit' | 'detected' | 'catalogOrder'
+
+function isNamespaceInstalled(
+  provider: SupportedProvider,
+  namespace: Namespace
+): boolean {
+  if (!('namespaceMetaData' in provider)) return false
+  const meta = provider.namespaceMetaData[
+    namespace as keyof typeof provider.namespaceMetaData
+  ] as { installed?: boolean } | undefined
+  return meta?.installed === true
+}
+
+/**
+ * Picks the network for a connect that named none. Candidates are the wallet's
+ * `supportedNetworkIds` that are also configured, in catalog order.
+ *
+ * For an injected connect where detection marked at least one candidate's
+ * namespace installed, only installed namespaces are eligible (connecting on an
+ * undetected namespace can only fail — e.g. Trust mobile has no
+ * `trustWallet.tronLink`), ranked by `preferredNamespaces`, catalog order
+ * breaking ties. Every other case keeps the legacy first-candidate pick, so
+ * WalletConnect / TON Connect and pre-detection connects are unchanged.
+ * Returns `undefined` when no candidate exists (the caller throws).
+ */
+export function pickAutoNetwork(
+  provider: SupportedProvider,
+  networks: readonly Network[],
+  connectionMode: ConnectionMode,
+  preferredNamespaces: readonly Namespace[]
+): { networkId: NetworkId; selection: NetworkSelection } | undefined {
+  const candidates = provider.supportedNetworkIds
+    .map(id => networks.find(n => n.id === id))
+    .filter((n): n is Network => n !== undefined)
+  const first = candidates[0]
+  if (!first) return undefined
+
+  if (connectionMode === 'injected') {
+    const installed = candidates.filter(n =>
+      isNamespaceInstalled(provider, n.namespace)
+    )
+    if (installed.length > 0) {
+      const rank = (namespace: Namespace) => {
+        const index = preferredNamespaces.indexOf(namespace)
+        return index === -1 ? preferredNamespaces.length : index
+      }
+      // Array.prototype.sort is stable, so equal ranks keep catalog order.
+      const [best] = [...installed].sort(
+        (a, b) => rank(a.namespace) - rank(b.namespace)
+      )
+      if (best) return { networkId: best.id, selection: 'detected' }
+    }
+  }
+
+  return { networkId: first.id, selection: 'catalogOrder' }
+}

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

@@ -30,6 +30,7 @@ import type { TronConnectorConfig } from '@meshconnect/uwc-tron-connector'
 import { SessionManager } from './managers/session-manager'
 import { EventManager } from './managers/event-manager'
 import { ConnectionService } from './services/connection-service'
+import { DEFAULT_NAMESPACE_PRIORITY } from './services/network-selection'
 import { NetworkSwitchService } from './services/network-switch-service'
 import { SignatureService } from './services/signature-service'
 import { TransactionService } from './services/transaction-service'
@@ -109,6 +110,13 @@ export interface UWCConfig {
    * Default 15_000.
    */
   secondaryGatherTimeoutMs?: number
+  /**
+   * Namespace preference for a connect that names no `networkId`. Injected mode
+   * only, and only among namespaces whose provider detection found installed —
+   * an undetected namespace is never auto-picked. Catalog order breaks ties.
+   * Default `DEFAULT_NAMESPACE_PRIORITY` (eip155, solana, tron, tvm, bip122).
+   */
+  preferredNamespaces?: readonly Namespace[]
 }
 
 /** Common options for user-initiated async operations. */
@@ -130,6 +138,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 {
@@ -436,7 +451,8 @@ export class UniversalWalletConnector {
       this.connectors,
       configuredUsingIntegratedBrowser,
       this.eventManager,
-      this.walletResponseTimeoutMs
+      this.walletResponseTimeoutMs,
+      config.preferredNamespaces ?? DEFAULT_NAMESPACE_PRIORITY
     )
     this.networkSwitchService = new NetworkSwitchService(
       networks,
@@ -473,8 +489,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'