@novasamatech/host-papp 0.8.7-0 → 0.8.7-1

package/dist/debugBus.js

@@ -15,9 +15,14 @@ const bus = createNanoEvents();
 let listenerCount = 0;
 /** @internal For host-papp emitters. */
 export function emitHostPappDebugMessage(event) {
-    if (listenerCount === 0)
-        return;
-    bus.emit('message', event);
+    try {
+        if (listenerCount === 0)
+            return;
+        bus.emit('message', event);
+    }
+    catch {
+        // do nothing
+    }
 }
 /**
  * @internal Lets call sites skip non-trivial payload construction

package/dist/index.d.ts

@@ -11,3 +11,4 @@ export type { StoredUserSession } from './sso/userSessionRepository.js';
 export type { Identity } from './identity/types.js';
 export type { SigningPayloadRequest, SigningPayloadResponse, SigningRawRequest, SigningRequest, } from './sso/sessionManager/scale/signing.js';
 export type { RingVrfAliasRequest, RingVrfAliasResponse } from './sso/sessionManager/scale/ringVrf.js';
+export type { CreateTransactionRequest, CreateTransactionResponse, } from './sso/sessionManager/scale/createTransaction.js';

package/dist/sso/allowance/impl.js

@@ -1,4 +1,4 @@
-import { createSr25519Prover, deriveSlotAccountPublicKey, ensureSubstrateSlotSr25519Ready, signSlotAccountSecret, } from '@novasamatech/statement-store';
+import { createSlotAccountProver, deriveSlotAccountPublicKey, ensureSubstrateSlotSr25519Ready, signSlotAccountSecret, } from '@novasamatech/statement-store';
 import { ResultAsync, errAsync, okAsync } from 'neverthrow';
 import { getPolkadotSigner } from 'polkadot-api/signer';
 export class AllowanceError extends Error {
@@ -56,7 +56,7 @@ export function createAllowanceService({ sessions, repository, }) {
             return fetchKey(sessionId, productId, 'bulletin').andThen(secret => ResultAsync.fromPromise(ensureSubstrateSlotSr25519Ready().then(() => getPolkadotSigner(deriveSlotAccountPublicKey(secret), 'Sr25519', input => signSlotAccountSecret(secret, input))), e => new AllowanceError('UnexpectedResponse', e instanceof Error ? e.message : String(e))));
         },
         getStatementStoreProver(sessionId, productId) {
-            return fetchKey(sessionId, productId, 'statementStore').map(secret => createSr25519Prover(secret));
+            return fetchKey(sessionId, productId, 'statementStore').andThen(secret => ResultAsync.fromPromise(ensureSubstrateSlotSr25519Ready().then(() => createSlotAccountProver(secret)), e => new AllowanceError('UnexpectedResponse', e instanceof Error ? e.message : String(e))));
         },
     };
 }

package/dist/sso/sessionManager/userSession.js

@@ -19,6 +19,22 @@ function withQueueTimeout(resultAsync, label) {
     const timeoutPromise = new Promise(resolve => setTimeout(() => resolve(err(new Error(`${label} timed out — queue freed`))), QUEUE_TASK_TIMEOUT_MS));
     return ResultAsync.fromPromise(Promise.race([resultAsync, timeoutPromise]), toError).andThen(r => r);
 }
+/**
+ * The transport ACK (`session.request`) and the peer's application `reply`
+ * (`session.waitForRequestMessage`) travel on independent channels whose
+ * arrival order is non-deterministic. Race them: resolve as soon as the reply
+ * arrives, and fail fast if the ACK errors first (e.g. the peer reports a
+ * decode failure and will never send a reply). A successful ACK is purely
+ * informational here — only the reply completes the call.
+ *
+ * Callers MUST register `reply` before issuing `request` so the reply
+ * subscriber is live before the request goes out.
+ */
+function awaitReplyOrAckFailure(request, reply) {
+    // ACK ok → never settle (let the reply win); ACK err → surface immediately.
+    const ackFailure = request.andThen(() => ResultAsync.fromSafePromise(new Promise(() => undefined)));
+    return ResultAsync.fromSafePromise(Promise.race([reply, ackFailure])).andThen(result => result);
+}
 /**
  * Derive a stable `actionKind` label from a remote-message envelope.
  * Shape: `OuterTag` for flat variants, `OuterTag:InnerTag` for variants
@@ -100,7 +116,6 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                 const messageId = nanoid();
                 const data = enumValue('v1', enumValue('SignRequest', enumValue('Payload', payload)));
                 emitHostAction(messageId, actionKindFromMessageData(data), userSession.id);
-                const request = session.request(RemoteMessageCodec, { messageId, data });
                 const responseFilter = (message) => {
                     if (message.data.tag === 'v1' &&
                         message.data.value.tag === 'SignResponse' &&
@@ -108,9 +123,10 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                         return message.data.value.value.payload;
                     }
                 };
-                const inner = request
-                    .andThen(() => session.waitForRequestMessage(RemoteMessageCodec, responseFilter))
-                    .andThen(message => {
+                // Register the reply waiter before sending the request (see awaitReplyOrAckFailure).
+                const request = session.request(RemoteMessageCodec, { messageId, data });
+                const reply = session.waitForRequestMessage(RemoteMessageCodec, responseFilter);
+                const inner = awaitReplyOrAckFailure(request, reply).andThen(message => {
                     if (message.success) {
                         return ok(message.value);
                     }
@@ -126,7 +142,6 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                 const messageId = nanoid();
                 const data = enumValue('v1', enumValue('SignRequest', enumValue('Raw', payload)));
                 emitHostAction(messageId, actionKindFromMessageData(data), userSession.id);
-                const request = session.request(RemoteMessageCodec, { messageId, data });
                 const responseFilter = (message) => {
                     if (message.data.tag === 'v1' &&
                         message.data.value.tag === 'SignResponse' &&
@@ -134,9 +149,9 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                         return message.data.value.value.payload;
                     }
                 };
-                const inner = request
-                    .andThen(() => session.waitForRequestMessage(RemoteMessageCodec, responseFilter))
-                    .andThen(message => {
+                const request = session.request(RemoteMessageCodec, { messageId, data });
+                const reply = session.waitForRequestMessage(RemoteMessageCodec, responseFilter);
+                const inner = awaitReplyOrAckFailure(request, reply).andThen(message => {
                     if (message.success) {
                         return ok(message.value);
                     }
@@ -150,10 +165,7 @@ export function createUserSession({ userSession, statementStore, encryption, sto
         createTransaction(payload) {
             return enqueue(() => {
                 const messageId = nanoid();
-                const request = session.request(RemoteMessageCodec, {
-                    messageId,
-                    data: enumValue('v1', enumValue('CreateTransactionRequest', payload)),
-                });
+                const data = enumValue('v1', enumValue('CreateTransactionRequest', payload));
                 const responseFilter = (message) => {
                     if (message.data.tag === 'v1' &&
                         message.data.value.tag === 'CreateTransactionResponse' &&
@@ -161,9 +173,9 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                         return message.data.value.value.signedTransaction;
                     }
                 };
-                const inner = request
-                    .andThen(() => session.waitForRequestMessage(RemoteMessageCodec, responseFilter))
-                    .andThen(message => {
+                const request = session.request(RemoteMessageCodec, { messageId, data });
+                const reply = session.waitForRequestMessage(RemoteMessageCodec, responseFilter);
+                const inner = awaitReplyOrAckFailure(request, reply).andThen(message => {
                     if (message.success) {
                         return ok(message.value);
                     }
@@ -174,14 +186,6 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                 return withQueueTimeout(inner, 'createTransaction');
             });
         },
-        sendDisconnectMessage() {
-            return enqueue(() => session
-                .submitRequestMessage(RemoteMessageCodec, {
-                messageId: nanoid(),
-                data: enumValue('v1', enumValue('Disconnected', undefined)),
-            })
-                .map(() => undefined));
-        },
         getRingVrfAlias(productAccountId, productId) {
             return enqueue(() => {
                 const messageId = nanoid();
@@ -190,7 +194,6 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                     productId,
                 }));
                 emitHostAction(messageId, actionKindFromMessageData(data), userSession.id);
-                const request = session.request(RemoteMessageCodec, { messageId, data });
                 const responseFilter = (message) => {
                     if (message.data.tag === 'v1' &&
                         message.data.value.tag === 'RingVrfAliasResponse' &&
@@ -198,18 +201,15 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                         return message.data.value.value.payload;
                     }
                 };
-                return withHostActionTrace(request
-                    .andThen(() => session.waitForRequestMessage(RemoteMessageCodec, responseFilter))
-                    .andThen(result => (result.success ? ok(result.value) : err(new Error(result.value)))), messageId, userSession.id);
+                const request = session.request(RemoteMessageCodec, { messageId, data });
+                const reply = session.waitForRequestMessage(RemoteMessageCodec, responseFilter);
+                return withHostActionTrace(awaitReplyOrAckFailure(request, reply).andThen(result => result.success ? ok(result.value) : err(new Error(result.value))), messageId, userSession.id);
             });
         },
-        requestResourceAllocation(request) {
+        requestResourceAllocation(payload) {
             return enqueue(() => {
                 const messageId = nanoid();
-                const sendRequest = session.request(RemoteMessageCodec, {
-                    messageId,
-                    data: enumValue('v1', enumValue('ResourceAllocationRequest', request)),
-                });
+                const data = enumValue('v1', enumValue('ResourceAllocationRequest', payload));
                 const responseFilter = (message) => {
                     if (message.data.tag === 'v1' &&
                         message.data.value.tag === 'ResourceAllocationResponse' &&
@@ -217,71 +217,80 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                         return message.data.value.value.payload;
                     }
                 };
-                const inner = sendRequest
-                    .andThen(() => session.waitForRequestMessage(RemoteMessageCodec, responseFilter))
-                    .andThen(result => (result.success ? ok(result.value) : err(new Error(result.value))));
+                const request = session.request(RemoteMessageCodec, { messageId, data });
+                const reply = session.waitForRequestMessage(RemoteMessageCodec, responseFilter);
+                const inner = awaitReplyOrAckFailure(request, reply).andThen(result => result.success ? ok(result.value) : err(new Error(result.value)));
                 return withQueueTimeout(inner, 'requestResourceAllocation');
             });
         },
+        sendDisconnectMessage() {
+            return enqueue(() => session
+                .submitRequestMessage(RemoteMessageCodec, {
+                messageId: nanoid(),
+                data: enumValue('v1', enumValue('Disconnected', undefined)),
+            })
+                .map(() => undefined));
+        },
         subscribe(callback) {
-            return session.subscribe(RemoteMessageCodec, messages => {
-                processedMessages
+            // App-level side effects for one decoded incoming request: dedup, invoke
+            // the consumer callback, emit debug events, and persist the processed id.
+            // Run independently of the ACK (see respondToRequests handler below) so a
+            // forgotten, failed, or duplicate handler never blocks the response we owe
+            // the peer.
+            const runSideEffects = (value) => {
+                const messageId = value.messageId;
+                void processedMessages
                     .read()
                     .andThen(processed => {
-                    const results = messages.map(message => {
-                        if (message.type === 'request' && message.payload.status === 'parsed') {
-                            const payload = message.payload;
-                            const isMessageProcessed = processed.includes(payload.value.messageId);
-                            if (isMessageProcessed) {
-                                return okAsync({ processed: false });
-                            }
-                            const messageId = payload.value.messageId;
-                            const actionKind = actionKindFromMessageData(payload.value.data);
+                    if (processed.includes(messageId))
+                        return okAsync(undefined);
+                    const actionKind = actionKindFromMessageData(value.data);
+                    emitHostPappDebugMessage({
+                        layer: 'session',
+                        event: 'peer_action_received',
+                        flowId: messageId,
+                        timestamp: Date.now(),
+                        payload: { sessionId: userSession.id, messageId, actionKind },
+                    });
+                    return callback(value)
+                        .andTee(processed => {
+                        if (processed) {
                             emitHostPappDebugMessage({
                                 layer: 'session',
-                                event: 'peer_action_received',
+                                event: 'peer_action_processed',
                                 flowId: messageId,
                                 timestamp: Date.now(),
-                                payload: { sessionId: userSession.id, messageId, actionKind },
+                                payload: { sessionId: userSession.id, messageId },
                             });
-                            return callback(payload.value)
-                                .andTee(processed => {
-                                if (processed) {
-                                    emitHostPappDebugMessage({
-                                        layer: 'session',
-                                        event: 'peer_action_processed',
-                                        flowId: messageId,
-                                        timestamp: Date.now(),
-                                        payload: { sessionId: userSession.id, messageId },
-                                    });
-                                }
-                            })
-                                .orTee(error => {
-                                console.error('Error while processing sso message:', error);
-                                emitHostPappDebugMessage({
-                                    layer: 'session',
-                                    event: 'peer_action_failed',
-                                    flowId: messageId,
-                                    timestamp: Date.now(),
-                                    payload: { sessionId: userSession.id, messageId, reason: error.message },
-                                });
-                            })
-                                .orElse(() => okAsync(false))
-                                .map(processed => (processed ? { processed, message: payload.value } : { processed }));
-                        }
-                        return okAsync({ processed: false });
-                    });
-                    return ResultAsync.combine(results).andThen(results => {
-                        const newMessages = results.filter(x => x.processed).map(x => x.message.messageId);
-                        if (newMessages.length > 0) {
-                            return processedMessages.mutate(x => x.concat(newMessages));
                         }
-                        return okAsync();
-                    });
+                    })
+                        .orTee(error => {
+                        console.error('Error while processing sso message:', error);
+                        emitHostPappDebugMessage({
+                            layer: 'session',
+                            event: 'peer_action_failed',
+                            flowId: messageId,
+                            timestamp: Date.now(),
+                            payload: { sessionId: userSession.id, messageId, reason: error.message },
+                        });
+                    })
+                        .orElse(() => okAsync(false))
+                        .andThen(processed => processed ? processedMessages.mutate(x => x.concat(messageId)) : okAsync(undefined));
                 })
                     .orTee(error => {
                     console.error('Error while updating processed sso messages:', error);
                 });
+            };
+            // The session auto-submits the ResponseStatus this handler returns, so an
+            // incoming request can never go unanswered. The ACK is transport-level:
+            // the statement already decrypted to be delivered, so the only failure
+            // observable here is a decode failure. Always answer — even a duplicate —
+            // because a peer retransmit means it never saw our previous ACK.
+            return session.respondToRequests(RemoteMessageCodec, message => {
+                if (message.payload.status !== 'parsed')
+                    return 'decodingFailed';
+                runSideEffects(message.payload.value);
+                return 'success';
             });
         },
         abortPendingRequests() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-papp",
   "type": "module",
-  "version": "0.8.7-0",
+  "version": "0.8.7-1",
   "description": "Polkadot app integration",
   "license": "Apache-2.0",
   "repository": {
@@ -34,10 +34,10 @@
     "@noble/ciphers": "2.2.0",
     "@noble/curves": "2.2.0",
     "@noble/hashes": "2.2.0",
-    "@novasamatech/host-api": "0.8.7-0",
-    "@novasamatech/scale": "0.8.7-0",
-    "@novasamatech/statement-store": "0.8.7-0",
-    "@novasamatech/storage-adapter": "0.8.7-0",
+    "@novasamatech/host-api": "0.8.7-1",
+    "@novasamatech/scale": "0.8.7-1",
+    "@novasamatech/statement-store": "0.8.7-1",
+    "@novasamatech/storage-adapter": "0.8.7-1",
     "@polkadot-api/utils": "^0.4.0",
     "@polkadot-labs/hdkd-helpers": "^0.0.30",
     "nanoevents": "9.1.0",