@novasamatech/statement-store 0.6.16 → 0.6.18

package/dist/adapter/lazyClient.js

@@ -1,5 +1,7 @@
 import { createClient as createSubstrateClient } from '@polkadot-api/substrate-client';
 import { createClient as createPolkadotClient } from 'polkadot-api';
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const noop = () => { };
 export const createLazyClient = (provider) => {
     let polkadotClient = null;
     let substrateClient = null;
@@ -28,12 +30,31 @@ export const createLazyClient = (provider) => {
         getSubscribeFn() {
             const c = getSubstrateClient();
             return (method, params, onMessage, onError) => {
-                return c._request(method, params, {
-                    onSuccess: (subscriptionId, followSubscription) => {
-                        followSubscription(subscriptionId, { next: onMessage, error: onError });
+                let subscriptionId = null;
+                let unsubscribeLocal = null;
+                const cancelRequest = c._request(method, params, {
+                    onSuccess: (subId, followSubscription) => {
+                        subscriptionId = subId;
+                        unsubscribeLocal = followSubscription(subId, { next: onMessage, error: onError });
                     },
                     onError,
                 });
+                // Derive the unsubscribe RPC method from the subscribe method name
+                // e.g. statement_subscribeStatement -> statement_unsubscribeStatement
+                const unsubscribeMethod = method.replace('subscribe', 'unsubscribe');
+                return () => {
+                    if (unsubscribeLocal) {
+                        unsubscribeLocal();
+                        // Send the server-side unsubscribe RPC call
+                        c._request(unsubscribeMethod, [subscriptionId], {
+                            onSuccess: noop,
+                            onError: noop,
+                        });
+                    }
+                    else {
+                        cancelRequest();
+                    }
+                };
             };
         },
         disconnect() {

package/dist/session/messageMapper.js

@@ -1,20 +1,20 @@
+function decode(payload, codec) {
+    try {
+        return { status: 'parsed', value: codec.dec(payload) };
+    }
+    catch {
+        return { status: 'failed', value: payload };
+    }
+}
 export function toMessage(statementData, codec) {
     switch (statementData.tag) {
         case 'request': {
-            const decode = (payload) => {
-                try {
-                    return { status: 'parsed', value: codec.dec(payload) };
-                }
-                catch {
-                    return { status: 'failed', value: payload };
-                }
-            };
             return statementData.value.data.map((payload, index) => {
                 return {
                     type: 'request',
                     localId: `${statementData.value.requestId}-${index.toString()}`,
                     requestId: statementData.value.requestId,
-                    payload: decode(payload),
+                    payload: decode(payload, codec),
                 };
             });
         }

package/dist/session/session.js

@@ -30,6 +30,7 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
     let subscribers = [];
     const bufferedMessages = [];
     let storeUnsub = null;
+    let responseStoreUnsub = null;
     function submitStatementData(channel, topicSessionId, data) {
         state.expiry = nextExpiry(state.expiry);
         const expiry = state.expiry;
@@ -53,12 +54,14 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
         });
     }
     function deliverStatementData(statementData) {
-        if (subscribers.length === 0) {
-            if (state.phase === 'initialization') {
-                bufferedMessages.push(statementData);
-            }
-            return;
+        // Buffer 'request' statements unconditionally so that waitForRequestMessage
+        // registered after delivery (race condition) still receives them via subscribe() replay.
+        // Buffer everything else during initialization when there are no subscribers yet.
+        if (statementData.tag === 'request' || (subscribers.length === 0 && state.phase === 'initialization')) {
+            bufferedMessages.push(statementData);
         }
+        if (subscribers.length === 0)
+            return;
         for (const sub of subscribers) {
             const messages = toMessage(statementData, sub.codec);
             if (messages.length > 0)
@@ -76,7 +79,7 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
             .map(decrypted => StatementData.dec(decrypted))
             .orElse(() => ok(null));
     }
-    function processIncomingStatement(statement) {
+    function processIncomingStatement(statement, responsesOnly = false) {
         if (!statement.data)
             return;
         const key = toHex(statement.data);
@@ -87,6 +90,8 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
             if (!statementData)
                 return;
             if (statementData.tag === 'request') {
+                if (responsesOnly)
+                    return;
                 if (statementData.value.requestId === state.incomingRequest?.requestId)
                     return;
                 state.incomingRequest = { requestId: statementData.value.requestId };
@@ -145,13 +150,25 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
         }
     }
     function ensureStoreSubscription() {
-        if (storeUnsub)
+        if (storeUnsub) {
+            console.info('[session] ensureStoreSubscription: already subscribed');
             return;
+        }
+        console.info('[session] ensureStoreSubscription: subscribing to', toHex(incomingSessionId));
         storeUnsub = statementStore.subscribeStatements([incomingSessionId], statements => {
+            console.info('[session] subscribeStatements callback fired — statements:', statements.length);
             for (const statement of statements) {
                 processIncomingStatement(statement);
             }
         });
+        // Subscribe to outgoing topic to receive peer ACK responses.
+        // Only process response-type statements — request-type statements on this topic
+        // are our own submissions echoed back and must be ignored.
+        responseStoreUnsub = statementStore.subscribeStatements([outgoingSessionId], statements => {
+            for (const statement of statements) {
+                processIncomingStatement(statement, true);
+            }
+        });
     }
     async function init() {
         const [ownResult, peerResult] = await Promise.all([
@@ -179,7 +196,7 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
         const peerRequest = peerDecoded.find(d => d.tag === 'request');
         const peerResponse = peerDecoded.find(d => d.tag === 'response');
         if (ownRequest?.tag === 'request') {
-            const hasResponse = peerResponse?.tag === 'response' && peerResponse.value.requestId === ownRequest.value.requestId;
+            const hasResponse = ownResponse?.tag === 'response' && ownResponse.value.requestId === ownRequest.value.requestId;
             if (!hasResponse) {
                 state.outgoingRequest = {
                     requestId: ownRequest.value.requestId,
@@ -191,7 +208,7 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
         if (peerRequest?.tag === 'request') {
             state.incomingRequest = { requestId: peerRequest.value.requestId };
             state.respondedIncomingRequest =
-                ownResponse?.tag === 'response' && ownResponse.value.requestId === peerRequest.value.requestId;
+                peerResponse?.tag === 'response' && peerResponse.value.requestId === peerRequest.value.requestId;
         }
         // Notify app of any unresponded incoming request.
         // Delivered while phase is still 'initialization' so that deliverStatementData
@@ -274,6 +291,7 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
                 callback: callback,
             };
             subscribers.push(sub);
+            console.info('[session] subscribe: subscriber count now', subscribers.length);
             ensureStoreSubscription();
             // Deliver buffered init messages to this subscriber
             if (bufferedMessages.length > 0) {
@@ -283,15 +301,25 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
             }
             return () => {
                 subscribers = subscribers.filter(s => s !== sub);
-                if (subscribers.length === 0 && storeUnsub) {
-                    storeUnsub();
-                    storeUnsub = null;
+                console.info('[session] unsubscribe: subscriber count now', subscribers.length);
+                if (subscribers.length === 0) {
+                    if (storeUnsub) {
+                        console.warn('[session] ALL subscribers removed — killing store subscription!');
+                        storeUnsub();
+                        storeUnsub = null;
+                    }
+                    if (responseStoreUnsub) {
+                        responseStoreUnsub();
+                        responseStoreUnsub = null;
+                    }
                 }
             };
         },
         dispose() {
             storeUnsub?.();
             storeUnsub = null;
+            responseStoreUnsub?.();
+            responseStoreUnsub = null;
             subscribers = [];
             for (const [, deferred] of state.pendingDelivery) {
                 deferred.reject(new Error('Session disposed'));
@@ -302,7 +330,6 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
     void init();
     return session;
 }
-// ── module-level helpers ──────────────────────────────────────────────────────
 function mapResponseCode(responseCode) {
     switch (responseCode) {
         case 'success':

package/dist/session/session.spec.js

@@ -177,9 +177,10 @@ describe('session', () => {
             let callCount = 0;
             adapter.queryStatements.mockImplementation(() => {
                 callCount++;
+                // Outgoing topic contains both our request AND the peer's response
                 if (callCount === 1)
-                    return okAsync([ownRequest]);
-                return okAsync([peerResponse]);
+                    return okAsync([ownRequest, peerResponse]);
+                return okAsync([]);
             });
             const { session } = makeSession(adapter);
             await flushPromises();
@@ -216,8 +217,9 @@ describe('session', () => {
             adapter.queryStatements.mockImplementation(() => {
                 callCount++;
                 if (callCount === 1)
-                    return okAsync([ownResponse]);
-                return okAsync([peerRequest]);
+                    return okAsync([]);
+                // Incoming topic contains both the peer's request AND our response
+                return okAsync([peerRequest, ownResponse]);
             });
             const { session } = makeSession(adapter);
             await flushPromises();
@@ -298,10 +300,10 @@ describe('session', () => {
         it('does NOT auto-send a response when an incoming request arrives', async () => {
             const requestId = 'no-auto-resp';
             const peerRequest = makeStatement({ tag: 'request', value: { requestId, data: [new Uint8Array([1])] } });
+            const subscribeCallbacks = [];
             const adapter = makeAdapter();
-            let subscribeCallback;
             adapter.subscribeStatements.mockImplementation((_topics, cb) => {
-                subscribeCallback = cb;
+                subscribeCallbacks.push(cb);
                 return vi.fn();
             });
             adapter.queryStatements.mockReturnValue(okAsync([]));
@@ -310,22 +312,134 @@ describe('session', () => {
             const callback = vi.fn();
             session.subscribe(rawCodec, callback);
             adapter.submitStatement.mockClear();
-            subscribeCallback([peerRequest]);
+            // Fire on the incoming topic callback (first subscription)
+            subscribeCallbacks[0]([peerRequest]);
             await flushPromises();
             // Message delivered to app callback but no automatic response submitted
             expect(callback).toHaveBeenCalled();
             expect(adapter.submitStatement).not.toHaveBeenCalled();
         });
+        it('delivers peer request to a subscriber that registers after the batch notification (race condition)', async () => {
+            // Regression test for PB-439: when peer's request and the ACK response arrive in the
+            // same subscribeStatements batch, the request is processed before waitForRequestMessage
+            // has a chance to register its subscriber. The fix ensures request statements are always
+            // buffered so late subscribers (simulating waitForRequestMessage called in .andThen()
+            // after waitForResponseMessage resolves) still receive them.
+            const subscribeCallbacks = [];
+            const subscribeStatements = vi
+                .fn()
+                .mockImplementation((_topics, cb) => {
+                subscribeCallbacks.push(cb);
+                return vi.fn();
+            });
+            const { session } = makeSession({ subscribeStatements });
+            await flushPromises();
+            // Register a dummy subscriber to activate the store subscription (simulates
+            // any pre-existing subscriber in the session, e.g. the app listening for messages).
+            const dummyUnsub = session.subscribe(rawCodec, vi.fn());
+            const peerRequestId = 'race-condition-request';
+            const peerRequest = makeStatement({
+                tag: 'request',
+                value: { requestId: peerRequestId, data: [new Uint8Array([42])] },
+            });
+            // Peer request arrives on the incoming topic (first subscription) while the
+            // dummy subscriber is active but waitForRequestMessage hasn't registered its
+            // subscriber yet (the race condition scenario).
+            subscribeCallbacks[0]([peerRequest]);
+            await flushPromises();
+            // Now the late subscriber registers (simulates waitForRequestMessage being called
+            // in the .andThen() chain after waitForResponseMessage resolves).
+            const lateCallback = vi.fn();
+            session.subscribe(rawCodec, lateCallback);
+            // The late subscriber must receive the buffered peer request, otherwise
+            // waitForRequestMessage would hang indefinitely.
+            expect(lateCallback).toHaveBeenCalledTimes(1);
+            const messages = lateCallback.mock.calls[0][0];
+            expect(messages[0]?.type).toBe('request');
+            expect(messages[0]?.requestId).toBe(peerRequestId);
+            dummyUnsub();
+        });
         it('unsubscribing last subscriber tears down the store subscription', () => {
             const { session, adapter } = makeSession();
             const unsub = session.subscribe(rawCodec, vi.fn());
-            expect(adapter.subscribeStatements).toHaveBeenCalledTimes(1);
+            expect(adapter.subscribeStatements).toHaveBeenCalledTimes(2);
             unsub();
             // subscribeStatements returns a mock unsubscribe fn — verify it was called
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const storeMockUnsub = adapter.subscribeStatements.mock.results[0].value;
             expect(storeMockUnsub).toHaveBeenCalled();
         });
+        it('subscribes to outgoing topic for peer responses alongside incoming topic', () => {
+            const { session, adapter } = makeSession();
+            session.subscribe(rawCodec, vi.fn());
+            // Two subscriptions: one for incoming (peer requests), one for outgoing (peer responses)
+            expect(adapter.subscribeStatements).toHaveBeenCalledTimes(2);
+        });
+        it('tears down outgoing subscription when last subscriber leaves', () => {
+            const { session, adapter } = makeSession();
+            const unsub = session.subscribe(rawCodec, vi.fn());
+            unsub();
+            // Both unsubscribe functions should be called
+            for (const result of adapter.subscribeStatements.mock.results) {
+                const mockUnsub = result.value;
+                expect(mockUnsub).toHaveBeenCalled();
+            }
+        });
+        it('delivers peer response from outgoing topic subscription to subscribers', async () => {
+            const subscribeCallbacks = [];
+            const subscribeStatements = vi
+                .fn()
+                .mockImplementation((_topics, cb) => {
+                subscribeCallbacks.push(cb);
+                return vi.fn();
+            });
+            const { session, adapter } = makeSession({ subscribeStatements });
+            await flushPromises();
+            // Submit a request so the session has an outgoingRequest
+            void session.submitRequestMessage(rawCodec, new Uint8Array([1]));
+            await flushPromises();
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const submitted = adapter.submitStatement.mock.calls[0][0];
+            const decoded = StatementData.dec(submitted.data);
+            const requestId = decoded.tag === 'request' ? decoded.value.requestId : '';
+            const callback = vi.fn();
+            session.subscribe(rawCodec, callback);
+            // Deliver the response via the SECOND subscription callback (outgoing topic)
+            // subscribeCallbacks[0] = incoming topic, subscribeCallbacks[1] = outgoing topic
+            const responseStatement = makeStatement({
+                tag: 'response',
+                value: { requestId, responseCode: 'success' },
+            });
+            subscribeCallbacks[1]([responseStatement]);
+            await flushPromises();
+            // Subscriber should receive the response
+            const allCalls = callback.mock.calls.flat();
+            const responseMessages = allCalls.flat().filter((m) => m.type === 'response');
+            expect(responseMessages.length).toBeGreaterThan(0);
+        });
+        it('ignores request-type statements from outgoing topic subscription', async () => {
+            const subscribeCallbacks = [];
+            const subscribeStatements = vi
+                .fn()
+                .mockImplementation((_topics, cb) => {
+                subscribeCallbacks.push(cb);
+                return vi.fn();
+            });
+            const { session } = makeSession({ subscribeStatements });
+            await flushPromises();
+            const callback = vi.fn();
+            session.subscribe(rawCodec, callback);
+            callback.mockClear(); // clear any buffered init messages
+            // Deliver a request via the outgoing topic subscription (would be our own echoed back)
+            const ownRequest = makeStatement({
+                tag: 'request',
+                value: { requestId: 'own-req', data: [new Uint8Array([1])] },
+            });
+            subscribeCallbacks[1]([ownRequest]);
+            await flushPromises();
+            // Should NOT be delivered to subscriber (filtered by responsesOnly flag)
+            expect(callback).not.toHaveBeenCalled();
+        });
     });
     describe('submitResponseMessage', () => {
         it('is idempotent — second call does not submit again', async () => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/statement-store",
   "type": "module",
-  "version": "0.6.16",
+  "version": "0.6.18",
   "description": "Statement store integration",
   "license": "Apache-2.0",
   "repository": {