@novasamatech/host-papp 0.8.10 → 0.8.11

package/README.md

@@ -200,6 +200,31 @@ await currentSession.signRaw({
 });
 ```
 
+## 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)

package/dist/index.d.ts

@@ -10,5 +10,5 @@ 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 { CreateTransactionLegacyRequest, CreateTransactionRequest, CreateTransactionResponse, } from './sso/sessionManager/scale/createTransaction.js';

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, "RingVrfError::Rejected"> | import("@novasamatech/scale").CodecError<{
+                    reason: string;
+                }, "RingVrfError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::RingNotFound"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::NotMember">>;
             };
         } | {
             tag: "ResourceAllocationRequest";
@@ -179,6 +191,39 @@ 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, "RingVrfError::Rejected"> | import("@novasamatech/scale").CodecError<{
+                    reason: string;
+                }, "RingVrfError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::RingNotFound"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::NotMember">>;
+            };
         };
     };
 }>;

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

@@ -1,7 +1,7 @@
 import { Enum, 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 { SignRawLegacyRequestCodec, SignRawLegacyResponseCodec, SigningRequestCodec, SigningResponseCodec, } from './signing.js';
 export const RemoteMessageCodec = Struct({
     messageId: str,
@@ -19,6 +19,8 @@ export const RemoteMessageCodec = Struct({
             CreateTransactionLegacyRequest: CreateTransactionLegacyRequestCodec,
             SignRawLegacyRequest: SignRawLegacyRequestCodec,
             SignRawLegacyResponse: SignRawLegacyResponseCodec,
+            RingVrfProofRequest: RingVrfProofRequestCodec,
+            RingVrfProofResponse: RingVrfProofResponseCodec,
         }),
     }),
 });

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

@@ -1,8 +1,41 @@
 import type { CodecType } from 'scale-ts';
+export declare const RingVrfError: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<undefined, "RingVrfError::Rejected"> | import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "RingVrfError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::RingNotFound"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::NotMember">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<undefined, "RingVrfError::Rejected"> | import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "RingVrfError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::RingNotFound"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::NotMember">>] & {
+    enc: import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<undefined, "RingVrfError::Rejected"> | import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "RingVrfError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::RingNotFound"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::NotMember">>;
+    dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<undefined, "RingVrfError::Rejected"> | import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "RingVrfError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::RingNotFound"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::NotMember">>;
+} & {
+    readonly RingNotFound: import("@novasamatech/scale").ErrCodec<undefined, "RingVrfError::RingNotFound">;
+    readonly NotMember: import("@novasamatech/scale").ErrCodec<undefined, "RingVrfError::NotMember">;
+    readonly Rejected: import("@novasamatech/scale").ErrCodec<undefined, "RingVrfError::Rejected">;
+    readonly Unknown: import("@novasamatech/scale").ErrCodec<{
+        reason: string;
+    }, "RingVrfError::Unknown">;
+} & {
+    [Symbol.hasInstance](v: unknown): v is import("@novasamatech/scale").CodecError<undefined, "RingVrfError::Rejected"> | import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "RingVrfError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::RingNotFound"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::NotMember">;
+};
 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 +43,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, "RingVrfError::Rejected"> | import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "RingVrfError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::RingNotFound"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::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, "RingVrfError::Rejected"> | import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "RingVrfError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::RingNotFound"> | import("@novasamatech/scale").CodecError<undefined, "RingVrfError::NotMember">>;
 }>;

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

@@ -1,10 +1,30 @@
-import { ContextualAlias, ProductAccountId } from '@novasamatech/host-api';
-import { Result, Struct, str } from 'scale-ts';
+import { ContextualAlias, DotNsIdentifier, ProductProofContext, RingLocation, RingVrfProof, } from '@novasamatech/host-api';
+import { ErrEnum } from '@novasamatech/scale';
+import { Bytes, Result, Struct, _void, str } from 'scale-ts';
+// Shared failure set for both alias and proof requests over the SSO channel;
+// mirrors the Account Holder's `RingVrfError` (RFC 0004).
+export const RingVrfError = ErrEnum('RingVrfError', {
+    RingNotFound: [_void, 'RingVrf: ring not found'],
+    NotMember: [_void, 'RingVrf: selected member key is not a member of the ring'],
+    Rejected: [_void, 'RingVrf: rejected'],
+    Unknown: [Struct({ reason: str }), 'RingVrf: unknown error'],
+});
 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, RingVrfError),
+});
+export const RingVrfProofRequestCodec = Struct({
+    callingProductId: DotNsIdentifier,
+    context: ProductProofContext,
+    ring: RingLocation,
+    message: Bytes(),
+});
+export const RingVrfProofResponseCodec = Struct({
+    respondingTo: str,
+    payload: Result(RingVrfProof, RingVrfError),
 });

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

@@ -1,4 +1,4 @@
-import { ContextualAlias, ProductAccountId } from '@novasamatech/host-api';
+import { ContextualAlias, ProductProofContext, RingLocation, RingVrfProof } from '@novasamatech/host-api';
 import type { Encryption, StatementProver, StatementStoreAdapter } from '@novasamatech/statement-store';
 import type { StorageAdapter } from '@novasamatech/storage-adapter';
 import { ResultAsync } from 'neverthrow';
@@ -17,7 +17,8 @@ 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>;
     requestResourceAllocation(request: ResourceAllocationRequest): ResultAsync<ApAllocationOutcome[], Error>;
     subscribe(callback: Callback<CodecType<typeof RemoteMessageCodec>, ResultAsync<boolean, Error>>): VoidFunction;
     dispose(): void;

package/dist/sso/sessionManager/userSession.js

@@ -1,4 +1,4 @@
-import { ContextualAlias, ProductAccountId } from '@novasamatech/host-api';
+import { ContextualAlias, ProductProofContext, RingLocation, RingVrfProof } from '@novasamatech/host-api';
 import { enumValue } from '@novasamatech/scale';
 import { createSession } from '@novasamatech/statement-store';
 import { fieldListView } from '@novasamatech/storage-adapter';
@@ -237,12 +237,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 +255,29 @@ 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);
             });
         },
         requestResourceAllocation(payload) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-papp",
   "type": "module",
-  "version": "0.8.10",
+  "version": "0.8.11",
   "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.10",
-    "@novasamatech/scale": "0.8.10",
-    "@novasamatech/statement-store": "0.8.10",
-    "@novasamatech/storage-adapter": "0.8.10",
+    "@novasamatech/host-api": "0.8.11",
+    "@novasamatech/scale": "0.8.11",
+    "@novasamatech/statement-store": "0.8.11",
+    "@novasamatech/storage-adapter": "0.8.11",
     "@polkadot-api/utils": "^0.4.0",
     "@polkadot-labs/hdkd-helpers": "^0.0.30",
     "nanoevents": "9.1.0",