@novasamatech/product-sdk 0.5.3-0 → 0.5.4-0

package/README.md

@@ -6,8 +6,9 @@ An easy way to embed Polkadot host functionality into your dapp.
 
 Product SDK provides a set of tools to integrate your application with any Polkadot host application.
 Core features:
-- Generic account provider similar to [polkadot-js extension](https://polkadot.js.org/extension/)
+- Generic injectWeb3 provider similar to [polkadot-js extension](https://polkadot.js.org/extension/)
 - Chat module integration
+- Statement store integration
 - Redirect [PAPI](https://papi.how/) requests to host application
 - Receive additional information from host application - supported chains, theme, etc.
 
@@ -114,3 +115,51 @@ const subscriber = chat.subscribeAction((action) => {
 
 **Note:** Messages sent before registration will be queued and sent automatically after successful registration.
 
+### Statement Store
+
+The Statement Store provides a decentralized way to store statements (messages).
+It can be used for various purposes like p2p communication, storing temp data, etc.
+
+```ts
+import { createStatementStore } from '@novasamatech/product-sdk';
+import type { Topic, Statement, SignedStatement } from '@novasamatech/product-sdk';
+
+// Create statement store instance
+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);
+});
+
+// Create a proof for a new statement
+const accountId = ['product.dot', 0]; // [DotNS identifier, derivation index]
+const statement: Statement = {
+  proof: undefined,
+  decryptionKey: undefined,
+  priority: undefined,
+  channel: undefined,
+  topics: [topic],
+  data: new Uint8Array([/* your data */]),
+};
+
+const proof = await statementStore.createProof(accountId, statement);
+
+// Submit a signed statement
+const signedStatement: SignedStatement = {
+  ...statement,
+  proof,
+};
+
+await statementStore.submit(signedStatement);
+
+// Unsubscribe when done
+subscription.unsubscribe();
+```
+

package/dist/accounts.d.ts

@@ -0,0 +1,41 @@
+import type { CodecType, Transport } from '@novasamatech/host-api';
+import { RingLocation } from '@novasamatech/host-api';
+import type { PolkadotSigner } from 'polkadot-api';
+export type ProductAccount = {
+    dotNsIdentifier: string;
+    derivationIndex: number;
+    publicKey: Uint8Array;
+};
+export declare const createAccountsProvider: (transport?: Transport) => {
+    getProductAccount(dotNsIdentifier: string, derivationIndex?: number): import("neverthrow").ResultAsync<{
+        publicKey: Uint8Array<ArrayBufferLike>;
+        name: string | undefined;
+    }, import("packages/scale/dist/err.js").CodecError<undefined, "RequestCredentialsErr::NotConnected"> | import("packages/scale/dist/err.js").CodecError<undefined, "RequestCredentialsErr::Rejected"> | import("packages/scale/dist/err.js").CodecError<undefined, "RequestCredentialsErr::DomainNotValid"> | import("packages/scale/dist/err.js").CodecError<{
+        reason: string;
+    }, "RequestCredentialsErr::Unknown"> | import("packages/scale/dist/err.js").CodecError<{
+        reason: string;
+    }, "RequestCredentialsErr::Unknown">>;
+    getProductAccountAlias(dotNsIdentifier: string, derivationIndex?: number): import("neverthrow").ResultAsync<{
+        context: Uint8Array<ArrayBufferLike>;
+        alias: Uint8Array<ArrayBufferLike>;
+    }, import("packages/scale/dist/err.js").CodecError<undefined, "RequestCredentialsErr::NotConnected"> | import("packages/scale/dist/err.js").CodecError<undefined, "RequestCredentialsErr::Rejected"> | import("packages/scale/dist/err.js").CodecError<undefined, "RequestCredentialsErr::DomainNotValid"> | import("packages/scale/dist/err.js").CodecError<{
+        reason: string;
+    }, "RequestCredentialsErr::Unknown"> | import("packages/scale/dist/err.js").CodecError<{
+        reason: string;
+    }, "RequestCredentialsErr::Unknown">>;
+    getNonProductAccounts(): import("neverthrow").ResultAsync<{
+        publicKey: Uint8Array<ArrayBufferLike>;
+        name: string | undefined;
+    }[], import("packages/scale/dist/err.js").CodecError<undefined, "RequestCredentialsErr::NotConnected"> | import("packages/scale/dist/err.js").CodecError<undefined, "RequestCredentialsErr::Rejected"> | import("packages/scale/dist/err.js").CodecError<undefined, "RequestCredentialsErr::DomainNotValid"> | import("packages/scale/dist/err.js").CodecError<{
+        reason: string;
+    }, "RequestCredentialsErr::Unknown"> | import("packages/scale/dist/err.js").CodecError<{
+        reason: string;
+    }, "RequestCredentialsErr::Unknown">>;
+    createRingVRFProof(dotNsIdentifier: string, derivationIndex: number | undefined, location: CodecType<typeof RingLocation>, message: Uint8Array): import("neverthrow").ResultAsync<Uint8Array<ArrayBufferLike>, import("packages/scale/dist/err.js").CodecError<undefined, "CreateProofErr::Rejected"> | import("packages/scale/dist/err.js").CodecError<{
+        reason: string;
+    }, "CreateProofErr::Unknown"> | import("packages/scale/dist/err.js").CodecError<undefined, "CreateProofErr::RingNotFound"> | import("packages/scale/dist/err.js").CodecError<{
+        reason: string;
+    }, "CreateProofErr::Unknown">>;
+    getProductAccountSigner(account: ProductAccount): PolkadotSigner;
+    getNonProductAccountSigner(account: ProductAccount): PolkadotSigner;
+};

package/dist/accounts.js

@@ -0,0 +1,172 @@
+import { CreateProofErr, RequestCredentialsErr, RingLocation, 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';
+const UNSUPPORTED_VERSION_ERROR = 'Unsupported message version';
+export const createAccountsProvider = (transport = sandboxTransport) => {
+    const hostApi = createHostApi(transport);
+    return {
+        getProductAccount(dotNsIdentifier, derivationIndex = 0) {
+            return hostApi
+                .accountGet(enumValue('v1', [dotNsIdentifier, derivationIndex]))
+                .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}` }));
+            });
+        },
+        getProductAccountAlias(dotNsIdentifier, derivationIndex = 0) {
+            return hostApi
+                .accountGetAlias(enumValue('v1', [dotNsIdentifier, derivationIndex]))
+                .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}` }));
+            });
+        },
+        getNonProductAccounts() {
+            return hostApi
+                .getNonProductAccounts(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}` }));
+            });
+        },
+        createRingVRFProof(dotNsIdentifier, derivationIndex = 0, location, message) {
+            return hostApi
+                .accountCreateProof(enumValue('v1', [[dotNsIdentifier, derivationIndex], location, message]))
+                .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 CreateProofErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
+            });
+        },
+        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,
+                };
+                const response = await hostApi.signPayload(enumValue('v1', codecPayload));
+                return response.match(response => {
+                    assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                    return {
+                        id: 0,
+                        signature: response.value.signature,
+                        signedTransaction: response.value.signedTransaction,
+                    };
+                }, err => {
+                    assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                    throw err.value;
+                });
+            }, async (raw) => {
+                const payload = {
+                    address: raw.address,
+                    data: raw.type === 'bytes'
+                        ? {
+                            tag: 'Bytes',
+                            value: fromHex(raw.data),
+                        }
+                        : {
+                            tag: 'Payload',
+                            value: raw.data,
+                        },
+                };
+                const response = await hostApi.signRaw(enumValue('v1', payload));
+                return response.match(response => {
+                    assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                    return {
+                        id: 0,
+                        signature: response.value.signature,
+                        signedTransaction: response.value.signedTransaction,
+                    };
+                }, err => {
+                    assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                    throw err.value;
+                });
+            });
+        },
+        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,
+                };
+                const response = await hostApi.signPayload(enumValue('v1', codecPayload));
+                return response.match(response => {
+                    assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                    return {
+                        id: 0,
+                        signature: response.value.signature,
+                        signedTransaction: response.value.signedTransaction,
+                    };
+                }, err => {
+                    assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                    throw err.value;
+                });
+            }, async (raw) => {
+                const payload = {
+                    address: raw.address,
+                    data: raw.type === 'bytes'
+                        ? {
+                            tag: 'Bytes',
+                            value: fromHex(raw.data),
+                        }
+                        : {
+                            tag: 'Payload',
+                            value: raw.data,
+                        },
+                };
+                const response = await hostApi.signRaw(enumValue('v1', payload));
+                return response.match(response => {
+                    assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                    return {
+                        id: 0,
+                        signature: response.value.signature,
+                        signedTransaction: response.value.signedTransaction,
+                    };
+                }, err => {
+                    assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                    throw err.value;
+                });
+            });
+        },
+    };
+};

package/dist/chat.d.ts

@@ -1,14 +1,19 @@
-import type { ChatContactRegistrationStatus as ChatContactRegistrationStatusCodec, ChatMessage as ChatMessageCodec, CodecType, ReceivedChatAction as ReceivedChatActionCodec, Transport } from '@novasamatech/host-api';
-export type ChatMessage = CodecType<typeof ChatMessageCodec>;
+import type { ChatMessageContent as ChatMessageContentCodec, ChatRoom as ChatRoomCodec, ChatRoomRegistrationResult as ChatRoomRegistrationResultCodec, CodecType, ReceivedChatAction as ReceivedChatActionCodec, Transport } from '@novasamatech/host-api';
+export type ChatMessageContent = CodecType<typeof ChatMessageContentCodec>;
 export type ReceivedChatAction = CodecType<typeof ReceivedChatActionCodec>;
-export type ChatContactRegistrationStatus = CodecType<typeof ChatContactRegistrationStatusCodec>;
+export type ChatRoomRegistrationResult = CodecType<typeof ChatRoomRegistrationResultCodec>;
+export type ChatRoom = CodecType<typeof ChatRoomCodec>;
 export declare const createChat: (transport?: Transport) => {
     register(params: {
+        roomId: string;
         name: string;
         icon: string;
-    }): Promise<"New" | "Exists">;
-    sendMessage(message: ChatMessage): Promise<{
+    }): Promise<{
+        status: "New" | "Exists";
+    }>;
+    sendMessage(roomId: string, payload: ChatMessageContent): Promise<{
         messageId: string;
     }>;
-    subscribeAction(callback: (action: ReceivedChatAction) => void): import("packages/host-api/dist/types.js").Subscription;
+    subscribeChatList(callback: (rooms: ChatRoom[]) => void): import("@novasamatech/host-api").Subscription;
+    subscribeAction(callback: (action: ReceivedChatAction) => void): import("@novasamatech/host-api").Subscription;
 };

package/dist/chat.js

@@ -1,8 +1,8 @@
 import { createHostApi, enumValue } from '@novasamatech/host-api';
-import { defaultTransport } from './defaultTransport.js';
 import { promiseWithResolvers } from './helpers.js';
+import { sandboxTransport } from './sandboxTransport.js';
 promiseWithResolvers();
-export const createChat = (transport = defaultTransport) => {
+export const createChat = (transport = sandboxTransport) => {
     const hostApi = createHostApi(transport);
     let registrationStatus = null;
     const messageQueue = [];
@@ -11,13 +11,13 @@ export const createChat = (transport = defaultTransport) => {
             if (registrationStatus) {
                 return registrationStatus;
             }
-            const result = await hostApi.chat_create_contact(enumValue('v1', params));
+            const result = await hostApi.chatCreateRoom(enumValue('v1', params));
             return result.match(payload => {
                 if (payload.tag === 'v1') {
                     registrationStatus = payload.value;
                     if (messageQueue.length > 0) {
-                        messageQueue.forEach(({ message, resolve, reject }) => {
-                            chat.sendMessage(message).then(resolve, reject);
+                        messageQueue.forEach(({ roomId, content, resolve, reject }) => {
+                            chat.sendMessage(roomId, content).then(resolve, reject);
                         });
                         messageQueue.length = 0;
                     }
@@ -30,9 +30,9 @@ export const createChat = (transport = defaultTransport) => {
                 throw err.value;
             });
         },
-        async sendMessage(message) {
+        async sendMessage(roomId, payload) {
             if (registrationStatus) {
-                const result = await hostApi.chat_post_message(enumValue('v1', message));
+                const result = await hostApi.chatPostMessage(enumValue('v1', { roomId, payload }));
                 return result.match(payload => {
                     if (payload.tag === 'v1') {
                         return { messageId: payload.value.messageId };
@@ -46,12 +46,19 @@ export const createChat = (transport = defaultTransport) => {
             }
             else {
                 const { promise, resolve, reject } = promiseWithResolvers();
-                messageQueue.push({ message, resolve, reject });
+                messageQueue.push({ roomId, content: payload, resolve, reject });
                 return promise;
             }
         },
+        subscribeChatList(callback) {
+            return hostApi.chatListSubscribe(enumValue('v1', undefined), action => {
+                if (action.tag === 'v1') {
+                    callback(action.value);
+                }
+            });
+        },
         subscribeAction(callback) {
-            return hostApi.chat_action_subscribe(enumValue('v1', undefined), action => {
+            return hostApi.chatActionSubscribe(enumValue('v1', undefined), action => {
                 if (action.tag === 'v1') {
                     callback(action.value);
                 }

package/dist/createPapiProvider.d.ts

@@ -1,11 +1,7 @@
 import type { HexString, Transport } from '@novasamatech/host-api';
 import type { JsonRpcProvider } from '@polkadot-api/json-rpc-provider';
-type Params = {
-    chainId: HexString;
-    fallback: JsonRpcProvider;
-};
 type InternalParams = {
     transport?: Transport;
 };
-export declare function createPapiProvider({ chainId: genesisHash, fallback }: Params, internal?: InternalParams): JsonRpcProvider;
+export declare function createPapiProvider(genesisHash: HexString, internal?: InternalParams): JsonRpcProvider;
 export {};

package/dist/createPapiProvider.js

@@ -1,14 +1,15 @@
 import { createHostApi, enumValue, unwrapResultOrThrow } from '@novasamatech/host-api';
 import { getSyncProvider } from '@polkadot-api/json-rpc-provider-proxy';
 import { defaultTransport } from './defaultTransport.js';
-export function createPapiProvider({ chainId: genesisHash, fallback }, internal) {
+export function createPapiProvider(genesisHash, internal) {
     const version = 'v1';
     const transport = internal?.transport ?? defaultTransport;
-    if (!transport.isCorrectEnvironment())
-        return fallback;
+    if (!transport.isCorrectEnvironment()) {
+        throw new Error('PapiProvider can only be used in a product environment');
+    }
     const hostApi = createHostApi(transport);
     const spektrProvider = onMessage => {
-        const subscription = hostApi.jsonrpc_message_subscribe(enumValue(version, genesisHash), payload => {
+        const subscription = hostApi.jsonrpcMessageSubscribe(enumValue(version, genesisHash), payload => {
             switch (payload.tag) {
                 case version:
                     onMessage(payload.value);
@@ -19,7 +20,7 @@ export function createPapiProvider({ chainId: genesisHash, fallback }, internal)
         });
         return {
             send(message) {
-                hostApi.jsonrpc_message_send(enumValue(version, [genesisHash, message]));
+                hostApi.jsonrpcMessageSend(enumValue(version, [genesisHash, message]));
             },
             disconnect() {
                 subscription.unsubscribe();
@@ -47,5 +48,9 @@ export function createPapiProvider({ chainId: genesisHash, fallback }, internal)
             });
         });
     }
-    return getSyncProvider(() => checkIfReady().then(ready => (ready ? spektrProvider : fallback)));
+    return getSyncProvider(() => checkIfReady().then(ready => {
+        if (ready)
+            return spektrProvider;
+        throw new Error(`Chain ${genesisHash} not supported by host`);
+    }));
 }