@novasamatech/host-substrate-chain-connection 0.7.6 → 0.7.8-0

package/dist/connectionPool.js

@@ -106,15 +106,31 @@ export const createChainConnection = ({ resolve, clientOptions, createProvider,
         },
         getProvider(chain) {
             return getSyncProvider(onResult => {
+                let teardownCalled = false;
+                let pendingUnlock = null;
+                // Idempotent: subsequent calls (e.g. teardown after disconnect) are no-ops.
+                const releaseUnlock = () => {
+                    const unlock = pendingUnlock;
+                    pendingUnlock = null;
+                    unlock?.();
+                };
                 rawAcquire(chain)
                     .then(({ pooled, unlock }) => {
-                    onResult((onMessage, _onHalt) => pooled.provider.branch(unlock)(onMessage));
+                    if (teardownCalled) {
+                        unlock();
+                        onResult(null);
+                        return;
+                    }
+                    pendingUnlock = unlock;
+                    onResult((onMessage, _onHalt) => pooled.provider.branch(releaseUnlock)(onMessage));
                 })
                     .catch(() => {
                     onResult(null);
                 });
+                // Covers teardown without disconnect, and teardown before acquire resolves.
                 return () => {
-                    /* empty */
+                    teardownCalled = true;
+                    releaseUnlock();
                 };
             });
         },

package/dist/connectionPool.spec.js

@@ -239,14 +239,19 @@ describe('createChainConnection', () => {
             expect(chainA.resume).toHaveBeenCalledTimes(1);
             unlock();
         });
-        it('skips providers that do not expose pause/resume', async () => {
-            const { connection } = createTestConnection();
-            const { unlock } = await connection.lockApi(testChain('a'));
-            expect(() => {
-                connection.pauseAll();
-                connection.resumeAll();
-            }).not.toThrow();
-            unlock();
+        it('skips non-pausable providers without preventing pause on the rest', async () => {
+            // Mixed pool: 'a' is non-pausable, 'b' is pausable. The pausable one must
+            // still receive pause/resume even though the other is silently skipped.
+            const pausable = createPausableMockProvider();
+            const connection = createChainConnection({
+                createProvider: c => (c.genesisHash === 'b' ? pausable.provider : createMockProvider().provider),
+            });
+            await connection.lockApi(testChain('a'));
+            await connection.lockApi(testChain('b'));
+            connection.pauseAll();
+            connection.resumeAll();
+            expect(pausable.pause).toHaveBeenCalledTimes(1);
+            expect(pausable.resume).toHaveBeenCalledTimes(1);
         });
         it('does not call pause on providers for chains that have been destroyed', async () => {
             const chainA = createPausableMockProvider();

package/dist/metadataCache.js

@@ -39,7 +39,10 @@ export const createMetadataCache = (options) => {
                 setMetadata(key, metadata) {
                     const k = cacheKey(chainId, key);
                     memory.set(k, metadata);
-                    storage?.write(k, bytesToBase64(metadata));
+                    // setMetadata is fire-and-forget by contract; log persist failures.
+                    storage?.write(k, bytesToBase64(metadata)).orTee(error => {
+                        console.error(`[metadataCache] failed to persist metadata for ${k}:`, error);
+                    });
                 },
             };
         },

package/dist/metadataCache.spec.js

@@ -3,8 +3,8 @@ import { describe, expect, it, vi } from 'vitest';
 import { createMetadataCache } from './metadataCache.js';
 const createMockStorage = () => ({
     read: vi.fn(),
-    write: vi.fn(),
-    clear: vi.fn(),
+    write: vi.fn(() => okAsync(undefined)),
+    clear: vi.fn(() => okAsync(undefined)),
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     subscribe: vi.fn(() => () => { }),
 });

package/dist/pauseControllerIntegration.spec.d.ts

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

package/dist/pauseControllerIntegration.spec.js

@@ -0,0 +1,106 @@
+import { getSyncProvider } from '@polkadot-api/json-rpc-provider-proxy';
+import { describe, expect, it, vi } from 'vitest';
+import { createPauseController } from './pauseController.js';
+const flushMicroAndTimers = async () => {
+    await vi.advanceTimersByTimeAsync(0);
+};
+const req = (id, method, params = []) => ({
+    jsonrpc: '2.0',
+    id,
+    method,
+    params,
+});
+const followNotif = (subscription, result) => ({
+    jsonrpc: '2.0',
+    method: 'chainHead_v1_followEvent',
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    params: { subscription, result },
+});
+describe('pauseController × getSyncProvider integration', () => {
+    it('routes follow events to the new listener after pause+resume+refollow (best blocks must keep flowing)', async () => {
+        vi.useFakeTimers();
+        try {
+            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 };
+            };
+            const pc = createPauseController();
+            const inner = pc.middleware(base);
+            // Wrap the pausable inner in getSyncProvider so we get the same proxy /
+            // synthetic-Stop machinery the WS provider gets via getWsProvider.
+            const provider = getSyncProvider(onReady => {
+                onReady((onMsg, onHalt) => inner(onMsg, onHalt));
+                return () => {
+                    /* no teardown for the scheduling step */
+                };
+            });
+            const events = [];
+            const conn = provider(msg => events.push(msg));
+            // getSyncProvider schedules input via setTimeout(0); flush it so the
+            // base receives onMessage/onHalt and the proxy reaches Connected.
+            await flushMicroAndTimers();
+            expect(invocations).toHaveLength(1);
+            // Initial follow: consumer sends chainHead_v1_follow, the base "chain"
+            // assigns sub-id-1, and a bestBlockChanged event arrives.
+            conn.send(req(1, 'chainHead_v1_follow', [true]));
+            expect(invocations[0].send).toHaveBeenCalledWith(req(1, 'chainHead_v1_follow', [true]));
+            invocations[0].onMessage({ jsonrpc: '2.0', id: 1, result: 'sub-id-1' });
+            invocations[0].onMessage(followNotif('sub-id-1', { event: 'bestBlockChanged', bestBlockHash: '0xaa' }));
+            expect(events).toContainEqual({ jsonrpc: '2.0', id: 1, result: 'sub-id-1' });
+            expect(events).toContainEqual(followNotif('sub-id-1', { event: 'bestBlockChanged', bestBlockHash: '0xaa' }));
+            // === pause ===
+            // pauseController.pause() disconnects the live socket and manually fires
+            // onHalt({type:'paused'}). The proxy reacts by synthesizing a stop
+            // notification for every active chainHead — which is what surfaces to
+            // the consumer as "the follow died, please refollow".
+            events.length = 0;
+            pc.pause();
+            const syntheticStop = events.find(m => 
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            m.method === 'chainHead_v1_follow' &&
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                m.params?.subscription === 'sub-id-1' &&
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                m.params?.result?.event === 'stop');
+            expect(syntheticStop).toBeDefined();
+            expect(invocations[0].disconnect).toHaveBeenCalledTimes(1);
+            // Consumer's substrate-client refollows synchronously inside the stop
+            // handler. The new chainHead_v1_follow goes into the proxy's pending
+            // queue while the base is paused.
+            conn.send(req(2, 'chainHead_v1_follow', [true]));
+            expect(invocations[0].send).not.toHaveBeenCalledWith(req(2, 'chainHead_v1_follow', [true]));
+            // === resume ===
+            pc.resume();
+            // After resume, the base is re-invoked (new "connection") and the
+            // queued send is flushed. proxy.start() has its own setTimeout backoff;
+            // flush all timers so the new connection is established.
+            await vi.advanceTimersByTimeAsync(10_000);
+            expect(invocations.length).toBeGreaterThanOrEqual(2);
+            const fresh = invocations[invocations.length - 1];
+            // The buffered chainHead_v1_follow must hit the fresh base.
+            expect(fresh.send).toHaveBeenCalledWith(req(2, 'chainHead_v1_follow', [true]));
+            // Server assigns a NEW subId on the new connection.
+            fresh.onMessage({ jsonrpc: '2.0', id: 2, result: 'sub-id-2' });
+            // bestBlockChanged on sub-id-2 must reach the consumer — this is the
+            // assertion that fails if pause/resume drops best-block flow.
+            events.length = 0;
+            fresh.onMessage(followNotif('sub-id-2', { event: 'bestBlockChanged', bestBlockHash: '0xcc' }));
+            expect(events).toContainEqual(followNotif('sub-id-2', { event: 'bestBlockChanged', bestBlockHash: '0xcc' }));
+            // And no stale sub-id-1 events should have leaked through after refollow.
+            expect(events.some(m => 
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            m.method === 'chainHead_v1_follow' && m.params?.subscription === 'sub-id-1')).toBe(false);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+});

package/dist/subscriptionReplayProvider.js

@@ -69,6 +69,15 @@ export const withSubscriptionReplay = (provider, onReconnect) => onMessage => {
         onMessage(message);
     });
     const unsubReconnect = onReconnect(() => {
+        // Replay unconfirmed subscribes first: their `reconnectFor === null`, so
+        // they're disjoint from the entries inserted by the active-replay loop
+        // below (which all carry a non-null `reconnectFor`).
+        for (const [, pending] of pendingSubscriptions) {
+            if (pending.reconnectFor === null)
+                conn.send(pending.payload);
+        }
+        // Replay confirmed subscriptions: the server returns a fresh subId, which
+        // we map back to the consumer's stable subId.
         for (const [consumerSubId, sub] of activeSubscriptions) {
             pendingSubscriptions.set(sub.id, { payload: sub.payload, reconnectFor: consumerSubId });
             conn.send(sub.payload);

package/dist/subscriptionReplayProvider.spec.js

@@ -61,15 +61,16 @@ describe('withSubscriptionReplay', () => {
         control.triggerReconnect();
         expect(mock.send).not.toHaveBeenCalled();
     });
-    it('does not replay pending subscriptions (no server response yet) on reconnect', () => {
+    it('replays pending subscriptions (no server response yet) on reconnect', () => {
         const mock = createMockProvider();
         const control = createReconnectControl();
         const conn = withSubscriptionReplay(mock.provider, control.onReconnect)(vi.fn());
-        conn.send(req(1, 'statement_subscribeStatement'));
+        const subscribeMsg = req(1, 'statement_subscribeStatement');
+        conn.send(subscribeMsg);
         // intentionally no simulateMessage — subscription not confirmed by server
         mock.send.mockClear();
         control.triggerReconnect();
-        expect(mock.send).not.toHaveBeenCalled();
+        expect(mock.send).toHaveBeenCalledWith(subscribeMsg);
     });
     it('replays active subscriptions on reconnect', () => {
         const mock = createMockProvider();

package/package.json

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