@meshconnect/uwc-core 1.10.4 → 2.1.0

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,210 @@ 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 pending-switch entry is gone — but the session
+    // already holds 0xNEW (the UWC switch applied it), so a re-fire of the SAME
+    // address is deduped (no redundant session write). A genuinely different
+    // address still propagates, proving the listener is live.
+    t = 1000 + 5000
+    emitAccounts(['0xNEW'])
+    expect(seen).toHaveLength(0)
+    emitAccounts(['0xOTHER'])
+    expect(seen).toEqual([['0xOTHER']])
+  })
+
+  it('does NOT cap account-sync at the telemetry ceiling (a focus-refiring wallet must not re-serve a stale signer)', () => {
+    const em = new EventManager()
+    const seen: string[][] = []
+    let emitAccounts!: (accounts: string[]) => void
+    const unavail: Array<{ reason?: string }> = []
+    em.on('lifecycleTelemetryUnavailable', d =>
+      unavail.push(d as { reason?: string })
+    )
+
+    attachLifecycle({
+      eventManager: em,
+      subscribeAccounts: l => {
+        emitAccounts = l
+        return () => {}
+      },
+      onAccountsChanged: accounts => seen.push(accounts),
+      getRouting: () => routing,
+      connectionMode: 'injected',
+      namespace: 'eip155'
+    })
+
+    // Far more than the telemetry cap, each a DISTINCT address (a genuine
+    // change) — every one must propagate; none may be silenced by a cap.
+    const total = MAX_LIFECYCLE_EVENTS_PER_ATTACHMENT + 50
+    for (let i = 0; i < total; i++) emitAccounts([`0xacct${i}`])
+    expect(seen).toHaveLength(total)
+    // Account-sync never trips the emission-cap signal.
+    expect(unavail.some(u => u.reason === 'emission_cap')).toBe(false)
+  })
+
+  it('dedupes an unchanged account re-fire (same address on focus) but propagates a real change', () => {
+    const em = new EventManager()
+    const seen: string[][] = []
+    let emitAccounts!: (accounts: string[]) => void
+
+    attachLifecycle({
+      eventManager: em,
+      subscribeAccounts: l => {
+        emitAccounts = l
+        return () => {}
+      },
+      onAccountsChanged: accounts => seen.push(accounts),
+      getRouting: () => routing,
+      connectionMode: 'injected',
+      namespace: 'eip155'
+    })
+
+    emitAccounts(['0xAAA'])
+    emitAccounts(['0xAAA']) // focus re-fire → deduped
+    emitAccounts(['0xAAA'])
+    expect(seen).toEqual([['0xAAA']])
+
+    emitAccounts(['0xBBB']) // real change → propagates
+    emitAccounts(['0xAAA']) // switched back → propagates (not consecutive-same)
+    expect(seen).toEqual([['0xAAA'], ['0xBBB'], ['0xAAA']])
+  })
+
+  it('suppresses an eip155 accountsChanged echo despite address CASE differing from the switch (checksum vs lowercase)', () => {
+    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'
+    })
+
+    // UWC switch applied a checksummed address; the wallet echoes the SAME
+    // account lowercased. Case-insensitive on eip155 → still suppressed, so the
+    // echo isn't forwarded as a wallet-initiated account change.
+    em.emit('networkSwitched', {
+      network: { id: 'eip155:8453' } as any,
+      address: '0xAbC123'
+    })
+    emitAccounts(['0xabc123'])
+    expect(seen).toHaveLength(0)
+  })
+
+  it('does NOT case-fold a non-eip155 (solana) address echo — case-sensitive namespaces stay exact', () => {
+    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: 'solana'
+    })
+
+    // Solana addresses are case-sensitive: a different-case string is a
+    // DIFFERENT address, so it must NOT be suppressed as an echo.
+    em.emit('networkSwitched', {
+      network: { id: 'solana:mainnet' } as any,
+      address: 'SoLAddr'
+    })
+    emitAccounts(['soladdr'])
+    expect(seen).toEqual([['soladdr']])
+  })
+
+  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 +472,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,