@novasamatech/host-api-wrapper 0.8.11 → 0.9.0

package/README.md

@@ -166,7 +166,13 @@ It can be used for various purposes like p2p communication, storing temp data, e
 
 ```ts
 import { createStatementStore } from '@novasamatech/host-api-wrapper';
-import type { Topic, Statement, SignedStatement, StatementTopicFilter } from '@novasamatech/host-api-wrapper';
+import type {
+  Topic,
+  Statement,
+  SignedStatement,
+  StatementTopicFilter,
+  ProductAccountRef,
+} from '@novasamatech/host-api-wrapper';
 
 // Create statement store instance
 const statementStore = createStatementStore();
@@ -182,7 +188,9 @@ const subscription = statementStore.subscribe(filter, (page) => {
 });
 
 // Create a proof for a new statement
-const accountId = ['product.dot', 0]; // [DotNS identifier, derivation index]
+// [DotNS identifier, account selector]. The selector is a plain index or a raw
+// 32-byte index (RFC 0022).
+const accountId: ProductAccountRef = ['product.dot', 0];
 const statement: Statement = {
   proof: undefined,
   decryptionKey: undefined,
@@ -212,7 +220,7 @@ The Accounts Provider allows you to access product accounts and create signers f
 
 ```ts
 import { accounts } from '@novasamatech/host-api-wrapper';
-import type { ProductAccount } from '@novasamatech/host-api-wrapper';
+import type { ProductAccount, ProofContext } from '@novasamatech/host-api-wrapper';
 
 // Get the user's primary DotNS username (RFC-0014)
 // — prompts for permission on first call
@@ -242,8 +250,12 @@ if (loginResult.isOk()) {
   console.error('Login error:', loginResult.error);
 }
 
-// Get a product account by DotNS identifier and derivation index
+// Get a product account by DotNS identifier and account selector. The selector
+// is a plain index (the primary, enumerable form) or a raw 32-byte index
+// (RFC 0022); it defaults to index 0, the product's default account.
 const accountResult = await accounts.getProductAccount('product.dot', 0);
+// …or, for a byte-valued selector:
+// const accountResult = await accounts.getProductAccount('product.dot', raw32);
 
 if (accountResult.isOk()) {
   const account: ProductAccount = accountResult.value;
@@ -252,7 +264,9 @@ if (accountResult.isOk()) {
 
 // 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]
+// The suffix is the same selector as an account's derivation index and expands
+// to the same 32-byte value (RFC 0022).
+const context: ProofContext = ['product.dot', 0]; // [productId, selector]
 const ring = {
   chainId: '0x…', // 32-byte chain genesis hash
   junctions: [{ tag: 'PalletInstance', value: 42 }],
@@ -274,6 +288,26 @@ if (proofResult.isOk()) {
   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)
 const legacyAccountsResult = await accounts.getLegacyAccounts();
 
@@ -427,10 +461,11 @@ const balanceSub = payments.subscribeBalance(balance => {
 });
 balanceSub.onInterrupt(() => console.log('Balance access denied or lost'));
 
-// Top up the user's balance from a product account
+// Top up the user's balance from one of the calling product's accounts.
+// `derivationIndex` is the same selector as `accounts.getProductAccount` takes:
+// a plain index or a raw 32-byte index (RFC 0022).
 await payments.topUp(1_000_000n, {
   type: 'productAccount',
-  dotNsIdentifier: 'my-product.dot',
   derivationIndex: 0,
 });
 

package/dist/accounts.d.ts

@@ -1,14 +1,27 @@
-import type { AccountConnectionStatus as AccountConnectionStatusCodec, CodecType, LegacyAccount as LegacyAccountCodec, ProductAccountId as ProductAccountIdCodec, Subscription, Transport } from '@novasamatech/host-api';
-import { ProductProofContext, RingLocation } from '@novasamatech/host-api';
+import type { AccountConnectionStatus as AccountConnectionStatusCodec, AccountSelector, CodecType, LegacyAccount as LegacyAccountCodec, ProductAccountId as ProductAccountIdCodec, Subscription, Transport, VrfTranscriptItem as VrfTranscriptItemCodec } from '@novasamatech/host-api';
+import { RingLocation } from '@novasamatech/host-api';
 import type { PolkadotSigner } from 'polkadot-api';
+export type { AccountSelector } from '@novasamatech/host-api';
 export type ProductAccountId = CodecType<typeof ProductAccountIdCodec>;
 export type ProductAccount = {
     dotNsIdentifier: string;
-    derivationIndex: number;
+    /**
+     * Account selector within the product subtree (RFC 0022): a plain index or a
+     * raw 32-byte index.
+     */
+    derivationIndex: AccountSelector;
     publicKey: Uint8Array;
 };
+/**
+ * Product-scoped proof context (RFC 0004, amended by RFC 0022): the product id
+ * plus a selector that expands to the same 32-byte derivation index as a
+ * product account's.
+ */
+export type ProofContext = [productId: string, suffix: AccountSelector];
 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;
@@ -18,14 +31,14 @@ export declare const createAccountsProvider: (transport?: Transport) => {
     requestLogin(reason?: string): import("neverthrow").ResultAsync<"success" | "alreadyConnected" | "rejected", import("@novasamatech/scale").CodecError<{
         reason: string;
     }, "LoginErr::Unknown">>;
-    getProductAccount(dotNsIdentifier: string, derivationIndex?: number): import("neverthrow").ResultAsync<{
+    getProductAccount(dotNsIdentifier: string, derivationIndex?: AccountSelector): import("neverthrow").ResultAsync<{
         publicKey: Uint8Array<ArrayBufferLike>;
         dotNsIdentifier: string;
-        derivationIndex: number;
+        derivationIndex: AccountSelector;
     }, 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">>;
-    getContextualAlias(context: CodecType<typeof ProductProofContext>, ring: CodecType<typeof RingLocation>): import("neverthrow").ResultAsync<{
+    getContextualAlias(context: ProofContext, ring: CodecType<typeof RingLocation>): import("neverthrow").ResultAsync<{
         context: Uint8Array<ArrayBufferLike>;
         alias: Uint8Array<ArrayBufferLike>;
     }, import("@novasamatech/scale").CodecError<undefined, "GetAliasErr::Rejected"> | import("@novasamatech/scale").CodecError<{
@@ -37,7 +50,7 @@ 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">>;
-    createRingVRFProof(context: CodecType<typeof ProductProofContext>, ring: CodecType<typeof RingLocation>, message: Uint8Array): import("neverthrow").ResultAsync<{
+    createRingVRFProof(context: ProofContext, ring: CodecType<typeof RingLocation>, message: Uint8Array): import("neverthrow").ResultAsync<{
         proof: Uint8Array<ArrayBufferLike>;
         contextualAlias: {
             context: Uint8Array<ArrayBufferLike>;
@@ -48,6 +61,20 @@ export declare const createAccountsProvider: (transport?: Transport) => {
     }, 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: AccountSelector, 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;
+    }, "SignVrfErr::Unknown">>;
     /**
      * Builds a `PolkadotSigner` that delegates to the host via `host_create_transaction`.
      *
@@ -67,14 +94,14 @@ export declare const accounts: {
     requestLogin(reason?: string): import("neverthrow").ResultAsync<"success" | "alreadyConnected" | "rejected", import("@novasamatech/scale").CodecError<{
         reason: string;
     }, "LoginErr::Unknown">>;
-    getProductAccount(dotNsIdentifier: string, derivationIndex?: number): import("neverthrow").ResultAsync<{
+    getProductAccount(dotNsIdentifier: string, derivationIndex?: AccountSelector): import("neverthrow").ResultAsync<{
         publicKey: Uint8Array<ArrayBufferLike>;
         dotNsIdentifier: string;
-        derivationIndex: number;
+        derivationIndex: AccountSelector;
     }, 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">>;
-    getContextualAlias(context: CodecType<typeof ProductProofContext>, ring: CodecType<typeof RingLocation>): import("neverthrow").ResultAsync<{
+    getContextualAlias(context: ProofContext, ring: CodecType<typeof RingLocation>): import("neverthrow").ResultAsync<{
         context: Uint8Array<ArrayBufferLike>;
         alias: Uint8Array<ArrayBufferLike>;
     }, import("@novasamatech/scale").CodecError<undefined, "GetAliasErr::Rejected"> | import("@novasamatech/scale").CodecError<{
@@ -86,7 +113,7 @@ 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">>;
-    createRingVRFProof(context: CodecType<typeof ProductProofContext>, ring: CodecType<typeof RingLocation>, message: Uint8Array): import("neverthrow").ResultAsync<{
+    createRingVRFProof(context: ProofContext, ring: CodecType<typeof RingLocation>, message: Uint8Array): import("neverthrow").ResultAsync<{
         proof: Uint8Array<ArrayBufferLike>;
         contextualAlias: {
             context: Uint8Array<ArrayBufferLike>;
@@ -97,6 +124,20 @@ export declare const accounts: {
     }, 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: AccountSelector, 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;
+    }, "SignVrfErr::Unknown">>;
     /**
      * Builds a `PolkadotSigner` that delegates to the host via `host_create_transaction`.
      *

package/dist/accounts.js

@@ -1,4 +1,4 @@
-import { CreateProofErr, GetAliasErr, GetUserIdErr, LoginErr, ProductProofContext, 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, derivationIndexOf, 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';
@@ -34,7 +34,7 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
         },
         getProductAccount(dotNsIdentifier, derivationIndex = 0) {
             return hostApi
-                .accountGet(enumValue('v1', [dotNsIdentifier, derivationIndex]))
+                .accountGet(enumValue('v1', [dotNsIdentifier, derivationIndexOf(derivationIndex)]))
                 .mapErr(e => e.value)
                 .andThen(response => {
                 if (isEnumVariant(response, 'v1')) {
@@ -50,7 +50,7 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
         },
         getContextualAlias(context, ring) {
             return hostApi
-                .accountGetAlias(enumValue('v1', [context, ring]))
+                .accountGetAlias(enumValue('v1', [toProofContext(context), ring]))
                 .mapErr(e => e.value)
                 .andThen(response => {
                 if (isEnumVariant(response, 'v1')) {
@@ -74,7 +74,7 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
         },
         createRingVRFProof(context, ring, message) {
             return hostApi
-                .accountCreateProof(enumValue('v1', [context, ring, message]))
+                .accountCreateProof(enumValue('v1', [toProofContext(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, derivationIndexOf(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`.
          *
@@ -92,14 +112,14 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
          */
         getProductAccountSigner(account, signerType = 'createTransaction') {
             const hostApi = createHostApi(transport);
-            const productAccountId = [account.dotNsIdentifier, account.derivationIndex];
+            const productAccountId = [account.dotNsIdentifier, derivationIndexOf(account.derivationIndex)];
             /**
              * @deprecated added for backward compatibility
              */
             if (signerType === 'signPayload') {
                 return getPolkadotSignerFromPjs(toHex(account.publicKey), async (payload) => {
                     const codecPayload = {
-                        account: [account.dotNsIdentifier, account.derivationIndex],
+                        account: productAccountId,
                         payload: buildSigningPayloadFields(payload),
                     };
                     const response = await hostApi.signPayload(enumValue('v1', codecPayload));
@@ -116,7 +136,7 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
                     });
                 }, async (raw) => {
                     const payload = {
-                        account: [account.dotNsIdentifier, account.derivationIndex],
+                        account: productAccountId,
                         payload: raw.type === 'bytes'
                             ? {
                                 tag: 'Bytes',
@@ -154,7 +174,7 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
                     }
                     const txPayload = {
                         signer: productAccountId,
-                        genesisHash: checkGenesis.additionalSigned,
+                        genesisHash: toHex(checkGenesis.additionalSigned),
                         callData,
                         extensions: Object.values(signedExtensions).map(({ identifier, value, additionalSigned }) => ({
                             id: identifier,
@@ -243,6 +263,9 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
     };
 };
 export const accounts = createAccountsProvider();
+function toProofContext([productId, suffix]) {
+    return [productId, derivationIndexOf(suffix)];
+}
 function asHex(v) {
     if (v.startsWith('0x'))
         return v;

package/dist/index.d.ts

@@ -6,9 +6,9 @@ export { createLegacyExtensionEnableFactory, injectSpektrExtension } from './inj
 export { createPapiProvider } from './papiProvider.js';
 export type { ChatBotRegistrationResult, ChatCustomMessageRenderer, ChatCustomMessageRendererParams, ChatMessageContent, ChatReceivedAction, ChatRoom, ChatRoomRegistrationResult, } from './chat.js';
 export { createProductChatManager, matchChatCustomRenderers } from './chat.js';
-export type { ProductAccountId, SignedStatement, Statement, StatementTopicFilter, StatementsPage, Topic, } from './statementStore.js';
+export type { ProductAccountId, ProductAccountRef, SignedStatement, Statement, StatementTopicFilter, StatementsPage, Topic, } from './statementStore.js';
 export { createStatementStore } from './statementStore.js';
-export type { AccountConnectionStatus, LegacyAccount, ProductAccount } from './accounts.js';
+export type { AccountConnectionStatus, AccountSelector, LegacyAccount, ProductAccount, ProofContext, VrfTranscriptItem, } from './accounts.js';
 export { accounts, createAccountsProvider } from './accounts.js';
 export type { ThemeMode } from './theme.js';
 export { createThemeProvider } from './theme.js';

package/dist/injectWeb3.js

@@ -115,7 +115,7 @@ export async function createLegacyExtensionEnableFactory(transport) {
                     const possibleAccountId = accountId.enc(signer);
                     const response = await hostApi.createTransactionWithLegacyAccount(enumValue('v1', {
                         signer: possibleAccountId,
-                        genesisHash: fromHex(checkGenesis.additionalSigned),
+                        genesisHash: checkGenesis.additionalSigned,
                         callData: fromHex(payload.callData),
                         txExtVersion: payload.txExtVersion,
                         extensions: payload.extensions.map(e => ({

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

@@ -1,4 +1,4 @@
-import type { CodecType, PaymentBalanceErr, Subscription, Transport } from '@novasamatech/host-api';
+import type { AccountSelector, CodecType, PaymentBalanceErr, Subscription, Transport } from '@novasamatech/host-api';
 export type PaymentBalance = {
     available: bigint;
 };
@@ -10,9 +10,11 @@ export type PaymentStatus = {
     type: 'failed';
     reason: string;
 };
-export type TopUpSource = {
+export type TopUpSource = 
+/** `derivationIndex` is the RFC-0022 selector: a plain index or a raw 32-byte index. */
+{
     type: 'productAccount';
-    derivationIndex: number;
+    derivationIndex: AccountSelector;
 } | {
     type: 'privateKey';
     key: Uint8Array;

package/dist/payments.js

@@ -1,4 +1,4 @@
-import { createHostApi, enumValue } from '@novasamatech/host-api';
+import { createHostApi, derivationIndexOf, enumValue } from '@novasamatech/host-api';
 import { resultToPromise, unwrapVersionedResult } from './helpers.js';
 import { sandboxTransport } from './sandboxTransport.js';
 export const createPaymentManager = (transport = sandboxTransport) => {
@@ -20,7 +20,7 @@ export const createPaymentManager = (transport = sandboxTransport) => {
             const sourceCodec = source.type === 'productAccount'
                 ? {
                     tag: 'ProductAccount',
-                    value: source.derivationIndex,
+                    value: derivationIndexOf(source.derivationIndex),
                 }
                 : source.type === 'privateKey'
                     ? { tag: 'PrivateKey', value: source.key }

package/dist/statementStore.d.ts

@@ -1,8 +1,14 @@
-import type { CodecType, ProductAccountId as ProductAccountIdCodec, SignedStatement as SignedStatementCodec, Statement as StatementCodec, Subscription, Topic as TopicCodec, Transport } from '@novasamatech/host-api';
+import type { AccountSelector, CodecType, ProductAccountId as ProductAccountIdCodec, SignedStatement as SignedStatementCodec, Statement as StatementCodec, Subscription, Topic as TopicCodec, Transport } from '@novasamatech/host-api';
 export type Statement = CodecType<typeof StatementCodec>;
 export type SignedStatement = CodecType<typeof SignedStatementCodec>;
 export type Topic = CodecType<typeof TopicCodec>;
+/** Wire-level product account id — the selector in its `Index`/`Raw` form. */
 export type ProductAccountId = CodecType<typeof ProductAccountIdCodec>;
+/**
+ * Product account reference in ergonomic form: the dotNS identifier plus a
+ * plain index or a raw 32-byte index (RFC 0022).
+ */
+export type ProductAccountRef = [dotNsIdentifier: string, derivationIndex: AccountSelector];
 export type StatementTopicFilter = {
     matchAll: Topic[];
 } | {
@@ -14,7 +20,7 @@ export type StatementsPage = {
 };
 export declare const createStatementStore: (transport?: Transport) => {
     subscribe(filter: StatementTopicFilter, callback: (page: StatementsPage) => void): Subscription<void>;
-    createProof(accountId: ProductAccountId, statement: Statement): Promise<{
+    createProof([dotNsIdentifier, derivationIndex]: ProductAccountRef, statement: Statement): Promise<{
         tag: "Sr25519";
         value: {
             signature: Uint8Array<ArrayBufferLike>;

package/dist/statementStore.js

@@ -1,4 +1,4 @@
-import { createHostApi, enumValue } from '@novasamatech/host-api';
+import { createHostApi, derivationIndexOf, enumValue } from '@novasamatech/host-api';
 import { sandboxTransport } from './sandboxTransport.js';
 export const createStatementStore = (transport = sandboxTransport) => {
     const hostApi = createHostApi(transport);
@@ -15,7 +15,8 @@ export const createStatementStore = (transport = sandboxTransport) => {
                 onInterrupt: cb => subscriber.onInterrupt(v => cb(v.value)),
             };
         },
-        async createProof(accountId, statement) {
+        async createProof([dotNsIdentifier, derivationIndex], statement) {
+            const accountId = [dotNsIdentifier, derivationIndexOf(derivationIndex)];
             const result = await hostApi.statementStoreCreateProof(enumValue('v1', [accountId, statement]));
             return result.match(payload => {
                 if (payload.tag === 'v1') {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-api-wrapper",
   "type": "module",
-  "version": "0.8.11",
+  "version": "0.9.0",
   "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.11",
+    "@novasamatech/host-api": "0.9.0",
     "polkadot-api": ">=2",
     "neverthrow": "^8.2.0"
   },