@meshconnect/uwc-core 1.2.3-snapshot.bd9aae7 → 1.2.3-snapshot.dcfdbbf

package/src/observability/focus-tracker.test.ts

@@ -88,57 +88,17 @@ describe('trackFocusDuringHandoff', () => {
 
     const { doc, fire } = makeFakeDoc()
     const { win } = makeFakeWin()
-    let t = 1000
-    trackFocusDuringHandoff(em, 'h-1', 'mobile', doc, win, () => t)
+    trackFocusDuringHandoff(em, 'h-1', 'mobile', doc, win)
 
     doc.visibilityState = 'hidden'
     doc.hidden = true
-    fire('visibilitychange') // hidden at t=1000
-    t = 1700
-    doc.visibilityState = 'visible'
-    doc.hidden = false
-    fire('visibilitychange') // visible at t=1700 → 700ms hidden
-
-    expect(hidden).toEqual([{ handoffId: 'h-1', platform: 'mobile' }])
-    expect(visible).toEqual([
-      { handoffId: 'h-1', platform: 'mobile', hiddenMs: 700 }
-    ])
-  })
-
-  it('summary() reports background count + cumulative hidden time, including an open segment', () => {
-    const em = new EventManager()
-    const { doc, fire } = makeFakeDoc()
-    let t = 0
-    const tracker = trackFocusDuringHandoff(
-      em,
-      'h-sum',
-      'mobile',
-      doc,
-      undefined,
-      () => t
-    )
-
-    // First hide→show: 100 → 600 = 500ms hidden.
-    t = 100
-    doc.visibilityState = 'hidden'
     fire('visibilitychange')
-    t = 600
     doc.visibilityState = 'visible'
+    doc.hidden = false
     fire('visibilitychange')
-    expect(tracker.summary()).toEqual({
-      backgroundCount: 1,
-      backgroundedMs: 500
-    })
 
-    // Second hide, still hidden when summary() runs at t=1000 → +200 open segment.
-    t = 800
-    doc.visibilityState = 'hidden'
-    fire('visibilitychange')
-    t = 1000
-    expect(tracker.summary()).toEqual({
-      backgroundCount: 2,
-      backgroundedMs: 700
-    })
+    expect(hidden).toEqual([{ handoffId: 'h-1', platform: 'mobile' }])
+    expect(visible).toEqual([{ handoffId: 'h-1', platform: 'mobile' }])
   })
 
   it('treats a bfcache pageshow ON THE WINDOW as a "returned" signal', () => {
@@ -177,13 +137,7 @@ describe('trackFocusDuringHandoff', () => {
     em.on('pageVisibleDuringHandoff', e => visible.push(e))
 
     const { win, fire } = makeFakeWin()
-    const { stop } = trackFocusDuringHandoff(
-      em,
-      'h-2c',
-      'mobile',
-      undefined,
-      win
-    )
+    const stop = trackFocusDuringHandoff(em, 'h-2c', 'mobile', undefined, win)
     fire('pageshow')
 
     expect(visible).toEqual([{ handoffId: 'h-2c', platform: 'mobile' }])
@@ -196,13 +150,7 @@ describe('trackFocusDuringHandoff', () => {
     em.on('pageHiddenDuringHandoff', e => hidden.push(e))
 
     const { doc, fire } = makeFakeDoc()
-    const { stop } = trackFocusDuringHandoff(
-      em,
-      'h-2d',
-      'desktop',
-      doc,
-      undefined
-    )
+    const stop = trackFocusDuringHandoff(em, 'h-2d', 'desktop', doc, undefined)
     doc.visibilityState = 'hidden'
     fire('visibilitychange')
 
@@ -218,7 +166,7 @@ describe('trackFocusDuringHandoff', () => {
 
     const { doc, fire: fireDoc } = makeFakeDoc()
     const { win, listeners: winListeners, fire: fireWin } = makeFakeWin()
-    const { stop } = trackFocusDuringHandoff(em, 'h-3', 'desktop', doc, win)
+    const stop = trackFocusDuringHandoff(em, 'h-3', 'desktop', doc, win)
     stop()
 
     doc.visibilityState = 'hidden'
@@ -231,7 +179,7 @@ describe('trackFocusDuringHandoff', () => {
 
   it('is a no-op (no throw) when there is neither document nor window (SSR)', () => {
     const em = new EventManager()
-    const { stop } = trackFocusDuringHandoff(
+    const stop = trackFocusDuringHandoff(
       em,
       'h-4',
       'unknown',

package/src/observability/focus-tracker.ts

@@ -35,52 +35,30 @@ function resolveWindow(): FocusWindowLike | undefined {
   return win && typeof win.addEventListener === 'function' ? win : undefined
 }
 
-/** Handle returned by `trackFocusDuringHandoff`. */
-export interface FocusHandoffTracker {
-  /** Remove the visibility listeners. Always call on settle (no-op if none attached). */
-  stop: () => void
-  /**
-   * Backgrounding summary at call time: how many times the page was hidden and the
-   * cumulative hidden duration (ms) during the handoff — including an in-progress
-   * hidden segment if the handoff settles while still backgrounded.
-   */
-  summary: () => { backgroundCount: number; backgroundedMs: number }
-}
-
 /**
  * While a wallet handoff is pending, emit a FACT on every tab-visibility
  * transition — `pageHiddenDuringHandoff` when the page is backgrounded (the user
- * likely left for the wallet app), `pageVisibleDuringHandoff` (with the segment's
- * `hiddenMs`) when it returns (including a bfcache `pageshow`, which iOS uses when
- * coming back from a wallet).
+ * likely left for the wallet app), `pageVisibleDuringHandoff` when it returns
+ * (including a bfcache `pageshow`, which iOS uses when coming back from a wallet).
+ *
+ * This is the raw signal behind "did the user actually app-switch to the wallet?"
+ * for deep-link flows — it does NOT interpret abandonment. The listeners are
+ * scoped to the single handoff: attach right after `awaitingWallet`, and the
+ * returned teardown (called the instant the op settles) removes them, so the
+ * page's visibility is only observed during the blind window. SSR-safe (no-op
+ * when there is neither `document` nor `window`).
  *
- * This is the raw signal behind "did the user actually app-switch to the wallet,
- * and for how long?" for deep-link flows — it does NOT interpret abandonment. The
- * listeners are scoped to the single handoff: attach right after `awaitingWallet`,
- * and `stop()` (called the instant the op settles) removes them, so the page's
- * visibility is only observed during the blind window. SSR-safe (no-op when there
- * is neither `document` nor `window`). `summary()` lets the handoff stamp the
- * cumulative backgrounding onto its terminal.
+ * @returns a teardown that removes the listeners. Always call it (even when
+ *   nothing was attached — it's a no-op then) to keep the call site symmetric.
  */
 export function trackFocusDuringHandoff(
   eventManager: EventManager,
   handoffId: string,
   platform: Platform,
   doc: FocusDocumentLike | undefined = resolveDocument(),
-  win: FocusWindowLike | undefined = resolveWindow(),
-  now: () => number = Date.now
-): FocusHandoffTracker {
-  let backgroundCount = 0
-  let totalHiddenMs = 0
-  let hiddenSince: number | undefined
-
-  const summary = (): { backgroundCount: number; backgroundedMs: number } => ({
-    backgroundCount,
-    backgroundedMs:
-      totalHiddenMs + (hiddenSince !== undefined ? now() - hiddenSince : 0)
-  })
-
-  if (!doc && !win) return { stop: () => {}, summary }
+  win: FocusWindowLike | undefined = resolveWindow()
+): () => void {
+  if (!doc && !win) return () => {}
 
   // One physical return can fire BOTH `pageshow` (window) and a
   // `visibilitychange`→visible (document) — an iOS bfcache restore does. Dedupe
@@ -89,23 +67,12 @@ export function trackFocusDuringHandoff(
   const emitState = (state: 'hidden' | 'visible') => {
     if (state === lastState) return
     lastState = state
-    if (state === 'hidden') {
-      hiddenSince = now()
-      backgroundCount++
-      eventManager.emit('pageHiddenDuringHandoff', { handoffId, platform })
-      return
-    }
-    let hiddenMs: number | undefined
-    if (hiddenSince !== undefined) {
-      hiddenMs = now() - hiddenSince
-      totalHiddenMs += hiddenMs
-      hiddenSince = undefined
-    }
-    eventManager.emit('pageVisibleDuringHandoff', {
-      handoffId,
-      platform,
-      ...(hiddenMs !== undefined ? { hiddenMs } : {})
-    })
+    eventManager.emit(
+      state === 'hidden'
+        ? 'pageHiddenDuringHandoff'
+        : 'pageVisibleDuringHandoff',
+      { handoffId, platform }
+    )
   }
 
   const onVisibility = () => {
@@ -122,11 +89,8 @@ export function trackFocusDuringHandoff(
   doc?.addEventListener('visibilitychange', onVisibility)
   win?.addEventListener('pageshow', onPageShow)
 
-  return {
-    stop: () => {
-      doc?.removeEventListener('visibilitychange', onVisibility)
-      win?.removeEventListener('pageshow', onPageShow)
-    },
-    summary
+  return () => {
+    doc?.removeEventListener('visibilitychange', onVisibility)
+    win?.removeEventListener('pageshow', onPageShow)
   }
 }

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

@@ -47,48 +47,6 @@ describe('instrumentHandoff', () => {
     expect(end.timedOut).toBe(false)
   })
 
-  it('counts relay-socket drops seen during the handoff onto the terminal', async () => {
-    const em = new EventManager()
-    const seen = record(em)
-    const wcCtx: HandoffContext = { ...CTX, connectionMode: 'walletConnect' }
-    await instrumentHandoff(
-      { eventManager: em, timeoutMs: 0 },
-      wcCtx,
-      async () => {
-        // The relay socket drops (and recovers) while the sign request is pending.
-        em.emit('relayDisconnected', {})
-        em.emit('relayReconnected', undefined)
-        em.emit('relayDisconnected', {})
-        return 'sig'
-      }
-    )
-    const end = seen.find(s => s.name === 'walletSucceeded')?.data as {
-      relayDropCount: number
-      backgroundCount: number
-      backgroundedMs: number
-    }
-    expect(end.relayDropCount).toBe(2)
-    // No backgrounding occurred in this test runtime.
-    expect(end.backgroundCount).toBe(0)
-    expect(end.backgroundedMs).toBe(0)
-  })
-
-  it('stops counting relay drops once the handoff settles', async () => {
-    const em = new EventManager()
-    const seen = record(em)
-    await instrumentHandoff(
-      { eventManager: em, timeoutMs: 0 },
-      CTX,
-      async () => 'sig'
-    )
-    // A drop after settle must be ignored (listener removed) and never throw.
-    expect(() => em.emit('relayDisconnected', {})).not.toThrow()
-    const end = seen.find(s => s.name === 'walletSucceeded')?.data as {
-      relayDropCount: number
-    }
-    expect(end.relayDropCount).toBe(0)
-  })
-
   it('carries targetAlreadyActive through awaitingWallet and the terminal', async () => {
     const em = new EventManager()
     const seen = record(em)

package/src/observability/instrument-handoff.ts

@@ -141,22 +141,7 @@ export async function instrumentHandoff<T>(
   // Observe page-visibility transitions ONLY while this handoff is pending — the
   // app-switch signal for deep-link flows (left for the wallet / came back). The
   // teardown in `finally` removes the listeners the instant the op settles.
-  const focus = trackFocusDuringHandoff(eventManager, handoffId, platform)
-
-  // Count relay-socket drops seen while this handoff is pending — the WC relay
-  // emits `relayDisconnected` on the same bus. Lets a terminal say "recovered
-  // after N drops" (the 88s suspend→reconnect case) without a cross-event join.
-  let relayDropCount = 0
-  const offRelayDrop = eventManager.on('relayDisconnected', () => {
-    relayDropCount++
-  })
-
-  // Backgrounding + relay-drop summary, snapshotted onto each terminal so ONE
-  // event answers "backgrounded? how long? socket dropped? recovered?".
-  const handoffMetrics = () => {
-    const { backgroundCount, backgroundedMs } = focus.summary()
-    return { backgroundedMs, backgroundCount, relayDropCount }
-  }
+  const stopFocus = trackFocusDuringHandoff(eventManager, handoffId, platform)
 
   // Same routing facets as `awaitingWallet` so every terminal is self-describing
   // (no handoffId self-join needed to know which wallet / chain / mode it closed).
@@ -179,8 +164,7 @@ export async function instrumentHandoff<T>(
           operation: context.operation,
           durationMs: now() - start,
           timeoutMs,
-          ...routing,
-          ...handoffMetrics()
+          ...routing
         })
       }, timeoutMs)
     : undefined
@@ -193,8 +177,7 @@ export async function instrumentHandoff<T>(
       durationMs: now() - start,
       timedOut,
       timeoutMs: timedOut ? timeoutMs : undefined,
-      ...routing,
-      ...handoffMetrics()
+      ...routing
     })
     return result
   } catch (error) {
@@ -224,8 +207,7 @@ export async function instrumentHandoff<T>(
         errorCode,
         failureKind,
         source,
-        ...routing,
-        ...handoffMetrics()
+        ...routing
       })
     } else {
       eventManager.emit('walletFailed', {
@@ -238,14 +220,12 @@ export async function instrumentHandoff<T>(
         errorCode,
         failureKind,
         source,
-        ...routing,
-        ...handoffMetrics()
+        ...routing
       })
     }
     throw error
   } finally {
     if (timer) clearTimeout(timer)
-    offRelayDrop()
-    focus.stop()
+    stopFocus()
   }
 }

package/src/observability/lifecycle-bridge.test.ts

@@ -55,6 +55,82 @@ describe('attachLifecycle', () => {
     expect(got.walletSessionExpired).toEqual([routing])
   })
 
+  it('forwards real accounts from subscribeAccounts to onAccountsChanged (a separate stream from telemetry)', () => {
+    const em = new EventManager()
+    let emitAccounts!: (accounts: string[]) => void
+    const seen: string[][] = []
+
+    attachLifecycle({
+      eventManager: em,
+      subscribe: () => () => {},
+      subscribeAccounts: l => {
+        emitAccounts = l
+        return () => {}
+      },
+      onAccountsChanged: accounts => seen.push(accounts),
+      getRouting: () => routing,
+      connectionMode: 'injected',
+      namespace: 'eip155'
+    })
+
+    emitAccounts(['0xNEW'])
+    expect(seen).toEqual([['0xNEW']])
+  })
+
+  it('attaches subscribeAccounts even when the connector has NO telemetry subscribe (the Tron shape today)', () => {
+    // TronConnector implements onAccountsChanged but not onLifecycleEvent —
+    // the two streams must be independently attachable.
+    const em = new EventManager()
+    const unavail: unknown[] = []
+    em.on('lifecycleTelemetryUnavailable', d => unavail.push(d))
+    let emitAccounts!: (accounts: string[]) => void
+    const seen: string[][] = []
+
+    attachLifecycle({
+      eventManager: em,
+      subscribe: undefined,
+      subscribeAccounts: l => {
+        emitAccounts = l
+        return () => {}
+      },
+      onAccountsChanged: accounts => seen.push(accounts),
+      getRouting: () => routing,
+      connectionMode: 'injected',
+      namespace: 'tron'
+    })
+
+    emitAccounts(['TSwitched'])
+    expect(seen).toEqual([['TSwitched']])
+    // No telemetry surface exists for this connector, but that's a SEPARATE
+    // concern from account-sync succeeding — no unavailable signal fires
+    // just because the account stream alone is present.
+    expect(unavail).toHaveLength(0)
+  })
+
+  it('teardown unsubscribes both streams', () => {
+    const em = new EventManager()
+    let lifecycleUnsubbed = false
+    let accountsUnsubbed = false
+
+    const teardown = attachLifecycle({
+      eventManager: em,
+      subscribe: () => () => {
+        lifecycleUnsubbed = true
+      },
+      subscribeAccounts: () => () => {
+        accountsUnsubbed = true
+      },
+      onAccountsChanged: () => {},
+      getRouting: () => routing,
+      connectionMode: 'injected',
+      namespace: 'eip155'
+    })
+
+    teardown()
+    expect(lifecycleUnsubbed).toBe(true)
+    expect(accountsUnsubbed).toBe(true)
+  })
+
   it('a throwing getRouting never escapes into the wallet emitter dispatch', () => {
     // Wallet SDKs dispatch listeners unguarded (e.g. TonConnect's bare
     // forEach) — a throw from our listener would abort delivery to the
@@ -152,6 +228,91 @@ describe('attachLifecycle', () => {
     expect(seen).toHaveLength(1)
   })
 
+  it('suppresses an accountsChanged echo that matches the address a UWC switch just applied', () => {
+    let t = 1000
+    const em = new EventManager()
+    const seen: string[][] = []
+    let emitAccounts!: (accounts: string[]) => void
+
+    attachLifecycle({
+      eventManager: em,
+      subscribe: () => () => {},
+      subscribeAccounts: l => {
+        emitAccounts = l
+        return () => {}
+      },
+      onAccountsChanged: accounts => seen.push(accounts),
+      getRouting: () => routing,
+      connectionMode: 'injected',
+      namespace: 'eip155',
+      now: () => t
+    })
+
+    em.emit('networkSwitched', {
+      network: { id: 'eip155:8453' } as any,
+      address: '0xNEW'
+    })
+    emitAccounts(['0xNEW'])
+    expect(seen).toHaveLength(0)
+
+    // Past the echo window, the same address is a genuine wallet-side switch.
+    t = 1000 + 5000
+    emitAccounts(['0xNEW'])
+    expect(seen).toHaveLength(1)
+  })
+
+  it('forwards an accountsChanged inside the echo window whose address does NOT match the switch (a real, different, user-initiated change)', () => {
+    const em = new EventManager()
+    const seen: string[][] = []
+    let emitAccounts!: (accounts: string[]) => void
+
+    attachLifecycle({
+      eventManager: em,
+      subscribe: () => () => {},
+      subscribeAccounts: l => {
+        emitAccounts = l
+        return () => {}
+      },
+      onAccountsChanged: accounts => seen.push(accounts),
+      getRouting: () => routing,
+      connectionMode: 'injected',
+      namespace: 'eip155'
+    })
+
+    em.emit('networkSwitched', {
+      network: { id: 'eip155:8453' } as any,
+      address: '0xNEW'
+    })
+    emitAccounts(['0xSOMETHING_ELSE'])
+    expect(seen).toEqual([['0xSOMETHING_ELSE']])
+  })
+
+  it('never suppresses an empty accounts list (the disconnect signal), even inside the echo window', () => {
+    const em = new EventManager()
+    const seen: string[][] = []
+    let emitAccounts!: (accounts: string[]) => void
+
+    attachLifecycle({
+      eventManager: em,
+      subscribe: () => () => {},
+      subscribeAccounts: l => {
+        emitAccounts = l
+        return () => {}
+      },
+      onAccountsChanged: accounts => seen.push(accounts),
+      getRouting: () => routing,
+      connectionMode: 'injected',
+      namespace: 'eip155'
+    })
+
+    em.emit('networkSwitched', {
+      network: { id: 'eip155:8453' } as any,
+      address: '0xNEW'
+    })
+    emitAccounts([])
+    expect(seen).toEqual([[]])
+  })
+
   it('caps lifecycle emissions per attachment (a storming provider cannot drive unbounded egress)', () => {
     // Every other telemetry sink added by this layer is bounded (relay / bridge /
     // observer-error all cap at 100); a wallet looping chainChanged must not be
@@ -192,6 +353,42 @@ describe('attachLifecycle', () => {
     expect(unavail[0]?.reason).toBe('emission_cap')
   })
 
+  it('does not drop a still-pending echo suppression when a SECOND switchNetwork arms before the FIRST wallet echo arrives', () => {
+    // Two rapid, back-to-back switches (A then B) each arm their OWN echo
+    // window. A's wallet echo can legitimately arrive AFTER B's switch has
+    // already completed — B arming/re-arming must not erase A's still-valid,
+    // not-yet-consumed suppression window.
+    let t = 1000
+    const em = new EventManager()
+    const seen: unknown[] = []
+    em.on('walletChainChanged', d => seen.push(d))
+
+    let emit!: (e: WalletLifecycleEvent) => void
+    attachLifecycle({
+      eventManager: em,
+      subscribe: l => {
+        emit = l
+        return () => {}
+      },
+      getRouting: () => routing,
+      connectionMode: 'injected',
+      namespace: 'eip155',
+      now: () => t
+    })
+
+    em.emit('networkSwitched', switchedTo('eip155:8453')) // switch to A
+    t = 1010
+    em.emit('networkSwitched', switchedTo('eip155:137')) // switch to B, A's echo still pending
+
+    t = 1020
+    emit({ type: 'chainChanged', chainId: 'eip155:8453' }) // A's delayed echo
+    expect(seen).toHaveLength(0)
+
+    t = 1030
+    emit({ type: 'chainChanged', chainId: 'eip155:137' }) // B's delayed echo
+    expect(seen).toHaveLength(0)
+  })
+
   it('seeds echo suppression from initialSwitch (the reattach-after-switch path)', () => {
     // A cross-namespace switchNetwork re-attaches the subscription AFTER the
     // switch completed — the fresh closure never saw that switch's bus events,