@novasamatech/host-papp 0.7.9 → 0.8.0-0

package/dist/sso/auth/v2/state.js

@@ -0,0 +1,65 @@
+/**
+ * Handshake V2 state machine — the public-facing observable shape of an
+ * in-flight SSO pairing exchange.
+ *
+ * Maps directly onto the inner `EncryptedHandshakeResponseV2` enum:
+ *
+ *   Idle       — no proposal emitted yet
+ *   Submitted  — proposal QR shown, waiting for the first response statement
+ *   Pending    — peer acknowledged; allocating Statement Store allowance on-chain
+ *   Success    — final state; identity keys received, device authorised
+ *   Failed     — final state; peer rejected (declined / duplicate / no-slot / tx-failed)
+ *
+ * Transitions are unidirectional except for Failed → Idle (user retries).
+ * The state object is what UIs render and what the chat layer gates on
+ * before submitting any V2 statements.
+ */
+import { deriveIdentityChatPublicKey } from '../scale/handshakeV2.js';
+export const idle = () => ({ tag: 'Idle' });
+export const submitted = () => ({ tag: 'Submitted' });
+/**
+ * Translate the length-dispatched-decoded `EncryptedHandshakeResponseV2` into
+ * the public state. Pure — no I/O. The caller decrypts the outer envelope and
+ * runs `decodeEncryptedHandshakeResponseV2` first.
+ */
+export const fromInnerResponse = (response, peerStatementAccountId = null) => {
+    switch (response.tag) {
+        case 'Pending':
+            // Only AllowanceAllocation today; widen here when the spec adds more variants.
+            return { tag: 'Pending', reason: 'AllowanceAllocation' };
+        case 'Success':
+            return {
+                tag: 'Success',
+                identityAccountId: response.value.identityAccountId,
+                rootAccountId: response.value.rootAccountId,
+                identityChatPrivateKey: response.value.identityChatPrivateKey,
+                identityChatPublicKey: deriveIdentityChatPublicKey(response.value.identityChatPrivateKey),
+                deviceEncPubKey: response.value.deviceEncPubKey,
+                peerStatementAccountId,
+            };
+        case 'Failed':
+            return { tag: 'Failed', reason: response.value };
+    }
+};
+/**
+ * Forward-only transition guard: rejects regressions like Success → Pending.
+ * Idempotent on same-tag transitions (returns current by reference) so callers
+ * can use `next === current` to detect "no change" without per-call equality.
+ */
+export const advance = (current, next) => {
+    if (isTerminal(current))
+        return current;
+    if (current.tag === 'Idle' && next.tag !== 'Submitted')
+        return current;
+    if (current.tag === 'Submitted' && next.tag === 'Idle')
+        return current;
+    if (current.tag === next.tag)
+        return current;
+    return next;
+};
+export const isTerminal = (state) => state.tag === 'Success' || state.tag === 'Failed';
+/**
+ * True only when the device is authorised to submit V2 statements. The
+ * chat-send path gates on this — V2 messages must wait for allowance.
+ */
+export const canSubmitV2Statements = (state) => state.tag === 'Success';

package/dist/sso/auth/v2/topic.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Pairing topic + channel derivation for the V2 SSO handshake.
+ *
+ *   topic   = blake2b256_keyed(encryptionPublicKey || "topic",   key=statementAccountId)
+ *   channel = blake2b256_keyed(encryptionPublicKey || "channel", key=statementAccountId)
+ *
+ * Where:
+ *   - `statementAccountId`     = the host's sr25519 device public key (32 bytes)
+ *   - `encryptionPublicKey`    = the host's P-256 device public key (65 bytes uncompressed)
+ *
+ * Both sides compute the same topic/channel deterministically from the same
+ * pubkeys carried in the QR-coded `VersionedHandshakeProposal::V2`, so they
+ * agree on where the response statement is delivered without any shared
+ * secret negotiation.
+ */
+export declare const computePairingTopic: (statementAccountId: Uint8Array, encryptionPublicKey: Uint8Array) => Uint8Array;
+export declare const computePairingChannel: (statementAccountId: Uint8Array, encryptionPublicKey: Uint8Array) => Uint8Array;

package/dist/sso/auth/v2/topic.js

@@ -0,0 +1,21 @@
+/**
+ * Pairing topic + channel derivation for the V2 SSO handshake.
+ *
+ *   topic   = blake2b256_keyed(encryptionPublicKey || "topic",   key=statementAccountId)
+ *   channel = blake2b256_keyed(encryptionPublicKey || "channel", key=statementAccountId)
+ *
+ * Where:
+ *   - `statementAccountId`     = the host's sr25519 device public key (32 bytes)
+ *   - `encryptionPublicKey`    = the host's P-256 device public key (65 bytes uncompressed)
+ *
+ * Both sides compute the same topic/channel deterministically from the same
+ * pubkeys carried in the QR-coded `VersionedHandshakeProposal::V2`, so they
+ * agree on where the response statement is delivered without any shared
+ * secret negotiation.
+ */
+import { khash } from '@novasamatech/statement-store';
+import { mergeUint8 } from '@polkadot-api/utils';
+const TOPIC_SUFFIX = new TextEncoder().encode('topic');
+const CHANNEL_SUFFIX = new TextEncoder().encode('channel');
+export const computePairingTopic = (statementAccountId, encryptionPublicKey) => khash(statementAccountId, mergeUint8([encryptionPublicKey, TOPIC_SUFFIX]));
+export const computePairingChannel = (statementAccountId, encryptionPublicKey) => khash(statementAccountId, mergeUint8([encryptionPublicKey, CHANNEL_SUFFIX]));

package/dist/sso/deviceIdentityStore.d.ts

@@ -0,0 +1,14 @@
+import type { StorageAdapter } from '@novasamatech/storage-adapter';
+import type { ResultAsync } from 'neverthrow';
+import type { SsSecret } from '../crypto.js';
+import type { DeviceIdentityForPairing } from './auth/v2/service.js';
+export type DeviceIdentity = DeviceIdentityForPairing & {
+    statementAccountSecret: SsSecret;
+};
+export type DeviceIdentityStore = {
+    loadOrCreate(): ResultAsync<DeviceIdentity, Error>;
+    readLastProcessedHandshakeStatement(): ResultAsync<string | null, Error>;
+    writeLastProcessedHandshakeStatement(hex: string): ResultAsync<void, Error>;
+};
+export declare function createDeviceIdentityStore(salt: string, storage: StorageAdapter): DeviceIdentityStore;
+export declare const awaitDeviceIdentity: (store: DeviceIdentityStore) => Promise<DeviceIdentity>;

package/dist/sso/deviceIdentityStore.js

@@ -0,0 +1,76 @@
+import { gcm } from '@noble/ciphers/aes.js';
+import { blake2b } from '@noble/hashes/blake2.js';
+import { createSr25519Secret, deriveSr25519PublicKey } from '@novasamatech/statement-store';
+import { errAsync, fromPromise, okAsync } from 'neverthrow';
+import { fromHex, toHex } from 'polkadot-api/utils';
+import { Bytes, Option, Struct, str } from 'scale-ts';
+import { getEncrPub, stringToBytes } from '../crypto.js';
+import { toError } from '../helpers/utils.js';
+const KEY = 'DeviceIdentity';
+// Persisted shape — kept under appId-derived AES-GCM at rest, same pattern as
+// UserSecretRepository.
+const StoredDeviceCodec = Struct({
+    statementAccountSeed: Bytes(32),
+    encryptionPrivateKey: Bytes(32),
+    lastProcessedHandshakeStatement: Option(str),
+});
+export function createDeviceIdentityStore(salt, storage) {
+    const aes = () => gcm(blake2b(stringToBytes(salt), { dkLen: 16 }), blake2b(stringToBytes('nonce'), { dkLen: 32 }));
+    const decode = (raw) => {
+        if (!raw)
+            return null;
+        try {
+            const decrypted = aes().decrypt(fromHex(raw));
+            return StoredDeviceCodec.dec(decrypted);
+        }
+        catch {
+            // 0.7.x had no DeviceIdentity key; any decode failure here means a
+            // schema rev or tampered blob — drop it and regenerate.
+            return null;
+        }
+    };
+    const encode = (stored) => toHex(aes().encrypt(StoredDeviceCodec.enc(stored)));
+    const read = () => storage.read(KEY).map(decode);
+    const write = (stored) => storage.write(KEY, encode(stored)).map(() => undefined);
+    const expand = (stored) => {
+        const statementAccountSecret = createSr25519Secret(stored.statementAccountSeed);
+        const statementAccountPublicKey = deriveSr25519PublicKey(statementAccountSecret);
+        const encryptionPrivateKey = stored.encryptionPrivateKey;
+        const encryptionPublicKey = getEncrPub(encryptionPrivateKey);
+        return { statementAccountPublicKey, statementAccountSecret, encryptionPublicKey, encryptionPrivateKey };
+    };
+    const generate = () => ({
+        statementAccountSeed: crypto.getRandomValues(new Uint8Array(32)),
+        encryptionPrivateKey: crypto.getRandomValues(new Uint8Array(32)),
+        lastProcessedHandshakeStatement: undefined,
+    });
+    return {
+        loadOrCreate() {
+            return read().andThen(existing => {
+                if (existing)
+                    return okAsync(expand(existing));
+                const fresh = generate();
+                return write(fresh).map(() => expand(fresh));
+            });
+        },
+        readLastProcessedHandshakeStatement() {
+            return read().map(stored => stored?.lastProcessedHandshakeStatement ?? null);
+        },
+        writeLastProcessedHandshakeStatement(hex) {
+            return read().andThen(existing => {
+                if (!existing) {
+                    // No identity yet — caller will populate via loadOrCreate first.
+                    return errAsync(new Error('writeLastProcessedHandshakeStatement: no device identity persisted'));
+                }
+                return write({ ...existing, lastProcessedHandshakeStatement: hex });
+            });
+        },
+    };
+}
+// Re-export the awaitable form for convenience, since most call sites already
+// live in async functions.
+export const awaitDeviceIdentity = (store) => fromPromise(Promise.resolve(), toError)
+    .andThen(() => store.loadOrCreate())
+    .match(ok => ok, err => {
+    throw err;
+});

package/dist/sso/sessionManager/userSession.js

@@ -78,10 +78,7 @@ export function createUserSession({ userSession, statementStore, encryption, sto
         to: JSON.stringify,
     });
     return {
-        id: userSession.id,
-        localAccount: userSession.localAccount,
-        remoteAccount: userSession.remoteAccount,
-        rootAccountId: userSession.rootAccountId,
+        ...userSession,
         signPayload(payload) {
             return requestQueue.call(() => {
                 const messageId = nanoid();

package/dist/sso/userSecretRepository.d.ts

@@ -7,6 +7,7 @@ declare const StoredUserSecretsCodec: import("scale-ts").Codec<{
     ssSecret: SsSecret;
     encrSecret: EncrSecret;
     entropy: Uint8Array<ArrayBufferLike>;
+    identityChatPrivateKey: Uint8Array<ArrayBufferLike>;
 }>;
 export type UserSecretRepository = ReturnType<typeof createUserSecretRepository>;
 export declare function createUserSecretRepository(salt: string, storage: StorageAdapter): {

package/dist/sso/userSecretRepository.js

@@ -9,11 +9,26 @@ const StoredUserSecretsCodec = Struct({
     ssSecret: BrandedBytesCodec(),
     encrSecret: BrandedBytesCodec(),
     entropy: Bytes(),
+    // V2 addition: user identity chat private key (P-256 raw scalar, 32 bytes).
+    // Sensitive — kept encrypted at rest alongside the per-session ss/encr secrets.
+    identityChatPrivateKey: Bytes(32),
 });
 export function createUserSecretRepository(salt, storage) {
     const baseKey = 'UserSecrets';
     const encode = fromThrowable(StoredUserSecretsCodec.enc, toError);
-    const decode = fromThrowable((value) => (value ? StoredUserSecretsCodec.dec(value) : null), toError);
+    const decode = fromThrowable((value) => {
+        if (!value)
+            return null;
+        try {
+            return StoredUserSecretsCodec.dec(value);
+        }
+        catch {
+            // 0.7.x V1 blobs are missing `identityChatPrivateKey` and decode short.
+            // Treat as absent — a fresh handshake (required after 0.8.0 upgrade)
+            // will overwrite.
+            return null;
+        }
+    }, toError);
     const encrypt = fromThrowable((value) => {
         const aes = getAes(salt);
         return toHex(aes.encrypt(value));

package/dist/sso/userSessionRepository.d.ts

@@ -15,8 +15,14 @@ declare const storedUserSessionCodec: import("scale-ts").Codec<{
         pin: string | undefined;
     };
     rootAccountId: AccountId;
+    identityAccountId: AccountId | undefined;
+    identityChatPublicKey: Uint8Array<ArrayBufferLike> | undefined;
 }>;
-export declare function createStoredUserSession(localAccount: LocalSessionAccount, remoteAccount: RemoteSessionAccount, rootAccountId: AccountId): StoredUserSession;
+type StoredUserSessionV2Extras = {
+    identityAccountId?: AccountId;
+    identityChatPublicKey?: Uint8Array;
+};
+export declare function createStoredUserSession(localAccount: LocalSessionAccount, remoteAccount: RemoteSessionAccount, rootAccountId: AccountId, extras?: StoredUserSessionV2Extras): StoredUserSession;
 export declare const createUserSessionRepository: (storage: StorageAdapter) => {
     add(value: {
         id: string;
@@ -30,6 +36,8 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
             pin: string | undefined;
         };
         rootAccountId: AccountId;
+        identityAccountId: AccountId | undefined;
+        identityChatPublicKey: Uint8Array<ArrayBufferLike> | undefined;
     }): import("neverthrow").ResultAsync<{
         id: string;
         localAccount: {
@@ -42,6 +50,8 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
             pin: string | undefined;
         };
         rootAccountId: AccountId;
+        identityAccountId: AccountId | undefined;
+        identityChatPublicKey: Uint8Array<ArrayBufferLike> | undefined;
     }, Error>;
     filter(fn: (value: {
         id: string;
@@ -55,6 +65,8 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
             pin: string | undefined;
         };
         rootAccountId: AccountId;
+        identityAccountId: AccountId | undefined;
+        identityChatPublicKey: Uint8Array<ArrayBufferLike> | undefined;
     }) => boolean): import("neverthrow").ResultAsync<{
         id: string;
         localAccount: {
@@ -67,6 +79,8 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
             pin: string | undefined;
         };
         rootAccountId: AccountId;
+        identityAccountId: AccountId | undefined;
+        identityChatPublicKey: Uint8Array<ArrayBufferLike> | undefined;
     }[], Error>;
     mutate(fn: (value: {
         id: string;
@@ -80,6 +94,8 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
             pin: string | undefined;
         };
         rootAccountId: AccountId;
+        identityAccountId: AccountId | undefined;
+        identityChatPublicKey: Uint8Array<ArrayBufferLike> | undefined;
     }[]) => {
         id: string;
         localAccount: {
@@ -92,6 +108,8 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
             pin: string | undefined;
         };
         rootAccountId: AccountId;
+        identityAccountId: AccountId | undefined;
+        identityChatPublicKey: Uint8Array<ArrayBufferLike> | undefined;
     }[]): import("neverthrow").ResultAsync<{
         id: string;
         localAccount: {
@@ -104,6 +122,8 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
             pin: string | undefined;
         };
         rootAccountId: AccountId;
+        identityAccountId: AccountId | undefined;
+        identityChatPublicKey: Uint8Array<ArrayBufferLike> | undefined;
     }[], Error>;
     read(): import("neverthrow").ResultAsync<{
         id: string;
@@ -117,6 +137,8 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
             pin: string | undefined;
         };
         rootAccountId: AccountId;
+        identityAccountId: AccountId | undefined;
+        identityChatPublicKey: Uint8Array<ArrayBufferLike> | undefined;
     }[], Error>;
     write(value: {
         id: string;
@@ -130,6 +152,8 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
             pin: string | undefined;
         };
         rootAccountId: AccountId;
+        identityAccountId: AccountId | undefined;
+        identityChatPublicKey: Uint8Array<ArrayBufferLike> | undefined;
     }[]): import("neverthrow").ResultAsync<null, Error> | import("neverthrow").ResultAsync<{
         id: string;
         localAccount: {
@@ -142,6 +166,8 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
             pin: string | undefined;
         };
         rootAccountId: AccountId;
+        identityAccountId: AccountId | undefined;
+        identityChatPublicKey: Uint8Array<ArrayBufferLike> | undefined;
     }[], Error>;
     clear(): import("neverthrow").ResultAsync<void, Error>;
     subscribe(fn: (value: {
@@ -156,6 +182,8 @@ export declare const createUserSessionRepository: (storage: StorageAdapter) => {
             pin: string | undefined;
         };
         rootAccountId: AccountId;
+        identityAccountId: AccountId | undefined;
+        identityChatPublicKey: Uint8Array<ArrayBufferLike> | undefined;
     }[]) => void): VoidFunction;
 };
 export {};

package/dist/sso/userSessionRepository.js

@@ -2,19 +2,25 @@ import { AccountIdCodec, LocalSessionAccountCodec, RemoteSessionAccountCodec } f
 import { fieldListView } from '@novasamatech/storage-adapter';
 import { nanoid } from 'nanoid';
 import { fromHex, toHex } from 'polkadot-api/utils';
-import { Struct, Vector, str } from 'scale-ts';
+import { Bytes, Option, 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,
     remoteAccount: RemoteSessionAccountCodec,
     rootAccountId: AccountIdCodec,
+    identityAccountId: Option(AccountIdCodec),
+    identityChatPublicKey: Option(Bytes(65)),
 });
-export function createStoredUserSession(localAccount, remoteAccount, rootAccountId) {
+export function createStoredUserSession(localAccount, remoteAccount, rootAccountId, extras = {}) {
     return {
         id: nanoid(12),
-        localAccount: localAccount,
-        remoteAccount: remoteAccount,
+        localAccount,
+        remoteAccount,
         rootAccountId,
+        identityAccountId: extras.identityAccountId,
+        identityChatPublicKey: extras.identityChatPublicKey,
     };
 }
 export const createUserSessionRepository = (storage) => {
@@ -22,7 +28,18 @@ export const createUserSessionRepository = (storage) => {
     return fieldListView({
         storage,
         key: 'SsoSessions',
-        from: x => codec.dec(fromHex(x)),
+        from: x => {
+            try {
+                return codec.dec(fromHex(x));
+            }
+            catch {
+                // 0.7.x V1 blobs use the prior codec shape and won't decode against
+                // V2's extended struct. Treat as empty so the caller (and the
+                // fieldListView mutate machinery) start clean; the next write
+                // overwrites the bad blob.
+                return [];
+            }
+        },
         to: x => toHex(codec.enc(x)),
     });
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-papp",
   "type": "module",
-  "version": "0.7.9",
+  "version": "0.8.0-0",
   "description": "Polkadot app integration",
   "license": "Apache-2.0",
   "repository": {
@@ -34,16 +34,19 @@
     "@noble/ciphers": "2.2.0",
     "@noble/curves": "2.2.0",
     "@noble/hashes": "2.2.0",
-    "@novasamatech/host-api": "0.7.9",
-    "@novasamatech/scale": "0.7.9",
-    "@novasamatech/statement-store": "0.7.9",
-    "@novasamatech/storage-adapter": "0.7.9",
+    "@novasamatech/host-api": "0.8.0-0",
+    "@novasamatech/scale": "0.8.0-0",
+    "@novasamatech/statement-store": "0.8.0-0",
+    "@novasamatech/storage-adapter": "0.8.0-0",
+    "@polkadot-api/utils": "^0.4.0",
     "@polkadot-labs/hdkd-helpers": "^0.0.30",
     "nanoevents": "9.1.0",
     "nanoid": "5.1.9",
     "neverthrow": "^8.2.0",
     "polkadot-api": ">=2",
-    "scale-ts": "1.6.1"
+    "rxjs": "^7.8.2",
+    "scale-ts": "1.6.1",
+    "verifiablejs": "1.2.0"
   },
   "publishConfig": {
     "access": "public"