@novasamatech/host-substrate-chain-connection 0.7.4 → 0.7.5-1

package/dist/pauseController.js

@@ -25,6 +25,12 @@ export const createPauseController = () => {
         base = b;
         return (onMsg, onH) => {
             reinvocationPending = false;
+            // A new inner invocation means a fresh consumer (e.g. the host cached
+            // this provider across destroy → re-acquire). Clear `destroyed` so
+            // pause/resume work on the new connection. The flag's job is to gate
+            // pause/resume between the previous inner.disconnect and the next
+            // inner re-invocation — outside that window it should not stick.
+            destroyed = false;
             onMessage = onMsg;
             onHalt = onH;
             real = null;

package/dist/pauseController.spec.js

@@ -174,4 +174,27 @@ describe('createPauseController', () => {
         inner(vi.fn(), vi.fn());
         expect(mock.latest.send).not.toHaveBeenCalled();
     });
+    it('pause/resume work again after disconnect + a fresh inner invocation', () => {
+        // The host caches one provider per chain. After destroyClient cascades
+        // through the inner connection's disconnect, the same pauseController is
+        // reused on the next lockApi. pause/resume must drive the new socket; the
+        // `destroyed` flag from the prior teardown must not stick.
+        const mock = createMockBase();
+        const pc = createPauseController();
+        const inner = pc.middleware(mock.base);
+        const firstConn = inner(vi.fn(), vi.fn());
+        firstConn.disconnect(); // sets destroyed = true under the old design
+        const secondOnHalt = vi.fn();
+        inner(vi.fn(), secondOnHalt);
+        expect(mock.invocations).toHaveLength(2); // new socket opened
+        pc.pause();
+        expect(pc.isPaused()).toBe(true);
+        expect(mock.invocations[1].disconnect).toHaveBeenCalledTimes(1);
+        expect(secondOnHalt).toHaveBeenCalledWith({ type: 'paused' });
+        inner(vi.fn(), vi.fn()); // simulate the post-halt re-invocation
+        expect(mock.invocations).toHaveLength(2); // still paused → no new base connection
+        pc.resume();
+        expect(pc.isPaused()).toBe(false);
+        expect(mock.invocations).toHaveLength(3); // resume opens a fresh socket
+    });
 });

package/dist/subscriptionReplayProvider.js

@@ -1,4 +1,4 @@
-import { isResponse } from '@polkadot-api/json-rpc-provider';
+import { isRequest, isResponse } from '@polkadot-api/json-rpc-provider';
 const isChainMethod = (method) => method.startsWith('chain_');
 const isSubscribeMethod = (method) => {
     if (isChainMethod(method))
@@ -8,47 +8,88 @@ const isSubscribeMethod = (method) => {
 };
 const isUnsubscribeMethod = (method) => !isChainMethod(method) && method.toLowerCase().includes('unsubscribe');
 export const withSubscriptionReplay = (provider, onReconnect) => onMessage => {
-    // request id → request object (sent, awaiting server subscription ID)
     const pendingSubscriptions = new Map();
-    // server subscription ID → request object (confirmed by server)
+    // Confirmed subscriptions keyed by the FIRST subId the consumer received.
+    // That key stays stable across reconnects so the consumer's subscription
+    // manager (which only ever sees the first subId) keeps routing notifications.
     const activeSubscriptions = new Map();
+    // Reverse index for inbound notification translation.
+    const currentToConsumer = new Map();
+    const removeSubscription = (consumerSubId) => {
+        const sub = activeSubscriptions.get(consumerSubId);
+        if (sub === undefined)
+            return undefined;
+        activeSubscriptions.delete(consumerSubId);
+        currentToConsumer.delete(sub.currentSubId);
+        // If a reconnect re-send for this entry is mid-flight, drop the pending
+        // record so the eventual response doesn't try to update a removed entry.
+        const pending = pendingSubscriptions.get(sub.id);
+        if (pending?.reconnectFor === consumerSubId)
+            pendingSubscriptions.delete(sub.id);
+        return sub;
+    };
     const conn = provider(message => {
-        // Response with a string result means it's a subscription confirmation
-        if (message.id && isResponse(message) && 'result' in message && typeof message.result === 'string') {
-            const id = message.id;
-            const pending = pendingSubscriptions.get(id);
+        // Subscribe response (string result) — register fresh, or update an
+        // existing entry's currentSubId on a re-confirmation after reconnect.
+        if (isResponse(message) && message.id != null && 'result' in message && typeof message.result === 'string') {
+            const pending = pendingSubscriptions.get(message.id);
             if (pending !== undefined) {
-                pendingSubscriptions.delete(id);
-                activeSubscriptions.set(message.result, { id, payload: pending });
+                pendingSubscriptions.delete(message.id);
+                const newSubId = message.result;
+                if (pending.reconnectFor !== null) {
+                    const sub = activeSubscriptions.get(pending.reconnectFor);
+                    if (sub !== undefined) {
+                        currentToConsumer.delete(sub.currentSubId);
+                        sub.currentSubId = newSubId;
+                        currentToConsumer.set(newSubId, pending.reconnectFor);
+                    }
+                    // Suppress: the consumer already saw the original response and
+                    // registered its subscriber under the original subId.
+                    return;
+                }
+                activeSubscriptions.set(newSubId, { id: message.id, payload: pending.payload, currentSubId: newSubId });
+                currentToConsumer.set(newSubId, newSubId);
+            }
+            onMessage(message);
+            return;
+        }
+        // Notification: rewrite the server's current subId back to the consumer's
+        // stable subId so raw-client's subscription manager routes the event.
+        if (isRequest(message)) {
+            const params = message.params;
+            const incoming = params?.subscription;
+            if (typeof incoming === 'string') {
+                const consumerSubId = currentToConsumer.get(incoming);
+                if (consumerSubId !== undefined && consumerSubId !== incoming) {
+                    onMessage({ ...message, params: { ...params, subscription: consumerSubId } });
+                    return;
+                }
             }
         }
         onMessage(message);
     });
     const unsubReconnect = onReconnect(() => {
-        const toResend = [...activeSubscriptions.values()];
-        activeSubscriptions.clear();
-        for (const { id, payload } of toResend) {
-            pendingSubscriptions.set(id, payload);
-            conn.send(payload);
+        for (const [consumerSubId, sub] of activeSubscriptions) {
+            pendingSubscriptions.set(sub.id, { payload: sub.payload, reconnectFor: consumerSubId });
+            conn.send(sub.payload);
         }
     });
     return {
         send(message) {
-            const { method, id, params } = message;
-            if (method) {
+            if (isRequest(message)) {
+                const { method, id, params } = message;
                 if (isSubscribeMethod(method)) {
-                    if (id !== undefined)
-                        pendingSubscriptions.set(id, message);
+                    if (id != null)
+                        pendingSubscriptions.set(id, { payload: message, reconnectFor: null });
                 }
                 else if (isUnsubscribeMethod(method)) {
-                    const subId = params?.[0];
-                    // Note: callers must use the most recently received server-assigned subscription
-                    // ID to successfully unsubscribe. Using a stale ID from a previous connection
-                    // will silently fail. Additionally, if the caller unsubscribes while a subscription
-                    // is in pendingSubscriptions (i.e. after reconnect but before the server assigns a
-                    // new ID), the pending entry is not removed and may be replayed on the next reconnect.
-                    if (subId !== undefined)
-                        activeSubscriptions.delete(subId);
+                    const consumerSubId = params?.[0];
+                    const sub = consumerSubId !== undefined ? removeSubscription(consumerSubId) : undefined;
+                    if (sub !== undefined && sub.currentSubId !== consumerSubId) {
+                        const rest = (params ?? []).slice(1);
+                        conn.send({ ...message, params: [sub.currentSubId, ...rest] });
+                        return;
+                    }
                 }
             }
             conn.send(message);
@@ -56,6 +97,7 @@ export const withSubscriptionReplay = (provider, onReconnect) => onMessage => {
         disconnect() {
             pendingSubscriptions.clear();
             activeSubscriptions.clear();
+            currentToConsumer.clear();
             unsubReconnect();
             conn.disconnect();
         },

package/dist/subscriptionReplayProvider.spec.js

@@ -98,23 +98,63 @@ describe('withSubscriptionReplay', () => {
         expect(mock.send).toHaveBeenCalledWith(msg1);
         expect(mock.send).toHaveBeenCalledWith(msg2);
     });
-    it('re-registers subscriptions under new server IDs after reconnect', () => {
+    it('translates inbound notifications from the new server subId back to the consumer-facing subId after reconnect', () => {
+        const mock = createMockProvider();
+        const control = createReconnectControl();
+        const onMessage = vi.fn();
+        const conn = withSubscriptionReplay(mock.provider, control.onReconnect)(onMessage);
+        conn.send(req(1, 'statement_subscribeStatement'));
+        mock.simulateMessage(res(1, 'old-sub-id'));
+        control.triggerReconnect();
+        mock.simulateMessage(res(1, 'new-sub-id'));
+        // The post-reconnect re-confirmation must NOT reach the consumer; it would be
+        // a duplicate response for a request whose callback was consumed on first connect.
+        expect(onMessage).not.toHaveBeenCalledWith(res(1, 'new-sub-id'));
+        // Notifications from the server now arrive under the new server subId. The
+        // middleware must rewrite them to the consumer's stable subId, otherwise
+        // the consumer's subscription manager (which only ever saw 'old-sub-id')
+        // would route them nowhere.
+        onMessage.mockClear();
+        mock.simulateMessage({
+            jsonrpc: '2.0',
+            method: 'state_storage',
+            params: { subscription: 'new-sub-id', result: { changes: [] } },
+        });
+        expect(onMessage).toHaveBeenCalledWith({
+            jsonrpc: '2.0',
+            method: 'state_storage',
+            params: { subscription: 'old-sub-id', result: { changes: [] } },
+        });
+    });
+    it('translates outbound unsubscribe requests from the consumer-facing subId to the current server subId', () => {
+        const mock = createMockProvider();
+        const control = createReconnectControl();
+        const conn = withSubscriptionReplay(mock.provider, control.onReconnect)(vi.fn());
+        conn.send(req(1, 'statement_subscribeStatement'));
+        mock.simulateMessage(res(1, 'old-sub-id'));
+        control.triggerReconnect();
+        mock.simulateMessage(res(1, 'new-sub-id'));
+        mock.send.mockClear();
+        // Consumer only knows 'old-sub-id' (the first response it ever received).
+        // Middleware must rewrite the unsubscribe params to use the current server subId.
+        conn.send(req(2, 'statement_unsubscribeStatement', ['old-sub-id']));
+        expect(mock.send).toHaveBeenCalledWith(expect.objectContaining({ method: 'statement_unsubscribeStatement', params: ['new-sub-id'] }));
+    });
+    it('drops a subscription on consumer-side unsubscribe so it is not replayed on the next reconnect', () => {
         const mock = createMockProvider();
         const control = createReconnectControl();
         const conn = withSubscriptionReplay(mock.provider, control.onReconnect)(vi.fn());
         const subscribeMsg = req(1, 'statement_subscribeStatement');
         conn.send(subscribeMsg);
         mock.simulateMessage(res(1, 'old-sub-id'));
-        // First reconnect — replays and moves to pending
         control.triggerReconnect();
-        // Server assigns new subscription ID
         mock.simulateMessage(res(1, 'new-sub-id'));
-        // Unsubscribing with the old ID should have no effect (old ID is no longer tracked)
+        // Consumer unsubscribes using the only subId it knows about.
         conn.send(req(2, 'statement_unsubscribeStatement', ['old-sub-id']));
         mock.send.mockClear();
-        // Second reconnect — subscription is still active (new-sub-id was not removed)
         control.triggerReconnect();
-        expect(mock.send).toHaveBeenCalledWith(subscribeMsg);
+        // Subscription was unsubscribed; nothing should be re-sent.
+        expect(mock.send).not.toHaveBeenCalled();
     });
     it('does not replay unsubscribed subscriptions on reconnect', () => {
         const mock = createMockProvider();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-substrate-chain-connection",
   "type": "module",
-  "version": "0.7.4",
+  "version": "0.7.5-1",
   "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.4",
+    "@novasamatech/storage-adapter": "0.7.5-1",
     "@polkadot-api/ws-provider": "^0.9.0",
     "@polkadot-api/json-rpc-provider": "^0.2.0",
     "@polkadot-api/json-rpc-provider-proxy": "^0.4.0",