@meshconnect/uwc-bridge-parent 1.4.2 → 1.5.0

package/dist/BridgeParent.test.js

@@ -1,4 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as Comlink from 'comlink';
 // Mock Comlink. windowEndpoint mirrors the real one (comlink 4.4.2): its
 // add/removeEventListener are window's own methods bound to window. This lets the
 // destroy tests assert real attachment/detachment on window via dispatchEvent,
@@ -76,14 +77,14 @@ describe('BridgeParent', () => {
             const { BridgeParent } = await import('./BridgeParent');
             new BridgeParent(mockIframe);
             // Allow the async initializeConnection to run
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             expect(Comlink.expose).toHaveBeenCalled();
         });
         it('should call Comlink.windowEndpoint with iframe contentWindow', async () => {
             const Comlink = await import('comlink');
             const { BridgeParent } = await import('./BridgeParent');
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             expect(Comlink.windowEndpoint).toHaveBeenCalledWith(mockIframe.contentWindow, window, 'https://child.example.com');
         });
         it('should not initialize if iframe has no contentWindow', async () => {
@@ -91,7 +92,7 @@ describe('BridgeParent', () => {
             const { BridgeParent } = await import('./BridgeParent');
             const iframeNoContent = { src: 'https://example.com' };
             new BridgeParent(iframeNoContent);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             expect(Comlink.expose).not.toHaveBeenCalled();
         });
     });
@@ -154,7 +155,7 @@ describe('BridgeParent', () => {
                 ep.addEventListener('message', exposedListener);
             });
             const bridge = new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             // Live before teardown: a window 'message' from the iframe reaches the
             // listener (source must match — the guard drops anything else).
             const liveEvt = new MessageEvent('message', { data: { id: 1 } });
@@ -198,7 +199,7 @@ describe('BridgeParent', () => {
             const Comlink = await import('comlink');
             const { BridgeParent } = await import('./BridgeParent');
             const bridge = new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             // Solana readiness is true right after init — a real precondition, not a setup.
             expect(exposedAPI.walletStandardWalletsReady).toBe(true);
@@ -215,13 +216,13 @@ describe('BridgeParent', () => {
             const { BridgeParent } = await import('./BridgeParent');
             const iframeNoContent = { src: 'https://child.example.com' };
             const bridge = new BridgeParent(iframeNoContent);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             expect(() => bridge.destroy()).not.toThrow();
         });
         it('clears state and tolerates a second destroy()', async () => {
             const { BridgeParent } = await import('./BridgeParent');
             const bridge = new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             bridge.destroy();
             expect(() => bridge.destroy()).not.toThrow();
         });
@@ -231,7 +232,7 @@ describe('BridgeParent', () => {
             const dispatchSpy = vi.spyOn(window, 'dispatchEvent');
             const { BridgeParent } = await import('./BridgeParent');
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({ type: 'eip6963:requestProvider' }));
         });
         it('should collect announced wallets', async () => {
@@ -253,7 +254,7 @@ describe('BridgeParent', () => {
                 }));
             });
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             // The exposed parentAPI should contain the discovered wallet
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             expect(exposedAPI).toBeDefined();
@@ -283,7 +284,7 @@ describe('BridgeParent', () => {
                 window.dispatchEvent(event);
             });
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             expect(exposedAPI.eip6963Wallets).toHaveLength(1);
         });
@@ -311,7 +312,7 @@ describe('BridgeParent', () => {
                 register: vi.fn()
             });
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             expect(exposedAPI.walletStandardWallets).toHaveLength(1);
             expect(exposedAPI.walletStandardWallets[0].name).toBe('Phantom');
@@ -327,7 +328,7 @@ describe('BridgeParent', () => {
                 register: vi.fn()
             });
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             expect(exposedAPI.walletStandardWallets).toEqual([]);
         });
@@ -337,7 +338,7 @@ describe('BridgeParent', () => {
             const Comlink = await import('comlink');
             const { BridgeParent } = await import('./BridgeParent');
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             expect(exposedAPI.tronWallets).toEqual([]);
             expect(exposedAPI.tronWalletsReady).toBe(false);
@@ -363,7 +364,7 @@ describe('BridgeParent', () => {
                 }
             };
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             // Simulate child calling discoverTronWallets
             exposedAPI.discoverTronWallets(['tronLink']);
@@ -398,7 +399,7 @@ describe('BridgeParent', () => {
                 }
             };
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             exposedAPI.discoverTronWallets(['tokenpocket.tron']);
             expect(exposedAPI.tronWallets).toHaveLength(1);
@@ -409,7 +410,7 @@ describe('BridgeParent', () => {
             const Comlink = await import('comlink');
             const { BridgeParent } = await import('./BridgeParent');
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             exposedAPI.discoverTronWallets([]);
             expect(exposedAPI.tronWallets).toEqual([]);
@@ -423,7 +424,7 @@ describe('BridgeParent', () => {
                 tronWeb: { notTrx: true }
             };
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             exposedAPI.discoverTronWallets(['badWallet']);
             expect(exposedAPI.tronWallets).toEqual([]);
@@ -450,7 +451,7 @@ describe('BridgeParent', () => {
                 }
             };
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             exposedAPI.discoverTronWallets(['tronLink', 'tronLink']);
             expect(exposedAPI.tronWallets).toHaveLength(1);
@@ -462,7 +463,7 @@ describe('BridgeParent', () => {
             const Comlink = await import('comlink');
             const { BridgeParent } = await import('./BridgeParent');
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             expect(exposedAPI.tonWallets).toEqual([]);
             expect(exposedAPI.tonWalletsReady).toBe(false);
@@ -498,7 +499,7 @@ describe('BridgeParent', () => {
                 }
             };
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             exposedAPI.discoverTonWallets(['trustwalletTon']);
             expect(exposedAPI.tonWalletsReady).toBe(true);
@@ -538,7 +539,7 @@ describe('BridgeParent', () => {
                 }
             };
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             exposedAPI.discoverTonWallets(['trustwalletTon']);
             const provider = exposedAPI.tonWallets[0].provider;
@@ -557,7 +558,7 @@ describe('BridgeParent', () => {
             const { BridgeParent } = await import('./BridgeParent');
             window.fakeTon = { tonconnect: { notABridge: true } };
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             exposedAPI.discoverTonWallets(['fakeTon']);
             expect(exposedAPI.tonWallets).toEqual([]);
@@ -575,7 +576,7 @@ describe('BridgeParent', () => {
                 }
             };
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             exposedAPI.discoverTonWallets(['trustwalletTon', 'trustwalletTon']);
             expect(exposedAPI.tonWallets).toHaveLength(1);
@@ -620,7 +621,7 @@ describe('BridgeParent', () => {
             const { BridgeParent } = await import('./BridgeParent');
             baseAdapterMock.readyState = 'Installed';
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             const baseWallet = exposedAPI.walletStandardWallets.find((w) => w.name === 'Base Wallet');
             expect(baseWallet).toBeDefined();
@@ -634,7 +635,7 @@ describe('BridgeParent', () => {
             const { BridgeParent } = await import('./BridgeParent');
             baseAdapterMock.readyState = 'Loadable';
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             const baseWallet = exposedAPI.walletStandardWallets.find((w) => w.name === 'Base Wallet');
             expect(baseWallet).toBeDefined();
@@ -643,7 +644,7 @@ describe('BridgeParent', () => {
             const Comlink = await import('comlink');
             const { BridgeParent } = await import('./BridgeParent');
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             const baseWallet = exposedAPI.walletStandardWallets.find((w) => w.name === 'Base Wallet');
             expect(baseWallet).toBeUndefined();
@@ -665,7 +666,7 @@ describe('BridgeParent', () => {
             });
             baseAdapterMock.readyState = 'Installed';
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             const baseWallets = exposedAPI.walletStandardWallets.filter((w) => w.name === 'Base Wallet');
             expect(baseWallets).toHaveLength(1);
@@ -676,11 +677,603 @@ describe('BridgeParent', () => {
             const { BridgeParent } = await import('./BridgeParent');
             baseAdapterMock.shouldThrow = true;
             new BridgeParent(mockIframe);
-            await vi.advanceTimersByTimeAsync(200);
+            await vi.advanceTimersByTimeAsync(400);
             const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0];
             expect(exposedAPI).toBeDefined();
             expect(exposedAPI.walletStandardWallets).toEqual([]);
         });
     });
+    describe('subscribeEip6963ProviderEvent', () => {
+        function makeMockProvider() {
+            return {
+                request: vi.fn(),
+                on: vi.fn(),
+                removeListener: vi.fn()
+            };
+        }
+        // Lets the real one-shot discovery window (300ms) resolve first, THEN
+        // overwrites eip6963Wallets with the test's fixture — otherwise the
+        // discovery's own `.then()` (see BridgeParent.ts's initializeConnection)
+        // would overwrite the fixture with `[]` out from under the test the
+        // moment `subscribeEip6963ProviderEvent`'s internal await lets it run.
+        async function readyBridgeParent(mockIframe) {
+            const { BridgeParent } = await import('./BridgeParent');
+            const bridgeParent = new BridgeParent(mockIframe);
+            await vi.advanceTimersByTimeAsync(400);
+            return bridgeParent;
+        }
+        it('attaches a real listener to the detected provider via a LOCAL wrapper, not the raw callback', async () => {
+            const bridgeParent = await readyBridgeParent(mockIframe);
+            const provider = makeMockProvider();
+            bridgeParent.parentAPI.eip6963Wallets = [
+                {
+                    uuid: 'uuid-1',
+                    name: 'MetaMask',
+                    icon: '',
+                    rdns: 'io.metamask',
+                    provider
+                }
+            ];
+            const callback = vi.fn();
+            const teardown = await bridgeParent.parentAPI.subscribeEip6963ProviderEvent('uuid-1', 'accountsChanged', callback);
+            expect(provider.on).toHaveBeenCalledWith('accountsChanged', expect.any(Function));
+            // Regression guard: `callback` here IS the Comlink proxy the child
+            // passed. Registering it directly on the real provider means Comlink
+            // must serialize EVERY argument the wallet's own dispatch calls it
+            // with — some wallets' internal EventEmitter pass extra, non-EIP-1193
+            // arguments (observed in production: a wallet's own internal handler
+            // function) alongside the real payload, and Comlink can't clone a
+            // function, throwing "DataCloneError" the moment the wallet fires the
+            // event. The registered listener must NOT be `callback` itself.
+            expect(provider.on).not.toHaveBeenCalledWith('accountsChanged', callback);
+            expect(typeof teardown).toBe('function');
+            // Regression guard: the teardown crosses back to the child as a
+            // Comlink return value — an un-proxied function throws "Unserializable
+            // return value" the moment a real postMessage transport (not this
+            // identity-mocked one) tries to deserialize it, exactly like TON's
+            // `listen()` teardown above must be (and is) proxied.
+            expect(Comlink.proxy).toHaveBeenCalledWith(expect.any(Function));
+        });
+        it('the local wrapper forwards ONLY the first argument to callback, discarding any extra ones the wallet passes', async () => {
+            const bridgeParent = await readyBridgeParent(mockIframe);
+            const provider = makeMockProvider();
+            bridgeParent.parentAPI.eip6963Wallets = [
+                {
+                    uuid: 'uuid-1',
+                    name: 'MetaMask',
+                    icon: '',
+                    rdns: 'io.metamask',
+                    provider
+                }
+            ];
+            const callback = vi.fn();
+            await bridgeParent.parentAPI.subscribeEip6963ProviderEvent('uuid-1', 'accountsChanged', callback);
+            const registeredWrapper = provider.on.mock.calls[0]?.[1];
+            const extraNonCloneableArg = () => { };
+            registeredWrapper(['0xNEW'], extraNonCloneableArg, { some: 'extra' });
+            expect(callback).toHaveBeenCalledTimes(1);
+            expect(callback).toHaveBeenCalledWith(['0xNEW']);
+        });
+        it("teardown returns undefined even when the real EventEmitter's removeListener returns `this` (the whole provider)", async () => {
+            // By EventEmitter convention (Node's `events` module, and wallet
+            // providers built on it, e.g. Trust Wallet's inpage.js), .removeListener
+            // returns `this` for chaining. An expression-bodied teardown
+            // (`() => provider.removeListener?.(...)`) would implicitly return that
+            // — the whole provider object — across the Comlink boundary, which is
+            // itself unserializable and reproduces the exact same failure one level
+            // down, the moment a caller actually invokes the teardown.
+            const bridgeParent = await readyBridgeParent(mockIframe);
+            const provider = {
+                request: vi.fn(),
+                on: vi.fn(),
+                removeListener: vi.fn(function () {
+                    return this;
+                })
+            };
+            bridgeParent.parentAPI.eip6963Wallets = [
+                {
+                    uuid: 'uuid-1',
+                    name: 'Trust Wallet',
+                    icon: '',
+                    rdns: 'com.trustwallet.app',
+                    provider
+                }
+            ];
+            const teardown = await bridgeParent.parentAPI.subscribeEip6963ProviderEvent('uuid-1', 'accountsChanged', vi.fn());
+            expect(teardown()).toBeUndefined();
+        });
+        it('teardown calls removeListener with the SAME wrapper reference registered via .on', async () => {
+            const bridgeParent = await readyBridgeParent(mockIframe);
+            const provider = makeMockProvider();
+            bridgeParent.parentAPI.eip6963Wallets = [
+                {
+                    uuid: 'uuid-1',
+                    name: 'MetaMask',
+                    icon: '',
+                    rdns: 'io.metamask',
+                    provider
+                }
+            ];
+            const callback = vi.fn();
+            const teardown = await bridgeParent.parentAPI.subscribeEip6963ProviderEvent('uuid-1', 'accountsChanged', callback);
+            const registeredWrapper = provider.on.mock.calls[0]?.[1];
+            teardown?.();
+            expect(provider.removeListener).toHaveBeenCalledWith('accountsChanged', registeredWrapper);
+        });
+        it('throws for an unknown uuid (wallet not detected)', async () => {
+            const bridgeParent = await readyBridgeParent(mockIframe);
+            bridgeParent.parentAPI.eip6963Wallets = [];
+            await expect(bridgeParent.parentAPI.subscribeEip6963ProviderEvent('unknown-uuid', 'accountsChanged', vi.fn())).rejects.toThrow(/no wallet found for uuid/);
+        });
+        it('throws when no wallet matches the given uuid (the uuid-mismatch bug this guards against)', async () => {
+            const bridgeParent = await readyBridgeParent(mockIframe);
+            bridgeParent.parentAPI.eip6963Wallets = [];
+            await expect(bridgeParent.parentAPI.subscribeEip6963ProviderEvent('uuid-not-discovered-by-this-parent', 'accountsChanged', vi.fn())).rejects.toThrow(/no wallet found for uuid/);
+        });
+        it('falls back to matching by rdns when the uuid does not match (the uuid-mismatch bug this closes structurally)', async () => {
+            const bridgeParent = await readyBridgeParent(mockIframe);
+            const provider = makeMockProvider();
+            bridgeParent.parentAPI.eip6963Wallets = [
+                {
+                    uuid: 'uuid-from-top-frame',
+                    name: 'MetaMask',
+                    icon: '',
+                    rdns: 'io.metamask',
+                    provider
+                }
+            ];
+            const callback = vi.fn();
+            const teardown = await bridgeParent.parentAPI.subscribeEip6963ProviderEvent('uuid-from-local-iframe-injection', 'accountsChanged', callback, 'io.metamask');
+            expect(typeof teardown).toBe('function');
+            expect(provider.on).toHaveBeenCalledWith('accountsChanged', expect.any(Function));
+        });
+        it('still throws when neither uuid nor rdns match anything', async () => {
+            const bridgeParent = await readyBridgeParent(mockIframe);
+            bridgeParent.parentAPI.eip6963Wallets = [];
+            await expect(bridgeParent.parentAPI.subscribeEip6963ProviderEvent('uuid-not-discovered-by-this-parent', 'accountsChanged', vi.fn(), 'com.nonexistent.wallet')).rejects.toThrow(/no wallet found for uuid/);
+        });
+        it('awaits the in-flight discovery window instead of failing permanently when subscribe is called BEFORE it resolves', async () => {
+            // Regression for the startup race: a subscribe call arriving while the
+            // one-shot 300ms discovery window is still open (e.g. immediately on
+            // page load, during a session restore) used to look up against a
+            // still-empty eip6963Wallets, miss, and throw — permanently, since the
+            // child never retries a rejected subscribe (see BridgeChild.ts's
+            // window.__uwcSubscribeEip6963ProviderEvent .catch()).
+            const provider = makeMockProvider();
+            window.addEventListener('eip6963:requestProvider', () => {
+                window.dispatchEvent(new CustomEvent('eip6963:announceProvider', {
+                    detail: {
+                        info: {
+                            uuid: 'uuid-1',
+                            name: 'MetaMask',
+                            icon: '',
+                            rdns: 'io.metamask'
+                        },
+                        provider
+                    }
+                }));
+            });
+            const { BridgeParent } = await import('./BridgeParent');
+            const bridgeParent = new BridgeParent(mockIframe);
+            // Call subscribe IMMEDIATELY — well before the 300ms discovery window
+            // (dispatched synchronously above, so the wallet IS in the discovery
+            // listener's closure, but the parent hasn't resolved/flipped
+            // eip6963WalletsReady yet).
+            const subscribePromise = bridgeParent.parentAPI.subscribeEip6963ProviderEvent('uuid-1', 'accountsChanged', vi.fn());
+            // Let the 300ms discovery window elapse.
+            await vi.advanceTimersByTimeAsync(400);
+            const teardown = await subscribePromise;
+            expect(typeof teardown).toBe('function');
+            expect(provider.on).toHaveBeenCalledWith('accountsChanged', expect.any(Function));
+        });
+    });
+    describe('subscribeTronProviderEvent', () => {
+        function makeMockTronProvider() {
+            return {
+                tronWeb: {},
+                on: vi.fn(),
+                removeListener: vi.fn()
+            };
+        }
+        it('resolves the provider by injectedId window path and attaches a real listener via a LOCAL wrapper', async () => {
+            const { BridgeParent } = await import('./BridgeParent');
+            const bridgeParent = new BridgeParent(mockIframe);
+            const provider = makeMockTronProvider();
+            window.tronLink = provider;
+            const callback = vi.fn();
+            const teardown = bridgeParent.parentAPI.subscribeTronProviderEvent('tronLink', 'accountsChanged', callback);
+            expect(provider.on).toHaveBeenCalledWith('accountsChanged', expect.any(Function));
+            // Regression guard: same "the registered listener must not be the raw
+            // Comlink-proxied callback" requirement as the EIP-6963 method above —
+            // a wallet's own dispatch calling the listener with an extra,
+            // non-serializable argument (e.g. an internal handler function)
+            // otherwise throws DataCloneError the moment the wallet fires the
+            // event.
+            expect(provider.on).not.toHaveBeenCalledWith('accountsChanged', callback);
+            expect(typeof teardown).toBe('function');
+            // Regression guard: same "must cross the bridge as a Comlink return
+            // value" requirement as the EIP-6963 subscribe method above.
+            expect(Comlink.proxy).toHaveBeenCalledWith(expect.any(Function));
+            const registeredWrapper = provider.on.mock.calls[0]?.[1];
+            teardown?.();
+            expect(provider.removeListener).toHaveBeenCalledWith('accountsChanged', registeredWrapper);
+            delete window.tronLink;
+        });
+        it('the local wrapper forwards ONLY the first argument to callback, discarding any extra ones the wallet passes', async () => {
+            const { BridgeParent } = await import('./BridgeParent');
+            const bridgeParent = new BridgeParent(mockIframe);
+            const provider = makeMockTronProvider();
+            window.tronLink = provider;
+            const callback = vi.fn();
+            bridgeParent.parentAPI.subscribeTronProviderEvent('tronLink', 'accountsChanged', callback);
+            const registeredWrapper = provider.on.mock.calls[0]?.[1];
+            const extraNonCloneableArg = () => { };
+            registeredWrapper('TSwitchedAddress', extraNonCloneableArg);
+            expect(callback).toHaveBeenCalledTimes(1);
+            expect(callback).toHaveBeenCalledWith('TSwitchedAddress');
+            delete window.tronLink;
+        });
+        it("teardown returns undefined even when the real provider's removeListener returns `this`", async () => {
+            const { BridgeParent } = await import('./BridgeParent');
+            const bridgeParent = new BridgeParent(mockIframe);
+            const provider = {
+                tronWeb: {},
+                on: vi.fn(),
+                removeListener: vi.fn(function () {
+                    return this;
+                })
+            };
+            window.tronLink = provider;
+            const teardown = bridgeParent.parentAPI.subscribeTronProviderEvent('tronLink', 'accountsChanged', vi.fn());
+            expect(teardown()).toBeUndefined();
+            delete window.tronLink;
+        });
+        it('throws when the injectedId window path resolves to nothing', async () => {
+            const { BridgeParent } = await import('./BridgeParent');
+            const bridgeParent = new BridgeParent(mockIframe);
+            expect(() => bridgeParent.parentAPI.subscribeTronProviderEvent('nonexistent.path', 'accountsChanged', vi.fn())).toThrow(/no provider found at injectedId/);
+        });
+        it('throws when no provider resolves at the given injectedId path', async () => {
+            const { BridgeParent } = await import('./BridgeParent');
+            const bridgeParent = new BridgeParent(mockIframe);
+            expect(() => bridgeParent.parentAPI.subscribeTronProviderEvent('nonExistentWallet', 'accountsChanged', vi.fn())).toThrow(/no provider found at injectedId/);
+        });
+        // MFS-778: TronLink resolves `window.tronLink` (request+tronWeb, no `.on`)
+        // for discovery/signing, but emits account/disconnect events on its
+        // separate TIP-1193 `window.tron`. Binding on the resolved provider alone
+        // silently dropped every account switch.
+        it('subscribes on the TIP-1193 window.tron when the resolved provider has no .on', async () => {
+            const { BridgeParent } = await import('./BridgeParent');
+            const bridgeParent = new BridgeParent(mockIframe);
+            window.tronLink = { tronWeb: {}, request: vi.fn() };
+            // TIP-1193 emitter TronLink actually fires events on.
+            const emitter = {
+                tronWeb: {},
+                request: vi.fn(),
+                on: vi.fn(),
+                removeListener: vi.fn()
+            };
+            window.tron = emitter;
+            const callback = vi.fn();
+            const teardown = bridgeParent.parentAPI.subscribeTronProviderEvent('tronLink', 'accountsChanged', callback);
+            expect(emitter.on).toHaveBeenCalledWith('accountsChanged', expect.any(Function));
+            // Same regression guard as the eip6963/direct paths: the raw
+            // Comlink-proxied callback is never registered directly.
+            expect(emitter.on).not.toHaveBeenCalledWith('accountsChanged', callback);
+            const registeredWrapper = emitter.on.mock.calls[0]?.[1];
+            registeredWrapper(['TSwitched'], () => { });
+            expect(callback).toHaveBeenCalledTimes(1);
+            expect(callback).toHaveBeenCalledWith(['TSwitched']);
+            teardown?.();
+            expect(emitter.removeListener).toHaveBeenCalledWith('accountsChanged', registeredWrapper);
+            delete window.tronLink;
+            delete window.tron;
+        });
+        // A non-TronLink wallet whose own Tron provider lacks `.on` (confirmed live
+        // for OKX's `okxwallet.tronLink`) must NOT inherit TronLink's `window.tron`.
+        // OKX broadcasts account switches on the window `message` channel; binding
+        // its `accountsChanged` on TronLink's `window.tron` means OKX's switches
+        // fire on the wrong wallet's provider and are silently dropped (the OKX+Tron
+        // account-switch bug). It must fall through to the `message` channel.
+        it('does NOT inherit TronLink window.tron for OKX (emitter-less, non-TronLink) — falls back to window `message`', async () => {
+            const { BridgeParent } = await import('./BridgeParent');
+            const bridgeParent = new BridgeParent(mockIframe);
+            window.okxwallet = {
+                tronLink: { tronWeb: {}, request: vi.fn() }
+            };
+            // TronLink's TIP-1193 emitter IS present (both wallets installed) and is a
+            // valid Tron provider — so ONLY the identity gate keeps OKX off it.
+            const tronLinkEmitter = {
+                tronWeb: {},
+                request: vi.fn(),
+                on: vi.fn(),
+                removeListener: vi.fn()
+            };
+            window.tron = tronLinkEmitter;
+            const addSpy = vi.spyOn(window, 'addEventListener');
+            const callback = vi.fn();
+            const teardown = bridgeParent.parentAPI.subscribeTronProviderEvent('okxwallet.tronLink', 'accountsChanged', callback);
+            // Must NOT bind on TronLink's window.tron.
+            expect(tronLinkEmitter.on).not.toHaveBeenCalled();
+            // Instead subscribes to the window `message` channel — OKX's real channel.
+            expect(addSpy).toHaveBeenCalledWith('message', expect.any(Function));
+            window.dispatchEvent(new MessageEvent('message', {
+                data: {
+                    message: {
+                        action: 'accountsChanged',
+                        data: { address: 'TOkxSwitched' }
+                    }
+                },
+                source: window,
+                origin: window.location.origin
+            }));
+            expect(callback).toHaveBeenCalledWith(['TOkxSwitched']);
+            teardown?.();
+            delete window.okxwallet;
+            delete window.tron;
+        });
+        it('ignores a forged Tron `setAccount` from a foreign source/origin (runs in the top frame)', async () => {
+            // This handler runs in the client's TOP frame and feeds the live session
+            // address, so a same-origin sibling frame or window.opener must not be
+            // able to post `{ message: { action: 'setAccount' } }` and move the account.
+            const { BridgeParent } = await import('./BridgeParent');
+            const bridgeParent = new BridgeParent(mockIframe);
+            window.tronLink = { tronWeb: {}, request: vi.fn() };
+            const callback = vi.fn();
+            const teardown = bridgeParent.parentAPI.subscribeTronProviderEvent('tronLink', 'accountsChanged', callback);
+            // Foreign source.
+            window.dispatchEvent(new MessageEvent('message', {
+                data: {
+                    message: { action: 'setAccount', data: { address: 'TAttacker' } }
+                },
+                source: {},
+                origin: window.location.origin
+            }));
+            // Right source, wrong origin.
+            window.dispatchEvent(new MessageEvent('message', {
+                data: {
+                    message: { action: 'setAccount', data: { address: 'TAttacker' } }
+                },
+                source: window,
+                origin: 'https://evil.example'
+            }));
+            expect(callback).not.toHaveBeenCalled();
+            teardown?.();
+            delete window.tronLink;
+        });
+        it('falls back to the window `message` channel when neither the resolved provider nor window.tron has .on', async () => {
+            const { BridgeParent } = await import('./BridgeParent');
+            const bridgeParent = new BridgeParent(mockIframe);
+            window.tronLink = { tronWeb: {}, request: vi.fn() };
+            // No window.tron emitter at all.
+            const addSpy = vi.spyOn(window, 'addEventListener');
+            const removeSpy = vi.spyOn(window, 'removeEventListener');
+            const callback = vi.fn();
+            const teardown = bridgeParent.parentAPI.subscribeTronProviderEvent('tronLink', 'accountsChanged', callback);
+            expect(addSpy).toHaveBeenCalledWith('message', expect.any(Function));
+            window.dispatchEvent(new MessageEvent('message', {
+                data: {
+                    message: { action: 'setAccount', data: { address: 'TSwitched' } }
+                },
+                source: window,
+                origin: window.location.origin
+            }));
+            expect(callback).toHaveBeenCalledWith(['TSwitched']);
+            teardown?.();
+            expect(removeSpy).toHaveBeenCalledWith('message', expect.any(Function));
+            delete window.tronLink;
+        });
+    });
+    describe('subscribeSolanaWalletEvent', () => {
+        beforeEach(async () => {
+            // Re-set mocks that vi.restoreAllMocks() may have cleared.
+            const { getWallets } = await import('@wallet-standard/app');
+            vi.mocked(getWallets).mockReturnValue({
+                get: () => [],
+                on: vi.fn(),
+                register: vi.fn()
+            });
+            const { isWalletAdapterCompatibleStandardWallet } = await import('@solana/wallet-adapter-base');
+            vi.mocked(isWalletAdapterCompatibleStandardWallet).mockReturnValue(false);
+            baseAdapterMock.readyState = 'NotDetected';
+            baseAdapterMock.shouldThrow = false;
+            baseAdapterMock.fn.mockImplementation(function () {
+                if (baseAdapterMock.shouldThrow)
+                    throw new Error('init failed');
+                return {
+                    readyState: baseAdapterMock.readyState,
+                    name: 'Base Wallet',
+                    on: vi.fn(),
+                    off: vi.fn()
+                };
+            });
+        });
+        function stubStandardWalletAdapter(adapter) {
+            return import('@solana/wallet-standard-wallet-adapter-base').then(({ StandardWalletAdapter }) => {
+                vi.mocked(StandardWalletAdapter).mockImplementation(function () {
+                    return adapter;
+                });
+            });
+        }
+        it('resolves the connected wallet-standard adapter by walletId and attaches connect/disconnect listeners via a LOCAL wrapper', async () => {
+            const { getWallets } = await import('@wallet-standard/app');
+            const { isWalletAdapterCompatibleStandardWallet } = await import('@solana/wallet-adapter-base');
+            const { BridgeParent } = await import('./BridgeParent');
+            vi.mocked(getWallets).mockReturnValue({
+                get: () => [
+                    {
+                        name: 'Phantom',
+                        chains: ['solana:mainnet'],
+                        features: {},
+                        accounts: []
+                    }
+                ],
+                on: vi.fn(),
+                register: vi.fn()
+            });
+            vi.mocked(isWalletAdapterCompatibleStandardWallet).mockReturnValue(true);
+            const adapterOn = vi.fn();
+            const adapterOff = vi.fn();
+            await stubStandardWalletAdapter({ on: adapterOn, off: adapterOff });
+            const bridgeParent = new BridgeParent(mockIframe);
+            await vi.advanceTimersByTimeAsync(400);
+            const callback = vi.fn();
+            const teardown = bridgeParent.parentAPI.subscribeSolanaWalletEvent('phantom-solana:mainnet', callback);
+            expect(adapterOn).toHaveBeenCalledWith('connect', expect.any(Function));
+            expect(adapterOn).toHaveBeenCalledWith('disconnect', expect.any(Function));
+            expect(typeof teardown).toBe('function');
+            // Regression guard: the teardown crosses back to the child as a
+            // Comlink return value, same requirement as the eip155/tron teardowns.
+            expect(Comlink.proxy).toHaveBeenCalledWith(expect.any(Function));
+            teardown?.();
+            expect(adapterOff).toHaveBeenCalledWith('connect', expect.any(Function));
+            expect(adapterOff).toHaveBeenCalledWith('disconnect', expect.any(Function));
+        });
+        it('reduces the PublicKey to a plain base58 string BEFORE forwarding to callback (never the object itself)', async () => {
+            const { getWallets } = await import('@wallet-standard/app');
+            const { isWalletAdapterCompatibleStandardWallet } = await import('@solana/wallet-adapter-base');
+            const { BridgeParent } = await import('./BridgeParent');
+            vi.mocked(getWallets).mockReturnValue({
+                get: () => [
+                    {
+                        name: 'Phantom',
+                        chains: ['solana:mainnet'],
+                        features: {},
+                        accounts: []
+                    }
+                ],
+                on: vi.fn(),
+                register: vi.fn()
+            });
+            vi.mocked(isWalletAdapterCompatibleStandardWallet).mockReturnValue(true);
+            const adapterOn = vi.fn();
+            const adapterOff = vi.fn();
+            await stubStandardWalletAdapter({ on: adapterOn, off: adapterOff });
+            const bridgeParent = new BridgeParent(mockIframe);
+            await vi.advanceTimersByTimeAsync(400);
+            const callback = vi.fn();
+            bridgeParent.parentAPI.subscribeSolanaWalletEvent('phantom-solana:mainnet', callback);
+            const onConnectWrapper = adapterOn.mock.calls.find(call => call[0] === 'connect')?.[1];
+            const onDisconnectWrapper = adapterOn.mock.calls.find(call => call[0] === 'disconnect')?.[1];
+            const fakePublicKey = { toBase58: () => 'SoLaNaAddr_NEW' };
+            onConnectWrapper(fakePublicKey);
+            expect(callback).toHaveBeenCalledWith('SoLaNaAddr_NEW');
+            expect(callback).not.toHaveBeenCalledWith(fakePublicKey);
+            onDisconnectWrapper();
+            expect(callback).toHaveBeenCalledWith(null);
+        });
+        it('throws when no wallet matches the given walletId', async () => {
+            const { BridgeParent } = await import('./BridgeParent');
+            const bridgeParent = new BridgeParent(mockIframe);
+            await vi.advanceTimersByTimeAsync(400);
+            expect(() => bridgeParent.parentAPI.subscribeSolanaWalletEvent('unknown-wallet-id', vi.fn())).toThrow(/no wallet found for walletId/);
+        });
+        it('resolves the traditional Base Wallet adapter by its "-traditional" walletId', async () => {
+            const { BridgeParent } = await import('./BridgeParent');
+            baseAdapterMock.readyState = 'Installed';
+            const bridgeParent = new BridgeParent(mockIframe);
+            await vi.advanceTimersByTimeAsync(400);
+            const callback = vi.fn();
+            const teardown = bridgeParent.parentAPI.subscribeSolanaWalletEvent('base-wallet-traditional', callback);
+            expect(typeof teardown).toBe('function');
+        });
+        // --- Phantom multi-switch regression (MFS-778) ------------------------
+        // The bridge resolves a FRESH, never-connected StandardWalletAdapter, whose
+        // connect/disconnect derivation ignores account-to-account switches — so it
+        // must observe the wallet's `standard:events` change stream directly.
+        function stubAdapterInstance(adapter) {
+            return import('@solana/wallet-standard-wallet-adapter-base').then(({ StandardWalletAdapter }) => {
+                // Must be a regular function (not an arrow): the SUT calls
+                // `new StandardWalletAdapter(...)`, and arrows can't be constructed.
+                vi.mocked(StandardWalletAdapter).mockImplementation(function () {
+                    return adapter;
+                });
+            });
+        }
+        async function armStandardEventsWallet(initialAccounts) {
+            const { getWallets } = await import('@wallet-standard/app');
+            const { isWalletAdapterCompatibleStandardWallet } = await import('@solana/wallet-adapter-base');
+            vi.mocked(getWallets).mockReturnValue({
+                get: () => [
+                    {
+                        name: 'Phantom',
+                        chains: ['solana:mainnet'],
+                        features: {},
+                        accounts: []
+                    }
+                ],
+                on: vi.fn(),
+                register: vi.fn()
+            });
+            vi.mocked(isWalletAdapterCompatibleStandardWallet).mockReturnValue(true);
+            let changeListener;
+            const off = vi.fn();
+            // `accounts` is mutable: the wallet updates it as the user switches, and
+            // the handler must read the CURRENT active account on each change.
+            const wallet = {
+                accounts: initialAccounts,
+                features: {
+                    'standard:events': {
+                        on: vi.fn((event, listener) => {
+                            if (event === 'change')
+                                changeListener = listener;
+                            return off;
+                        })
+                    }
+                }
+            };
+            const adapterOn = vi.fn();
+            const adapterOff = vi.fn();
+            await stubAdapterInstance({ on: adapterOn, off: adapterOff, wallet });
+            const { BridgeParent } = await import('./BridgeParent');
+            const bridgeParent = new BridgeParent(mockIframe);
+            await vi.advanceTimersByTimeAsync(400);
+            const callback = vi.fn();
+            const teardown = bridgeParent.parentAPI.subscribeSolanaWalletEvent('phantom-solana:mainnet', callback);
+            return {
+                wallet,
+                off,
+                adapterOn,
+                callback,
+                teardown,
+                fire: (props) => changeListener?.(props)
+            };
+        }
+        it('subscribes to the wallet `standard:events` change stream and NOT the fresh adapter connect/disconnect (the multi-switch fix)', async () => {
+            const { wallet, adapterOn, teardown, off } = await armStandardEventsWallet([{ address: 'ACC_1' }]);
+            // Subscribed to the change stream — the signal that fires on every switch.
+            expect(wallet.features['standard:events'].on).toHaveBeenCalledWith('change', expect.any(Function));
+            // NOT the never-connected adapter's connect/disconnect, which silently
+            // dropped account-to-account switches on the bridge.
+            expect(adapterOn).not.toHaveBeenCalledWith('connect', expect.any(Function));
+            expect(adapterOn).not.toHaveBeenCalledWith('disconnect', expect.any(Function));
+            // Teardown crosses back to the child as a Comlink return value.
+            expect(typeof teardown).toBe('function');
+            expect(Comlink.proxy).toHaveBeenCalledWith(expect.any(Function));
+            expect(off).not.toHaveBeenCalled();
+        });
+        it('propagates each of multiple switches, then null on de-auth, and ignores non-account changes', async () => {
+            const { wallet, callback, off, teardown, fire } = await armStandardEventsWallet([{ address: 'ACC_1' }]);
+            // Switch #1
+            wallet.accounts = [{ address: 'ACC_2' }];
+            fire({ accounts: wallet.accounts });
+            expect(callback).toHaveBeenNthCalledWith(1, 'ACC_2');
+            // Switch #2 (the intermediate switch that used to be dropped)
+            wallet.accounts = [{ address: 'ACC_3' }];
+            fire({ accounts: wallet.accounts });
+            expect(callback).toHaveBeenNthCalledWith(2, 'ACC_3');
+            // A pure chain/feature change (no `accounts` key) must be ignored.
+            fire({ chains: ['solana:devnet'] });
+            expect(callback).toHaveBeenCalledTimes(2);
+            // Switch to an account not authorized for the dapp → empty accounts → null,
+            // which the child maps to [] (disconnect).
+            wallet.accounts = [];
+            fire({ accounts: [] });
+            expect(callback).toHaveBeenNthCalledWith(3, null);
+            // Teardown unsubscribes the change stream.
+            teardown?.();
+            expect(off).toHaveBeenCalledTimes(1);
+        });
+    });
 });
 //# sourceMappingURL=BridgeParent.test.js.map