@novasamatech/host-papp 0.8.10 → 0.8.12

package/README.md

@@ -35,10 +35,6 @@ const papp = createPappAdapter({
   // otherwise existing pairings will be lost.
   appId: 'my-host-app',
 
-  // URL to a JSON document describing the host: { name: string, icon: string }.
-  // The icon should be a rasterized image at least 256x256 px.
-  metadata: 'https://my-host-app.example/papp-metadata.json',
-
   // Optional environment metadata shown on the wallet's confirmation screen.
   hostMetadata: {
     hostVersion: '1.4.0',
@@ -48,14 +44,15 @@ const papp = createPappAdapter({
 });
 ```
 
-`createPappAdapter` returns four sub-modules:
+`createPappAdapter` returns five sub-modules:
 
-| Module          | Purpose                                                                |
-| --------------- | ---------------------------------------------------------------------- |
-| `papp.sso`      | Authentication / pairing flow with a remote wallet.                    |
-| `papp.sessions` | List of paired user sessions and per-session messaging (sign, etc.).   |
-| `papp.secrets`  | Local secret storage for the derived guest accounts.                   |
-| `papp.identity` | On-chain identity lookups for arbitrary account ids.                   |
+| Module           | Purpose                                                              |
+| ---------------- | ------------------------------------------------------------------- |
+| `papp.sso`       | Authentication / pairing flow with a remote wallet.                 |
+| `papp.sessions`  | List of paired user sessions and per-session messaging (sign, etc.).|
+| `papp.secrets`   | Local secret storage for the derived guest accounts.                |
+| `papp.identity`  | On-chain identity lookups for arbitrary account ids.                |
+| `papp.allowance` | Resource allowances (bulletin / statement-store signers) per product.|
 
 Custom adapters (statement store, identity RPC, storage, lazy chain client) can be supplied
 via the `adapters` option for testing or non-browser environments.
@@ -200,6 +197,59 @@ await currentSession.signRaw({
 });
 ```
 
+`signVrf` asks the wallet for an sr25519 (schnorrkel) VRF signature from a product account
+(RFC-0023). The transcript travels as a recipe — a root domain-separation label plus an
+ordered list of `(label, value)` items — which the wallet replays verbatim into a Merlin
+transcript and signs. Callers that need a `signer` item must supply their own public key;
+the host never injects it.
+
+```ts
+const encoder = new TextEncoder();
+
+const vrf = await currentSession.signVrf({
+  productAccountId: ['product.dot', 0],
+  productId: 'product.dot',
+  transcriptLabel: encoder.encode('pop:airdrop'),
+  items: [
+    { label: encoder.encode('domain'), value: domainBytes },
+    { label: encoder.encode('signer'), value: accountPublicKey },
+  ],
+});
+
+vrf.match(
+  ({ preOutput, proof }) => submitLotteryTicket(preOutput, proof),
+  error => console.error('VRF signing failed:', error),
+);
+```
+
+This is the non-`AutoSigning` path only: when `AutoSigning` covers the account the host
+signs locally and never round-trips to the wallet.
+
+## Ring VRF proofs and aliases
+
+A `UserSession` can ask the paired device for a privacy-preserving contextual alias, or a
+ring VRF proof, for a product-scoped `context` and a `ring` location. The device
+selects the member key for the ring; `callingProductId` names the product the host is acting
+for. Both take the same `(context, ring)` so the alias in the proof matches `getRingVrfAlias`.
+
+```ts
+const context = ['product.dot', '0x00']; // [productId, suffix] — suffix is a 0x-hex string
+const ring = {
+  chainId: '0x…', // 32-byte chain genesis hash
+  junctions: [{ tag: 'PalletInstance', value: 42 }],
+};
+
+const alias = await currentSession.getRingVrfAlias('caller.dot', context, ring);
+
+const proof = await currentSession.createRingVrfProof('caller.dot', context, ring, new Uint8Array([0x48, 0x69]));
+proof.match(
+  ({ proof, contextualAlias, ringIndex, ringRevision }) =>
+    console.log('proof at ring', ringIndex, 'revision', ringRevision),
+  // failures decode to a structured `RingVrfError` (RingNotFound / NotMember / Rejected / Unknown)
+  error => console.error('proof failed:', error),
+);
+```
+
 ## Identity lookups
 
 `papp.identity` resolves on-chain identity data (lite / full username, credibility, slots)
@@ -221,6 +271,13 @@ const lookup = async (accountId: string) => {
 await papp.identity.getIdentities([accountIdA, accountIdB]);
 ```
 
+A paired `UserSession` also exposes `getIdentity()` as a shortcut that looks up the identity
+of its own user identity account — no account id to pass:
+
+```ts
+const identity = await session.getIdentity(); // Result<Identity | null, Error>
+```
+
 ## V2 SSO handshake
 
 V2 is a redesign of the SSO pairing flow that supports the same user identity across
@@ -233,38 +290,15 @@ identity, so contacts, chats, and roster events are shared between them.
 V2 is **not interoperable with V1**: a V1-only peer can't decode a V2 proposal QR and vice
 versa. Hosts that want to support both should branch on which protocol the peer advertises.
 
-### Shape of the flow
-
-```
-host                                          peer (authorising device)
-────────────────────────────────────────────────────────────────────────
-buildPairingDeeplink(device, metadata)
-  →  polkadotapp://pair?handshake=<hex>
-                                              scan QR, decode proposal
-                                              compute pairing topic from
-                                              the host's pubkeys
-                                              ECDH-encrypt + post:
-                                                Pending(AllowanceAllocation)
-                                                Success { encryptionKey,
-                                                          accountId,
-                                                          identitySignature }
-                                                Failed(reason)
-service.subscribeStatements(topic) +
-  poll the topic every 2s
-  ↓
-decode VersionedHandshakeResponse::V2
-  → ECDH-decrypt envelope with the
-    device encryption private key
-  → SCALE-decode inner payload
-  → state machine: Submitted → Pending →
-    Success | Failed
-  → on Success persist user identity
-```
+### The flow
 
-The user identity carried in `Success` is the chat encryption pubkey + the user's identity
-sr25519 accountId. The host verifies the 64-byte sr25519 `identitySignature` against the
-canonical 97 bytes `statementAccountId || encryptionPublicKey`
-(see `IDENTITY_SIGNATURE_PAYLOAD_BYTES`).
+1. The host builds a pairing deeplink from its device keypair and shows it as a QR code.
+2. The authorising device scans it and posts its response to the Statement Store: first a
+   `Pending` acknowledgement, then either `Success` — carrying the user's identity keys,
+   signed to authorise this device — or `Failed`.
+3. The host polls the pairing topic, decrypts and verifies each response, and drives a
+   `Submitted → Pending → Success | Failed` state machine. On `Success` it persists the
+   user identity.
 
 ### Building and rendering the QR
 
@@ -293,7 +327,7 @@ renderQrCode(deeplink); // 'polkadotapp://pair?handshake=<hex>'
 import { startPairingV2 } from '@novasamatech/host-papp';
 
 const pairing = startPairingV2({
-  statementStore: papp.adapters.statementStore, // any StatementStoreAdapter
+  statementStore, // any StatementStoreAdapter
   deviceIdentity: {
     statementAccountPublicKey: device.statementAccountPublicKey,
     encryptionPublicKey: device.encryptionPublicKey,
@@ -355,33 +389,14 @@ The service skips any incoming statement whose bytes match `initialProcessedData
 re-encrypts every Success with a fresh ephemeral key + AES-GCM nonce, so a genuine re-pair
 always produces different bytes and passes the dedupe.
 
-### Pairing topic / channel
+## Reading allowances
 
-If the host needs to derive the pairing topic or channel itself (for example to subscribe
-in-line, or to verify a statement source):
+Each `UserSession` can read its own persisted allowance slot-account key for a given
+product and resource. The session id is implicit — you only pass the product and resource:
 
 ```ts
-import { computePairingTopic, computePairingChannel } from '@novasamatech/host-papp';
+const session = papp.sessions.sessions.read().at(0);
 
-const topic   = computePairingTopic(statementAccountId, encryptionPublicKey);
-const channel = computePairingChannel(statementAccountId, encryptionPublicKey);
-//   topic   = blake2b256_keyed(encryptionPublicKey || "topic",   key=statementAccountId)
-//   channel = blake2b256_keyed(encryptionPublicKey || "channel", key=statementAccountId)
+// resource: 'bulletin' | 'statementStore'
+const key = await session.readAllowance(productId, 'statementStore'); // Result<Uint8Array | null, Error>
 ```
-
-### Codec exports
-
-The SCALE codecs are exported as plain `Codec<T>` values for callers that need to
-encode/decode statements outside the orchestrator:
-
-| Export                            | Description                                                                                  |
-| --------------------------------- | -------------------------------------------------------------------------------------------- |
-| `VersionedHandshakeProposal`      | Outer enum; V2 at SCALE discriminant 1, with `_v1Reserved` at 0.                             |
-| `HandshakeProposalV2`             | `{ device, metadata }` — what the QR encodes.                                                |
-| `Device`                          | `{ statementAccountId(32), encryptionPublicKey(65) }`.                                        |
-| `MetadataKey`, `MetadataEntry`    | Metadata enum + `(MetadataKey, str)` tuple.                                                   |
-| `VersionedHandshakeResponse`      | Outer enum for the answer; `V1` legacy + `V2`.                                                |
-| `HandshakeResponseV2`             | `{ encrypted, tmpKey(65) }` — the ECDH-wrapped envelope.                                      |
-| `EncryptedHandshakeResponseV2`    | Inner payload after envelope decrypt: `Pending` (1 byte), `Success` (161 bytes), `Failed`.    |
-| `HandshakeSuccessV2`              | `{ encryptionKey(65), accountId(32), identitySignature(64) }`.                                |
-| `IDENTITY_SIGNATURE_PAYLOAD_BYTES`| `97` — the bytes the user identity sr25519 signs over.                                       |

package/dist/helpers/createAsyncTaskPool.spec.js

@@ -1,5 +1,5 @@
 import { setTimeout } from 'node:timers/promises';
-import { err, fromPromise, ok, okAsync } from 'neverthrow';
+import { fromPromise, okAsync } from 'neverthrow';
 import { describe, expect, it, vi } from 'vitest';
 import { createAsyncTaskPool } from './createAsyncTaskPool.js';
 import { toError } from './utils.js';
@@ -8,7 +8,7 @@ describe('asyncTaskPool', () => {
     it('should exec async task', async () => {
         const pool = createAsyncTaskPool({ poolSize: 1, retryCount: 0, retryDelay: () => 0 });
         const result = await pool.call(() => fromPromise(delay().then(() => 'test'), toError));
-        expect(result).toEqual(ok('test'));
+        await expect(result).toBeOkWith('test');
     });
     it('should handle sync errors', async () => {
         const pool = createAsyncTaskPool({ poolSize: 1, retryCount: 0, retryDelay: () => 0 });
@@ -16,13 +16,13 @@ describe('asyncTaskPool', () => {
         const result = await pool.call(() => {
             throw error;
         });
-        expect(result).toEqual(err(error));
+        await expect(result).toBeErrWith(error);
     });
     it('should handle async errors', async () => {
         const pool = createAsyncTaskPool({ poolSize: 1, retryCount: 0, retryDelay: () => 0 });
         const error = new Error('test');
         const result = await pool.call(() => fromPromise(Promise.reject(error), toError));
-        return expect(result).toEqual(err(error));
+        await expect(result).toBeErrWith(error);
     });
     it('should handle queue', async () => {
         const pool = createAsyncTaskPool({ poolSize: 2, retryCount: 0, retryDelay: () => 0 });
@@ -52,7 +52,7 @@ describe('asyncTaskPool', () => {
             tries++;
             throw new Error();
         });
-        expect(result).toEqual(ok('test'));
+        await expect(result).toBeOkWith('test');
     });
     it('should throw on retry limit exceeding', async () => {
         const spy = vi.fn(() => 0);
@@ -66,7 +66,7 @@ describe('asyncTaskPool', () => {
             throw new Error();
         });
         expect(spy).toBeCalledTimes(1);
-        expect(result).toEqual(err(new Error()));
+        await expect(result).toBeErrWith(new Error());
     });
     it('should correctly calculate retry delay', async () => {
         const spy = vi.fn((retry) => retry * 10);
@@ -125,9 +125,9 @@ describe('asyncTaskPool', () => {
             const queued = pool.call(queuedSpy, { signal: controller.signal });
             controller.abort();
             const queuedResult = await queued;
-            expect(queuedResult.isErr()).toBe(true);
+            await expect(queuedResult).toBeErr();
             expect(queuedSpy).not.toHaveBeenCalled();
-            expect((await active).isOk()).toBe(true);
+            await expect(await active).toBeOk();
         });
         it('rejects the in-flight active task when the signal aborts', async () => {
             const pool = createAsyncTaskPool({ poolSize: 1, retryCount: 0, retryDelay: 0 });
@@ -136,7 +136,7 @@ describe('asyncTaskPool', () => {
                 signal: controller.signal,
             });
             controller.abort();
-            expect((await active).isErr()).toBe(true);
+            await expect(await active).toBeErr();
         });
         it('frees the slot for later tasks after an abort', async () => {
             const pool = createAsyncTaskPool({ poolSize: 1, retryCount: 0, retryDelay: 0 });
@@ -147,7 +147,7 @@ describe('asyncTaskPool', () => {
             controller.abort();
             await aborted;
             const next = await pool.call(() => okAsync('next'));
-            expect(next).toEqual(ok('next'));
+            await expect(next).toBeOkWith('next');
         });
         it('rejects immediately when called with an already-aborted signal', async () => {
             const pool = createAsyncTaskPool({ poolSize: 1, retryCount: 0, retryDelay: 0 });
@@ -155,7 +155,7 @@ describe('asyncTaskPool', () => {
             controller.abort();
             const spy = vi.fn(() => okAsync('x'));
             const result = await pool.call(spy, { signal: controller.signal });
-            expect(result.isErr()).toBe(true);
+            await expect(result).toBeErr();
             expect(spy).not.toHaveBeenCalled();
         });
     });

package/dist/index.d.ts

@@ -6,9 +6,11 @@ export type { PairingStatus } from './sso/auth/types.js';
 export type { DeviceIdentityForPairing } from './sso/auth/v2/service.js';
 export type { AllowanceErrorReason, AllowanceService } from './sso/allowance/index.js';
 export { AllowanceError } from './sso/allowance/index.js';
+export type { AllowanceResourceKind } from './sso/allowance/index.js';
 export type { UserSession } from './sso/sessionManager/userSession.js';
 export type { StoredUserSession } from './sso/userSessionRepository.js';
 export type { Identity } from './identity/types.js';
 export type { SignRawLegacyRequest, SignRawLegacyResponse, SigningPayloadRequest, SigningPayloadResponse, SigningRawRequest, SigningRequest, } from './sso/sessionManager/scale/signing.js';
-export type { RingVrfAliasRequest, RingVrfAliasResponse } from './sso/sessionManager/scale/ringVrf.js';
+export type { RingVrfAliasRequest, RingVrfAliasResponse, RingVrfProofRequest, RingVrfProofResponse, } from './sso/sessionManager/scale/ringVrf.js';
+export type { SignVrfErr, SignVrfRequest, SignVrfResponse } from './sso/sessionManager/scale/signVrf.js';
 export type { CreateTransactionLegacyRequest, CreateTransactionRequest, CreateTransactionResponse, } from './sso/sessionManager/scale/createTransaction.js';

package/dist/papp.js

@@ -19,6 +19,7 @@ export function createPappAdapter({ appId, hostMetadata, deviceIdentity, onAuthS
     const ssoSessionRepository = createUserSessionRepository(storage);
     const userSecretRepository = createUserSecretRepository(appId, storage);
     const allowanceRepository = createAllowanceRepository(appId, storage);
+    const identityRepository = createIdentityRepository({ adapter: identities, storage });
     const deviceIdentityStore = createDeviceIdentityStore(appId, storage);
     const sessions = createSsoSessionManager({
         storage,
@@ -26,6 +27,7 @@ export function createPappAdapter({ appId, hostMetadata, deviceIdentity, onAuthS
         ssoSessionRepository,
         userSecretRepository,
         allowanceRepository,
+        identityRepository,
     });
     return {
         sso: createAuth({
@@ -39,7 +41,7 @@ export function createPappAdapter({ appId, hostMetadata, deviceIdentity, onAuthS
         }),
         sessions,
         secrets: userSecretRepository,
-        identity: createIdentityRepository({ adapter: identities, storage }),
+        identity: identityRepository,
         allowance: createAllowanceService({ sessions: sessions.sessions, repository: allowanceRepository }),
     };
 }

package/dist/sso/sessionManager/impl.d.ts

@@ -1,5 +1,6 @@
 import type { StatementStoreAdapter } from '@novasamatech/statement-store';
 import type { StorageAdapter } from '@novasamatech/storage-adapter';
+import type { IdentityRepository } from '../../identity/types.js';
 import type { Callback } from '../../types.js';
 import type { AllowanceRepository } from '../allowance/index.js';
 import type { UserSecretRepository } from '../userSecretRepository.js';
@@ -12,8 +13,9 @@ type Params = {
     ssoSessionRepository: UserSessionRepository;
     userSecretRepository: UserSecretRepository;
     allowanceRepository: AllowanceRepository;
+    identityRepository: IdentityRepository;
 };
-export declare function createSsoSessionManager({ ssoSessionRepository, userSecretRepository, allowanceRepository, statementStore, storage, }: Params): {
+export declare function createSsoSessionManager({ ssoSessionRepository, userSecretRepository, allowanceRepository, identityRepository, statementStore, storage, }: Params): {
     sessions: {
         read: () => UserSession[];
         subscribe: (callback: Callback<UserSession[]>) => () => void;

package/dist/sso/sessionManager/impl.js

@@ -4,7 +4,7 @@ import { emitHostPappDebugMessage } from '../../debugBus.js';
 import { createState } from '../../helpers/state.js';
 import { createSsoStatementProver } from '../ssoSessionProver.js';
 import { createUserSession } from './userSession.js';
-export function createSsoSessionManager({ ssoSessionRepository, userSecretRepository, allowanceRepository, statementStore, storage, }) {
+export function createSsoSessionManager({ ssoSessionRepository, userSecretRepository, allowanceRepository, identityRepository, statementStore, storage, }) {
     const localSessions = createState({});
     const sessionUnsubscribes = new Map();
     const releaseSession = (id) => {
@@ -22,7 +22,7 @@ export function createSsoSessionManager({ ssoSessionRepository, userSecretReposi
             toRemove.delete(userSession.id);
             if (userSession.id in activeSessions)
                 continue;
-            const session = createSession(userSession, statementStore, storage, userSecretRepository);
+            const session = createSession(userSession, statementStore, storage, userSecretRepository, allowanceRepository, identityRepository);
             toAdd.add(session);
             emitHostPappDebugMessage({
                 layer: 'session',
@@ -73,7 +73,7 @@ export function createSsoSessionManager({ ssoSessionRepository, userSecretReposi
             subscribe: (callback) => localSessions.subscribe(sessions => callback(Object.values(sessions))),
         },
         disconnect(userSession) {
-            const session = createSession(userSession, statementStore, storage, userSecretRepository);
+            const session = createSession(userSession, statementStore, storage, userSecretRepository, allowanceRepository, identityRepository);
             return session
                 .sendDisconnectMessage()
                 .andThen(() => disconnect(userSession))
@@ -88,7 +88,7 @@ export function createSsoSessionManager({ ssoSessionRepository, userSecretReposi
         },
     };
 }
-function createSession(userSession, statementStore, storage, userSecretRepository) {
+function createSession(userSession, statementStore, storage, userSecretRepository, allowanceRepository, identityRepository) {
     const encryption = createEncryption(userSession.remoteAccount.publicKey);
     const prover = createSsoStatementProver(userSession, userSecretRepository);
     return createUserSession({
@@ -97,5 +97,7 @@ function createSession(userSession, statementStore, storage, userSecretRepositor
         encryption,
         storage,
         prover,
+        allowanceRepository,
+        identityRepository,
     });
 }

package/dist/sso/sessionManager/scale/productSubtree.d.ts

@@ -0,0 +1,12 @@
+import type { CodecType } from 'scale-ts';
+export type ProductSubtreeRequest = CodecType<typeof ProductSubtreeRequestCodec>;
+export declare const ProductSubtreeRequestCodec: import("scale-ts").Codec<{
+    productId: string;
+}>;
+export type ProductSubtreeResponse = CodecType<typeof ProductSubtreeResponseCodec>;
+export declare const ProductSubtreeResponseCodec: import("scale-ts").Codec<{
+    respondingTo: string;
+    payload: import("scale-ts").ResultPayload<{
+        productPublicKey: Uint8Array<ArrayBufferLike>;
+    }, string>;
+}>;

package/dist/sso/sessionManager/scale/productSubtree.js

@@ -0,0 +1,21 @@
+import { DotNsIdentifier } from '@novasamatech/host-api';
+import { Bytes, Result, Struct, str } from 'scale-ts';
+// RFC-0022 made `//product//{productId}` a hard junction, so the root public
+// key alone no longer determines product account public keys. This request
+// closes the gap: the Account Holder returns the product-subtree public key,
+// from which the Host soft-derives account public keys locally.
+//
+// Consent-free — the response carries no secret material. Fetch once per
+// product and cache; only `AutoSigning` (secret material) requires consent.
+/** 32-byte sr25519 public key of `//product//{productId}`. */
+const Sr25519PublicKey = Bytes(32);
+export const ProductSubtreeRequestCodec = Struct({
+    productId: DotNsIdentifier,
+});
+export const ProductSubtreeResponseCodec = Struct({
+    // referencing to RemoteMessage.messageId
+    respondingTo: str,
+    payload: Result(Struct({
+        productPublicKey: Sr25519PublicKey,
+    }), str),
+});

package/dist/sso/sessionManager/scale/remoteMessage.d.ts

@@ -54,8 +54,18 @@ export declare const RemoteMessageCodec: import("scale-ts").Codec<{
         } | {
             tag: "RingVrfAliasRequest";
             value: {
-                productAccountId: [string, number];
-                productId: string;
+                callingProductId: string;
+                context: [string, `0x${string}`];
+                ring: {
+                    chainId: `0x${string}`;
+                    junctions: ({
+                        tag: "PalletInstance";
+                        value: number;
+                    } | {
+                        tag: "CollectionId";
+                        value: Uint8Array<ArrayBufferLike>;
+                    })[];
+                };
             };
         } | {
             tag: "RingVrfAliasResponse";
@@ -64,7 +74,9 @@ export declare const RemoteMessageCodec: import("scale-ts").Codec<{
                 payload: import("scale-ts").ResultPayload<{
                     context: Uint8Array<ArrayBufferLike>;
                     alias: Uint8Array<ArrayBufferLike>;
-                }, string>;
+                }, import("@novasamatech/scale").CodecError<undefined, "GetAliasErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+                    reason: string;
+                }, "GetAliasErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "GetAliasErr::RingNotFound"> | import("@novasamatech/scale").CodecError<undefined, "GetAliasErr::NotMember">>;
             };
         } | {
             tag: "ResourceAllocationRequest";
@@ -179,6 +191,61 @@ export declare const RemoteMessageCodec: import("scale-ts").Codec<{
                 respondingTo: string;
                 signature: import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike>, string>;
             };
+        } | {
+            tag: "RingVrfProofRequest";
+            value: {
+                callingProductId: string;
+                context: [string, `0x${string}`];
+                ring: {
+                    chainId: `0x${string}`;
+                    junctions: ({
+                        tag: "PalletInstance";
+                        value: number;
+                    } | {
+                        tag: "CollectionId";
+                        value: Uint8Array<ArrayBufferLike>;
+                    })[];
+                };
+                message: Uint8Array<ArrayBufferLike>;
+            };
+        } | {
+            tag: "RingVrfProofResponse";
+            value: {
+                respondingTo: string;
+                payload: import("scale-ts").ResultPayload<{
+                    proof: Uint8Array<ArrayBufferLike>;
+                    contextualAlias: {
+                        context: Uint8Array<ArrayBufferLike>;
+                        alias: Uint8Array<ArrayBufferLike>;
+                    };
+                    ringIndex: number;
+                    ringRevision: number;
+                }, import("@novasamatech/scale").CodecError<undefined, "CreateProofErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+                    reason: string;
+                }, "CreateProofErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "CreateProofErr::RingNotFound"> | import("@novasamatech/scale").CodecError<undefined, "CreateProofErr::NotMember">>;
+            };
+        } | {
+            tag: "SignVrfRequest";
+            value: {
+                productAccountId: [string, number];
+                productId: string;
+                transcriptLabel: Uint8Array<ArrayBufferLike>;
+                items: {
+                    label: Uint8Array<ArrayBufferLike>;
+                    value: Uint8Array<ArrayBufferLike>;
+                }[];
+            };
+        } | {
+            tag: "SignVrfResponse";
+            value: {
+                respondingTo: string;
+                payload: import("scale-ts").ResultPayload<{
+                    preOutput: Uint8Array<ArrayBufferLike>;
+                    proof: Uint8Array<ArrayBufferLike>;
+                }, import("@novasamatech/scale").CodecError<undefined, "SignVrfErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+                    reason: string;
+                }, "SignVrfErr::Unknown">>;
+            };
         };
     };
 }>;

package/dist/sso/sessionManager/scale/remoteMessage.js

@@ -1,11 +1,15 @@
-import { Enum, Struct, _void, str } from 'scale-ts';
+import { Enum } from '@novasamatech/scale';
+import { Struct, _void, str } from 'scale-ts';
 import { CreateTransactionLegacyRequestCodec, CreateTransactionRequestCodec, CreateTransactionResponseCodec, } from './createTransaction.js';
 import { ResourceAllocationRequestCodec, ResourceAllocationResponseCodec } from './resourceAllocation.js';
-import { RingVrfAliasRequestCodec, RingVrfAliasResponseCodec } from './ringVrf.js';
+import { RingVrfAliasRequestCodec, RingVrfAliasResponseCodec, RingVrfProofRequestCodec, RingVrfProofResponseCodec, } from './ringVrf.js';
+import { SignVrfRequestCodec, SignVrfResponseCodec } from './signVrf.js';
 import { SignRawLegacyRequestCodec, SignRawLegacyResponseCodec, SigningRequestCodec, SigningResponseCodec, } from './signing.js';
 export const RemoteMessageCodec = Struct({
     messageId: str,
     data: Enum({
+        // Declaration order is the SCALE wire order and must stay in lockstep with the
+        // truapi `host_logic::sso::messages::v1::RemoteMessage` enum. Append only.
         v1: Enum({
             Disconnected: _void,
             SignRequest: SigningRequestCodec,
@@ -19,6 +23,10 @@ export const RemoteMessageCodec = Struct({
             CreateTransactionLegacyRequest: CreateTransactionLegacyRequestCodec,
             SignRawLegacyRequest: SignRawLegacyRequestCodec,
             SignRawLegacyResponse: SignRawLegacyResponseCodec,
+            RingVrfProofRequest: RingVrfProofRequestCodec,
+            RingVrfProofResponse: RingVrfProofResponseCodec,
+            SignVrfRequest: SignVrfRequestCodec,
+            SignVrfResponse: SignVrfResponseCodec,
         }),
     }),
 });

package/dist/sso/sessionManager/scale/ringVrf.d.ts

@@ -1,8 +1,18 @@
 import type { CodecType } from 'scale-ts';
 export type RingVrfAliasRequest = CodecType<typeof RingVrfAliasRequestCodec>;
 export declare const RingVrfAliasRequestCodec: import("scale-ts").Codec<{
-    productAccountId: [string, number];
-    productId: string;
+    callingProductId: string;
+    context: [string, `0x${string}`];
+    ring: {
+        chainId: `0x${string}`;
+        junctions: ({
+            tag: "PalletInstance";
+            value: number;
+        } | {
+            tag: "CollectionId";
+            value: Uint8Array<ArrayBufferLike>;
+        })[];
+    };
 }>;
 export type RingVrfAliasResponse = CodecType<typeof RingVrfAliasResponseCodec>;
 export declare const RingVrfAliasResponseCodec: import("scale-ts").Codec<{
@@ -10,5 +20,38 @@ export declare const RingVrfAliasResponseCodec: import("scale-ts").Codec<{
     payload: import("scale-ts").ResultPayload<{
         context: Uint8Array<ArrayBufferLike>;
         alias: Uint8Array<ArrayBufferLike>;
-    }, string>;
+    }, import("@novasamatech/scale").CodecError<undefined, "GetAliasErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "GetAliasErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "GetAliasErr::RingNotFound"> | import("@novasamatech/scale").CodecError<undefined, "GetAliasErr::NotMember">>;
+}>;
+export type RingVrfProofRequest = CodecType<typeof RingVrfProofRequestCodec>;
+export declare const RingVrfProofRequestCodec: import("scale-ts").Codec<{
+    callingProductId: string;
+    context: [string, `0x${string}`];
+    ring: {
+        chainId: `0x${string}`;
+        junctions: ({
+            tag: "PalletInstance";
+            value: number;
+        } | {
+            tag: "CollectionId";
+            value: Uint8Array<ArrayBufferLike>;
+        })[];
+    };
+    message: Uint8Array<ArrayBufferLike>;
+}>;
+export type RingVrfProofResponse = CodecType<typeof RingVrfProofResponseCodec>;
+export declare const RingVrfProofResponseCodec: import("scale-ts").Codec<{
+    respondingTo: string;
+    payload: import("scale-ts").ResultPayload<{
+        proof: Uint8Array<ArrayBufferLike>;
+        contextualAlias: {
+            context: Uint8Array<ArrayBufferLike>;
+            alias: Uint8Array<ArrayBufferLike>;
+        };
+        ringIndex: number;
+        ringRevision: number;
+    }, import("@novasamatech/scale").CodecError<undefined, "CreateProofErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "CreateProofErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "CreateProofErr::RingNotFound"> | import("@novasamatech/scale").CodecError<undefined, "CreateProofErr::NotMember">>;
 }>;

package/dist/sso/sessionManager/scale/ringVrf.js

@@ -1,10 +1,21 @@
-import { ContextualAlias, ProductAccountId } from '@novasamatech/host-api';
-import { Result, Struct, str } from 'scale-ts';
+import { ContextualAlias, CreateProofErr, DotNsIdentifier, GetAliasErr, ProductProofContext, RingLocation, RingVrfProof, } from '@novasamatech/host-api';
+import { Bytes, Result, Struct, str } from 'scale-ts';
 export const RingVrfAliasRequestCodec = Struct({
-    productAccountId: ProductAccountId,
-    productId: str,
+    callingProductId: DotNsIdentifier,
+    context: ProductProofContext,
+    ring: RingLocation,
 });
 export const RingVrfAliasResponseCodec = Struct({
     respondingTo: str,
-    payload: Result(ContextualAlias, str),
+    payload: Result(ContextualAlias, GetAliasErr),
+});
+export const RingVrfProofRequestCodec = Struct({
+    callingProductId: DotNsIdentifier,
+    context: ProductProofContext,
+    ring: RingLocation,
+    message: Bytes(),
+});
+export const RingVrfProofResponseCodec = Struct({
+    respondingTo: str,
+    payload: Result(RingVrfProof, CreateProofErr),
 });

package/dist/sso/sessionManager/scale/signVrf.d.ts

@@ -0,0 +1,56 @@
+import type { CodecType } from 'scale-ts';
+/**
+ * Host → Account Holder request for an sr25519 (schnorrkel) VRF signature over a
+ * caller-supplied Merlin transcript (RFC-0023, "Accounts Protocol companion").
+ *
+ * The Account Holder derives `productAccountId`, presents the signing confirmation,
+ * replays the transcript verbatim — `Transcript::new(transcriptLabel)` then one
+ * `append_message(label, value)` per item, in order — and signs it. It performs no
+ * interpretation of labels or values.
+ *
+ * This is the non-`AutoSigning` path; when `AutoSigning` covers the account the host
+ * signs locally and never sends this message.
+ */
+export type SignVrfRequest = CodecType<typeof SignVrfRequestCodec>;
+export declare const SignVrfRequestCodec: import("scale-ts").Codec<{
+    productAccountId: [string, number];
+    productId: string;
+    transcriptLabel: Uint8Array<ArrayBufferLike>;
+    items: {
+        label: Uint8Array<ArrayBufferLike>;
+        value: Uint8Array<ArrayBufferLike>;
+    }[];
+}>;
+/** Failure returned by the Account Holder for a VRF signing request. */
+export type SignVrfErr = CodecType<typeof SignVrfErrCodec>;
+export declare const SignVrfErrCodec: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<undefined, "SignVrfErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "SignVrfErr::Unknown">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<undefined, "SignVrfErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "SignVrfErr::Unknown">>] & {
+    enc: import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<undefined, "SignVrfErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "SignVrfErr::Unknown">>;
+    dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<undefined, "SignVrfErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "SignVrfErr::Unknown">>;
+} & {
+    readonly Rejected: import("@novasamatech/scale").ErrCodec<undefined, "SignVrfErr::Rejected">;
+    readonly Unknown: import("@novasamatech/scale").ErrCodec<{
+        reason: string;
+    }, "SignVrfErr::Unknown">;
+} & {
+    [Symbol.hasInstance](v: unknown): v is import("@novasamatech/scale").CodecError<undefined, "SignVrfErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "SignVrfErr::Unknown">;
+};
+export type SignVrfResponse = CodecType<typeof SignVrfResponseCodec>;
+export declare const SignVrfResponseCodec: import("scale-ts").Codec<{
+    respondingTo: string;
+    payload: import("scale-ts").ResultPayload<{
+        preOutput: Uint8Array<ArrayBufferLike>;
+        proof: Uint8Array<ArrayBufferLike>;
+    }, import("@novasamatech/scale").CodecError<undefined, "SignVrfErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "SignVrfErr::Unknown">>;
+}>;

package/dist/sso/sessionManager/scale/signVrf.js

@@ -0,0 +1,18 @@
+import { ProductAccountId, VrfSignature, VrfTranscriptItem } from '@novasamatech/host-api';
+import { ErrEnum } from '@novasamatech/scale';
+import { Bytes, Result, Struct, Vector, _void, str } from 'scale-ts';
+export const SignVrfRequestCodec = Struct({
+    productAccountId: ProductAccountId,
+    productId: str,
+    transcriptLabel: Bytes(),
+    items: Vector(VrfTranscriptItem),
+});
+export const SignVrfErrCodec = ErrEnum('SignVrfErr', {
+    Rejected: [_void, 'Rejected'],
+    Unknown: [Struct({ reason: str }), ({ reason }) => reason],
+});
+export const SignVrfResponseCodec = Struct({
+    // referencing to RemoteMessage.messageId
+    respondingTo: str,
+    payload: Result(VrfSignature, SignVrfErrCodec),
+});

package/dist/sso/sessionManager/userSession.d.ts

@@ -1,15 +1,22 @@
-import { ContextualAlias, ProductAccountId } from '@novasamatech/host-api';
+import { ContextualAlias, ProductProofContext, RingLocation, RingVrfProof, VrfSignature } from '@novasamatech/host-api';
 import type { Encryption, StatementProver, StatementStoreAdapter } from '@novasamatech/statement-store';
 import type { StorageAdapter } from '@novasamatech/storage-adapter';
 import { ResultAsync } from 'neverthrow';
 import type { CodecType } from 'scale-ts';
+import type { Identity, IdentityRepository } from '../../identity/types.js';
 import type { Callback } from '../../types.js';
+import type { AllowanceRepository, AllowanceResourceKind } from '../allowance/index.js';
 import type { StoredUserSession } from '../userSessionRepository.js';
 import type { CreateTransactionLegacyRequest, CreateTransactionRequest } from './scale/createTransaction.js';
 import { RemoteMessageCodec } from './scale/remoteMessage.js';
 import type { ApAllocationOutcome, ResourceAllocationRequest } from './scale/resourceAllocation.js';
+import type { SignVrfRequest } from './scale/signVrf.js';
 import type { SignRawLegacyRequest, SigningPayloadRequest, SigningPayloadResponseData, SigningRawRequest } from './scale/signing.js';
 export type UserSession = StoredUserSession & {
+    /** Read this session's persisted allowance slot-account key for a product/resource. */
+    readAllowance(productId: string, resource: AllowanceResourceKind): ResultAsync<Uint8Array | null, Error>;
+    /** Look up the on-chain identity of this session's user identity account. */
+    getIdentity(): ResultAsync<Identity | null, Error>;
     sendDisconnectMessage(): ResultAsync<void, Error>;
     abortPendingRequests(): ResultAsync<void, Error>;
     signPayload(payload: SigningPayloadRequest): ResultAsync<SigningPayloadResponseData, Error>;
@@ -17,15 +24,19 @@ export type UserSession = StoredUserSession & {
     signRawLegacy(payload: SignRawLegacyRequest): ResultAsync<Uint8Array, Error>;
     createTransaction(payload: CreateTransactionRequest): ResultAsync<Uint8Array, Error>;
     createTransactionLegacy(payload: CreateTransactionLegacyRequest): ResultAsync<Uint8Array, Error>;
-    getRingVrfAlias(productAccountId: CodecType<typeof ProductAccountId>, productId: string): ResultAsync<CodecType<typeof ContextualAlias>, Error>;
+    getRingVrfAlias(callingProductId: string, context: CodecType<typeof ProductProofContext>, ring: CodecType<typeof RingLocation>): ResultAsync<CodecType<typeof ContextualAlias>, Error>;
+    createRingVrfProof(callingProductId: string, context: CodecType<typeof ProductProofContext>, ring: CodecType<typeof RingLocation>, message: Uint8Array): ResultAsync<CodecType<typeof RingVrfProof>, Error>;
+    signVrf(payload: SignVrfRequest): ResultAsync<CodecType<typeof VrfSignature>, Error>;
     requestResourceAllocation(request: ResourceAllocationRequest): ResultAsync<ApAllocationOutcome[], Error>;
     subscribe(callback: Callback<CodecType<typeof RemoteMessageCodec>, ResultAsync<boolean, Error>>): VoidFunction;
     dispose(): void;
 };
-export declare function createUserSession({ userSession, statementStore, encryption, storage, prover, }: {
+export declare function createUserSession({ userSession, statementStore, encryption, storage, prover, allowanceRepository, identityRepository, }: {
     userSession: StoredUserSession;
     statementStore: StatementStoreAdapter;
     encryption: Encryption;
     storage: StorageAdapter;
     prover: StatementProver;
+    allowanceRepository: AllowanceRepository;
+    identityRepository: IdentityRepository;
 }): UserSession;

package/dist/sso/sessionManager/userSession.js

@@ -1,9 +1,10 @@
-import { ContextualAlias, ProductAccountId } from '@novasamatech/host-api';
+import { ContextualAlias, ProductProofContext, RingLocation, RingVrfProof, VrfSignature } from '@novasamatech/host-api';
 import { enumValue } from '@novasamatech/scale';
 import { createSession } from '@novasamatech/statement-store';
 import { fieldListView } from '@novasamatech/storage-adapter';
 import { nanoid } from 'nanoid';
 import { ResultAsync, err, ok, okAsync } from 'neverthrow';
+import { toHex } from 'polkadot-api/utils';
 import { emitHostPappDebugMessage } from '../../debugBus.js';
 import { createAsyncTaskPool } from '../../helpers/createAsyncTaskPool.js';
 import { toError } from '../../helpers/utils.js';
@@ -80,7 +81,7 @@ function withHostActionTrace(result, messageId, sessionId) {
         });
     });
 }
-export function createUserSession({ userSession, statementStore, encryption, storage, prover, }) {
+export function createUserSession({ userSession, statementStore, encryption, storage, prover, allowanceRepository, identityRepository, }) {
     const requestQueue = createAsyncTaskPool({ poolSize: 1, retryCount: 0, retryDelay: 0 });
     // Shared abort handle for everything currently on the request queue.
     // abortPendingRequests() fires it to drop the in-flight task plus anything
@@ -111,6 +112,12 @@ export function createUserSession({ userSession, statementStore, encryption, sto
     });
     return {
         ...userSession,
+        readAllowance(productId, resource) {
+            return allowanceRepository.read(userSession.id, productId, resource);
+        },
+        getIdentity() {
+            return identityRepository.getIdentity(toHex(userSession.identityAccountId));
+        },
         signPayload(payload) {
             return enqueue(() => {
                 const messageId = nanoid();
@@ -237,12 +244,13 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                 return withHostActionTrace(withQueueTimeout(inner, 'createTransactionLegacy'), messageId, userSession.id);
             });
         },
-        getRingVrfAlias(productAccountId, productId) {
+        getRingVrfAlias(callingProductId, context, ring) {
             return enqueue(() => {
                 const messageId = nanoid();
                 const data = enumValue('v1', enumValue('RingVrfAliasRequest', {
-                    productAccountId,
-                    productId,
+                    callingProductId,
+                    context,
+                    ring,
                 }));
                 emitHostAction(messageId, actionKindFromMessageData(data), userSession.id);
                 const responseFilter = (message) => {
@@ -254,7 +262,47 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                 };
                 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);
+                return withHostActionTrace(awaitReplyOrAckFailure(request, reply).andThen(result => result.success ? ok(result.value) : err(result.value)), messageId, userSession.id);
+            });
+        },
+        createRingVrfProof(callingProductId, context, ring, message) {
+            return enqueue(() => {
+                const messageId = nanoid();
+                const data = enumValue('v1', enumValue('RingVrfProofRequest', {
+                    callingProductId,
+                    context,
+                    ring,
+                    message,
+                }));
+                emitHostAction(messageId, actionKindFromMessageData(data), userSession.id);
+                const responseFilter = (incoming) => {
+                    if (incoming.data.tag === 'v1' &&
+                        incoming.data.value.tag === 'RingVrfProofResponse' &&
+                        incoming.data.value.value.respondingTo === messageId) {
+                        return incoming.data.value.value.payload;
+                    }
+                };
+                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(result.value)), messageId, userSession.id);
+            });
+        },
+        signVrf(payload) {
+            return enqueue(() => {
+                const messageId = nanoid();
+                const data = enumValue('v1', enumValue('SignVrfRequest', payload));
+                emitHostAction(messageId, actionKindFromMessageData(data), userSession.id);
+                const responseFilter = (message) => {
+                    if (message.data.tag === 'v1' &&
+                        message.data.value.tag === 'SignVrfResponse' &&
+                        message.data.value.value.respondingTo === messageId) {
+                        return message.data.value.value.payload;
+                    }
+                };
+                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(result.value));
+                return withHostActionTrace(withQueueTimeout(inner, 'signVrf'), messageId, userSession.id);
             });
         },
         requestResourceAllocation(payload) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-papp",
   "type": "module",
-  "version": "0.8.10",
+  "version": "0.8.12",
   "description": "Polkadot app integration",
   "license": "Apache-2.0",
   "repository": {
@@ -34,14 +34,14 @@
     "@noble/ciphers": "2.2.0",
     "@noble/curves": "2.2.0",
     "@noble/hashes": "2.2.0",
-    "@novasamatech/host-api": "0.8.10",
-    "@novasamatech/scale": "0.8.10",
-    "@novasamatech/statement-store": "0.8.10",
-    "@novasamatech/storage-adapter": "0.8.10",
+    "@novasamatech/host-api": "0.8.12",
+    "@novasamatech/scale": "0.8.12",
+    "@novasamatech/statement-store": "0.8.12",
+    "@novasamatech/storage-adapter": "0.8.12",
     "@polkadot-api/utils": "^0.4.0",
-    "@polkadot-labs/hdkd-helpers": "^0.0.30",
-    "nanoevents": "9.1.0",
-    "nanoid": "5.1.11",
+    "@polkadot-labs/hdkd-helpers": "^0.0.31",
+    "nanoevents": "10.0.0",
+    "nanoid": "6.0.0",
     "neverthrow": "^8.2.0",
     "polkadot-api": ">=2",
     "rxjs": "^7.8.2",