@meshconnect/uwc-core 1.7.0 → 1.9.0-snapshot.66a45b0

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

@@ -8,7 +8,41 @@ import type { SessionManager } from '../managers/session-manager'
 import type { EventManager } from '../managers/event-manager'
 import type { ServiceOptions } from './connection-service'
 
+/**
+ * How long an EMPTY capabilities result is served from cache before a re-fetch
+ * is allowed. Empty is ambiguous: it means either "wallet doesn't support
+ * wallet_getCapabilities" (stable — could be cached forever) or "the fetch
+ * failed/timed out" (transient — caching it forever would freeze capabilities
+ * at {} for the whole session). A short TTL serves both: repeat UI triggers
+ * stay coalesced/cached in the window that matters, while a transient failure
+ * self-heals on a later trigger. Non-empty results don't expire — a wallet's
+ * capability surface doesn't change mid-session.
+ */
+const EMPTY_RESULT_RETRY_MS = 30_000
+
 export class WalletCapabilitiesService {
+  /**
+   * In-flight `connector.getWalletCapabilities` promise per cache key, so
+   * concurrent callers share ONE wallet RPC instead of each issuing their own.
+   * Why this matters: consumers commonly trigger a capabilities fetch from UI
+   * state (per rendered component, per session change), fanning N identical
+   * calls at once. MetaMask processes `wallet_getCapabilities` slowly (~1s
+   * each, observed) AND serializes dapp requests behind it, so an uncoalesced
+   * flood queues for ~10s and delays every subsequent RPC — measured as a 5s+
+   * `eth_accounts` stall on reconnect. The connector-level 3s timeout doesn't
+   * help: racing past a request can't cancel it wallet-side.
+   */
+  private readonly inFlightFetches = new Map<
+    string,
+    Promise<Record<string, EVMCapabilities>>
+  >()
+
+  /** Settled results per cache key; empty results expire (see EMPTY_RESULT_RETRY_MS). */
+  private readonly resultCache = new Map<
+    string,
+    { capabilities: Record<string, EVMCapabilities>; fetchedAt: number }
+  >()
+
   constructor(
     private networks: Network[],
     private connectors: Map<ConnectionMode, Connector>,
@@ -16,6 +50,65 @@ export class WalletCapabilitiesService {
     private eventManager: EventManager
   ) {}
 
+  /**
+   * Fetch capabilities through the coalescing/caching layer. The key includes
+   * the connection mode, the active wallet id, and the address, so switching
+   * wallet, account, or mode naturally misses the cache — the wallet id
+   * matters because the same address can live in two different wallets (one
+   * seed imported into both), whose capability surfaces differ; `networks` is
+   * constructor-fixed and needs no key part. The result promise never
+   * rejects — failures resolve to {} (preserving the previous inline
+   * behavior), which also guarantees in-flight cleanup runs.
+   *
+   * `source` reports how THIS caller was served (`cache` / `inflight` /
+   * `rpc`) and rides the `capabilitiesUpdated` emit — the prod signal that
+   * the coalescing layer works (a flood should show one `rpc` and N-1
+   * `inflight`/`cache` records, not N slow `rpc`s).
+   */
+  private fetchCapabilities(
+    connectionMode: ConnectionMode,
+    walletId: string | undefined,
+    fetch: () => Promise<Record<string, EVMCapabilities>>,
+    address: string
+  ): {
+    source: 'cache' | 'inflight' | 'rpc'
+    result: Promise<Record<string, EVMCapabilities>>
+  } {
+    const key = `${connectionMode}:${walletId ?? ''}:${address.toLowerCase()}`
+
+    const cached = this.resultCache.get(key)
+    if (cached) {
+      const isEmpty = Object.keys(cached.capabilities).length === 0
+      if (!isEmpty || Date.now() - cached.fetchedAt < EMPTY_RESULT_RETRY_MS) {
+        return { source: 'cache', result: Promise.resolve(cached.capabilities) }
+      }
+      // Empty and past its retry window — fall through to a fresh fetch.
+    }
+
+    const pending = this.inFlightFetches.get(key)
+    if (pending) {
+      return { source: 'inflight', result: pending }
+    }
+
+    const fetchPromise = (async () => {
+      try {
+        return await fetch()
+      } catch {
+        return {}
+      }
+    })()
+      .then(capabilities => {
+        this.resultCache.set(key, { capabilities, fetchedAt: Date.now() })
+        return capabilities
+      })
+      .finally(() => {
+        this.inFlightFetches.delete(key)
+      })
+
+    this.inFlightFetches.set(key, fetchPromise)
+    return { source: 'rpc', result: fetchPromise }
+  }
+
   async getWalletCapabilities(
     address: string,
     activeNetwork?: Network,
@@ -43,15 +136,17 @@ export class WalletCapabilitiesService {
       activeConnector &&
       typeof activeConnector.getWalletCapabilities === 'function'
     ) {
-      let capabilities: Record<string, EVMCapabilities>
-      try {
-        capabilities = await activeConnector.getWalletCapabilities(
-          address,
-          this.networks
-        )
-      } catch {
-        capabilities = {}
-      }
+      const fetchStarted = Date.now()
+      const { source, result } = this.fetchCapabilities(
+        session.connectionMode,
+        session.activeWallet?.id,
+        () => activeConnector.getWalletCapabilities!(address, this.networks),
+        address
+      )
+      const capabilities = await result
+      // THIS caller's wait — for an 'inflight' join that's the remaining RPC
+      // time, for 'cache' ~0, for 'rpc' the full wallet round-trip.
+      const durationMs = Date.now() - fetchStarted
 
       options?.signal?.throwIfAborted()
 
@@ -79,7 +174,9 @@ export class WalletCapabilitiesService {
       }
 
       this.eventManager.emit('capabilitiesUpdated', {
-        capabilities: activeWalletCapabilities
+        capabilities: activeWalletCapabilities,
+        source,
+        durationMs
       })
       this.eventManager.emit('sessionChanged', {
         session: this.sessionManager.getSession()

package/src/universal-wallet-connector.ts

@@ -309,7 +309,22 @@ export class UniversalWalletConnector {
             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 secondary Solana gather
+      // gate was active for a legacy-`injectedId` wallet inside the wallet's
+      // own browser (framed embed or top-level in-app / dapp deep-link flow)
+      // so an EVM send can't be parked on the Solana namespace (Coinbase
+      // Legacy-mode hang).
+      onSecondarySolanaConnectSkipped: info =>
+        this.eventManager.emit('secondarySolanaConnectSkipped', info),
+      // Positive counterpart (ONC-231): a legacy-`injectedId` wallet's secondary
+      // Solana address WAS gathered — confirms the framed gather works.
+      onSecondarySolanaConnectGathered: info =>
+        this.eventManager.emit('secondarySolanaConnectGathered', info),
+      // The wallet-switch guard released a different wallet's live state —
+      // surface it so the otherwise-silent release is observable in prod.
+      onWalletConnectionsReleased: info =>
+        this.eventManager.emit('walletConnectionsReleased', info)
     })
     this.connectors.set('injected', this.injectedConnector)
 

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 = '1.7.0'
+export const UWC_CORE_VERSION = '1.9.0'