@novasamatech/product-sdk 0.6.18 → 0.7.0-1

package/README.md

@@ -166,7 +166,7 @@ It can be used for various purposes like p2p communication, storing temp data, e
 
 ```ts
 import { createStatementStore } from '@novasamatech/product-sdk';
-import type { Topic, Statement, SignedStatement } from '@novasamatech/product-sdk';
+import type { Topic, Statement, SignedStatement, StatementTopicFilter } from '@novasamatech/product-sdk';
 
 // Create statement store instance
 const statementStore = createStatementStore();
@@ -174,9 +174,11 @@ const statementStore = createStatementStore();
 // Define topics (32-byte identifiers) to categorize statements
 const topic: Topic = new Uint8Array(32);
 
-// Subscribe to statement updates for specific topics
-const subscription = statementStore.subscribe([topic], (statements) => {
-  console.log('Received statement updates:', statements);
+// Subscribe to statements matching ALL listed topics (AND semantics)
+const filter: StatementTopicFilter = { matchAll: [topic] };
+const subscription = statementStore.subscribe(filter, (page) => {
+  // page.isComplete is true once the initial historical dump is done
+  console.log('Received statements:', page.statements, 'synced:', page.isComplete);
 });
 
 // Create a proof for a new statement
@@ -215,6 +217,34 @@ import type { ProductAccount } from '@novasamatech/product-sdk';
 // Create accounts provider instance
 const accountsProvider = createAccountsProvider();
 
+// Get the root (primary) account — prompts for permission on first call
+const rootResult = await accountsProvider.getRootAccount();
+
+if (rootResult.isOk()) {
+  const root = rootResult.value;
+  console.log('Root account public key:', root.publicKey);
+  console.log('Root DotNS name:', root.name);
+} else {
+  const rootErr = rootResult.error;
+  if (rootErr.tag === 'Rejected') {
+    console.log('User denied access to root account');
+  } else if (rootErr.tag === 'NotFound') {
+    console.log('User has no DotNS account yet');
+  }
+}
+
+// Request login — triggers host sign-in UI; reason is shown to the user
+const loginResult = await accountsProvider.requestLogin('Sign in to access your account');
+
+if (loginResult.isOk()) {
+  const outcome = loginResult.value; // 'success' | 'alreadyConnected' | 'rejected'
+  if (outcome === 'rejected') {
+    console.log('User cancelled login');
+  }
+} else {
+  console.error('Login error:', loginResult.error);
+}
+
 // Get a product account by DotNS identifier and derivation index
 const accountResult = await accountsProvider.getProductAccount('product.dot', 0);
 
@@ -230,11 +260,11 @@ if (aliasResult.isOk()) {
   console.log('Alias:', aliasResult.value);
 }
 
-// Get non-product accounts (external wallets)
-const nonProductAccountsResult = await accountsProvider.getNonProductAccounts();
+// Get legacy accounts (external wallets)
+const legacyAccountsResult = await accountsProvider.getLegacyAccounts();
 
-if (nonProductAccountsResult.isOk()) {
-  console.log('Non-product accounts:', nonProductAccountsResult.value);
+if (legacyAccountsResult.isOk()) {
+  console.log('Legacy accounts:', legacyAccountsResult.value);
 }
 
 // Subscribe to account connection status changes
@@ -251,13 +281,13 @@ const account: ProductAccount = {
 };
 const signer = accountsProvider.getProductAccountSigner(account);
 
-// Create a signer for a non-product account
-const nonProductSigner = accountsProvider.getNonProductAccountSigner(account);
+// Create a signer for a legacy account
+const legacySigner = accountsProvider.getLegacyAccountSigner(account);
 
 // PAPI transaction signing example
 
 const productAccountSignedTx = await tx.signAndSubmit(signer);
-const nonProductAccountSignedTx = await tx.signAndSubmit(nonProductSigner);
+const legacyAccountSignedTx = await tx.signAndSubmit(legacySigner);
 ```
 
 ### Local Storage
@@ -289,6 +319,50 @@ const config = await storage.readJSON('config');
 await storage.clear('key');
 ```
 
+### Derive Entropy
+
+The Derive Entropy function allows products to derive deterministic 32-byte entropy scoped to the product and a caller-chosen key.
+
+```ts
+import { deriveEntropy } from '@novasamatech/product-sdk';
+
+const result = await deriveEntropy(new Uint8Array([1, 2, 3]));
+
+if (result.isOk()) {
+  const entropy: Uint8Array = result.value;
+  console.log('Derived entropy:', entropy);
+}
+```
+
+### Permissions
+
+Products can request device and remote permissions from the host. Decisions are prompted once and persisted permanently — subsequent calls for the same permission resolve immediately without prompting.
+
+```ts
+import { requestDevicePermission, requestPermission } from '@novasamatech/product-sdk';
+
+// Request a single device permission
+const deviceResult = await requestDevicePermission('Camera');
+if (deviceResult.isOk()) {
+  console.log('Camera granted:', deviceResult.value); // boolean
+}
+
+// Request remote permissions in a batch (single user prompt for all)
+const remoteResult = await requestPermission([
+  { tag: 'Remote', value: ['api.coingecko.com', '*.example.com'] },
+  { tag: 'ChainSubmit', value: undefined },
+]);
+if (remoteResult.isOk()) {
+  console.log('All remote permissions granted:', remoteResult.value); // boolean
+}
+```
+
+Available device permission values: `'Notifications'`, `'Camera'`, `'Microphone'`, `'Bluetooth'`, `'NFC'`, `'Location'`, `'Clipboard'`, `'OpenUrl'`, `'Biometrics'`.
+
+Available remote permission tags: `'Remote'` (HTTP/WS domain patterns), `'WebRTC'`, `'ChainSubmit'`, `'PreimageSubmit'`, `'StatementSubmit'`.
+
+> **Note:** `remote_chain_transaction_broadcast`, `remote_preimage_submit`, and `remote_statement_store_submit` implicitly trigger a permission prompt if the relevant permission has not yet been resolved. Call `requestPermission(...)` proactively before entering those flows for a controlled UX.
+
 ### Preimage Manager
 
 The Preimage Manager allows you to lookup and submit preimages to the host application.
@@ -318,3 +392,34 @@ subscription.unsubscribe();
 const preimageKey = await manager.submit(new Uint8Array([1, 2, 3, 4]));
 ```
 
+### Payment manager
+
+```ts
+import { createPaymentManager } from '@novasamatech/product-sdk';
+
+const payments = createPaymentManager();
+
+// Subscribe to the user's payment balance (host will prompt for consent)
+const balanceSub = payments.subscribeBalance(balance => {
+  console.log('Available:', balance.available);
+  console.log('Pending:', balance.pending);
+});
+balanceSub.onInterrupt(() => console.log('Balance access denied or lost'));
+
+// Top up the user's balance from a product account
+await payments.topUp(1_000_000n, {
+  type: 'productAccount',
+  dotNsIdentifier: 'my-product.dot',
+  derivationIndex: 0,
+});
+
+// Request a payment from the user (host shows confirmation UI)
+const destination = new Uint8Array(32); // 32-byte AccountId
+const receipt = await payments.requestPayment(500_000n, destination);
+
+// Track payment settlement
+const statusSub = payments.subscribePaymentStatus(receipt.id, status => {
+  if (status.type === 'completed') console.log('Payment settled');
+  if (status.type === 'failed') console.log('Payment failed:', status.reason);
+});
+```

package/dist/accounts.d.ts

@@ -8,6 +8,15 @@ export type ProductAccount = {
 };
 export type AccountConnectionStatus = CodecType<typeof AccountConnectionStatusCodec>;
 export declare const createAccountsProvider: (transport?: Transport) => {
+    getRootAccount(): import("neverthrow").ResultAsync<{
+        publicKey: Uint8Array<ArrayBufferLike>;
+        name: string | undefined;
+    }, import("packages/scale/src/err.js").CodecError<undefined, "RequestCredentialsErr::NotConnected"> | import("packages/scale/src/err.js").CodecError<undefined, "RequestCredentialsErr::Rejected"> | import("packages/scale/src/err.js").CodecError<undefined, "RequestCredentialsErr::DomainNotValid"> | import("packages/scale/src/err.js").CodecError<{
+        reason: string;
+    }, "RequestCredentialsErr::Unknown">>;
+    requestLogin(reason?: string): import("neverthrow").ResultAsync<"success" | "alreadyConnected" | "rejected", import("packages/scale/src/err.js").CodecError<{
+        reason: string;
+    }, "LoginErr::Unknown">>;
     getProductAccount(dotNsIdentifier: string, derivationIndex?: number): import("neverthrow").ResultAsync<{
         publicKey: Uint8Array<ArrayBufferLike>;
         name: string | undefined;
@@ -20,7 +29,7 @@ export declare const createAccountsProvider: (transport?: Transport) => {
     }, import("packages/scale/src/err.js").CodecError<undefined, "RequestCredentialsErr::NotConnected"> | import("packages/scale/src/err.js").CodecError<undefined, "RequestCredentialsErr::Rejected"> | import("packages/scale/src/err.js").CodecError<undefined, "RequestCredentialsErr::DomainNotValid"> | import("packages/scale/src/err.js").CodecError<{
         reason: string;
     }, "RequestCredentialsErr::Unknown">>;
-    getNonProductAccounts(): import("neverthrow").ResultAsync<{
+    getLegacyAccounts(): import("neverthrow").ResultAsync<{
         publicKey: Uint8Array<ArrayBufferLike>;
         name: string | undefined;
     }[], import("packages/scale/src/err.js").CodecError<undefined, "RequestCredentialsErr::NotConnected"> | import("packages/scale/src/err.js").CodecError<undefined, "RequestCredentialsErr::Rejected"> | import("packages/scale/src/err.js").CodecError<undefined, "RequestCredentialsErr::DomainNotValid"> | import("packages/scale/src/err.js").CodecError<{
@@ -31,5 +40,5 @@ export declare const createAccountsProvider: (transport?: Transport) => {
     }, "CreateProofErr::Unknown"> | import("packages/scale/src/err.js").CodecError<undefined, "CreateProofErr::RingNotFound">>;
     getProductAccountSigner(account: ProductAccount): PolkadotSigner;
     subscribeAccountConnectionStatus(callback: (status: AccountConnectionStatus) => void): import("@novasamatech/host-api").Subscription;
-    getNonProductAccountSigner(account: ProductAccount): PolkadotSigner;
+    getLegacyAccountSigner(account: ProductAccount): PolkadotSigner;
 };

package/dist/accounts.js

@@ -1,11 +1,35 @@
-import { CreateProofErr, RequestCredentialsErr, RingLocation, assertEnumVariant, createHostApi, enumValue, fromHex, isEnumVariant, toHex, } from '@novasamatech/host-api';
-import { getPolkadotSignerFromPjs } from '@polkadot-api/pjs-signer';
+import { CreateProofErr, LoginErr, RequestCredentialsErr, RingLocation, SigningPayload, SigningPayloadWithoutAccount, SigningRawPayload, SigningRawPayloadWithoutAccount, assertEnumVariant, createHostApi, enumValue, fromHex, isEnumVariant, toHex, } from '@novasamatech/host-api';
 import { err, ok } from 'neverthrow';
+import { getPolkadotSignerFromPjs } from 'polkadot-api/pjs-signer';
 import { sandboxTransport } from './sandboxTransport.js';
 const UNSUPPORTED_VERSION_ERROR = 'Unsupported message version';
 export const createAccountsProvider = (transport = sandboxTransport) => {
     const hostApi = createHostApi(transport);
     return {
+        getRootAccount() {
+            return hostApi
+                .accountGetRoot(enumValue('v1', undefined))
+                .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}` }));
+            });
+        },
+        requestLogin(reason) {
+            return hostApi
+                .requestLogin(enumValue('v1', reason))
+                .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 LoginErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
+            });
+        },
         getProductAccount(dotNsIdentifier, derivationIndex = 0) {
             return hostApi
                 .accountGet(enumValue('v1', [dotNsIdentifier, derivationIndex]))
@@ -30,9 +54,9 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
                 return err(new RequestCredentialsErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
             });
         },
-        getNonProductAccounts() {
+        getLegacyAccounts() {
             return hostApi
-                .getNonProductAccounts(enumValue('v1', undefined))
+                .getLegacyAccounts(enumValue('v1', undefined))
                 .mapErr(e => e.value)
                 .andThen(response => {
                 if (isEnumVariant(response, 'v1')) {
@@ -57,20 +81,8 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
         getProductAccountSigner(account) {
             return getPolkadotSignerFromPjs(toHex(account.publicKey), async (payload) => {
                 const codecPayload = {
-                    ...payload,
-                    blockHash: payload.blockHash,
-                    blockNumber: payload.blockNumber,
-                    era: payload.era,
-                    genesisHash: payload.genesisHash,
-                    nonce: payload.nonce,
-                    method: payload.method,
-                    specVersion: payload.specVersion,
-                    transactionVersion: payload.transactionVersion,
-                    metadataHash: payload.metadataHash,
-                    tip: payload.tip,
-                    assetId: payload.assetId,
-                    mode: payload.mode,
-                    withSignedTransaction: payload.withSignedTransaction,
+                    account: [account.dotNsIdentifier, account.derivationIndex],
+                    payload: buildSigningPayloadFields(payload),
                 };
                 const response = await hostApi.signPayload(enumValue('v1', codecPayload));
                 return response.match(response => {
@@ -86,11 +98,11 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
                 });
             }, async (raw) => {
                 const payload = {
-                    address: raw.address,
-                    data: raw.type === 'bytes'
+                    account: [account.dotNsIdentifier, account.derivationIndex],
+                    payload: raw.type === 'bytes'
                         ? {
                             tag: 'Bytes',
-                            value: fromHex(raw.data),
+                            value: fromHex(asHex(raw.data)),
                         }
                         : {
                             tag: 'Payload',
@@ -118,25 +130,13 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
                 }
             });
         },
-        getNonProductAccountSigner(account) {
+        getLegacyAccountSigner(account) {
             return getPolkadotSignerFromPjs(toHex(account.publicKey), async (payload) => {
                 const codecPayload = {
-                    ...payload,
-                    blockHash: payload.blockHash,
-                    blockNumber: payload.blockNumber,
-                    era: payload.era,
-                    genesisHash: payload.genesisHash,
-                    nonce: payload.nonce,
-                    method: payload.method,
-                    specVersion: payload.specVersion,
-                    transactionVersion: payload.transactionVersion,
-                    metadataHash: payload.metadataHash,
-                    tip: payload.tip,
-                    assetId: payload.assetId,
-                    mode: payload.mode,
-                    withSignedTransaction: payload.withSignedTransaction,
+                    signer: payload.address,
+                    payload: buildSigningPayloadFields(payload),
                 };
-                const response = await hostApi.signPayload(enumValue('v1', codecPayload));
+                const response = await hostApi.signPayloadWithLegacyAccount(enumValue('v1', codecPayload));
                 return response.match(response => {
                     assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
                     return {
@@ -150,18 +150,10 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
                 });
             }, async (raw) => {
                 const payload = {
-                    address: raw.address,
-                    data: raw.type === 'bytes'
-                        ? {
-                            tag: 'Bytes',
-                            value: fromHex(raw.data),
-                        }
-                        : {
-                            tag: 'Payload',
-                            value: raw.data,
-                        },
+                    signer: raw.address,
+                    payload: { tag: 'Bytes', value: fromHex(asHex(raw.data)) },
                 };
-                const response = await hostApi.signRaw(enumValue('v1', payload));
+                const response = await hostApi.signRawWithLegacyAccount(enumValue('v1', payload));
                 return response.match(response => {
                     assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
                     return {
@@ -177,3 +169,27 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
         },
     };
 };
+function asHex(v) {
+    if (v.startsWith('0x'))
+        return v;
+    return `0x${v}`;
+}
+function buildSigningPayloadFields(payload) {
+    return {
+        blockHash: asHex(payload.blockHash),
+        blockNumber: asHex(payload.blockNumber),
+        era: asHex(payload.era),
+        genesisHash: asHex(payload.genesisHash),
+        nonce: asHex(payload.nonce),
+        method: asHex(payload.method),
+        specVersion: asHex(payload.specVersion),
+        transactionVersion: asHex(payload.transactionVersion),
+        metadataHash: payload.metadataHash ? asHex(payload.metadataHash) : undefined,
+        tip: asHex(payload.tip),
+        assetId: payload.assetId !== undefined ? payload.assetId : undefined,
+        mode: payload.mode,
+        withSignedTransaction: payload.withSignedTransaction,
+        signedExtensions: payload.signedExtensions,
+        version: payload.version,
+    };
+}

package/dist/index.d.ts

@@ -2,13 +2,20 @@ export { SpektrExtensionName, WellKnownChain } from './constants.js';
 export { sandboxProvider, sandboxTransport } from './sandboxTransport.js';
 export { hostApi } from './hostApi.js';
 export { createMetaProvider, metaProvider } from './metaProvider.js';
-export { createNonProductExtensionEnableFactory, injectSpektrExtension } from './injectWeb3.js';
+export { createLegacyExtensionEnableFactory, injectSpektrExtension } from './injectWeb3.js';
 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, Topic } from './statementStore.js';
+export type { ProductAccountId, SignedStatement, Statement, StatementTopicFilter, StatementsPage, Topic, } from './statementStore.js';
 export { createStatementStore } from './statementStore.js';
 export type { AccountConnectionStatus, ProductAccount } from './accounts.js';
 export { createAccountsProvider } from './accounts.js';
+export type { ThemeMode, ThemeSubscription } from './theme.js';
+export { createThemeProvider } from './theme.js';
 export { createLocalStorage, hostLocalStorage } from './localStorage.js';
 export { createPreimageManager, preimageManager } from './preimage.js';
+export type { PaymentBalance, PaymentStatus, TopUpSource } from './payments.js';
+export { createPaymentManager, paymentManager } from './payments.js';
+export { deriveEntropy } from './deriveEntropy.js';
+export type { DevicePermissionKind, RemotePermissionItem } from './permission.js';
+export { requestDevicePermission, requestPermission } from './permission.js';

package/dist/index.js

@@ -2,10 +2,14 @@ export { SpektrExtensionName, WellKnownChain } from './constants.js';
 export { sandboxProvider, sandboxTransport } from './sandboxTransport.js';
 export { hostApi } from './hostApi.js';
 export { createMetaProvider, metaProvider } from './metaProvider.js';
-export { createNonProductExtensionEnableFactory, injectSpektrExtension } from './injectWeb3.js';
+export { createLegacyExtensionEnableFactory, injectSpektrExtension } from './injectWeb3.js';
 export { createPapiProvider } from './papiProvider.js';
 export { createProductChatManager, matchChatCustomRenderers } from './chat.js';
 export { createStatementStore } from './statementStore.js';
 export { createAccountsProvider } from './accounts.js';
+export { createThemeProvider } from './theme.js';
 export { createLocalStorage, hostLocalStorage } from './localStorage.js';
 export { createPreimageManager, preimageManager } from './preimage.js';
+export { createPaymentManager, paymentManager } from './payments.js';
+export { deriveEntropy } from './deriveEntropy.js';
+export { requestDevicePermission, requestPermission } from './permission.js';

package/dist/injectWeb3.d.ts

@@ -19,6 +19,6 @@ interface Injected {
     accounts: InjectedAccounts;
     signer: Signer;
 }
-export declare function createNonProductExtensionEnableFactory(transport: Transport): Promise<(() => Promise<Injected>) | null>;
+export declare function createLegacyExtensionEnableFactory(transport: Transport): Promise<(() => Promise<Injected>) | null>;
 export declare function injectSpektrExtension(transport?: Transport | null): Promise<boolean>;
 export {};

package/dist/injectWeb3.js

@@ -1,10 +1,10 @@
 import { assertEnumVariant, createHostApi, enumValue, fromHex, toHex } from '@novasamatech/host-api';
 import { injectExtension } from '@polkadot/extension-inject';
-import { AccountId } from '@polkadot-api/substrate-bindings';
+import { AccountId } from 'polkadot-api';
 import { SpektrExtensionName, Version } from './constants.js';
 import { sandboxTransport } from './sandboxTransport.js';
 const UNSUPPORTED_VERSION_ERROR = 'Unsupported message version';
-export async function createNonProductExtensionEnableFactory(transport) {
+export async function createLegacyExtensionEnableFactory(transport) {
     const ready = await transport.isReady();
     if (!ready)
         return null;
@@ -12,7 +12,7 @@ export async function createNonProductExtensionEnableFactory(transport) {
     const accountId = AccountId();
     async function enable() {
         async function getAccounts() {
-            const response = await hostApi.getNonProductAccounts(enumValue('v1', undefined));
+            const response = await hostApi.getLegacyAccounts(enumValue('v1', undefined));
             return response.match(response => {
                 assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
                 return response.value.map(account => ({
@@ -40,8 +40,8 @@ export async function createNonProductExtensionEnableFactory(transport) {
             signer: {
                 async signRaw(raw) {
                     const payload = {
-                        address: raw.address,
-                        data: raw.type === 'bytes'
+                        signer: raw.address,
+                        payload: raw.type === 'bytes'
                             ? {
                                 tag: 'Bytes',
                                 value: fromHex(raw.data),
@@ -51,7 +51,7 @@ export async function createNonProductExtensionEnableFactory(transport) {
                                 value: raw.data,
                             },
                     };
-                    const response = await hostApi.signRaw(enumValue('v1', payload));
+                    const response = await hostApi.signRawWithLegacyAccount(enumValue('v1', payload));
                     return response.match(response => {
                         assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
                         return {
@@ -66,14 +66,26 @@ export async function createNonProductExtensionEnableFactory(transport) {
                 },
                 async signPayload(payload) {
                     const codecPayload = {
-                        ...payload,
-                        method: payload.method,
-                        assetId: payload.assetId,
-                        mode: payload.mode,
-                        withSignedTransaction: payload.withSignedTransaction,
-                        metadataHash: payload.metadataHash,
+                        signer: payload.address,
+                        payload: {
+                            blockHash: payload.blockHash,
+                            blockNumber: payload.blockNumber,
+                            era: payload.era,
+                            genesisHash: payload.genesisHash,
+                            nonce: payload.nonce,
+                            method: payload.method,
+                            specVersion: payload.specVersion,
+                            transactionVersion: payload.transactionVersion,
+                            metadataHash: payload.metadataHash,
+                            tip: payload.tip,
+                            assetId: payload.assetId,
+                            mode: payload.mode,
+                            withSignedTransaction: payload.withSignedTransaction,
+                            signedExtensions: payload.signedExtensions,
+                            version: payload.version,
+                        },
                     };
-                    const response = await hostApi.signPayload(enumValue('v1', codecPayload));
+                    const response = await hostApi.signPayloadWithLegacyAccount(enumValue('v1', codecPayload));
                     return response.match(response => {
                         assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
                         return {
@@ -87,7 +99,7 @@ export async function createNonProductExtensionEnableFactory(transport) {
                     });
                 },
                 async createTransaction(payload) {
-                    const response = await hostApi.createTransactionWithNonProductAccount(enumValue('v1', payload));
+                    const response = await hostApi.createTransactionWithLegacyAccount(enumValue('v1', payload));
                     return response.match(response => {
                         assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
                         return toHex(response.value);
@@ -105,7 +117,7 @@ export async function injectSpektrExtension(transport = sandboxTransport) {
     if (!transport)
         return false;
     try {
-        const enable = await createNonProductExtensionEnableFactory(transport);
+        const enable = await createLegacyExtensionEnableFactory(transport);
         if (enable) {
             injectExtension(enable, { name: SpektrExtensionName, version: Version });
             return true;

package/dist/papiProvider.d.ts

@@ -1,5 +1,5 @@
 import type { HexString, Transport } from '@novasamatech/host-api';
-import type { JsonRpcProvider } from '@polkadot-api/json-rpc-provider';
+import type { JsonRpcProvider } from 'polkadot-api';
 type InternalParams = {
     transport?: Transport;
 };

package/dist/papiProvider.js

@@ -18,17 +18,17 @@ __fallback, internal) {
             return `follow_${nextSubId++}`;
         }
         function sendJsonRpcResponse(id, result) {
-            onMessage(JSON.stringify({ jsonrpc: '2.0', id, result }));
+            onMessage({ jsonrpc: '2.0', id, result });
         }
         function sendJsonRpcError(id, code, message) {
-            onMessage(JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } }));
+            onMessage({ jsonrpc: '2.0', id, error: { code, message } });
         }
         function sendFollowEvent(syntheticSubId, event) {
-            onMessage(JSON.stringify({
+            onMessage({
                 jsonrpc: '2.0',
                 method: 'chainHead_v1_followEvent',
                 params: { subscription: syntheticSubId, result: event },
-            }));
+            });
         }
         function convertTypedEventToJsonRpc(event) {
             switch (event.tag) {
@@ -145,14 +145,9 @@ __fallback, internal) {
             return { result: 'limitReached' };
         }
         function handleMessage(message) {
-            let parsed;
-            try {
-                parsed = JSON.parse(message);
-            }
-            catch {
-                return;
-            }
-            const { id, method, params } = parsed;
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const id = message.id;
+            const { method, params } = message;
             switch (method) {
                 case 'chainHead_v1_follow': {
                     const [withRuntime] = params;
@@ -319,20 +314,27 @@ __fallback, internal) {
             });
         });
     }
-    return getSyncProvider(() => checkIfReady().then(ready => {
-        if (ready)
-            return typedProvider;
-        if (__fallback)
-            return __fallback;
+    return getSyncProvider(onResult => {
+        checkIfReady().then(ready => {
+            if (ready) {
+                onResult((onMessage, _onHalt) => typedProvider(onMessage));
+            }
+            else if (__fallback) {
+                onResult((onMessage, _onHalt) => __fallback(onMessage));
+            }
+            else {
+                onResult((_onMessage, _onHalt) => ({
+                    send() {
+                        transport.provider.logger.error(`Provider for chain ${genesisHash} was not started because Host doesn't support it`);
+                    },
+                    disconnect() {
+                        /* empty */
+                    },
+                }));
+            }
+        });
         return () => {
-            return {
-                send() {
-                    transport.provider.logger.error(`Provider for chain ${genesisHash} was not started because Host doesn't support it`);
-                },
-                disconnect() {
-                    /* empty */
-                },
-            };
+            /* empty */
         };
-    }));
+    });
 }

package/dist/statementStore.d.ts

@@ -3,8 +3,17 @@ export type Statement = CodecType<typeof StatementCodec>;
 export type SignedStatement = CodecType<typeof SignedStatementCodec>;
 export type Topic = CodecType<typeof TopicCodec>;
 export type ProductAccountId = CodecType<typeof ProductAccountIdCodec>;
+export type StatementTopicFilter = {
+    matchAll: Topic[];
+} | {
+    matchAny: Topic[];
+};
+export type StatementsPage = {
+    statements: SignedStatement[];
+    isComplete: boolean;
+};
 export declare const createStatementStore: (transport?: Transport) => {
-    subscribe(topics: Topic[], callback: (statements: SignedStatement[]) => void): import("@novasamatech/host-api").Subscription;
+    subscribe(filter: StatementTopicFilter, callback: (page: StatementsPage) => void): import("@novasamatech/host-api").Subscription;
     createProof(accountId: ProductAccountId, statement: Statement): Promise<{
         tag: "Sr25519";
         value: {

package/dist/statementStore.js

@@ -3,8 +3,9 @@ import { sandboxTransport } from './sandboxTransport.js';
 export const createStatementStore = (transport = sandboxTransport) => {
     const hostApi = createHostApi(transport);
     return {
-        subscribe(topics, callback) {
-            return hostApi.statementStoreSubscribe(enumValue('v1', topics), payload => {
+        subscribe(filter, callback) {
+            const scaleFilter = 'matchAll' in filter ? enumValue('MatchAll', filter.matchAll) : enumValue('MatchAny', filter.matchAny);
+            return hostApi.statementStoreSubscribe(enumValue('v1', scaleFilter), payload => {
                 if (payload.tag === 'v1') {
                     callback(payload.value);
                 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/product-sdk",
   "type": "module",
-  "version": "0.6.18",
+  "version": "0.7.0-1",
   "description": "Polkadot product SDK: integrate and run your product inside Polkadot browser.",
   "license": "Apache-2.0",
   "repository": {
@@ -25,11 +25,11 @@
     "README.md"
   ],
   "dependencies": {
-    "@polkadot/extension-inject": "^0.62.6",
-    "@polkadot-api/substrate-bindings": "^0.17.0",
-    "@polkadot-api/json-rpc-provider": "^0.0.4",
-    "@polkadot-api/json-rpc-provider-proxy": "^0.2.7",
-    "@novasamatech/host-api": "0.6.18"
+    "@polkadot/extension-inject": "^0.63.1",
+    "@polkadot-api/json-rpc-provider-proxy": "^0.4.0",
+    "@novasamatech/host-api": "0.7.0-1",
+    "polkadot-api": ">=2",
+    "neverthrow": "^8.2.0"
   },
   "publishConfig": {
     "access": "public"