@novasamatech/host-api-wrapper 0.8.10 → 0.8.12

package/README.md

@@ -250,11 +250,48 @@ if (accountResult.isOk()) {
   console.log('Public key:', account.publicKey);
 }
 
-// Get account alias
-const aliasResult = await accounts.getProductAccountAlias('product.dot', 0);
+// Ring VRF: a contextual alias and a proof are addressed by a product-scoped
+// `context` (`[productId, suffix]`) and a `ring` location on a chain (RFC 0004).
+const context: [string, string] = ['product.dot', '0x00']; // [productId, 0x-hex suffix]
+const ring = {
+  chainId: '0x…', // 32-byte chain genesis hash
+  junctions: [{ tag: 'PalletInstance', value: 42 }],
+};
+
+// Get the contextual alias for that (context, ring).
+const aliasResult = await accounts.getContextualAlias(context, ring);
 
 if (aliasResult.isOk()) {
-  console.log('Alias:', aliasResult.value);
+  const { context: contextBytes, alias } = aliasResult.value;
+  console.log('Alias:', alias);
+}
+
+// Create a ring VRF proof binding `message`; the host selects the member key.
+const proofResult = await accounts.createRingVRFProof(context, ring, new Uint8Array([0x48, 0x69]));
+
+if (proofResult.isOk()) {
+  const { proof, contextualAlias, ringIndex, ringRevision } = proofResult.value;
+  console.log('Proof:', proof, 'at ring index', ringIndex, 'revision', ringRevision);
+}
+
+// sr25519 VRF signature over a product account (RFC-0023). The transcript is a
+// recipe — a root label plus ordered `(label, value)` items — that the host
+// replays verbatim (`Transcript::new(label)` then one `append_message` per item)
+// and signs. It never injects a `signer` item; pass the account's public key
+// yourself if the transcript needs one.
+import type { VrfTranscriptItem } from '@novasamatech/host-api-wrapper';
+
+const transcriptLabel = new TextEncoder().encode('my-product-lottery');
+const items: VrfTranscriptItem[] = [{ label: new TextEncoder().encode('round'), value: new Uint8Array([7]) }];
+
+const vrfResult = await accounts.signVrf('product.dot', 0, transcriptLabel, items);
+
+if (vrfResult.isOk()) {
+  const { preOutput, proof } = vrfResult.value; // 32-byte VRFPreOut, 64-byte VRFProof
+  console.log('VRF pre-output:', preOutput, 'proof:', proof);
+} else {
+  // err.tag: 'NotConnected' | 'Rejected' | 'Unknown'
+  console.error('signVrf failed:', vrfResult.error.tag);
 }
 
 // Get legacy accounts (external wallets)

package/dist/accounts.d.ts

@@ -1,5 +1,5 @@
-import type { AccountConnectionStatus as AccountConnectionStatusCodec, CodecType, LegacyAccount as LegacyAccountCodec, ProductAccountId as ProductAccountIdCodec, Subscription, Transport } from '@novasamatech/host-api';
-import { RingLocation } from '@novasamatech/host-api';
+import type { AccountConnectionStatus as AccountConnectionStatusCodec, CodecType, LegacyAccount as LegacyAccountCodec, ProductAccountId as ProductAccountIdCodec, Subscription, Transport, VrfTranscriptItem as VrfTranscriptItemCodec } from '@novasamatech/host-api';
+import { ProductProofContext, RingLocation } from '@novasamatech/host-api';
 import type { PolkadotSigner } from 'polkadot-api';
 export type ProductAccountId = CodecType<typeof ProductAccountIdCodec>;
 export type ProductAccount = {
@@ -9,6 +9,8 @@ export type ProductAccount = {
 };
 export type LegacyAccount = CodecType<typeof LegacyAccountCodec>;
 export type AccountConnectionStatus = CodecType<typeof AccountConnectionStatusCodec>;
+/** One `transcript.append_message(label, value)` call replayed by the host (RFC-0023). */
+export type VrfTranscriptItem = CodecType<typeof VrfTranscriptItemCodec>;
 export declare const createAccountsProvider: (transport?: Transport) => {
     getUserId(): import("neverthrow").ResultAsync<{
         primaryUsername: string;
@@ -25,21 +27,43 @@ export declare const createAccountsProvider: (transport?: Transport) => {
     }, import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::NotConnected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::Rejected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::DomainNotValid"> | import("@novasamatech/scale").CodecError<{
         reason: string;
     }, "RequestCredentialsErr::Unknown">>;
-    getProductAccountAlias(dotNsIdentifier: string, derivationIndex?: number): import("neverthrow").ResultAsync<{
+    getContextualAlias(context: CodecType<typeof ProductProofContext>, ring: CodecType<typeof RingLocation>): import("neverthrow").ResultAsync<{
         context: Uint8Array<ArrayBufferLike>;
         alias: Uint8Array<ArrayBufferLike>;
-    }, import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::NotConnected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::Rejected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::DomainNotValid"> | import("@novasamatech/scale").CodecError<{
+    }, import("@novasamatech/scale").CodecError<undefined, "GetAliasErr::Rejected"> | import("@novasamatech/scale").CodecError<{
         reason: string;
-    }, "RequestCredentialsErr::Unknown">>;
+    }, "GetAliasErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "GetAliasErr::RingNotFound"> | import("@novasamatech/scale").CodecError<undefined, "GetAliasErr::NotMember">>;
     getLegacyAccounts(): import("neverthrow").ResultAsync<{
         publicKey: Uint8Array<ArrayBufferLike>;
         name: string | undefined;
     }[], import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::NotConnected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::Rejected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::DomainNotValid"> | import("@novasamatech/scale").CodecError<{
         reason: string;
     }, "RequestCredentialsErr::Unknown">>;
-    createRingVRFProof(dotNsIdentifier: string, derivationIndex: number | undefined, location: CodecType<typeof RingLocation>, message: Uint8Array): import("neverthrow").ResultAsync<Uint8Array<ArrayBufferLike>, import("@novasamatech/scale").CodecError<undefined, "CreateProofErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+    createRingVRFProof(context: CodecType<typeof ProductProofContext>, ring: CodecType<typeof RingLocation>, message: Uint8Array): import("neverthrow").ResultAsync<{
+        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">>;
+    /**
+     * Produces an sr25519 (schnorrkel) VRF signature from a product account (RFC-0023).
+     *
+     * The host replays `transcriptLabel` and `items` into a Merlin transcript verbatim —
+     * `Transcript::new(transcriptLabel)` then one `append_message(label, value)` per item,
+     * in order — and signs it. Callers that need a `signer` item must pass their own public
+     * key (from `getProductAccount`); the host never injects it.
+     */
+    signVrf(dotNsIdentifier: string, derivationIndex: number, transcriptLabel: Uint8Array, items: VrfTranscriptItem[]): import("neverthrow").ResultAsync<{
+        preOutput: Uint8Array<ArrayBufferLike>;
+        proof: Uint8Array<ArrayBufferLike>;
+    }, import("@novasamatech/scale").CodecError<undefined, "SignVrfErr::NotConnected"> | import("@novasamatech/scale").CodecError<undefined, "SignVrfErr::Rejected"> | import("@novasamatech/scale").CodecError<{
         reason: string;
-    }, "CreateProofErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "CreateProofErr::RingNotFound">>;
+    }, "SignVrfErr::Unknown">>;
     /**
      * Builds a `PolkadotSigner` that delegates to the host via `host_create_transaction`.
      *
@@ -66,21 +90,43 @@ export declare const accounts: {
     }, import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::NotConnected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::Rejected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::DomainNotValid"> | import("@novasamatech/scale").CodecError<{
         reason: string;
     }, "RequestCredentialsErr::Unknown">>;
-    getProductAccountAlias(dotNsIdentifier: string, derivationIndex?: number): import("neverthrow").ResultAsync<{
+    getContextualAlias(context: CodecType<typeof ProductProofContext>, ring: CodecType<typeof RingLocation>): import("neverthrow").ResultAsync<{
         context: Uint8Array<ArrayBufferLike>;
         alias: Uint8Array<ArrayBufferLike>;
-    }, import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::NotConnected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::Rejected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::DomainNotValid"> | import("@novasamatech/scale").CodecError<{
+    }, import("@novasamatech/scale").CodecError<undefined, "GetAliasErr::Rejected"> | import("@novasamatech/scale").CodecError<{
         reason: string;
-    }, "RequestCredentialsErr::Unknown">>;
+    }, "GetAliasErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "GetAliasErr::RingNotFound"> | import("@novasamatech/scale").CodecError<undefined, "GetAliasErr::NotMember">>;
     getLegacyAccounts(): import("neverthrow").ResultAsync<{
         publicKey: Uint8Array<ArrayBufferLike>;
         name: string | undefined;
     }[], import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::NotConnected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::Rejected"> | import("@novasamatech/scale").CodecError<undefined, "RequestCredentialsErr::DomainNotValid"> | import("@novasamatech/scale").CodecError<{
         reason: string;
     }, "RequestCredentialsErr::Unknown">>;
-    createRingVRFProof(dotNsIdentifier: string, derivationIndex: number | undefined, location: CodecType<typeof RingLocation>, message: Uint8Array): import("neverthrow").ResultAsync<Uint8Array<ArrayBufferLike>, import("@novasamatech/scale").CodecError<undefined, "CreateProofErr::Rejected"> | import("@novasamatech/scale").CodecError<{
+    createRingVRFProof(context: CodecType<typeof ProductProofContext>, ring: CodecType<typeof RingLocation>, message: Uint8Array): import("neverthrow").ResultAsync<{
+        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">>;
+    /**
+     * Produces an sr25519 (schnorrkel) VRF signature from a product account (RFC-0023).
+     *
+     * The host replays `transcriptLabel` and `items` into a Merlin transcript verbatim —
+     * `Transcript::new(transcriptLabel)` then one `append_message(label, value)` per item,
+     * in order — and signs it. Callers that need a `signer` item must pass their own public
+     * key (from `getProductAccount`); the host never injects it.
+     */
+    signVrf(dotNsIdentifier: string, derivationIndex: number, transcriptLabel: Uint8Array, items: VrfTranscriptItem[]): import("neverthrow").ResultAsync<{
+        preOutput: Uint8Array<ArrayBufferLike>;
+        proof: Uint8Array<ArrayBufferLike>;
+    }, import("@novasamatech/scale").CodecError<undefined, "SignVrfErr::NotConnected"> | import("@novasamatech/scale").CodecError<undefined, "SignVrfErr::Rejected"> | import("@novasamatech/scale").CodecError<{
         reason: string;
-    }, "CreateProofErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "CreateProofErr::RingNotFound">>;
+    }, "SignVrfErr::Unknown">>;
     /**
      * Builds a `PolkadotSigner` that delegates to the host via `host_create_transaction`.
      *

package/dist/accounts.js

@@ -1,4 +1,4 @@
-import { CreateProofErr, GetUserIdErr, LoginErr, RequestCredentialsErr, RingLocation, SigningPayload, SigningPayloadWithoutAccount, SigningRawPayload, SigningRawPayloadWithoutAccount, assertEnumVariant, createHostApi, enumValue, fromHex, isEnumVariant, toHex, } from '@novasamatech/host-api';
+import { CreateProofErr, GetAliasErr, GetUserIdErr, LoginErr, ProductProofContext, RequestCredentialsErr, RingLocation, SignVrfErr, SigningPayload, SigningPayloadWithoutAccount, SigningRawPayload, SigningRawPayloadWithoutAccount, assertEnumVariant, createHostApi, enumValue, fromHex, isEnumVariant, toHex, } from '@novasamatech/host-api';
 import { decAnyMetadata, unifyMetadata } from '@polkadot-api/substrate-bindings';
 import { err, ok } from 'neverthrow';
 import { AccountId } from 'polkadot-api';
@@ -48,16 +48,16 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
                 return err(new RequestCredentialsErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
             });
         },
-        getProductAccountAlias(dotNsIdentifier, derivationIndex = 0) {
+        getContextualAlias(context, ring) {
             return hostApi
-                .accountGetAlias(enumValue('v1', [dotNsIdentifier, derivationIndex]))
+                .accountGetAlias(enumValue('v1', [context, ring]))
                 .mapErr(e => e.value)
                 .andThen(response => {
                 if (isEnumVariant(response, 'v1')) {
                     return ok(response.value);
                 }
                 // @ts-expect-error response.tag is never here
-                return err(new RequestCredentialsErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
+                return err(new GetAliasErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
             });
         },
         getLegacyAccounts() {
@@ -72,9 +72,9 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
                 return err(new RequestCredentialsErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
             });
         },
-        createRingVRFProof(dotNsIdentifier, derivationIndex = 0, location, message) {
+        createRingVRFProof(context, ring, message) {
             return hostApi
-                .accountCreateProof(enumValue('v1', [[dotNsIdentifier, derivationIndex], location, message]))
+                .accountCreateProof(enumValue('v1', [context, ring, message]))
                 .mapErr(e => e.value)
                 .andThen(response => {
                 if (isEnumVariant(response, 'v1')) {
@@ -84,6 +84,26 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
                 return err(new CreateProofErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
             });
         },
+        /**
+         * Produces an sr25519 (schnorrkel) VRF signature from a product account (RFC-0023).
+         *
+         * The host replays `transcriptLabel` and `items` into a Merlin transcript verbatim —
+         * `Transcript::new(transcriptLabel)` then one `append_message(label, value)` per item,
+         * in order — and signs it. Callers that need a `signer` item must pass their own public
+         * key (from `getProductAccount`); the host never injects it.
+         */
+        signVrf(dotNsIdentifier, derivationIndex, transcriptLabel, items) {
+            return hostApi
+                .accountSignVrf(enumValue('v1', { account: [dotNsIdentifier, derivationIndex], transcriptLabel, items }))
+                .mapErr(e => e.value)
+                .andThen(response => {
+                if (isEnumVariant(response, 'v1')) {
+                    return ok(response.value);
+                }
+                // @ts-expect-error response.tag is never here
+                return err(new SignVrfErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
+            });
+        },
         /**
          * Builds a `PolkadotSigner` that delegates to the host via `host_create_transaction`.
          *

package/dist/index.d.ts

@@ -8,7 +8,7 @@ export type { ChatBotRegistrationResult, ChatCustomMessageRenderer, ChatCustomMe
 export { createProductChatManager, matchChatCustomRenderers } from './chat.js';
 export type { ProductAccountId, SignedStatement, Statement, StatementTopicFilter, StatementsPage, Topic, } from './statementStore.js';
 export { createStatementStore } from './statementStore.js';
-export type { AccountConnectionStatus, LegacyAccount, ProductAccount } from './accounts.js';
+export type { AccountConnectionStatus, LegacyAccount, ProductAccount, VrfTranscriptItem } from './accounts.js';
 export { accounts, createAccountsProvider } from './accounts.js';
 export type { ThemeMode } from './theme.js';
 export { createThemeProvider } from './theme.js';

package/dist/localStorage.js

@@ -32,9 +32,10 @@ export const createLocalStorage = (transport = sandboxTransport) => {
             return writeBytes(key, textEncoder.encode(value));
         },
         async readJSON(key) {
-            return readBytes(key)
-                .then(bytes => textDecoder.decode(bytes))
-                .then(JSON.parse);
+            const bytes = await readBytes(key);
+            if (bytes === undefined || bytes.length === 0)
+                return undefined;
+            return JSON.parse(textDecoder.decode(bytes));
         },
         async writeJSON(key, value) {
             return writeBytes(key, textEncoder.encode(JSON.stringify(value)));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-api-wrapper",
   "type": "module",
-  "version": "0.8.10",
+  "version": "0.8.12",
   "description": "Host API wrapper: integrate and run your product inside Polkadot browser.",
   "license": "Apache-2.0",
   "repository": {
@@ -28,7 +28,7 @@
     "@polkadot/extension-inject": "^0.63.1",
     "@polkadot-api/json-rpc-provider-proxy": "^0.4.0",
     "@polkadot-api/substrate-bindings": "^0.20.3",
-    "@novasamatech/host-api": "0.8.10",
+    "@novasamatech/host-api": "0.8.12",
     "polkadot-api": ">=2",
     "neverthrow": "^8.2.0"
   },