@novasamatech/product-sdk 0.6.17 → 0.7.0-0

package/README.md

@@ -289,6 +289,21 @@ 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);
+}
+```
+
 ### Preimage Manager
 
 The Preimage Manager allows you to lookup and submit preimages to the host application.
@@ -318,3 +333,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.js

@@ -1,4 +1,4 @@
-import { CreateProofErr, RequestCredentialsErr, RingLocation, assertEnumVariant, createHostApi, enumValue, fromHex, isEnumVariant, toHex, } from '@novasamatech/host-api';
+import { CreateProofErr, RequestCredentialsErr, RingLocation, SigningPayload, SigningPayloadWithoutAccount, SigningRawPayload, SigningRawPayloadWithoutAccount, assertEnumVariant, createHostApi, enumValue, fromHex, isEnumVariant, toHex, } from '@novasamatech/host-api';
 import { getPolkadotSignerFromPjs } from '@polkadot-api/pjs-signer';
 import { err, ok } from 'neverthrow';
 import { sandboxTransport } from './sandboxTransport.js';
@@ -57,20 +57,24 @@ 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: {
+                        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,
+                    },
                 };
                 const response = await hostApi.signPayload(enumValue('v1', codecPayload));
                 return response.match(response => {
@@ -86,11 +90,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',
@@ -121,22 +125,26 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
         getNonProductAccountSigner(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: {
+                        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,
+                    },
                 };
-                const response = await hostApi.signPayload(enumValue('v1', codecPayload));
+                const response = await hostApi.signPayloadWithNonProductAccount(enumValue('v1', codecPayload));
                 return response.match(response => {
                     assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
                     return {
@@ -150,18 +158,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.signRawWithNonProductAccount(enumValue('v1', payload));
                 return response.match(response => {
                     assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
                     return {
@@ -177,3 +177,8 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
         },
     };
 };
+function asHex(v) {
+    if (v.startsWith('0x'))
+        return v;
+    return `0x${v}`;
+}

package/dist/index.d.ts

@@ -10,5 +10,10 @@ export type { ProductAccountId, SignedStatement, Statement, Topic } from './stat
 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';

package/dist/index.js

@@ -7,5 +7,8 @@ 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';

package/dist/injectWeb3.js

@@ -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.signRawWithNonProductAccount(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.signPayloadWithNonProductAccount(enumValue('v1', codecPayload));
                     return response.match(response => {
                         assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
                         return {

package/dist/payments.d.ts

@@ -0,0 +1,36 @@
+import type { Subscription, Transport } from '@novasamatech/host-api';
+export type PaymentBalance = {
+    available: bigint;
+};
+export type PaymentStatus = {
+    type: 'processing';
+} | {
+    type: 'completed';
+} | {
+    type: 'failed';
+    reason: string;
+};
+export type TopUpSource = {
+    type: 'productAccount';
+    dotNsIdentifier: string;
+    derivationIndex: number;
+} | {
+    type: 'privateKey';
+    key: Uint8Array;
+};
+export declare const createPaymentManager: (transport?: Transport) => {
+    subscribeBalance(callback: (balance: PaymentBalance) => void): Subscription;
+    topUp(amount: bigint, source: TopUpSource): Promise<void>;
+    requestPayment(amount: bigint, destination: Uint8Array): Promise<{
+        id: string;
+    }>;
+    subscribePaymentStatus(id: string, callback: (status: PaymentStatus) => void): Subscription;
+};
+export declare const paymentManager: {
+    subscribeBalance(callback: (balance: PaymentBalance) => void): Subscription;
+    topUp(amount: bigint, source: TopUpSource): Promise<void>;
+    requestPayment(amount: bigint, destination: Uint8Array): Promise<{
+        id: string;
+    }>;
+    subscribePaymentStatus(id: string, callback: (status: PaymentStatus) => void): Subscription;
+};

package/dist/payments.js

@@ -0,0 +1,45 @@
+import { createHostApi, enumValue } from '@novasamatech/host-api';
+import { resultToPromise, unwrapVersionedResult } from './helpers.js';
+import { sandboxTransport } from './sandboxTransport.js';
+export const createPaymentManager = (transport = sandboxTransport) => {
+    const hostApi = createHostApi(transport);
+    const version = 'v1';
+    return {
+        subscribeBalance(callback) {
+            return hostApi.paymentBalanceSubscribe(enumValue(version, undefined), payload => {
+                if (payload.tag === version) {
+                    callback(payload.value);
+                }
+            });
+        },
+        topUp(amount, source) {
+            const sourceCodec = source.type === 'productAccount'
+                ? {
+                    tag: 'ProductAccount',
+                    value: [source.dotNsIdentifier, source.derivationIndex],
+                }
+                : { tag: 'PrivateKey', value: source.key };
+            return resultToPromise(unwrapVersionedResult(version, hostApi.paymentTopUp(enumValue(version, { amount, source: sourceCodec }))));
+        },
+        requestPayment(amount, destination) {
+            return resultToPromise(unwrapVersionedResult(version, hostApi.paymentRequest(enumValue(version, { amount, destination }))));
+        },
+        subscribePaymentStatus(id, callback) {
+            return hostApi.paymentStatusSubscribe(enumValue(version, id), payload => {
+                if (payload.tag === version) {
+                    const raw = payload.value;
+                    if (raw.tag === 'Processing') {
+                        callback({ type: 'processing' });
+                    }
+                    else if (raw.tag === 'Completed') {
+                        callback({ type: 'completed' });
+                    }
+                    else if (raw.tag === 'Failed') {
+                        callback({ type: 'failed', reason: raw.value });
+                    }
+                }
+            });
+        },
+    };
+};
+export const paymentManager = createPaymentManager();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/product-sdk",
   "type": "module",
-  "version": "0.6.17",
+  "version": "0.7.0-0",
   "description": "Polkadot product SDK: integrate and run your product inside Polkadot browser.",
   "license": "Apache-2.0",
   "repository": {
@@ -29,7 +29,7 @@
     "@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.17"
+    "@novasamatech/host-api": "0.7.0-0"
   },
   "publishConfig": {
     "access": "public"