@novasamatech/host-papp 0.8.6 → 0.8.7-1

package/LICENSE

@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

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/auth/impl.js

@@ -159,6 +159,11 @@ export function createAuth({ hostMetadata, deviceIdentity, deviceIdentityStore,
             identityChatPublicKey: success.identityChatPublicKey,
             ssoEncPubKey: success.ssoEncPubKey,
             rootEntropySource: success.rootEntropySource,
+            // The peer device's long-lived P-256 encryption key. Persisted (rather
+            // than derived into `remoteAccount.publicKey`, which is the SSO shared
+            // secret consumed by the session manager's `createEncryption`) so the
+            // host's device-sync channel can address the paired device by ECDH.
+            deviceEncPubKey: success.deviceEncPubKey,
         });
         return userSecretRepository
             .write(session.id, {

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/dist/sso/userSessionRepository.d.ts

@@ -19,12 +19,14 @@ declare const storedUserSessionCodec: import("scale-ts").Codec<{
     identityChatPublicKey: Uint8Array<ArrayBufferLike>;
     ssoEncPubKey: Uint8Array<ArrayBufferLike>;
     rootEntropySource: Uint8Array<ArrayBufferLike>;
+    deviceEncPubKey: Uint8Array<ArrayBufferLike>;
 }>;
 type StoredUserSessionV2Extras = {
     identityAccountId: AccountId;
     identityChatPublicKey: Uint8Array;
     ssoEncPubKey: Uint8Array;
     rootEntropySource: Uint8Array;
+    deviceEncPubKey: Uint8Array;
 };
 export declare function createStoredUserSession(localAccount: LocalSessionAccount, remoteAccount: RemoteSessionAccount, rootAccountId: AccountId, extras: StoredUserSessionV2Extras): StoredUserSession;
 export declare const createUserSessionRepository: (storage: StorageAdapter) => {
@@ -44,6 +46,7 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
         identityChatPublicKey: Uint8Array<ArrayBufferLike>;
         ssoEncPubKey: Uint8Array<ArrayBufferLike>;
         rootEntropySource: Uint8Array<ArrayBufferLike>;
+        deviceEncPubKey: Uint8Array<ArrayBufferLike>;
     }): import("neverthrow").ResultAsync<{
         id: string;
         localAccount: {
@@ -60,6 +63,7 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
         identityChatPublicKey: Uint8Array<ArrayBufferLike>;
         ssoEncPubKey: Uint8Array<ArrayBufferLike>;
         rootEntropySource: Uint8Array<ArrayBufferLike>;
+        deviceEncPubKey: Uint8Array<ArrayBufferLike>;
     }, Error>;
     filter(fn: (value: {
         id: string;
@@ -77,6 +81,7 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
         identityChatPublicKey: Uint8Array<ArrayBufferLike>;
         ssoEncPubKey: Uint8Array<ArrayBufferLike>;
         rootEntropySource: Uint8Array<ArrayBufferLike>;
+        deviceEncPubKey: Uint8Array<ArrayBufferLike>;
     }) => boolean): import("neverthrow").ResultAsync<{
         id: string;
         localAccount: {
@@ -93,6 +98,7 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
         identityChatPublicKey: Uint8Array<ArrayBufferLike>;
         ssoEncPubKey: Uint8Array<ArrayBufferLike>;
         rootEntropySource: Uint8Array<ArrayBufferLike>;
+        deviceEncPubKey: Uint8Array<ArrayBufferLike>;
     }[], Error>;
     mutate(fn: (value: {
         id: string;
@@ -110,6 +116,7 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
         identityChatPublicKey: Uint8Array<ArrayBufferLike>;
         ssoEncPubKey: Uint8Array<ArrayBufferLike>;
         rootEntropySource: Uint8Array<ArrayBufferLike>;
+        deviceEncPubKey: Uint8Array<ArrayBufferLike>;
     }[]) => {
         id: string;
         localAccount: {
@@ -126,6 +133,7 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
         identityChatPublicKey: Uint8Array<ArrayBufferLike>;
         ssoEncPubKey: Uint8Array<ArrayBufferLike>;
         rootEntropySource: Uint8Array<ArrayBufferLike>;
+        deviceEncPubKey: Uint8Array<ArrayBufferLike>;
     }[]): import("neverthrow").ResultAsync<{
         id: string;
         localAccount: {
@@ -142,6 +150,7 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
         identityChatPublicKey: Uint8Array<ArrayBufferLike>;
         ssoEncPubKey: Uint8Array<ArrayBufferLike>;
         rootEntropySource: Uint8Array<ArrayBufferLike>;
+        deviceEncPubKey: Uint8Array<ArrayBufferLike>;
     }[], Error>;
     read(): import("neverthrow").ResultAsync<{
         id: string;
@@ -159,6 +168,7 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
         identityChatPublicKey: Uint8Array<ArrayBufferLike>;
         ssoEncPubKey: Uint8Array<ArrayBufferLike>;
         rootEntropySource: Uint8Array<ArrayBufferLike>;
+        deviceEncPubKey: Uint8Array<ArrayBufferLike>;
     }[], Error>;
     write(value: {
         id: string;
@@ -176,6 +186,7 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
         identityChatPublicKey: Uint8Array<ArrayBufferLike>;
         ssoEncPubKey: Uint8Array<ArrayBufferLike>;
         rootEntropySource: Uint8Array<ArrayBufferLike>;
+        deviceEncPubKey: Uint8Array<ArrayBufferLike>;
     }[]): import("neverthrow").ResultAsync<null, Error> | import("neverthrow").ResultAsync<{
         id: string;
         localAccount: {
@@ -192,6 +203,7 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
         identityChatPublicKey: Uint8Array<ArrayBufferLike>;
         ssoEncPubKey: Uint8Array<ArrayBufferLike>;
         rootEntropySource: Uint8Array<ArrayBufferLike>;
+        deviceEncPubKey: Uint8Array<ArrayBufferLike>;
     }[], Error>;
     clear(): import("neverthrow").ResultAsync<void, Error>;
     subscribe(fn: (value: {
@@ -210,6 +222,7 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
         identityChatPublicKey: Uint8Array<ArrayBufferLike>;
         ssoEncPubKey: Uint8Array<ArrayBufferLike>;
         rootEntropySource: Uint8Array<ArrayBufferLike>;
+        deviceEncPubKey: Uint8Array<ArrayBufferLike>;
     }[]) => void): VoidFunction;
 };
 export {};

package/dist/sso/userSessionRepository.js

@@ -3,8 +3,6 @@ import { fieldListView } from '@novasamatech/storage-adapter';
 import { nanoid } from 'nanoid';
 import { fromHex, toHex } from 'polkadot-api/utils';
 import { Bytes, Struct, Vector, str } from 'scale-ts';
-// V2 fields trail V1 fields so a future schema rev can append further
-// `Option`-wrapped fields without breaking decode of 0.8.0 blobs.
 const storedUserSessionCodec = Struct({
     id: str,
     localAccount: LocalSessionAccountCodec,
@@ -20,6 +18,13 @@ const storedUserSessionCodec = Struct({
     // RFC-0007 layer-1 `rootEntropySource` from the handshake; consumed by the
     // host's `host_derive_entropy` handler via `deriveProductEntropyFromSource`.
     rootEntropySource: Bytes(32),
+    // Encryption public key of the authorising PApp device (65-byte uncompressed
+    // P-256), lifted from `HandshakeResponseV2.deviceEncPubKey`. Distinct from
+    // `ssoEncPubKey` (the SSO session keypair) and from `remoteAccount.publicKey`
+    // (the derived SSO shared secret): this is the peer device's long-lived ECDH
+    // key, used by the host's device-sync channel to address the paired device.
+    // Always present — `HandshakeResponseV2` carries it for every V2 pairing.
+    deviceEncPubKey: Bytes(65),
 });
 export function createStoredUserSession(localAccount, remoteAccount, rootAccountId, extras) {
     return {
@@ -31,13 +36,14 @@ export function createStoredUserSession(localAccount, remoteAccount, rootAccount
         identityChatPublicKey: extras.identityChatPublicKey,
         ssoEncPubKey: extras.ssoEncPubKey,
         rootEntropySource: extras.rootEntropySource,
+        deviceEncPubKey: extras.deviceEncPubKey,
     };
 }
 export const createUserSessionRepository = (storage) => {
     const codec = Vector(storedUserSessionCodec);
     return fieldListView({
         storage,
-        key: 'SsoSessionsV2',
+        key: 'SsoSessionsV3',
         from: x => codec.dec(fromHex(x)),
         to: x => toHex(codec.enc(x)),
     });

package/dist/sso/userSessionRepository.spec.d.ts

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

package/dist/sso/userSessionRepository.spec.js

@@ -0,0 +1,28 @@
+import { createAccountId, createLocalSessionAccount, createRemoteSessionAccount } from '@novasamatech/statement-store';
+import { createMemoryAdapter } from '@novasamatech/storage-adapter';
+import { toHex } from 'polkadot-api/utils';
+import { describe, expect, it } from 'vitest';
+import { createStoredUserSession, createUserSessionRepository } from './userSessionRepository.js';
+const bytes = (len, fill) => new Uint8Array(len).fill(fill);
+// remoteAccount.publicKey is a fixed 32-byte field (the SSO shared secret),
+// which is exactly why the peer device's 65-byte encryption key needs its own
+// `deviceEncPubKey` field rather than being squeezed in here.
+const SHARED_SECRET = bytes(32, 0x07);
+const DEVICE_ENC_PUB = bytes(65, 0x04);
+const baseExtras = {
+    identityAccountId: createAccountId(bytes(32, 0x11)),
+    identityChatPublicKey: bytes(65, 0x22),
+    ssoEncPubKey: bytes(65, 0x33),
+    rootEntropySource: bytes(32, 0x44),
+};
+const makeSession = (deviceEncPubKey = DEVICE_ENC_PUB) => createStoredUserSession(createLocalSessionAccount(createAccountId(bytes(32, 0x01))), createRemoteSessionAccount(createAccountId(bytes(32, 0x02)), SHARED_SECRET), createAccountId(bytes(32, 0x55)), { ...baseExtras, deviceEncPubKey });
+describe('userSessionRepository — deviceEncPubKey persistence', () => {
+    it('round-trips deviceEncPubKey through SCALE persistence', async () => {
+        const repo = createUserSessionRepository(createMemoryAdapter());
+        await repo.add(makeSession(DEVICE_ENC_PUB));
+        const stored = (await repo.read())._unsafeUnwrap().at(0);
+        expect(stored?.deviceEncPubKey && toHex(stored.deviceEncPubKey)).toBe(toHex(DEVICE_ENC_PUB));
+        // The 32-byte SSO shared secret stays in remoteAccount.publicKey, untouched.
+        expect(stored && toHex(stored.remoteAccount.publicKey)).toBe(toHex(SHARED_SECRET));
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-papp",
   "type": "module",
-  "version": "0.8.6",
+  "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.6",
-    "@novasamatech/scale": "0.8.6",
-    "@novasamatech/statement-store": "0.8.6",
-    "@novasamatech/storage-adapter": "0.8.6",
+    "@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",