@novasamatech/product-sdk 0.5.0-8 → 0.5.0

package/README.md

@@ -1,12 +1,13 @@
 # @novasamatech/product-sdk
 
-Easy way to embed Polkadot host functionality into your dapp.
+An easy way to embed Polkadot host functionality into your dapp.
 
 ## Overview
 
-Spektr SDK provides a set of tools to integrate your application with Spektr dapp browser.
+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 account provider similar to [polkadot-js extension](https://polkadot.js.org/extension/)
+- Chat module integration
 - Redirect [PAPI](https://papi.how/) requests to host application
 - Receive additional information from host application - supported chains, theme, etc.
 
@@ -20,7 +21,7 @@ npm install @novasamatech/product-sdk --save -E
 
 ### Injecting account provider into `injectedWeb3` interface
 
-Spektr SDK can provide account information and signers with same interface as any other polkadot compatible wallet.
+Product SDK can provide account information and signers with the same interface as any other Polkadot-compatible wallet.
 
 ```ts
 import { injectSpektrExtension, SpektrExtensionName } from '@novasamatech/product-sdk';
@@ -50,7 +51,7 @@ async function getAccounts(): Promise<InjectedPolkadotAccount[]> {
 
 ### Redirecting PAPI requests to host application
 
-You can wrap your PAPI provider with spektr provider to support redirecting requests to host application.
+You can wrap your PAPI provider with Spektr provider to support redirecting requests to the host application.
 
 ```diff
 import { createClient, type PolkadotClient } from 'polkadot-api';
@@ -80,3 +81,36 @@ const unsubscribe = spektrMetaProvider.subscribeConnectionStatus((status) => {
 });
 ```
 
+### Chat Integration
+
+```ts
+import { createChat } from '@novasamatech/product-sdk';
+
+// Create chat instance
+const chat = createChat();
+
+// Register your dapp as a chat contact
+const registrationStatus = await chat.register({
+  name: 'My Product',
+  icon: 'https://example.com/icon.png'
+});
+
+// Send a message
+const { messageId } = await chat.sendMessage({
+  tag: 'Text',
+  value: 'Hello dear user!'
+});
+
+// Subscribe to chat actions (incoming messages, etc.)
+const subscriber = chat.subscribeAction((action) => {
+  if (action.tag === 'MessagePosted') {
+    console.log('Received message:', action.value);
+  }
+  if (action.tag === 'ActionTriggered') {
+    console.log('User triggered action:', action.value)
+  }
+});
+```
+
+**Note:** Messages sent before registration will be queued and sent automatically after successful registration.
+

package/dist/chat.d.ts

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

package/dist/chat.js

@@ -0,0 +1,62 @@
+import { createHostApi, enumValue } from '@novasamatech/host-api';
+import { defaultTransport } from './defaultTransport.js';
+import { promiseWithResolvers } from './helpers.js';
+promiseWithResolvers();
+export const createChat = (transport = defaultTransport) => {
+    const hostApi = createHostApi(transport);
+    let registrationStatus = null;
+    const messageQueue = [];
+    const chat = {
+        async register(params) {
+            if (registrationStatus) {
+                return registrationStatus;
+            }
+            const result = await hostApi.chat_create_contact(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.length = 0;
+                    }
+                    return registrationStatus;
+                }
+                else {
+                    throw new Error(`Unknown message version ${payload.tag}`);
+                }
+            }, err => {
+                throw err.value;
+            });
+        },
+        async sendMessage(message) {
+            if (registrationStatus) {
+                const result = await hostApi.chat_post_message(enumValue('v1', message));
+                return result.match(payload => {
+                    if (payload.tag === 'v1') {
+                        return { messageId: payload.value.messageId };
+                    }
+                    else {
+                        throw new Error(`Unknown message version ${payload.tag}`);
+                    }
+                }, err => {
+                    throw err.value;
+                });
+            }
+            else {
+                const { promise, resolve, reject } = promiseWithResolvers();
+                messageQueue.push({ message, resolve, reject });
+                return promise;
+            }
+        },
+        subscribeAction(callback) {
+            return hostApi.chat_action_subscribe(enumValue('v1', undefined), action => {
+                if (action.tag === 'v1') {
+                    callback(action.value);
+                }
+            });
+        },
+    };
+    return chat;
+};

package/dist/{createSpektrMetaProvider.d.ts → createMetaProvider.d.ts}

@@ -1,7 +1,7 @@
 import type { ConnectionStatus, Transport } from '@novasamatech/host-api';
-export declare function createSpektrMetaProvider(transport?: Transport): {
+export declare function createMetaProvider(transport?: Transport): {
     subscribeConnectionStatus(callback: (connectionStatus: ConnectionStatus) => void): VoidFunction;
 };
-export declare const spektrMetaProvider: {
+export declare const metaProvider: {
     subscribeConnectionStatus(callback: (connectionStatus: ConnectionStatus) => void): VoidFunction;
 };

package/dist/createMetaProvider.js

@@ -0,0 +1,24 @@
+import { defaultTransport } from './defaultTransport.js';
+export function createMetaProvider(transport = defaultTransport) {
+    // if (transport.isCorrectEnvironment() && typeof window !== 'undefined') {
+    //   const getUrl = () => {
+    //     return window.location.pathname + window.location.hash + window.location.search;
+    //   };
+    //
+    //   window.addEventListener('hashchange', () => {
+    //     transport.postMessage('_', { tag: 'locationChangedV1', value: getUrl() });
+    //   });
+    //
+    //   window.addEventListener('popstate', () => {
+    //     transport.postMessage('_', { tag: 'locationChangedV1', value: getUrl() });
+    //   });
+    //
+    //   transport.postMessage('_', { tag: 'locationChangedV1', value: getUrl() });
+    // }
+    return {
+        subscribeConnectionStatus(callback) {
+            return transport.onConnectionStatusChange(callback);
+        },
+    };
+}
+export const metaProvider = createMetaProvider();

package/dist/{createSpektrPapiProvider.d.ts → createPapiProvider.d.ts}

@@ -7,5 +7,5 @@ type Params = {
 type InternalParams = {
     transport?: Transport;
 };
-export declare function createSpektrPapiProvider({ chainId, fallback }: Params, internal?: InternalParams): JsonRpcProvider;
+export declare function createPapiProvider({ chainId: genesisHash, fallback }: Params, internal?: InternalParams): JsonRpcProvider;
 export {};

package/dist/createPapiProvider.js

@@ -0,0 +1,51 @@
+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) {
+    const version = 'v1';
+    const transport = internal?.transport ?? defaultTransport;
+    if (!transport.isCorrectEnvironment())
+        return fallback;
+    const hostApi = createHostApi(transport);
+    const spektrProvider = onMessage => {
+        const subscription = hostApi.jsonrpc_message_subscribe(enumValue(version, genesisHash), payload => {
+            switch (payload.tag) {
+                case version:
+                    onMessage(payload.value);
+                    break;
+                default:
+                    transport.provider.logger.error('Unknown message version', payload.tag);
+            }
+        });
+        return {
+            send(message) {
+                hostApi.jsonrpc_message_send(enumValue(version, [genesisHash, message]));
+            },
+            disconnect() {
+                subscription.unsubscribe();
+            },
+        };
+    };
+    function checkIfReady() {
+        return transport.isReady().then(ready => {
+            if (!ready)
+                return false;
+            return transport
+                .request('feature', enumValue('v1', enumValue('Chain', genesisHash)))
+                .then(payload => {
+                switch (payload.tag) {
+                    case 'v1': {
+                        return unwrapResultOrThrow(payload.value, e => new Error(e.payload.reason));
+                    }
+                    default:
+                        throw new Error(`Unknown message version ${payload.tag}`);
+                }
+            })
+                .catch(e => {
+                transport.provider.logger.error('Error checking chain support', e);
+                return false;
+            });
+        });
+    }
+    return getSyncProvider(() => checkIfReady().then(ready => (ready ? spektrProvider : fallback)));
+}

package/dist/defaultTransport.d.ts

@@ -1,3 +1,3 @@
-import type { TransportProvider } from '@novasamatech/host-api';
-export declare const defaultProvider: TransportProvider;
+import type { Provider } from '@novasamatech/host-api';
+export declare const defaultProvider: Provider;
 export declare const defaultTransport: import("@novasamatech/host-api").Transport;

package/dist/defaultTransport.js

@@ -54,4 +54,4 @@ function createDefaultSdkProvider() {
     };
 }
 export const defaultProvider = createDefaultSdkProvider();
-export const defaultTransport = createTransport(defaultProvider, { handshakeTimeout: 1_000 });
+export const defaultTransport = createTransport(defaultProvider);

package/dist/helpers.d.ts

@@ -0,0 +1,7 @@
+type PromiseWithResolvers<T> = {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason: unknown) => void;
+};
+export declare const promiseWithResolvers: <const T>() => PromiseWithResolvers<T>;
+export {};

package/dist/helpers.js

@@ -0,0 +1,10 @@
+export const promiseWithResolvers = () => {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    // @ts-expect-error before assign
+    return { promise, resolve, reject };
+};