@novasamatech/product-sdk 0.5.4 → 0.6.0

package/README.md

@@ -12,6 +12,8 @@ Core features:
 - Accounts provider for product accounts and signing
 - Redirect [PAPI](https://papi.how/) requests to host application
 - Receive additional information from host application - supported chains, theme, etc.
+- Local storage for persisting data in the host application
+- Preimage manager for looking up and submitting preimages
 
 ## Installation
 
@@ -130,6 +132,29 @@ const subscriber = chat.subscribeAction((action) => {
 const chatListSubscriber = chat.subscribeChatList((rooms) => {
   console.log('Chat rooms updated:', rooms);
 });
+
+// Sending a custom message
+await chat.sendMessage('my-product-room', {
+  tag: 'Custom',
+  value: { messageType: 'my-custom-type', payload: new Uint8Array([/* ... */]) }
+});
+
+// Handling custom message rendering requests from host
+const unsubscribeRenderer = chat.onCustomMessageRenderingRequest((messageType, payload, render) => {
+  // Build a CustomRendererNode tree and pass it to render()
+  render({
+    tag: 'Text',
+    value: {
+      modifiers: undefined,
+      props: { style: undefined, color: undefined },
+      children: [{ tag: 'String', value: 'Custom message content' }],
+    },
+  });
+
+  return () => {
+    // cleanup when subscription ends
+  };
+});
 ```
 
 **Note:** Messages sent before registration will be queued and sent automatically after successful registration.
@@ -149,9 +174,6 @@ const statementStore = createStatementStore();
 // Define topics (32-byte identifiers) to categorize statements
 const topic: Topic = new Uint8Array(32);
 
-// Query existing statements by topics
-const statements: SignedStatement[] = await statementStore.query([topic]);
-
 // Subscribe to statement updates for specific topics
 const subscription = statementStore.subscribe([topic], (statements) => {
   console.log('Received statement updates:', statements);
@@ -215,6 +237,12 @@ if (nonProductAccountsResult.isOk()) {
   console.log('Non-product accounts:', nonProductAccountsResult.value);
 }
 
+// Subscribe to account connection status changes
+const unsubscribe = accountsProvider.subscribeAccountConnectionStatus((status) => {
+  // status: 'connected' | 'disconnected'
+  console.log('Account connection status:', status);
+});
+
 // Create a signer for a product account (for use with PAPI)
 const account: ProductAccount = {
   dotNsIdentifier: 'product.dot',
@@ -232,3 +260,61 @@ const productAccountSignedTx = await tx.signAndSubmit(signer);
 const nonProductAccountSignedTx = await tx.signAndSubmit(nonProductSigner);
 ```
 
+### Local Storage
+
+The Local Storage module provides a way to persist data in the host application's storage.
+
+```ts
+import { hostLocalStorage, createLocalStorage } from '@novasamatech/product-sdk';
+
+// Use the default instance
+const storage = hostLocalStorage;
+
+// Or create a custom instance with a different transport
+// const storage = createLocalStorage(customTransport);
+
+// Write and read raw bytes
+await storage.writeBytes('key', new Uint8Array([1, 2, 3]));
+const bytes = await storage.readBytes('key');
+
+// Write and read strings
+await storage.writeString('greeting', 'Hello, World!');
+const greeting = await storage.readString('greeting');
+
+// Write and read JSON
+await storage.writeJSON('config', { theme: 'dark', fontSize: 14 });
+const config = await storage.readJSON('config');
+
+// Clear a key
+await storage.clear('key');
+```
+
+### Preimage Manager
+
+The Preimage Manager allows you to lookup and submit preimages to the host application.
+
+```ts
+import { preimageManager, createPreimageManager } from '@novasamatech/product-sdk';
+
+// Use the default instance
+const manager = preimageManager;
+
+// Or create a custom instance with a different transport
+// const manager = createPreimageManager(customTransport);
+
+// Lookup a preimage by its hash key
+const subscription = manager.lookup('0x1234...', (preimage) => {
+  if (preimage) {
+    console.log('Preimage found:', preimage);
+  } else {
+    console.log('Preimage not found');
+  }
+});
+
+// Unsubscribe when done
+subscription.unsubscribe();
+
+// Submit a preimage
+const preimageKey = await manager.submit(new Uint8Array([1, 2, 3, 4]));
+```
+

package/dist/accounts.d.ts

@@ -1,4 +1,4 @@
-import type { CodecType, Transport } from '@novasamatech/host-api';
+import type { AccountConnectionStatus as AccountConnectionStatusCodec, CodecType, Transport } from '@novasamatech/host-api';
 import { RingLocation } from '@novasamatech/host-api';
 import type { PolkadotSigner } from 'polkadot-api';
 export type ProductAccount = {
@@ -6,6 +6,7 @@ export type ProductAccount = {
     derivationIndex: number;
     publicKey: Uint8Array;
 };
+export type AccountConnectionStatus = CodecType<typeof AccountConnectionStatusCodec>;
 export declare const createAccountsProvider: (transport?: Transport) => {
     getProductAccount(dotNsIdentifier: string, derivationIndex?: number): import("neverthrow").ResultAsync<{
         publicKey: Uint8Array<ArrayBufferLike>;
@@ -37,5 +38,6 @@ export declare const createAccountsProvider: (transport?: Transport) => {
         reason: string;
     }, "CreateProofErr::Unknown">>;
     getProductAccountSigner(account: ProductAccount): PolkadotSigner;
+    subscribeAccountConnectionStatus(callback: (status: AccountConnectionStatus) => void): import("@novasamatech/host-api").Subscription;
     getNonProductAccountSigner(account: ProductAccount): PolkadotSigner;
 };

package/dist/accounts.js

@@ -111,6 +111,13 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
                 });
             });
         },
+        subscribeAccountConnectionStatus(callback) {
+            return hostApi.accountConnectionStatusSubscribe(enumValue('v1', undefined), status => {
+                if (status.tag === 'v1') {
+                    callback(status.value);
+                }
+            });
+        },
         getNonProductAccountSigner(account) {
             return getPolkadotSignerFromPjs(toHex(account.publicKey), async (payload) => {
                 const codecPayload = {

package/dist/chat.d.ts

@@ -1,4 +1,5 @@
 import type { ChatBotRegistrationStatus as ChatBotRegistrationStatusCodec, ChatMessageContent as ChatMessageContentCodec, ChatRoom as ChatRoomCodec, ChatRoomRegistrationStatus as ChatRoomRegistrationStatusCodec, CodecType, ReceivedChatAction as ReceivedChatActionCodec, Transport } from '@novasamatech/host-api';
+import { CustomRendererNode } from '@novasamatech/host-api';
 export type ChatMessageContent = CodecType<typeof ChatMessageContentCodec>;
 export type ReceivedChatAction = CodecType<typeof ReceivedChatActionCodec>;
 export type ChatRoomRegistrationResult = CodecType<typeof ChatRoomRegistrationStatusCodec>;
@@ -20,4 +21,5 @@ export declare const createProductChatManager: (transport?: Transport) => {
     }>;
     subscribeChatList(callback: (rooms: ChatRoom[]) => void): import("@novasamatech/host-api").Subscription;
     subscribeAction(callback: (action: ReceivedChatAction) => void): import("@novasamatech/host-api").Subscription;
+    onCustomMessageRenderingRequest(callback: (messageType: string, payload: Uint8Array, render: (node: CodecType<typeof CustomRendererNode>) => void) => VoidFunction): VoidFunction;
 };

package/dist/chat.js

@@ -1,4 +1,4 @@
-import { createHostApi, enumValue } from '@novasamatech/host-api';
+import { CustomRendererNode, createHostApi, enumValue } from '@novasamatech/host-api';
 import { sandboxTransport } from './sandboxTransport.js';
 export const createProductChatManager = (transport = sandboxTransport) => {
     const hostApi = createHostApi(transport);
@@ -75,6 +75,18 @@ export const createProductChatManager = (transport = sandboxTransport) => {
                 }
             });
         },
+        onCustomMessageRenderingRequest(callback) {
+            return transport.handleSubscription('product_chat_custom_message_render_subscribe', (params, send, interrupt) => {
+                if (params.tag === 'v1') {
+                    return callback(params.value.messageType, params.value.payload, node => send(enumValue('v1', node)));
+                }
+                // unsupported version
+                interrupt();
+                return () => {
+                    /* empty */
+                };
+            });
+        },
     };
     return chat;
 };

package/dist/helpers.d.ts

@@ -1,7 +1,9 @@
-type PromiseWithResolvers<T> = {
-    promise: Promise<T>;
-    resolve: (value: T) => void;
-    reject: (reason: unknown) => void;
-};
-export declare const promiseWithResolvers: <const T>() => PromiseWithResolvers<T>;
-export {};
+import type { ResultAsync } from 'neverthrow';
+export declare function unwrapVersionedResult<OK, KO, V extends string>(version: V, result: ResultAsync<{
+    tag: V;
+    value: OK;
+}, {
+    tag: V;
+    value: KO;
+}>): ResultAsync<OK, Error | KO>;
+export declare function resultToPromise<T>(result: ResultAsync<T, unknown>): Promise<T>;

package/dist/helpers.js

@@ -1,10 +1,19 @@
-export const promiseWithResolvers = () => {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
+import { err, ok } from 'neverthrow';
+export function unwrapVersionedResult(version, result) {
+    return result
+        .orElse(payload => {
+        if (payload.tag !== version) {
+            return err(new Error(`Unsupported result version ${payload.tag}`));
+        }
+        return err(payload.value);
+    })
+        .andThen(payload => {
+        if (payload.tag !== version) {
+            return err(new Error(`Unsupported result version ${payload.tag}`));
+        }
+        return ok(payload.value);
     });
-    // @ts-expect-error before assign
-    return { promise, resolve, reject };
-};
+}
+export function resultToPromise(result) {
+    return new Promise((resolve, reject) => result.match(resolve, reject));
+}

package/dist/index.d.ts

@@ -8,5 +8,7 @@ export type { ChatBotRegistrationResult, ChatMessageContent, ChatRoom, ChatRoomR
 export { createProductChatManager } from './chat.js';
 export type { ProductAccountId, SignedStatement, Statement, Topic } from './statementStore.js';
 export { createStatementStore } from './statementStore.js';
-export type { ProductAccount } from './accounts.js';
+export type { AccountConnectionStatus, ProductAccount } from './accounts.js';
 export { createAccountsProvider } from './accounts.js';
+export { createLocalStorage, hostLocalStorage } from './localStorage.js';
+export { createPreimageManager, preimageManager } from './preimage.js';

package/dist/index.js

@@ -7,3 +7,5 @@ export { createPapiProvider } from './papiProvider.js';
 export { createProductChatManager } from './chat.js';
 export { createStatementStore } from './statementStore.js';
 export { createAccountsProvider } from './accounts.js';
+export { createLocalStorage, hostLocalStorage } from './localStorage.js';
+export { createPreimageManager, preimageManager } from './preimage.js';

package/dist/localStorage.d.ts

@@ -0,0 +1,18 @@
+export declare const createLocalStorage: (transport?: import("@novasamatech/host-api").Transport) => {
+    clear(key: string): Promise<undefined>;
+    readBytes(key: string): Promise<Uint8Array<ArrayBufferLike> | undefined>;
+    writeBytes(key: string, value: Uint8Array): Promise<undefined>;
+    readString(key: string): Promise<string>;
+    writeString(key: string, value: string): Promise<undefined>;
+    readJSON(key: string): Promise<any>;
+    writeJSON(key: string, value: unknown): Promise<undefined>;
+};
+export declare const hostLocalStorage: {
+    clear(key: string): Promise<undefined>;
+    readBytes(key: string): Promise<Uint8Array<ArrayBufferLike> | undefined>;
+    writeBytes(key: string, value: Uint8Array): Promise<undefined>;
+    readString(key: string): Promise<string>;
+    writeString(key: string, value: string): Promise<undefined>;
+    readJSON(key: string): Promise<any>;
+    writeJSON(key: string, value: unknown): Promise<undefined>;
+};

package/dist/localStorage.js

@@ -0,0 +1,44 @@
+import { createHostApi, enumValue } from '@novasamatech/host-api';
+import { resultToPromise, unwrapVersionedResult } from './helpers.js';
+import { sandboxTransport } from './sandboxTransport.js';
+export const createLocalStorage = (transport = sandboxTransport) => {
+    const supportedVersion = 'v1';
+    const hostApi = createHostApi(transport);
+    const textEncoder = new TextEncoder();
+    const textDecoder = new TextDecoder();
+    function readBytes(key) {
+        return resultToPromise(unwrapVersionedResult(supportedVersion, hostApi.localStorageRead(enumValue(supportedVersion, key))));
+    }
+    function writeBytes(key, value) {
+        return resultToPromise(unwrapVersionedResult(supportedVersion, hostApi.localStorageWrite(enumValue(supportedVersion, [key, value]))));
+    }
+    function clearKey(key) {
+        return resultToPromise(unwrapVersionedResult(supportedVersion, hostApi.localStorageClear(enumValue(supportedVersion, key))));
+    }
+    return {
+        async clear(key) {
+            return clearKey(key);
+        },
+        async readBytes(key) {
+            return readBytes(key);
+        },
+        async writeBytes(key, value) {
+            return writeBytes(key, value);
+        },
+        async readString(key) {
+            return readBytes(key).then(bytes => textDecoder.decode(bytes));
+        },
+        async writeString(key, value) {
+            return writeBytes(key, textEncoder.encode(value));
+        },
+        async readJSON(key) {
+            return readBytes(key)
+                .then(bytes => textDecoder.decode(bytes))
+                .then(JSON.parse);
+        },
+        async writeJSON(key, value) {
+            return writeBytes(key, textEncoder.encode(JSON.stringify(value)));
+        },
+    };
+};
+export const hostLocalStorage = createLocalStorage();

package/dist/papiProvider.js

@@ -34,7 +34,7 @@ __fallback, internal) {
             if (!ready)
                 return false;
             return transport
-                .request('feature', enumValue('v1', enumValue('Chain', genesisHash)))
+                .request('host_feature_supported', enumValue('v1', enumValue('Chain', genesisHash)))
                 .then(payload => {
                 switch (payload.tag) {
                     case 'v1': {

package/dist/preimage.d.ts

@@ -0,0 +1,9 @@
+import type { HexString } from '@novasamatech/host-api';
+export declare const createPreimageManager: (transport?: import("@novasamatech/host-api").Transport) => {
+    lookup(key: HexString, callback: (preimage: Uint8Array | null) => void): import("@novasamatech/host-api").Subscription;
+    submit(value: Uint8Array): Promise<`0x${string}`>;
+};
+export declare const preimageManager: {
+    lookup(key: HexString, callback: (preimage: Uint8Array | null) => void): import("@novasamatech/host-api").Subscription;
+    submit(value: Uint8Array): Promise<`0x${string}`>;
+};

package/dist/preimage.js

@@ -0,0 +1,20 @@
+import { createHostApi, enumValue } from '@novasamatech/host-api';
+import { resultToPromise, unwrapVersionedResult } from './helpers.js';
+import { sandboxTransport } from './sandboxTransport.js';
+export const createPreimageManager = (transport = sandboxTransport) => {
+    const supportedVersion = 'v1';
+    const hostApi = createHostApi(transport);
+    return {
+        lookup(key, callback) {
+            return hostApi.preimageLookupSubscribe(enumValue(supportedVersion, key), payload => {
+                if (payload.tag === supportedVersion) {
+                    callback(payload.value);
+                }
+            });
+        },
+        submit(value) {
+            return resultToPromise(unwrapVersionedResult(supportedVersion, hostApi.preimageSubmit(enumValue(supportedVersion, value))));
+        },
+    };
+};
+export const preimageManager = createPreimageManager();

package/dist/statementStore.d.ts

@@ -4,7 +4,6 @@ export type SignedStatement = CodecType<typeof SignedStatementCodec>;
 export type Topic = CodecType<typeof TopicCodec>;
 export type ProductAccountId = CodecType<typeof ProductAccountIdCodec>;
 export declare const createStatementStore: (transport?: Transport) => {
-    query(topics: Topic[]): Promise<SignedStatement[]>;
     subscribe(topics: Topic[], callback: (statements: SignedStatement[]) => void): import("@novasamatech/host-api").Subscription;
     createProof(accountId: ProductAccountId, statement: Statement): Promise<{
         tag: "Sr25519";

package/dist/statementStore.js

@@ -3,17 +3,6 @@ import { sandboxTransport } from './sandboxTransport.js';
 export const createStatementStore = (transport = sandboxTransport) => {
     const hostApi = createHostApi(transport);
     return {
-        async query(topics) {
-            const result = await hostApi.statementStoreQuery(enumValue('v1', topics));
-            return result.match(payload => {
-                if (payload.tag === 'v1') {
-                    return payload.value;
-                }
-                throw new Error(`Unknown response version ${payload.tag}`);
-            }, err => {
-                throw err.value;
-            });
-        },
         subscribe(topics, callback) {
             return hostApi.statementStoreSubscribe(enumValue('v1', topics), payload => {
                 if (payload.tag === 'v1') {

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@novasamatech/product-sdk",
   "type": "module",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "description": "Polkadot product SDK: integrate and run your product inside Polkadot browser.",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/novasamatech/spektr-sdk.git"
+    "url": "git+https://github.com/Polkadot-Community-Foundation/triangle-js-sdks.git"
   },
   "keywords": [
     "polkadot",
@@ -30,7 +30,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.5.4"
+    "@novasamatech/host-api": "0.6.0"
   },
   "publishConfig": {
     "access": "public"