@novasamatech/host-substrate-chain-connection 0.7.9-2 → 0.7.9-4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-substrate-chain-connection",
   "type": "module",
-  "version": "0.7.9-2",
+  "version": "0.7.9-4",
   "description": "Chain connection pool with ref counting and provider branching for Polkadot API",
   "license": "Apache-2.0",
   "repository": {
@@ -25,7 +25,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@novasamatech/storage-adapter": "0.7.9-2",
+    "@novasamatech/storage-adapter": "0.7.9-4",
     "@polkadot-api/ws-provider": "^0.9.0",
     "@polkadot-api/json-rpc-provider": "^0.2.0",
     "@polkadot-api/json-rpc-provider-proxy": "^0.4.0",

package/dist/nodeSubscriptionReplayMiddleware.d.ts

@@ -1,2 +0,0 @@
-import type { Middleware } from '@polkadot-api/ws-provider';
-export declare const nodeSubscriptionReplayMiddleware: Middleware;

package/dist/nodeSubscriptionReplayMiddleware.js

@@ -1,105 +0,0 @@
-import { isResponse } from '@polkadot-api/json-rpc-provider';
-const isChainMethod = (method) => method.startsWith('chain_');
-const isSubscribeMethod = (method) => {
-    if (isChainMethod(method))
-        return false;
-    const m = method.toLowerCase();
-    return m.includes('subscribe') && !m.includes('unsubscribe');
-};
-const isUnsubscribeMethod = (method) => !isChainMethod(method) && method.toLowerCase().includes('unsubscribe');
-// Middleware that replays non-chain subscriptions across reconnects (chain_*
-// subscriptions are handled by PAPI itself).
-//
-// Outgoing subscribe requests are remembered. When the inner provider hands
-// over a new connection, every such request is re-sent so the server assigns
-// fresh subscription ids. The new server ids are remapped back to the id the
-// consumer first saw, keeping inbound notifications and outbound unsubscribes
-// transparent across the drop.
-export const nodeSubscriptionReplayMiddleware = base => {
-    const subs = new Map();
-    const remap = new Map();
-    const pendingReplays = new Map();
-    let counter = 0;
-    const nextReplayId = () => `__replay_${counter++}`;
-    const findReqIdByConsumerSub = (consumerSubId) => {
-        for (const [reqId, sub] of subs)
-            if (sub.consumerSubId === consumerSubId)
-                return reqId;
-        return null;
-    };
-    const consumerToServerSubId = (consumerSubId) => {
-        for (const [server, consumer] of remap)
-            if (consumer === consumerSubId)
-                return server;
-        return consumerSubId;
-    };
-    return (onMessage, onHalt) => {
-        const handleMessage = (raw) => {
-            let msg = raw;
-            if (isResponse(msg)) {
-                const pendingConsumerSubId = pendingReplays.get(msg.id);
-                if (pendingConsumerSubId !== undefined) {
-                    pendingReplays.delete(msg.id);
-                    if ('result' in msg && msg.result !== pendingConsumerSubId)
-                        remap.set(msg.result, pendingConsumerSubId);
-                    return;
-                }
-                const sub = subs.get(msg.id);
-                if (sub) {
-                    if ('result' in msg)
-                        sub.consumerSubId = msg.result;
-                    // subscribe failed — drop so we don't keep a zombie entry across reconnects
-                    else
-                        subs.delete(msg.id);
-                }
-            }
-            else {
-                const consumerSubId = remap.get(msg.params?.subscription);
-                if (consumerSubId !== undefined)
-                    msg = { ...msg, params: { ...msg.params, subscription: consumerSubId } };
-            }
-            onMessage(msg);
-        };
-        // Server sub ids from the prior connection are dead now.
-        remap.clear();
-        pendingReplays.clear();
-        const connection = base(handleMessage, onHalt);
-        for (const { req, consumerSubId } of subs.values()) {
-            if (consumerSubId === undefined)
-                continue;
-            const id = nextReplayId();
-            pendingReplays.set(id, consumerSubId);
-            connection.send({ ...req, id });
-        }
-        return {
-            send(msg) {
-                if (msg.id != null) {
-                    if (isSubscribeMethod(msg.method)) {
-                        subs.set(msg.id, { req: msg });
-                    }
-                    else if (isUnsubscribeMethod(msg.method)) {
-                        const consumerSubId = msg.params?.[0];
-                        if (typeof consumerSubId === 'string') {
-                            const reqId = findReqIdByConsumerSub(consumerSubId);
-                            if (reqId !== null)
-                                subs.delete(reqId);
-                            const serverSubId = consumerToServerSubId(consumerSubId);
-                            if (serverSubId !== consumerSubId) {
-                                remap.delete(serverSubId);
-                                connection.send({ ...msg, params: [serverSubId, ...msg.params.slice(1)] });
-                                return;
-                            }
-                        }
-                    }
-                }
-                connection.send(msg);
-            },
-            disconnect() {
-                subs.clear();
-                remap.clear();
-                pendingReplays.clear();
-                connection.disconnect();
-            },
-        };
-    };
-};

package/dist/nodeSubscriptionReplayMiddleware.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/nodeSubscriptionReplayMiddleware.spec.js

@@ -1,255 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { nodeSubscriptionReplayMiddleware } from './nodeSubscriptionReplayMiddleware.js';
-const createMockBase = () => {
-    const invocations = [];
-    const base = (onMessage, onHalt) => {
-        const send = vi.fn();
-        const disconnect = vi.fn();
-        invocations.push({ onMessage: onMessage, onHalt: onHalt, send, disconnect });
-        return { send, disconnect };
-    };
-    return {
-        base,
-        invocations,
-        get latest() {
-            const last = invocations[invocations.length - 1];
-            if (!last)
-                throw new Error('no base connection has been created yet');
-            return last;
-        },
-    };
-};
-const req = (id, method, params = []) => ({
-    jsonrpc: '2.0',
-    id,
-    method,
-    params,
-});
-const res = (id, result) => ({ jsonrpc: '2.0', id, result });
-const notify = (method, subscription, result = {}) => ({
-    jsonrpc: '2.0',
-    method,
-    params: { subscription, result },
-});
-const firstSent = (send) => {
-    const call = send.mock.calls[0];
-    if (!call)
-        throw new Error('expected send to have been called at least once');
-    return call[0];
-};
-describe('nodeSubscriptionReplayMiddleware', () => {
-    it('forwards incoming messages to onMessage unmodified', () => {
-        const mock = createMockBase();
-        const onMessage = vi.fn();
-        nodeSubscriptionReplayMiddleware(mock.base)(onMessage, vi.fn());
-        mock.latest.onMessage(res(1, '0xabc'));
-        expect(onMessage).toHaveBeenCalledWith(res(1, '0xabc'));
-    });
-    it('forwards send calls to the underlying connection', () => {
-        const mock = createMockBase();
-        const conn = nodeSubscriptionReplayMiddleware(mock.base)(vi.fn(), vi.fn());
-        conn.send(req(1, 'chain_getBlock'));
-        expect(mock.latest.send).toHaveBeenCalledWith(req(1, 'chain_getBlock'));
-    });
-    it('passes onHalt through to the base connection', () => {
-        const mock = createMockBase();
-        const onHalt = vi.fn();
-        nodeSubscriptionReplayMiddleware(mock.base)(vi.fn(), onHalt);
-        expect(mock.latest.onHalt).toBe(onHalt);
-    });
-    it('does not replay non-subscription requests on reconnect', () => {
-        const mock = createMockBase();
-        const inner = nodeSubscriptionReplayMiddleware(mock.base);
-        const conn = inner(vi.fn(), vi.fn());
-        conn.send(req(1, 'chain_getBlock'));
-        inner(vi.fn(), vi.fn());
-        expect(mock.latest.send).not.toHaveBeenCalled();
-    });
-    it('does not replay pending subscriptions (no server response yet) on reconnect', () => {
-        const mock = createMockBase();
-        const inner = nodeSubscriptionReplayMiddleware(mock.base);
-        const conn = inner(vi.fn(), vi.fn());
-        conn.send(req(1, 'statement_subscribeStatement'));
-        // intentionally no simulated response — subscription not confirmed by server
-        inner(vi.fn(), vi.fn());
-        expect(mock.latest.send).not.toHaveBeenCalled();
-    });
-    it('replays an active subscription on reconnect with a fresh internal id', () => {
-        const mock = createMockBase();
-        const inner = nodeSubscriptionReplayMiddleware(mock.base);
-        const conn = inner(vi.fn(), vi.fn());
-        conn.send(req(1, 'statement_subscribeStatement'));
-        mock.latest.onMessage(res(1, 'srv-1'));
-        inner(vi.fn(), vi.fn());
-        expect(mock.latest.send).toHaveBeenCalledTimes(1);
-        const resent = firstSent(mock.latest.send);
-        expect(resent.method).toBe('statement_subscribeStatement');
-        expect(resent.params).toEqual([]);
-        // internal replay id, distinct from the consumer's original id
-        expect(resent.id).not.toBe(1);
-        expect(typeof resent.id).toBe('string');
-    });
-    it('replays multiple active subscriptions on reconnect', () => {
-        const mock = createMockBase();
-        const inner = nodeSubscriptionReplayMiddleware(mock.base);
-        const conn = inner(vi.fn(), vi.fn());
-        conn.send(req(1, 'statement_subscribeStatement'));
-        mock.latest.onMessage(res(1, 'srv-1'));
-        conn.send(req(2, 'state_subscribeStorage', [[]]));
-        mock.latest.onMessage(res(2, 'srv-2'));
-        inner(vi.fn(), vi.fn());
-        const methods = mock.latest.send.mock.calls.map(c => c[0].method);
-        expect(methods).toHaveLength(2);
-        expect(methods).toContain('statement_subscribeStatement');
-        expect(methods).toContain('state_subscribeStorage');
-    });
-    it('suppresses the replay subscribe response from reaching onMessage', () => {
-        const mock = createMockBase();
-        const inner = nodeSubscriptionReplayMiddleware(mock.base);
-        const conn = inner(vi.fn(), vi.fn());
-        conn.send(req(1, 'statement_subscribeStatement'));
-        mock.latest.onMessage(res(1, 'srv-1'));
-        const onMessage2 = vi.fn();
-        inner(onMessage2, vi.fn());
-        const replayId = firstSent(mock.latest.send).id;
-        mock.latest.onMessage(res(replayId, 'srv-2'));
-        expect(onMessage2).not.toHaveBeenCalled();
-    });
-    it('remaps notifications from the new server sub id to the original consumer id', () => {
-        const mock = createMockBase();
-        const inner = nodeSubscriptionReplayMiddleware(mock.base);
-        const conn = inner(vi.fn(), vi.fn());
-        conn.send(req(1, 'statement_subscribeStatement'));
-        mock.latest.onMessage(res(1, 'srv-1'));
-        const onMessage2 = vi.fn();
-        inner(onMessage2, vi.fn());
-        const replayId = firstSent(mock.latest.send).id;
-        mock.latest.onMessage(res(replayId, 'srv-2'));
-        mock.latest.onMessage(notify('chain_newHead', 'srv-2', { n: 42 }));
-        expect(onMessage2).toHaveBeenCalledWith(notify('chain_newHead', 'srv-1', { n: 42 }));
-    });
-    it('forwards notifications with no remap entry unchanged', () => {
-        const mock = createMockBase();
-        const onMessage = vi.fn();
-        const conn = nodeSubscriptionReplayMiddleware(mock.base)(onMessage, vi.fn());
-        conn.send(req(1, 'statement_subscribeStatement'));
-        mock.latest.onMessage(res(1, 'srv-1'));
-        onMessage.mockClear();
-        const n = notify('chain_newHead', 'srv-1', { n: 1 });
-        mock.latest.onMessage(n);
-        expect(onMessage).toHaveBeenCalledWith(n);
-    });
-    it('does not remap when the replay response returns the same sub id', () => {
-        const mock = createMockBase();
-        const inner = nodeSubscriptionReplayMiddleware(mock.base);
-        const conn = inner(vi.fn(), vi.fn());
-        conn.send(req(1, 'statement_subscribeStatement'));
-        mock.latest.onMessage(res(1, 'srv-1'));
-        const onMessage2 = vi.fn();
-        inner(onMessage2, vi.fn());
-        const replayId = firstSent(mock.latest.send).id;
-        // server assigns the same sub id after reconnect
-        mock.latest.onMessage(res(replayId, 'srv-1'));
-        const n = notify('chain_newHead', 'srv-1', { n: 1 });
-        mock.latest.onMessage(n);
-        expect(onMessage2).toHaveBeenCalledWith(n);
-    });
-    it('translates the consumer sub id to the current server sub id on unsubscribe', () => {
-        const mock = createMockBase();
-        const inner = nodeSubscriptionReplayMiddleware(mock.base);
-        const conn = inner(vi.fn(), vi.fn());
-        conn.send(req(1, 'statement_subscribeStatement'));
-        mock.latest.onMessage(res(1, 'srv-1'));
-        const conn2 = inner(vi.fn(), vi.fn());
-        const replayId = firstSent(mock.latest.send).id;
-        mock.latest.onMessage(res(replayId, 'srv-2'));
-        mock.latest.send.mockClear();
-        conn2.send(req(2, 'statement_unsubscribeStatement', ['srv-1']));
-        expect(mock.latest.send).toHaveBeenCalledWith(req(2, 'statement_unsubscribeStatement', ['srv-2']));
-    });
-    it('forwards unsubscribe unchanged when the sub id was never remapped', () => {
-        const mock = createMockBase();
-        const conn = nodeSubscriptionReplayMiddleware(mock.base)(vi.fn(), vi.fn());
-        conn.send(req(1, 'statement_subscribeStatement'));
-        mock.latest.onMessage(res(1, 'srv-1'));
-        mock.latest.send.mockClear();
-        conn.send(req(2, 'statement_unsubscribeStatement', ['srv-1']));
-        expect(mock.latest.send).toHaveBeenCalledWith(req(2, 'statement_unsubscribeStatement', ['srv-1']));
-    });
-    it('preserves extra unsubscribe params while rewriting only the sub id', () => {
-        const mock = createMockBase();
-        const inner = nodeSubscriptionReplayMiddleware(mock.base);
-        const conn = inner(vi.fn(), vi.fn());
-        conn.send(req(1, 'some_subscribe'));
-        mock.latest.onMessage(res(1, 'srv-1'));
-        const conn2 = inner(vi.fn(), vi.fn());
-        const replayId = firstSent(mock.latest.send).id;
-        mock.latest.onMessage(res(replayId, 'srv-2'));
-        mock.latest.send.mockClear();
-        conn2.send(req(2, 'some_unsubscribe', ['srv-1', 'extra-arg']));
-        expect(mock.latest.send).toHaveBeenCalledWith(req(2, 'some_unsubscribe', ['srv-2', 'extra-arg']));
-    });
-    it('does not replay a subscription after it has been unsubscribed', () => {
-        const mock = createMockBase();
-        const inner = nodeSubscriptionReplayMiddleware(mock.base);
-        const conn = inner(vi.fn(), vi.fn());
-        conn.send(req(1, 'statement_subscribeStatement'));
-        mock.latest.onMessage(res(1, 'srv-1'));
-        conn.send(req(2, 'statement_unsubscribeStatement', ['srv-1']));
-        inner(vi.fn(), vi.fn());
-        expect(mock.latest.send).not.toHaveBeenCalled();
-    });
-    it('removes the remap entry on unsubscribe so late notifications under the old server id pass through unchanged', () => {
-        const mock = createMockBase();
-        const inner = nodeSubscriptionReplayMiddleware(mock.base);
-        const conn = inner(vi.fn(), vi.fn());
-        conn.send(req(1, 'statement_subscribeStatement'));
-        mock.latest.onMessage(res(1, 'srv-1'));
-        const onMessage2 = vi.fn();
-        const conn2 = inner(onMessage2, vi.fn());
-        const replayId = firstSent(mock.latest.send).id;
-        mock.latest.onMessage(res(replayId, 'srv-2'));
-        conn2.send(req(2, 'statement_unsubscribeStatement', ['srv-1']));
-        onMessage2.mockClear();
-        const straggler = notify('chain_newHead', 'srv-2', { n: 9 });
-        mock.latest.onMessage(straggler);
-        expect(onMessage2).toHaveBeenCalledWith(straggler);
-    });
-    it('clears all state on disconnect', () => {
-        const mock = createMockBase();
-        const inner = nodeSubscriptionReplayMiddleware(mock.base);
-        const conn = inner(vi.fn(), vi.fn());
-        conn.send(req(1, 'statement_subscribeStatement'));
-        mock.latest.onMessage(res(1, 'srv-1'));
-        conn.disconnect();
-        expect(mock.latest.disconnect).toHaveBeenCalledTimes(1);
-        // a fresh invocation after disconnect should not replay anything
-        inner(vi.fn(), vi.fn());
-        expect(mock.latest.send).not.toHaveBeenCalled();
-    });
-    it('clears remap across reconnects so stale ids from the prior connection do not leak', () => {
-        const mock = createMockBase();
-        const inner = nodeSubscriptionReplayMiddleware(mock.base);
-        const conn = inner(vi.fn(), vi.fn());
-        conn.send(req(1, 'statement_subscribeStatement'));
-        mock.latest.onMessage(res(1, 'srv-1'));
-        // first reconnect: server re-assigns srv-2 (remap gains srv-2 -> srv-1)
-        const onMessage2 = vi.fn();
-        inner(onMessage2, vi.fn());
-        const replayId2 = firstSent(mock.latest.send).id;
-        mock.latest.onMessage(res(replayId2, 'srv-2'));
-        // second reconnect: remap is cleared BEFORE replay; server assigns srv-3
-        const onMessage3 = vi.fn();
-        inner(onMessage3, vi.fn());
-        const replayId3 = firstSent(mock.latest.send).id;
-        mock.latest.onMessage(res(replayId3, 'srv-3'));
-        // notification under srv-2 from the previous connection must not remap to srv-1
-        const stale = notify('chain_newHead', 'srv-2', { n: 0 });
-        mock.latest.onMessage(stale);
-        expect(onMessage3).toHaveBeenCalledWith(stale);
-        // notification under srv-3 is remapped to the consumer's original id (srv-1)
-        onMessage3.mockClear();
-        mock.latest.onMessage(notify('chain_newHead', 'srv-3', { n: 1 }));
-        expect(onMessage3).toHaveBeenCalledWith(notify('chain_newHead', 'srv-1', { n: 1 }));
-    });
-});

package/dist/providers.d.ts

@@ -1,6 +0,0 @@
-import type { JsonRpcProvider } from '@polkadot-api/json-rpc-provider';
-import type { ConnectionStatus } from './types.js';
-export declare const createWsJsonRpcProvider: (options: {
-    endpoints: string[];
-    onStatusChanged?: (status: ConnectionStatus) => void;
-}) => JsonRpcProvider;

package/dist/providers.js

@@ -1,38 +0,0 @@
-import { withPolkadotSdkCompat } from 'polkadot-api/polkadot-sdk-compat';
-import { WsEvent, getWsProvider } from 'polkadot-api/ws-provider';
-import { withSubscriptionReplay } from './subscriptionReplayProvider.js';
-const noop = () => {
-    // empty
-};
-export const createWsJsonRpcProvider = (options) => {
-    let notifyReconnect = noop;
-    const onReconnect = (cb) => {
-        notifyReconnect = cb;
-        return () => {
-            notifyReconnect = noop;
-        };
-    };
-    return withPolkadotSdkCompat(withSubscriptionReplay(getWsProvider(options.endpoints, {
-        heartbeatTimeout: Number.POSITIVE_INFINITY,
-        onStatusChanged: event => {
-            let status;
-            switch (event.type) {
-                case WsEvent.CONNECTING:
-                    status = 'connecting';
-                    break;
-                case WsEvent.CONNECTED:
-                    notifyReconnect();
-                    status = 'connected';
-                    break;
-                case WsEvent.ERROR:
-                case WsEvent.CLOSE:
-                    status = 'disconnected';
-                    break;
-                default:
-                    status = 'disconnected';
-                    break;
-            }
-            options.onStatusChanged?.(status);
-        },
-    }), onReconnect));
-};