@geeqdev/geeq-sdk 0.1.0 → 0.2.0

package/dist/tests/socket.test.js

@@ -0,0 +1,607 @@
+import { afterEach, beforeAll, beforeEach, describe, expect, it, jest } from '@jest/globals';
+import { GeeqSocket, GeeqTrackedTx, createAttestationTx, createCoinTransferTx, defaultWebSocketFactory, generateKeypair, initGeeq, keypairFromMnemonic, socketRoute, toBase64, transactionIdOf, } from '../src/index';
+import { fakeSocketFactory, uutStatus } from './fixtures/fake-socket';
+const MNEMONIC = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+const URL_WS = 'wss://10.0.0.1:2082/ws/';
+const HASH = new Uint8Array(32).fill(7);
+const ID = toBase64(HASH);
+let keypair;
+let receiver;
+let open = [];
+// A browser WebSocket fits the factory type with no adapter. Compile-time only.
+const browserFactory = (url) => new WebSocket(url);
+void browserFactory;
+beforeAll(async () => {
+    await initGeeq();
+    keypair = await keypairFromMnemonic(MNEMONIC);
+    receiver = await generateKeypair();
+});
+beforeEach(() => {
+    jest.useFakeTimers({ doNotFake: ['nextTick', 'queueMicrotask'] });
+});
+afterEach(() => {
+    for (const socket of open)
+        socket.dispose();
+    open = [];
+    jest.useRealTimers();
+});
+async function failure(promise) {
+    try {
+        await promise;
+    }
+    catch (error) {
+        return error;
+    }
+    throw new Error('expected a rejection');
+}
+/** Connect through a fake socket whose handshake completes at once. */
+async function connected(options = {}) {
+    const factory = fakeSocketFactory();
+    const pending = GeeqSocket.connect({ url: URL_WS, webSocket: factory, ...options });
+    factory.last().open();
+    const socket = await pending;
+    open.push(socket);
+    return { socket, factory, wire: () => factory.last() };
+}
+describe('socketRoute', () => {
+    it('is the node origin with a ws scheme and the /ws/ path, trailing slash included', () => {
+        expect(socketRoute('https://10.0.0.1:2082')).toBe('wss://10.0.0.1:2082/ws/');
+        expect(socketRoute('http://127.0.0.1:3000')).toBe('ws://127.0.0.1:3000/ws/');
+        expect(socketRoute('https://node.example.com:2082/')).toBe('wss://node.example.com:2082/ws/');
+    });
+});
+describe('GeeqSocket.connect', () => {
+    it('derives the socket from the node endpoint, on the node port', async () => {
+        const factory = fakeSocketFactory();
+        const pending = GeeqSocket.connect({ endpoint: 'https://10.0.0.1', webSocket: factory });
+        factory.last().open();
+        const socket = await pending;
+        open.push(socket);
+        expect(factory.last().url).toBe('wss://10.0.0.1:2082/ws/');
+        expect(socket.url).toBe('wss://10.0.0.1:2082/ws/');
+        expect(socket.state).toBe('open');
+    });
+    it('wants exactly one of endpoint and url', async () => {
+        await expect(GeeqSocket.connect({})).rejects.toMatchObject({ code: 'invalid-argument' });
+        await expect(GeeqSocket.connect({ endpoint: 'https://10.0.0.1:2082', url: URL_WS })).rejects.toMatchObject({ code: 'invalid-argument' });
+    });
+    it('refuses a url that is not a socket', async () => {
+        const error = await failure(GeeqSocket.connect({ url: 'https://10.0.0.1:2082' }));
+        expect(error.code).toBe('invalid-argument');
+        expect(error.message).toMatch(/pass it as endpoint/u);
+    });
+    // A socket that never opened is a certificate, a page scheme or a wrong URL. Retrying
+    // quietly would hide which, so the first failure is reported, with all four causes.
+    it('reports a failed first handshake instead of retrying it', async () => {
+        const factory = fakeSocketFactory();
+        const pending = GeeqSocket.connect({ url: URL_WS, webSocket: factory });
+        factory.last().drop();
+        const error = await failure(pending);
+        expect(error.code).toBe('socket-unreachable');
+        expect(error.message).toMatch(/TLS certificate/u);
+        expect(error.message).toMatch(/\/ws\//u);
+        await jest.advanceTimersByTimeAsync(60_000);
+        expect(factory.sockets).toHaveLength(1);
+    });
+    it('gives up on a handshake that never completes', async () => {
+        const factory = fakeSocketFactory();
+        const pending = GeeqSocket.connect({ url: URL_WS, webSocket: factory, openTimeoutMs: 500 });
+        const caught = failure(pending);
+        await jest.advanceTimersByTimeAsync(500);
+        const error = await caught;
+        expect(error.code).toBe('socket-unreachable');
+        expect(error.message).toMatch(/within 500ms/u);
+        expect(factory.last().readyState).toBe(3);
+    });
+    it('can be abandoned with a signal', async () => {
+        const controller = new AbortController();
+        const factory = fakeSocketFactory();
+        const pending = GeeqSocket.connect({ url: URL_WS, webSocket: factory, signal: controller.signal });
+        controller.abort(new Error('user left'));
+        await expect(pending).rejects.toThrow('user left');
+        expect(factory.last().readyState).toBe(3);
+    });
+    it('names the fix when the runtime has no WebSocket', async () => {
+        const real = globalThis.WebSocket;
+        Object.assign(globalThis, { WebSocket: undefined });
+        try {
+            expect(() => defaultWebSocketFactory(URL_WS)).toThrow(expect.objectContaining({ code: 'socket-unreachable' }));
+            const error = await failure(GeeqSocket.connect({ url: URL_WS }));
+            expect(error.code).toBe('socket-unreachable');
+            expect(error.message).toMatch(/import WebSocket from "ws"/u);
+        }
+        finally {
+            Object.assign(globalThis, { WebSocket: real });
+        }
+    });
+    it('refuses a ws:// socket from an https page before trying it', async () => {
+        Object.assign(globalThis, { location: { protocol: 'https:' } });
+        try {
+            const error = await failure(GeeqSocket.connect({ url: 'ws://10.0.0.1:3100/ws/' }));
+            expect(error.code).toBe('socket-unreachable');
+            expect(error.message).toMatch(/mixed content/u);
+        }
+        finally {
+            delete globalThis.location;
+        }
+    });
+});
+describe('subscriptions', () => {
+    it('subscribes an account under its public key and its account id', async () => {
+        const { socket, wire } = await connected();
+        await socket.subscribe(keypair);
+        expect(wire().frames()).toEqual([
+            {
+                event: 'client',
+                payload: { publicKeys: [toBase64(keypair.publicKey), toBase64(keypair.accountId)] },
+            },
+        ]);
+    });
+    // The node replaces a connection's subscription with each frame and has no
+    // unsubscribe, so subscribing one more account must resend everyone.
+    it('only ever grows the set, and always sends all of it', async () => {
+        const { socket, wire } = await connected();
+        await socket.subscribe(keypair);
+        await socket.subscribe(receiver.accountId);
+        const last = wire().frames().at(-1);
+        expect(last).toEqual({
+            event: 'client',
+            payload: {
+                publicKeys: [
+                    toBase64(keypair.publicKey),
+                    toBase64(keypair.accountId),
+                    toBase64(receiver.accountId),
+                ],
+            },
+        });
+        expect(socket.subscriptions).toHaveLength(3);
+    });
+    it('does not tell a connection the same thing twice', async () => {
+        const { socket, wire } = await connected();
+        await socket.subscribe(keypair);
+        await socket.subscribe(keypair);
+        await socket.subscribe(toBase64(keypair.accountId));
+        expect(wire().frames()).toHaveLength(1);
+    });
+    it('rejects a key that is not 32 bytes, without half-applying the list', async () => {
+        const { socket } = await connected();
+        const error = await failure(socket.subscribe([keypair, 'AAAA']));
+        expect(error.code).toBe('invalid-argument');
+        expect(socket.subscriptions).toEqual([]);
+    });
+    it('sends listen and block-explorer frames', async () => {
+        const { socket, wire } = await connected();
+        await socket.listen();
+        await socket.listen({ blockNumber: 12, now: false });
+        await socket.subscribeBlockExplorer();
+        expect(wire().frames()).toEqual([
+            { event: 'listen', payload: { now: true } },
+            { event: 'listen', payload: { blockNumber: 12, now: false } },
+            { event: 'block-explorer' },
+        ]);
+    });
+});
+describe('staying connected', () => {
+    it('sends a text ping every 25 seconds while open', async () => {
+        const { wire } = await connected();
+        await jest.advanceTimersByTimeAsync(25_000 * 3);
+        expect(wire().sent.filter((frame) => frame === 'ping')).toHaveLength(3);
+    });
+    // A node forgets a connection's subscriptions when it drops. Replaying them before
+    // announcing 'open' is what lets listeners trust the state they are told about.
+    it('reconnects with backoff and restores every subscription before announcing it', async () => {
+        const { socket, factory, wire } = await connected();
+        await socket.subscribe(keypair);
+        await socket.listen();
+        const states = [];
+        socket.onConnectionChange((state) => {
+            states.push(state);
+            if (state === 'open')
+                expect(wire().frames()).toHaveLength(2);
+        });
+        wire().drop();
+        expect(socket.state).toBe('reconnecting');
+        await jest.advanceTimersByTimeAsync(999);
+        expect(factory.sockets).toHaveLength(1);
+        await jest.advanceTimersByTimeAsync(1);
+        expect(factory.sockets).toHaveLength(2);
+        // A second failure doubles the delay.
+        wire().drop();
+        await jest.advanceTimersByTimeAsync(1_999);
+        expect(factory.sockets).toHaveLength(2);
+        await jest.advanceTimersByTimeAsync(1);
+        expect(factory.sockets).toHaveLength(3);
+        wire().open();
+        expect(states).toEqual(['reconnecting', 'open']);
+        expect(wire().frames().map((frame) => frame.event)).toEqual(['client', 'listen']);
+    });
+    it('ignores a superseded connection', async () => {
+        const { socket, factory } = await connected();
+        const first = factory.last();
+        first.drop();
+        await jest.advanceTimersByTimeAsync(1_000);
+        factory.last().open();
+        const seen = [];
+        socket.on('fee-update', (payload) => seen.push(payload));
+        first.receive({ event: 'fee-update', payload: 'stale' });
+        factory.last().receive({ event: 'fee-update', payload: 'fresh' });
+        expect(seen).toEqual(['fresh']);
+    });
+    it('holds a send until the socket is back', async () => {
+        const { socket, wire } = await connected();
+        wire().drop();
+        const sending = socket.send('custom', { a: 1 });
+        await jest.advanceTimersByTimeAsync(1_000);
+        wire().open();
+        await sending;
+        expect(wire().frames()).toEqual([{ event: 'custom', payload: { a: 1 } }]);
+    });
+    // A browser delivers 'close' asynchronously, so a socket can be open by the SDK's books
+    // and already closed by its own. A subscription reported as sent in that window never
+    // reached the node, and a transaction submitted on the strength of it is never heard.
+    it('does not report a frame as sent on a socket that is already closing', async () => {
+        const { socket, factory, wire } = await connected();
+        wire().readyState = 3; // closed, with its close event still to come
+        let sent = false;
+        const subscribing = socket.subscribe(keypair).then(() => {
+            sent = true;
+        });
+        await jest.advanceTimersByTimeAsync(0);
+        expect(sent).toBe(false);
+        expect(socket.state).toBe('reconnecting');
+        await jest.advanceTimersByTimeAsync(1_000);
+        expect(factory.sockets).toHaveLength(2);
+        factory.last().open();
+        await subscribing;
+        expect(factory.last().frames().map((frame) => frame.event)).toEqual(['client']);
+    });
+    // Only a connection that took its subscriptions is a working one. Resetting the backoff
+    // on the handshake alone would redial a node that keeps dying there every second.
+    it('does not announce a connection that dies while its subscriptions are replayed', async () => {
+        const { socket, factory, wire } = await connected();
+        await socket.subscribe(keypair);
+        const states = [];
+        socket.onConnectionChange((state) => states.push(state));
+        wire().drop();
+        let sent = false;
+        const sending = socket.send('custom', { a: 1 }).then(() => {
+            sent = true;
+        });
+        // If an expectation below fails, disposal rejects this mid-wait; report the expectation.
+        sending.catch(() => { });
+        await jest.advanceTimersByTimeAsync(1_000);
+        expect(factory.sockets).toHaveLength(2);
+        const dying = factory.last();
+        dying.send = () => {
+            dying.readyState = 3; // closed under the first replayed frame
+            throw new Error('InvalidStateError: the socket is not open');
+        };
+        dying.open();
+        await jest.advanceTimersByTimeAsync(0);
+        expect(socket.state).toBe('reconnecting');
+        expect(sent).toBe(false);
+        // Still the second attempt as far as the backoff is concerned: two seconds, not one.
+        await jest.advanceTimersByTimeAsync(1_999);
+        expect(factory.sockets).toHaveLength(2);
+        await jest.advanceTimersByTimeAsync(1);
+        expect(factory.sockets).toHaveLength(3);
+        factory.last().open();
+        await sending;
+        expect(states).toEqual(['reconnecting', 'open']);
+        expect(factory.last().frames().map((frame) => frame.event)).toEqual(['client', 'custom']);
+    });
+    it('rejects a send that waited too long, but keeps a replayed frame', async () => {
+        const { socket, factory, wire } = await connected({ openTimeoutMs: 5_000 });
+        wire().drop();
+        const caught = failure(socket.subscribe(keypair));
+        await jest.advanceTimersByTimeAsync(5_000);
+        expect((await caught).code).toBe('socket-unreachable');
+        // The retry dialled at one second is still mid-handshake.
+        expect(factory.sockets).toHaveLength(2);
+        factory.last().open();
+        expect(factory.last().frames().map((frame) => frame.event)).toEqual(['client']);
+    });
+    it('stays down when reconnect is off', async () => {
+        const { socket, factory, wire } = await connected({ reconnect: false });
+        wire().drop();
+        await jest.advanceTimersByTimeAsync(60_000);
+        expect(socket.state).toBe('closed');
+        expect(factory.sockets).toHaveLength(1);
+    });
+});
+describe('receiving', () => {
+    it('hands any event to its listeners, and every frame to onMessage', async () => {
+        const { socket, wire } = await connected();
+        const updates = [];
+        const all = [];
+        const off = socket.on('coin-account-update', (payload) => updates.push(payload));
+        socket.onMessage((message) => all.push(message.event));
+        wire().receive({ event: 'coin-account-update', payload: { buffer: 'AA==', block: 3 } });
+        wire().receive({ event: 'something-new', payload: 1 });
+        off();
+        wire().receive({ event: 'coin-account-update', payload: { buffer: 'AA==', block: 4 } });
+        expect(updates).toEqual([{ buffer: 'AA==', block: 3 }]);
+        expect(all).toEqual(['coin-account-update', 'something-new', 'coin-account-update']);
+    });
+    it('ignores heartbeat replies and anything else that is not an event', async () => {
+        const { socket, wire } = await connected();
+        const all = [];
+        socket.onMessage((message) => all.push(message));
+        wire().receive('pong');
+        wire().receive('[1,2]');
+        wire().receive({ payload: 'no event name' });
+        expect(all).toEqual([]);
+    });
+    it('keeps delivering when a listener throws', async () => {
+        const { socket, wire } = await connected();
+        const report = jest.fn();
+        Object.assign(globalThis, { reportError: report });
+        try {
+            const seen = [];
+            socket.on('x', () => {
+                throw new Error('app bug');
+            });
+            socket.on('x', (payload) => seen.push(payload));
+            wire().receive({ event: 'x', payload: 1 });
+            expect(seen).toEqual([1]);
+            expect(report).toHaveBeenCalledWith(expect.objectContaining({ message: 'app bug' }));
+        }
+        finally {
+            delete globalThis.reportError;
+        }
+    });
+    it('parses transaction statuses the way nodes actually send them', async () => {
+        const { socket, wire } = await connected();
+        const seen = [];
+        socket.onTxStatus((event) => seen.push(event));
+        wire().receive(uutStatus(ID, 'invalid', { error: 'Nonce Check' }));
+        // An older node: numeric status, one publicKey, no type or createdAt.
+        wire().receive({
+            event: 'uut_status',
+            payload: { refHash: ID, publicKey: 'cGs=', status: 3, isValid: true, blockNumber: 9 },
+        });
+        wire().receive({ event: 'uut_status', payload: { refHash: ID, status: 'mystery' } });
+        expect(seen).toHaveLength(2);
+        expect(seen[0]).toMatchObject({
+            id: ID,
+            verdict: 'invalid',
+            isValid: false,
+            error: 'Nonce Check',
+            blockNumber: 42,
+            vlbBlock: 43,
+            direction: 'outgoing',
+        });
+        expect(seen[0]?.createdAt?.toISOString()).toBe('2026-09-30T10:00:00.000Z');
+        expect(seen[1]).toMatchObject({
+            verdict: 'valid',
+            isValid: true,
+            signer: 'cGs=',
+            direction: undefined,
+            createdAt: undefined,
+            vlbBlock: undefined,
+        });
+    });
+});
+describe('socket.track', () => {
+    const tx = () => ({ transactionHash: HASH, publicKey: keypair.publicKey });
+    // Subscribing after submitting is a race the status can win.
+    it('subscribes the signer before it resolves', async () => {
+        const { socket, wire } = await connected();
+        const tracked = await socket.track(tx());
+        expect(tracked).toBeInstanceOf(GeeqTrackedTx);
+        expect(tracked.id).toBe(ID);
+        expect(tracked.status).toBe('pending');
+        expect(wire().frames()).toEqual([
+            {
+                event: 'client',
+                payload: { publicKeys: [toBase64(keypair.publicKey), toBase64(keypair.accountId)] },
+            },
+        ]);
+    });
+    it('settles confirmed on valid, and ignores everything after', async () => {
+        const { socket, wire } = await connected();
+        const tracked = await socket.track(tx());
+        const changes = [];
+        tracked.onChange((t) => changes.push(t.status));
+        wire().receive(uutStatus(toBase64(new Uint8Array(32).fill(1)), 'invalid'));
+        wire().receive(uutStatus(ID, 'valid'));
+        wire().receive(uutStatus(ID, 'invalid'));
+        const outcome = await tracked.settled();
+        expect(outcome).toMatchObject({ status: 'confirmed', id: ID, event: { verdict: 'valid' } });
+        expect(tracked.events).toHaveLength(1);
+        expect(changes).toEqual(['confirmed']);
+        expect(socket.toJSON()).toMatchObject({ tracking: 0 });
+    });
+    it('settles rejected on invalid, with the node reason', async () => {
+        const { socket, wire } = await connected();
+        const tracked = await socket.track(tx());
+        wire().receive(uutStatus(ID, 'invalid', { error: 'Nonce Check failed' }));
+        expect(await tracked.settled()).toMatchObject({
+            status: 'rejected',
+            reason: 'invalid',
+            message: 'Nonce Check failed',
+        });
+    });
+    it('settles rejected on incorrectlyIncluded', async () => {
+        const { socket, wire } = await connected();
+        const tracked = await socket.track(tx());
+        wire().receive(uutStatus(ID, 'incorrectlyIncluded'));
+        expect(await tracked.settled()).toMatchObject({ reason: 'incorrectly-included' });
+    });
+    // A node files a transfer's status under the receiver's account too, marked incoming. A
+    // page subscribed to both ends hears it twice and must decide it once.
+    it('hears the receiver copy as incoming, and settles once on both copies', async () => {
+        const { socket, wire } = await connected();
+        const seen = [];
+        socket.onTxStatus((event) => seen.push(event));
+        await socket.subscribe(receiver);
+        const tracked = await socket.track(tx());
+        const changes = [];
+        tracked.onChange((t) => changes.push(t.status));
+        wire().receive(uutStatus(ID, 'valid'));
+        wire().receive(uutStatus(ID, 'valid', { type: 'incoming' }));
+        expect(seen.map((event) => event.direction)).toEqual(['outgoing', 'incoming']);
+        expect(changes).toEqual(['confirmed']);
+        expect(tracked.events).toHaveLength(1);
+        expect(await tracked.settled()).toMatchObject({ status: 'confirmed' });
+    });
+    // First-event-wins reports false failures: a restarted node can carry a nonsane
+    // transaction forward into a block that then decides it.
+    it('lets a real verdict overturn a nonsane within the grace window', async () => {
+        const { socket, wire } = await connected();
+        const tracked = await socket.track(tx());
+        wire().receive(uutStatus(ID, 'nonsane'));
+        expect(tracked.status).toBe('pending');
+        expect(tracked.events.map((event) => event.verdict)).toEqual(['nonsane']);
+        await jest.advanceTimersByTimeAsync(10_000);
+        wire().receive(uutStatus(ID, 'valid'));
+        expect(await tracked.settled()).toMatchObject({ status: 'confirmed' });
+    });
+    it('settles a nonsane that nothing overturns', async () => {
+        const { socket, wire } = await connected();
+        const tracked = await socket.track(tx(), { nonsaneGraceMs: 2_000 });
+        wire().receive(uutStatus(ID, 'nonsane', { error: 'Receive uvt, reason: target block' }));
+        await jest.advanceTimersByTimeAsync(2_000);
+        expect(await tracked.settled()).toMatchObject({
+            status: 'rejected',
+            reason: 'nonsane',
+            message: 'Receive uvt, reason: target block',
+        });
+    });
+    // A node emits nothing for a submission it answered with an error, so waiting on the
+    // socket would turn a clear refusal into a timeout.
+    it('settles at once when the caller reports a refused submission', async () => {
+        const { socket } = await connected();
+        const tracked = await socket.track(tx());
+        tracked.refused({ status: 503, message: 'Block chain is stopped' });
+        expect(await tracked.settled()).toMatchObject({
+            status: 'rejected',
+            reason: 'refused',
+            httpStatus: 503,
+            message: 'Block chain is stopped',
+        });
+    });
+    it('uses the nonsane reason for a refusal the node also explained', async () => {
+        const { socket, wire } = await connected();
+        const tracked = await socket.track(tx());
+        wire().receive(uutStatus(ID, 'nonsane', { error: 'Receive uat, reason: nonce' }));
+        tracked.refused({ status: 400 });
+        expect(await tracked.settled()).toMatchObject({
+            reason: 'refused',
+            httpStatus: 400,
+            message: 'Receive uat, reason: nonce',
+            event: { verdict: 'nonsane' },
+        });
+    });
+    it('says unknown, not rejected, when nothing final arrives in time', async () => {
+        const { socket } = await connected();
+        const tracked = await socket.track(tx(), { timeoutMs: 60_000 });
+        await jest.advanceTimersByTimeAsync(60_000);
+        const outcome = await tracked.settled();
+        expect(outcome).toMatchObject({ status: 'unknown', reason: 'timeout' });
+        expect(outcome.status === 'unknown' && outcome.message).toMatch(/not a rejection/u);
+    });
+    it('returns the same handle for the same transaction', async () => {
+        const { socket } = await connected();
+        const a = await socket.track(tx());
+        const b = await socket.track(tx());
+        expect(b).toBe(a);
+    });
+    it('stops tracking on release', async () => {
+        const { socket, wire } = await connected();
+        const tracked = await socket.track(tx());
+        tracked.release();
+        wire().receive(uutStatus(ID, 'valid'));
+        expect(await tracked.settled()).toMatchObject({ status: 'unknown', reason: 'released' });
+    });
+    it('needs someone to subscribe to', async () => {
+        const { socket } = await connected();
+        await expect(socket.track({ transactionHash: HASH })).rejects.toMatchObject({
+            code: 'invalid-argument',
+        });
+        await expect(socket.track({ transactionHash: new Uint8Array(3) })).rejects.toMatchObject({
+            code: 'invalid-argument',
+        });
+    });
+    it('does not hand back a handle it could not subscribe for', async () => {
+        const { socket, wire } = await connected({ openTimeoutMs: 1_000 });
+        wire().drop();
+        const caught = failure(socket.track(tx()));
+        await jest.advanceTimersByTimeAsync(1_000);
+        expect((await caught).code).toBe('socket-unreachable');
+        expect(socket.toJSON()).toMatchObject({ tracking: 0 });
+    });
+    it('matches the transactions the SDK builds, by the hash each kind is known by', async () => {
+        const { socket, wire } = await connected();
+        const chainState = { chainNumber: 1, blockNumber: 42, nodeNumber: 3, nonce: 7 };
+        const transfer = await createCoinTransferTx({
+            keypair,
+            to: receiver.accountId,
+            amount: 150n,
+            chainState,
+        });
+        const attestation = await createAttestationTx({
+            keypair,
+            attestHash: new Uint8Array(32).fill(9),
+            chainState,
+        });
+        const a = await socket.track(transfer);
+        const b = await socket.track(attestation);
+        expect(a.id).toBe(transactionIdOf(transfer));
+        expect(b.id).toBe(transactionIdOf(attestation));
+        wire().receive(uutStatus(transactionIdOf(transfer), 'valid'));
+        wire().receive(uutStatus(transactionIdOf(attestation), 'invalid'));
+        expect((await a.settled()).status).toBe('confirmed');
+        expect((await b.settled()).status).toBe('rejected');
+    });
+});
+describe('dispose', () => {
+    it('settles everything pending as unknown and refuses further use', async () => {
+        const { socket, wire } = await connected();
+        const tracked = await socket.track({ transactionHash: HASH, publicKey: keypair.publicKey });
+        const states = [];
+        socket.onConnectionChange((state) => states.push(state));
+        socket.dispose();
+        expect(await tracked.settled()).toMatchObject({ status: 'unknown', reason: 'closed' });
+        expect(states).toEqual(['closed']);
+        expect(wire().readyState).toBe(3);
+        await expect(socket.subscribe(keypair)).rejects.toMatchObject({ code: 'socket-closed' });
+        await expect(socket.send('x')).rejects.toMatchObject({ code: 'socket-closed' });
+    });
+    it('rejects a send still waiting for the connection', async () => {
+        const { socket, wire } = await connected();
+        wire().drop();
+        const sending = socket.send('x');
+        socket.dispose();
+        await expect(sending).rejects.toMatchObject({ code: 'socket-closed' });
+    });
+    it('stops the heartbeat and the reconnect loop', async () => {
+        const { socket, factory, wire } = await connected();
+        wire().drop();
+        socket.dispose();
+        await jest.advanceTimersByTimeAsync(120_000);
+        expect(factory.sockets).toHaveLength(1);
+    });
+});
+describe('in a reactive framework', () => {
+    // Nothing but the URL is enumerable, so a spread, a devtools panel or a structured
+    // clone never walks into a native socket, a timer or a listener.
+    it('exposes only its URL as own enumerable state', async () => {
+        const { socket } = await connected();
+        expect(Object.keys(socket)).toEqual(['url']);
+        expect(socket.toJSON()).toEqual({
+            url: URL_WS,
+            state: 'open',
+            subscriptions: 0,
+            tracking: 0,
+        });
+        expect(String(socket)).toBe(`GeeqSocket(${URL_WS}, open)`);
+    });
+    it('works through a Proxy, as ref() would wrap it', async () => {
+        const { socket, wire } = await connected();
+        const proxied = new Proxy(socket, {});
+        await proxied.subscribe(keypair);
+        expect(wire().frames()).toHaveLength(1);
+    });
+});
+//# sourceMappingURL=socket.test.js.map