@novasamatech/host-api-wrapper 0.8.12 → 0.9.1

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 }],
@@ -447,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,12 +1,23 @@
-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 { 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). */
@@ -20,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<{
@@ -39,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>;
@@ -58,7 +69,7 @@ export declare const createAccountsProvider: (transport?: Transport) => {
      * 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<{
+    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<{
@@ -83,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<{
@@ -102,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>;
@@ -121,7 +132,7 @@ export declare const accounts: {
      * 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<{
+    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<{

package/dist/accounts.js

@@ -1,4 +1,4 @@
-import { CreateProofErr, GetAliasErr, GetUserIdErr, LoginErr, ProductProofContext, RequestCredentialsErr, RingLocation, SignVrfErr, 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')) {
@@ -94,7 +94,7 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
          */
         signVrf(dotNsIdentifier, derivationIndex, transcriptLabel, items) {
             return hostApi
-                .accountSignVrf(enumValue('v1', { account: [dotNsIdentifier, derivationIndex], transcriptLabel, items }))
+                .accountSignVrf(enumValue('v1', { account: [dotNsIdentifier, derivationIndexOf(derivationIndex)], transcriptLabel, items }))
                 .mapErr(e => e.value)
                 .andThen(response => {
                 if (isEnumVariant(response, 'v1')) {
@@ -112,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));
@@ -136,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',
@@ -174,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,
@@ -263,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, VrfTranscriptItem } 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/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.12",
+  "version": "0.9.1",
   "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.12",
+    "@novasamatech/host-api": "0.9.1",
     "polkadot-api": ">=2",
     "neverthrow": "^8.2.0"
   },