@meshconnect/uwc-core 1.5.0 → 1.7.0-snapshot.56a9011

package/src/events.ts

@@ -56,7 +56,10 @@ export interface UWCEventMap {
   walletsDetected: {
     wallets: WalletMetadata[]
     discovery?:
-      | Record<string, { requested: number; matched: number }>
+      | Record<
+          string,
+          { requested: number; matched: number; legacyInjected?: number }
+        >
       | undefined
   }
   /**
@@ -234,6 +237,13 @@ export interface UWCEventMap {
     handoffId: string
     operation: UWCOperation
     durationMs: number
+    /**
+     * The rejection error, PII-light and scrubbed on egress. Present so triage can
+     * see WHY a reject fired (e.g. the wallet's own decline string) without a join.
+     * Optional so adding it stays non-breaking for consumers of this exported event
+     * type; `instrumentHandoff` always sets it.
+     */
+    error?: WalletError | undefined
     connectionMode: ConnectionMode
     walletId?: string | undefined
     namespace?: Namespace | undefined
@@ -366,6 +376,24 @@ export interface UWCEventMap {
     hiddenMs?: number | undefined
   }
 
+  /**
+   * The framed secondary Solana gather was SKIPPED for a wallet that declares
+   * a legacy `solana.injectedId` (ONC-3536 follow-up). In such wallets'
+   * in-app browsers (Coinbase/Base Wallet Legacy mode) any secondary Solana
+   * connect after an EVM connect parks the wallet's active namespace on
+   * Solana, and the following EVM `eth_sendTransaction` never surfaces an
+   * approval sheet (60s `walletTimedOut`, the USDC.base hang). Triage
+   * telemetry: confirms the gate fired when retesting the fix. Deduped per
+   * injectedId per connector instance. Carries the metadata key + discovery
+   * mode only — never an address.
+   */
+  secondarySolanaConnectSkipped: {
+    /** The `solana.injectedId` metadata key that triggered the skip (e.g. `coinbaseSolana`). */
+    injectedId: string
+    /** True = wallet discovered via the legacy injected fallback (true "Legacy mode"); false = Wallet Standard. */
+    legacyInjected: boolean
+  }
+
   /**
    * Back-compat catch-all. Fires after every other event above.
    * New code should prefer the specific events.
@@ -397,7 +425,8 @@ export const TELEMETRY_ONLY_EVENTS: ReadonlySet<UWCEventName> = new Set([
   'walletSessionExpired',
   'lifecycleTelemetryUnavailable',
   'pageHiddenDuringHandoff',
-  'pageVisibleDuringHandoff'
+  'pageVisibleDuringHandoff',
+  'secondarySolanaConnectSkipped'
 ])
 
 export type UWCEventName = keyof UWCEventMap
@@ -442,6 +471,7 @@ const EVENT_NAME_FLAGS: Record<UWCEventName, true> = {
   lifecycleTelemetryUnavailable: true,
   pageHiddenDuringHandoff: true,
   pageVisibleDuringHandoff: true,
+  secondarySolanaConnectSkipped: true,
   change: true
 }
 

package/src/observability/instrument-handoff.test.ts

@@ -137,10 +137,31 @@ describe('instrumentHandoff', () => {
       errorCode?: string
       failureKind?: string
       source?: string
+      error?: { type: string; message: string }
     }
     expect(rejected.errorCode).toBe('4001')
     expect(rejected.failureKind).toBe('user_rejected')
     expect(rejected.source).toBe('provider')
+    // walletRejected now carries the error (mirroring walletFailed) so triage
+    // sees WHY the reject fired without joining to another event. type is forced
+    // to 'rejected' — a raw 4001 Error would otherwise normalize to 'unknown',
+    // which would contradict the walletRejected terminal.
+    expect(rejected.error).toEqual({ type: 'rejected', message: 'rejected' })
+  })
+
+  it('a WalletConnectorError{rejected} keeps type rejected on the walletRejected error', async () => {
+    const em = new EventManager()
+    const seen = record(em)
+    await expect(
+      instrumentHandoff({ eventManager: em, timeoutMs: 0 }, CTX, async () => {
+        throw new WalletConnectorError({ type: 'rejected', message: 'user no' })
+      })
+    ).rejects.toThrow()
+    const rejected = seen[1].data as {
+      error?: { type: string; message: string }
+    }
+    expect(seen[1].name).toBe('walletRejected')
+    expect(rejected.error).toEqual({ type: 'rejected', message: 'user no' })
   })
 
   it('classifies an unmapped failure as unknown (no guess)', async () => {

package/src/observability/instrument-handoff.ts

@@ -230,6 +230,12 @@ export async function instrumentHandoff<T>(
         handoffId,
         operation: context.operation,
         durationMs,
+        // We are in the isUserRejection branch — a reliable structural rejection
+        // signal — so the type is 'rejected' even for a raw EIP-1193 4001 Error
+        // (which toWalletError would otherwise report as 'unknown'). Keep the
+        // normalized/scrubbed message; correct the type so error.type never
+        // contradicts the walletRejected terminal.
+        error: { ...toWalletError(error), type: 'rejected' },
         timedOut,
         timeoutMs: timedOut ? timeoutMs : undefined,
         errorCode,

package/src/observability/telemetry.test.ts

@@ -320,6 +320,7 @@ describe('normalizeEvent', () => {
         handoffId: 'h-1',
         operation: 'signMessage',
         durationMs: 5,
+        error: { type: 'rejected', message: 'User rejected the request' },
         connectionMode: 'injected',
         timedOut: false,
         errorCode: '4001',
@@ -332,6 +333,11 @@ describe('normalizeEvent', () => {
     expect(rejected.errorCode).toBe('4001')
     expect(rejected.failureKind).toBe('user_rejected')
     expect(rejected.source).toBe('provider')
+    // The rejection error rides along so triage sees WHY, mirroring walletFailed.
+    expect(rejected.error).toEqual({
+      type: 'rejected',
+      message: 'User rejected the request'
+    })
 
     const failed = normalizeEvent(
       'walletFailed',
@@ -352,6 +358,48 @@ describe('normalizeEvent', () => {
     expect(failed.source).toBe('unknown')
   })
 
+  it('scrubs a PII address out of the walletRejected error message on egress', () => {
+    const addr = '0x' + 'a'.repeat(40)
+    const out = normalizeEvent(
+      'walletRejected',
+      {
+        handoffId: 'h-1',
+        operation: 'connect',
+        durationMs: 5,
+        error: { type: 'rejected', message: `declined for ${addr}` },
+        connectionMode: 'injected',
+        timedOut: false,
+        failureKind: 'user_rejected',
+        source: 'provider'
+      },
+      SDK_SESSION,
+      NOW
+    )
+    expect(out.error?.message).not.toContain(addr)
+    expect(out.error?.message).toContain('[redacted-hex]')
+  })
+
+  it('maps a walletRejected without error to error:undefined (optional field, no throw)', () => {
+    // `error` is optional on the exported walletRejected type; the mapping must
+    // not assume it. Guards against a regression if a caller omits it.
+    const out = normalizeEvent(
+      'walletRejected',
+      {
+        handoffId: 'h-1',
+        operation: 'connect',
+        durationMs: 5,
+        connectionMode: 'injected',
+        timedOut: false,
+        failureKind: 'user_rejected',
+        source: 'provider'
+      },
+      SDK_SESSION,
+      NOW
+    )
+    expect(out.error).toBeUndefined()
+    expect(out.failureKind).toBe('user_rejected')
+  })
+
   it('summarizes capabilitiesUpdated to per-chain supported feature names', () => {
     const out = normalizeEvent(
       'capabilitiesUpdated',
@@ -433,6 +481,26 @@ describe('normalizeEvent', () => {
     expect(out.error?.message).toBe('bridge unreachable')
   })
 
+  it('carries injectedId + legacyInjected for secondarySolanaConnectSkipped, length-capped (ONC-3536)', () => {
+    const out = normalizeEvent(
+      'secondarySolanaConnectSkipped',
+      { injectedId: 'coinbaseSolana', legacyInjected: true },
+      SDK_SESSION,
+      NOW
+    )
+    expect(out.injectedId).toBe('coinbaseSolana')
+    expect(out.legacyInjected).toBe(true)
+
+    const capped = normalizeEvent(
+      'secondarySolanaConnectSkipped',
+      { injectedId: 'x'.repeat(200), legacyInjected: false },
+      SDK_SESSION,
+      NOW
+    )
+    expect(capped.injectedId).toHaveLength(64)
+    expect(capped.legacyInjected).toBe(false)
+  })
+
   it('normalizes lifecycle events with routing only, no address (P2)', () => {
     const acct = normalizeEvent(
       'walletAccountChanged',

package/src/observability/telemetry.ts

@@ -31,6 +31,9 @@ export const TELEMETRY_SCHEMA_VERSION = 1
 const MAX_NETWORK_MISMATCH_IDS = 20
 const MAX_NETWORK_ID_LENGTH = 64
 
+/** Egress cap for `injectedId` (a catalog-metadata window-global key). */
+const MAX_INJECTED_ID_LENGTH = 64
+
 function capNetworkMismatch(
   mismatch:
     | { walletNetworkIds: string[]; configuredNetworkIds: string[] }
@@ -125,9 +128,16 @@ export interface UWCTelemetryEvent {
   capabilities?: Record<string, string[]> | undefined
   /**
    * Per-namespace requested-vs-matched discovery summary, present only on
-   * `walletsDetected`. Counts only — never a wallet id or address.
+   * `walletsDetected`. Counts only — never a wallet id or address. `legacyInjected`
+   * (solana-only) counts matched wallets found via the legacy injected-Solana
+   * fallback rather than the Wallet Standard registry (MFS-805); omitted when 0.
    */
-  discovery?: Record<string, { requested: number; matched: number }> | undefined
+  discovery?:
+    | Record<
+        string,
+        { requested: number; matched: number; legacyInjected?: number }
+      >
+    | undefined
   /**
    * Per-namespace count of the session's available addresses, present on
    * `connected` / `sessionChanged`. Counts only — never an address.
@@ -162,6 +172,19 @@ export interface UWCTelemetryEvent {
   backgroundCount?: number | undefined
   /** Handoff terminals, WalletConnect only: relay-socket drops seen while the handoff was pending. */
   relayDropCount?: number | undefined
+  /**
+   * `secondarySolanaConnectSkipped` only: the `solana.injectedId` metadata key
+   * whose framed secondary gather was suppressed (e.g. `coinbaseSolana`) —
+   * a consumer-configured metadata key, never an address. Length-capped as
+   * defense-in-depth since the value originates in catalog metadata.
+   */
+  injectedId?: string | undefined
+  /**
+   * `secondarySolanaConnectSkipped` only: true when the skipped wallet was
+   * discovered via the legacy injected-Solana fallback (true "Legacy mode")
+   * rather than the Wallet Standard registry.
+   */
+  legacyInjected?: boolean | undefined
 }
 
 /**
@@ -393,6 +416,9 @@ function buildTelemetryEvent<K extends UWCEventName>(
         errorCode: d.errorCode,
         failureKind: d.failureKind,
         source: d.source,
+        error: d.error
+          ? { type: d.error.type, message: scrubMessage(d.error.message) }
+          : undefined,
         backgroundedMs: d.backgroundedMs,
         backgroundCount: d.backgroundCount,
         relayDropCount: d.relayDropCount
@@ -466,6 +492,14 @@ function buildTelemetryEvent<K extends UWCEventName>(
         error: { type: d.error.type, message: scrubMessage(d.error.message) }
       }
     }
+    case 'secondarySolanaConnectSkipped': {
+      const d = data as UWCEventMap['secondarySolanaConnectSkipped']
+      return {
+        ...base,
+        injectedId: d.injectedId.slice(0, MAX_INJECTED_ID_LENGTH),
+        legacyInjected: d.legacyInjected
+      }
+    }
     case 'pageHiddenDuringHandoff':
     case 'pageVisibleDuringHandoff': {
       // Cast to the visible shape (superset). `hiddenMs` is absent on the hidden

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

@@ -539,6 +539,118 @@ describe('UniversalWalletConnector — observability wiring', () => {
     expect(detected.discovery).toEqual({ eip155: { requested: 1, matched: 0 } })
   })
 
+  it('matches a Solana wallet by the in-wallet provider name when usingIntegratedBrowser (ONC-3536)', async () => {
+    // Regression guard for the Coinbase/Base legacy fallback: the extension and
+    // in-wallet Solana names differ ("Base Wallet" vs "Base"). With
+    // usingIntegratedBrowser, core must match the DISCOVERED name against the
+    // in-wallet provider — matching the extension name would miss (matched: 0).
+    const SOL_ID = 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'
+    getAvailableWalletsMock.mockImplementation((ns: string) =>
+      Promise.resolve(
+        ns === 'solana' ? [{ uuid: 'sol-1', name: 'Base', features: [] }] : []
+      )
+    )
+    const wallet = {
+      id: 'coinbase',
+      name: 'Base Wallet',
+      extensionInjectedProvider: {
+        supportedNetworkIds: [SOL_ID],
+        namespaceMetaData: {
+          solana: {
+            walletStandardName: 'Base Wallet',
+            injectedId: 'coinbaseSolana'
+          }
+        }
+      },
+      integratedBrowserInjectedProvider: {
+        supportedNetworkIds: [SOL_ID],
+        namespaceMetaData: {
+          solana: { walletStandardName: 'Base', injectedId: 'coinbaseSolana' }
+        }
+      }
+    } as unknown as WalletMetadata
+
+    const events: UWCTelemetryEvent[] = []
+    let resolveReady!: () => void
+    const ready = new Promise<void>(r => (resolveReady = r))
+    new UniversalWalletConnector({
+      networks,
+      wallets: [wallet],
+      usingIntegratedBrowser: true,
+      observer: {
+        onEvent: e => {
+          events.push(e)
+          if (e.name === 'ready') resolveReady()
+        }
+      }
+    })
+    await ready
+
+    const detected = events.find(e => e.name === 'walletsDetected')!
+    expect(detected.discovery).toEqual({ solana: { requested: 1, matched: 1 } })
+  })
+
+  it('walletsDetected discovery.solana counts legacyInjected for the fallback path (MFS-805)', async () => {
+    // A solana wallet detected via the legacy injected fallback (window-global)
+    // carries legacyInjected — the summary must surface that count so a dashboard
+    // can confirm the legacy path (not the Wallet Standard registry) was used.
+    const SOL_ID = 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'
+    getAvailableWalletsMock.mockImplementation((ns: string) =>
+      Promise.resolve(
+        ns === 'solana'
+          ? [
+              {
+                uuid: 'sol-1',
+                name: 'Base',
+                features: [],
+                legacyInjected: true
+              }
+            ]
+          : []
+      )
+    )
+    const wallet = {
+      id: 'coinbase',
+      name: 'Base Wallet',
+      extensionInjectedProvider: {
+        supportedNetworkIds: [SOL_ID],
+        namespaceMetaData: {
+          solana: {
+            walletStandardName: 'Base Wallet',
+            injectedId: 'coinbaseSolana'
+          }
+        }
+      },
+      integratedBrowserInjectedProvider: {
+        supportedNetworkIds: [SOL_ID],
+        namespaceMetaData: {
+          solana: { walletStandardName: 'Base', injectedId: 'coinbaseSolana' }
+        }
+      }
+    } as unknown as WalletMetadata
+
+    const events: UWCTelemetryEvent[] = []
+    let resolveReady!: () => void
+    const ready = new Promise<void>(r => (resolveReady = r))
+    new UniversalWalletConnector({
+      networks,
+      wallets: [wallet],
+      usingIntegratedBrowser: true,
+      observer: {
+        onEvent: e => {
+          events.push(e)
+          if (e.name === 'ready') resolveReady()
+        }
+      }
+    })
+    await ready
+
+    const detected = events.find(e => e.name === 'walletsDetected')!
+    expect(detected.discovery).toEqual({
+      solana: { requested: 1, matched: 1, legacyInjected: 1 }
+    })
+  })
+
   it('a missing provider fails BEFORE the funnel — config error, not a wallet outcome', async () => {
     // Design parity with connect/switch: provider resolution is validation, so
     // its failure must surface only via the `error` event, never as an

package/src/universal-wallet-connector.solana-legacy-e2e.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import type { Network, WalletMetadata } from '@meshconnect/uwc-types'
+import { solanaNetwork } from '@meshconnect/uwc-constants'
+import { UniversalWalletConnector } from './universal-wallet-connector'
+import type { UWCObserver, UWCTelemetryEvent } from './observability/telemetry'
+
+// End-to-end seam test (ONC-3536 review): the other observability tests stub
+// `getAvailableWallets`, so they prove discovery EMITS a synthetic entry but not
+// that core actually MATCHES it. Here the real `InjectedConnector` +
+// `getSolanaWallets` run — only the non-injected connectors are stubbed (they'd
+// otherwise attempt real WC/TON init) and the Wallet Standard registry is mocked
+// empty so the legacy window-global path is the one exercised.
+//
+// `discovery.solana.matched` counts wallets marked `installed`, and `installed`
+// is set ONLY by core's `applyDetectedWallet` when the discovered name matches
+// the session provider's `walletStandardName`. So `matched: 1` here IS proof
+// that the real discovery output flowed through core detection and matched.
+vi.mock('@meshconnect/uwc-wallet-connect-connector', () => ({
+  WalletConnectConnector: vi.fn().mockImplementation(() => ({
+    getAvailableWallets: vi.fn().mockResolvedValue([])
+  }))
+}))
+vi.mock('@meshconnect/uwc-ton-connector', () => ({
+  TonConnectConnector: vi.fn().mockImplementation(() => ({
+    getAvailableWallets: vi.fn().mockResolvedValue([])
+  }))
+}))
+// Empty Wallet Standard registry → forces the legacy `window[injectedId]` path.
+vi.mock('@wallet-standard/app', () => ({
+  getWallets: () => ({ get: () => [], on: () => () => {} })
+}))
+
+const SOL_ID = solanaNetwork.id
+const networks = [solanaNetwork] as unknown as Network[]
+
+// A minimal but VALID legacy injected-Solana provider — all 8 methods the real
+// `isLegacyInjectedSolanaProvider` duck-type check requires, so
+// `window.coinbaseSolana` is accepted by the real adapter.
+function makeLegacyProvider() {
+  return {
+    connect: vi.fn(),
+    disconnect: vi.fn(),
+    on: vi.fn(),
+    off: vi.fn(),
+    signTransaction: vi.fn(),
+    signAllTransactions: vi.fn(),
+    signMessage: vi.fn(),
+    signAndSendTransaction: vi.fn()
+  }
+}
+
+describe('UWC — legacy injected-Solana discovery → core match (end-to-end)', () => {
+  beforeEach(() => {
+    UniversalWalletConnector.resetInstance()
+    ;(window as unknown as Record<string, unknown>).coinbaseSolana =
+      makeLegacyProvider()
+  })
+  afterEach(() => {
+    delete (window as unknown as Record<string, unknown>).coinbaseSolana
+  })
+
+  it('matches the real synthetic entry end-to-end and reports legacyInjected:1', async () => {
+    // In-wallet browser session: the solana block lives on the integrated
+    // provider ("Base"), exactly what core's pickProvider reads.
+    const wallet = {
+      id: 'coinbase',
+      name: 'Base Wallet',
+      integratedBrowserInjectedProvider: {
+        supportedNetworkIds: [SOL_ID],
+        namespaceMetaData: {
+          solana: { walletStandardName: 'Base', injectedId: 'coinbaseSolana' }
+        }
+      }
+    } as unknown as WalletMetadata
+
+    const events: UWCTelemetryEvent[] = []
+    let resolveReady!: () => void
+    const ready = new Promise<void>(r => (resolveReady = r))
+    const observer: UWCObserver = {
+      onEvent: e => {
+        events.push(e)
+        if (e.name === 'ready') resolveReady()
+      }
+    }
+
+    new UniversalWalletConnector({
+      networks,
+      wallets: [wallet],
+      usingIntegratedBrowser: true,
+      observer
+    })
+    await ready
+
+    const detected = events.find(e => e.name === 'walletsDetected')!
+    // matched:1 ⇒ core matched the real getSolanaWallets() output and marked it
+    // installed; legacyInjected:1 ⇒ it came via the window-global fallback.
+    expect(detected.discovery).toEqual({
+      solana: { requested: 1, matched: 1, legacyInjected: 1 }
+    })
+  })
+
+  it('does NOT match when the legacy global is absent (fail-closed)', async () => {
+    delete (window as unknown as Record<string, unknown>).coinbaseSolana
+
+    const wallet = {
+      id: 'coinbase',
+      name: 'Base Wallet',
+      integratedBrowserInjectedProvider: {
+        supportedNetworkIds: [SOL_ID],
+        namespaceMetaData: {
+          solana: { walletStandardName: 'Base', injectedId: 'coinbaseSolana' }
+        }
+      }
+    } as unknown as WalletMetadata
+
+    const events: UWCTelemetryEvent[] = []
+    let resolveReady!: () => void
+    const ready = new Promise<void>(r => (resolveReady = r))
+    new UniversalWalletConnector({
+      networks,
+      wallets: [wallet],
+      usingIntegratedBrowser: true,
+      observer: {
+        onEvent: e => {
+          events.push(e)
+          if (e.name === 'ready') resolveReady()
+        }
+      }
+    })
+    await ready
+
+    const detected = events.find(e => e.name === 'walletsDetected')!
+    // No global → no synthetic entry → not installed → legacyInjected omitted.
+    expect(detected.discovery).toEqual({ solana: { requested: 1, matched: 0 } })
+  })
+})

package/src/universal-wallet-connector.ts

@@ -284,20 +284,38 @@ export class UniversalWalletConnector {
 
     // Initialize connectors with RPC map
     this.connectors = new Map()
-    this.injectedConnector = new InjectedConnector(
-      this.networkRpcMap,
-      this.wallets,
-      configuredTonConnectConfig,
-      configuredTronConnectorConfig,
+    this.injectedConnector = new InjectedConnector({
+      networkRpcMap: this.networkRpcMap,
+      expectedWallets: this.wallets,
+      tonConnectConfig: configuredTonConnectConfig,
+      tronConnectorConfig: configuredTronConnectorConfig,
       networks,
       // Surface BridgeChild discovery failures (the Bitstarz "wallet never
       // appeared via the bridge" class) as a telemetry event.
-      info =>
+      onBridgeError: info =>
         this.eventManager.emit('bridgeError', {
           namespace: info.namespace as Namespace,
           error: { type: 'unknown', message: info.message }
-        })
-    )
+        }),
+      usingIntegratedBrowser: this.usingIntegratedBrowser,
+      // A configured legacy injected-Solana global is present but the wrong shape
+      // (the wallet changed its provider) — surface as a discovery failure so the
+      // otherwise-silent breakage is observable in prod telemetry.
+      onLegacyDiscoveryFailure: info =>
+        this.eventManager.emit('walletDiscoveryFailed', {
+          namespace: 'solana',
+          connectionMode: 'injected',
+          error: {
+            type: 'unknown',
+            message: `legacy injected-Solana provider at "${info.injectedId}" for ${info.walletName} is not a valid Solana provider`
+          }
+        }),
+      // Triage telemetry (ONC-3536 follow-up): the framed secondary Solana
+      // gather was suppressed for a legacy-`injectedId` wallet so an EVM send
+      // can't be parked on the Solana namespace (Coinbase Legacy-mode hang).
+      onSecondarySolanaConnectSkipped: info =>
+        this.eventManager.emit('secondarySolanaConnectSkipped', info)
+    })
     this.connectors.set('injected', this.injectedConnector)
 
     if (configuredTonConnectConfig) {
@@ -576,7 +594,12 @@ export class UniversalWalletConnector {
       m.detectedWallet = {
         uuid: d.uuid,
         name: d.name,
-        features: d.features
+        features: d.features,
+        // Preserve which discovery path matched (registry vs legacy injected
+        // fallback) so summarizeDiscovery can report it (MFS-805).
+        ...(d.legacyInjected !== undefined && {
+          legacyInjected: d.legacyInjected
+        })
       }
     } else if (namespace === 'tron') {
       const m = nsMetadata as {
@@ -610,25 +633,45 @@ export class UniversalWalletConnector {
    */
   private summarizeDiscovery(
     namespaces: Set<string>
-  ): Record<string, { requested: number; matched: number }> {
+  ): Record<
+    string,
+    { requested: number; matched: number; legacyInjected?: number }
+  > {
     const pickProvider = (w: WalletMetadata) =>
       this.usingIntegratedBrowser
         ? w.integratedBrowserInjectedProvider
         : w.extensionInjectedProvider
 
-    const summary: Record<string, { requested: number; matched: number }> = {}
+    const summary: Record<
+      string,
+      { requested: number; matched: number; legacyInjected?: number }
+    > = {}
     for (const namespace of namespaces) {
       let requested = 0
       let matched = 0
+      // How many matched wallets came from the legacy injected-Solana fallback
+      // rather than the Wallet Standard registry (MFS-805). Solana-only in
+      // practice; other namespaces never set the flag, so it stays 0/omitted.
+      let legacyInjected = 0
       for (const wallet of this.wallets) {
         const nsMeta = pickProvider(wallet)?.namespaceMetaData?.[
           namespace as Namespace
-        ] as { installed?: boolean } | undefined
+        ] as
+          | {
+              installed?: boolean
+              detectedWallet?: { legacyInjected?: boolean }
+            }
+          | undefined
         if (!nsMeta) continue
         requested++
         if (nsMeta.installed) matched++
+        if (nsMeta.detectedWallet?.legacyInjected) legacyInjected++
+      }
+      summary[namespace] = {
+        requested,
+        matched,
+        ...(legacyInjected > 0 && { legacyInjected })
       }
-      summary[namespace] = { requested, matched }
     }
     return summary
   }