@novasamatech/host-container 0.5.4 → 0.6.0

package/README.md

@@ -49,10 +49,10 @@ document.body.appendChild(webview);
 
 ## API reference
 
-### handleFeature
+### handleFeatureSupported
 
 ```ts
-container.handleFeature((params, { ok, err }) => {
+container.handleFeatureSupported((params, { ok, err }) => {
   if (params.tag === 'Chat') {
     return ok(supportedChains.has(params.value));
   }
@@ -60,6 +60,48 @@ container.handleFeature((params, { ok, err }) => {
 });
 ```
 
+### handleDevicePermission
+
+```ts
+container.handleDevicePermission(async (request, { ok, err }) => {
+  const granted = await requestDevicePermission(request);
+  return ok(granted);
+});
+```
+
+### handlePermission
+
+```ts
+container.handlePermission(async (request, { ok, err }) => {
+  if (request.tag === 'ExternalRequest') {
+    const allowed = await checkExternalRequestPermission(request.value);
+    return ok(allowed);
+  }
+  if (request.tag === 'TransactionSubmit') {
+    return ok(true);
+  }
+  return ok(false);
+});
+```
+
+### handlePushNotification
+
+```ts
+container.handlePushNotification(async (notification, { ok, err }) => {
+  await showNotification(notification);
+  return ok(undefined);
+});
+```
+
+### handleNavigateTo
+
+```ts
+container.handleNavigateTo(async (url, { ok, err }) => {
+  await navigate(url);
+  return ok(undefined);
+});
+```
+
 ### handleLocalStorageRead
 
 ```ts
@@ -91,6 +133,16 @@ container.handleLocalStorageClear(async (key, { ok, err }) => {
 });
 ```
 
+### handleAccountConnectionStatusSubscribe
+
+```ts
+container.handleAccountConnectionStatusSubscribe((_, send, interrupt) => {
+  const listener = (status) => send(status);
+  accountService.on('connectionStatusChange', listener);
+  return () => accountService.off('connectionStatusChange', listener);
+});
+```
+
 ### handleAccountGet
 
 ```ts
@@ -198,7 +250,14 @@ container.handleChatCreateRoom(async (room, { ok, err }) => {
 });
 ```
 
-## handleChatBotRegistration
+### handleChatBotRegistration
+
+```ts
+container.handleChatBotRegistration(async (bot, { ok, err }) => {
+  await chatService.registerBot(bot);
+  return ok(undefined);
+});
+```
 
 ### handleChatListSubscribe
 
@@ -229,13 +288,16 @@ container.handleChatActionSubscribe((_, send, interrupt) => {
 });
 ```
 
-### handleStatementStoreQuery
+### renderChatCustomMessage
 
 ```ts
-container.handleStatementStoreQuery(async (query, { ok, err }) => {
-  const statements = await statementStore.query(query);
-  return ok(statements);
+const subscription = container.renderChatCustomMessage('my-custom-type', payload, (node) => {
+  // node is a CustomRendererNode tree describing the UI to render
+  console.log('Render custom message:', node);
 });
+
+// Unsubscribe when done
+subscription.unsubscribe();
 ```
 
 ### handleStatementStoreSubscribe
@@ -274,6 +336,29 @@ container.handleStatementStoreSubmit(async (statement, { ok, err }) => {
 });
 ```
 
+### handlePreimageLookupSubscribe
+
+```ts
+container.handlePreimageLookupSubscribe((key, send, interrupt) => {
+  const listener = (value) => send(value);
+  preimageService.subscribe(key, listener);
+  return () => preimageService.unsubscribe(key, listener);
+});
+```
+
+### handlePreimageSubmit
+
+```ts
+container.handlePreimageSubmit(async (preimage, { ok, err }) => {
+  try {
+    const key = await preimageService.submit(preimage);
+    return ok(key);
+  } catch (e) {
+    return err({ tag: 'Unknown', value: { reason: e.message } });
+  }
+});
+```
+
 ### handleChainConnection
 
 ```ts

package/dist/createContainer.js

@@ -1,4 +1,4 @@
-import { ChatBotRegistrationErr, ChatMessagePostingErr, ChatRoomRegistrationErr, CreateProofErr, CreateTransactionErr, GenericError, RequestCredentialsErr, SigningErr, StatementProofErr, StorageErr, assertEnumVariant, createTransport, enumValue, isEnumVariant, resultErr, resultOk, } from '@novasamatech/host-api';
+import { ChatBotRegistrationErr, ChatMessagePostingErr, ChatRoomRegistrationErr, CreateProofErr, CreateTransactionErr, GenericError, NavigateToErr, PreimageSubmitErr, RequestCredentialsErr, SigningErr, StatementProofErr, StorageErr, assertEnumVariant, createTransport, enumValue, isEnumVariant, resultErr, resultOk, } from '@novasamatech/host-api';
 import { err, errAsync, ok, okAsync } from 'neverthrow';
 const UNSUPPORTED_MESSAGE_FORMAT_ERROR = 'Unsupported message format';
 function guardVersion(value, tag, error) {
@@ -17,9 +17,9 @@ export function createContainer(provider) {
         transport.isReady();
     }
     return {
-        handleFeature(handler) {
+        handleFeatureSupported(handler) {
             init();
-            return transport.handleRequest('feature', async (message) => {
+            return transport.handleRequest('host_feature_supported', async (message) => {
                 const version = 'v1';
                 const error = new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(message, version, error)
@@ -29,9 +29,57 @@ export function createContainer(provider) {
                     .unwrapOr(enumValue(version, resultErr(error)));
             });
         },
+        handleDevicePermission(handler) {
+            init();
+            return transport.handleRequest('host_device_permission', async (message) => {
+                const version = 'v1';
+                const error = new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
+                return guardVersion(message, version, error)
+                    .asyncMap(async (params) => handler(params, { ok: (okAsync), err: (errAsync) }))
+                    .andThen(r => r.map(r => enumValue(version, resultOk(r))))
+                    .orElse(r => ok(enumValue(version, resultErr(r))))
+                    .unwrapOr(enumValue(version, resultErr(error)));
+            });
+        },
+        handlePermission(handler) {
+            init();
+            return transport.handleRequest('remote_permission', async (message) => {
+                const version = 'v1';
+                const error = new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
+                return guardVersion(message, version, error)
+                    .asyncMap(async (params) => handler(params, { ok: (okAsync), err: (errAsync) }))
+                    .andThen(r => r.map(r => enumValue(version, resultOk(r))))
+                    .orElse(r => ok(enumValue(version, resultErr(r))))
+                    .unwrapOr(enumValue(version, resultErr(error)));
+            });
+        },
+        handlePushNotification(handler) {
+            init();
+            return transport.handleRequest('host_push_notification', async (message) => {
+                const version = 'v1';
+                const error = new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
+                return guardVersion(message, version, error)
+                    .asyncMap(async (params) => handler(params, { ok: (okAsync), err: (errAsync) }))
+                    .andThen(r => r.map(r => enumValue(version, resultOk(r))))
+                    .orElse(r => ok(enumValue(version, resultErr(r))))
+                    .unwrapOr(enumValue(version, resultErr(error)));
+            });
+        },
+        handleNavigateTo(handler) {
+            init();
+            return transport.handleRequest('host_navigate_to', async (message) => {
+                const version = 'v1';
+                const error = new NavigateToErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
+                return guardVersion(message, version, error)
+                    .asyncMap(async (params) => handler(params, { ok: (okAsync), err: (errAsync) }))
+                    .andThen(r => r.map(r => enumValue(version, resultOk(r))))
+                    .orElse(r => ok(enumValue(version, resultErr(r))))
+                    .unwrapOr(enumValue(version, resultErr(error)));
+            });
+        },
         handleLocalStorageRead(handler) {
             init();
-            return transport.handleRequest('local_storage_read', async (message) => {
+            return transport.handleRequest('host_local_storage_read', async (message) => {
                 const version = 'v1';
                 const error = new StorageErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(message, version, error)
@@ -43,7 +91,7 @@ export function createContainer(provider) {
         },
         handleLocalStorageWrite(handler) {
             init();
-            return transport.handleRequest('local_storage_write', async (message) => {
+            return transport.handleRequest('host_local_storage_write', async (message) => {
                 const version = 'v1';
                 const error = new StorageErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(message, version, error)
@@ -55,7 +103,7 @@ export function createContainer(provider) {
         },
         handleLocalStorageClear(handler) {
             init();
-            return transport.handleRequest('local_storage_clear', async (params) => {
+            return transport.handleRequest('host_local_storage_clear', async (params) => {
                 const version = 'v1';
                 const error = new StorageErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(params, version, error)
@@ -65,9 +113,21 @@ export function createContainer(provider) {
                     .unwrapOr(enumValue(version, resultErr(error)));
             });
         },
+        handleAccountConnectionStatusSubscribe(handler) {
+            init();
+            return transport.handleSubscription('host_account_connection_status_subscribe', (params, send, interrupt) => {
+                const version = 'v1';
+                return guardVersion(params, version, null)
+                    .map(params => handler(params, payload => send(enumValue(version, payload)), interrupt))
+                    .orTee(interrupt)
+                    .unwrapOr(() => {
+                    /* empty */
+                });
+            });
+        },
         handleAccountGet(handler) {
             init();
-            return transport.handleRequest('account_get', async (params) => {
+            return transport.handleRequest('host_account_get', async (params) => {
                 const version = 'v1';
                 const error = new RequestCredentialsErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(params, version, error)
@@ -79,7 +139,7 @@ export function createContainer(provider) {
         },
         handleAccountGetAlias(handler) {
             init();
-            return transport.handleRequest('account_get_alias', async (params) => {
+            return transport.handleRequest('host_account_get_alias', async (params) => {
                 const version = 'v1';
                 const error = new RequestCredentialsErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(params, version, error)
@@ -91,7 +151,7 @@ export function createContainer(provider) {
         },
         handleAccountCreateProof(handler) {
             init();
-            return transport.handleRequest('account_create_proof', async (params) => {
+            return transport.handleRequest('host_account_create_proof', async (params) => {
                 const version = 'v1';
                 const error = new CreateProofErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(params, version, error)
@@ -103,7 +163,7 @@ export function createContainer(provider) {
         },
         handleGetNonProductAccounts(handler) {
             init();
-            return transport.handleRequest('get_non_product_accounts', async (params) => {
+            return transport.handleRequest('host_get_non_product_accounts', async (params) => {
                 const version = 'v1';
                 const error = new RequestCredentialsErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(params, version, error)
@@ -115,7 +175,7 @@ export function createContainer(provider) {
         },
         handleCreateTransaction(handler) {
             init();
-            return transport.handleRequest('create_transaction', async (params) => {
+            return transport.handleRequest('host_create_transaction', async (params) => {
                 const version = 'v1';
                 const error = new CreateTransactionErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(params, version, error)
@@ -127,7 +187,7 @@ export function createContainer(provider) {
         },
         handleCreateTransactionWithNonProductAccount(handler) {
             init();
-            return transport.handleRequest('create_transaction_with_non_product_account', async (params) => {
+            return transport.handleRequest('host_create_transaction_with_non_product_account', async (params) => {
                 const version = 'v1';
                 const error = new CreateTransactionErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(params, version, error)
@@ -139,7 +199,7 @@ export function createContainer(provider) {
         },
         handleSignRaw(handler) {
             init();
-            return transport.handleRequest('sign_raw', async (params) => {
+            return transport.handleRequest('host_sign_raw', async (params) => {
                 const version = 'v1';
                 const error = new SigningErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(params, version, error)
@@ -151,7 +211,7 @@ export function createContainer(provider) {
         },
         handleSignPayload(handler) {
             init();
-            return transport.handleRequest('sign_payload', async (params) => {
+            return transport.handleRequest('host_sign_payload', async (params) => {
                 const version = 'v1';
                 const error = new SigningErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(params, version, error)
@@ -163,7 +223,7 @@ export function createContainer(provider) {
         },
         handleChatCreateRoom(handler) {
             init();
-            return transport.handleRequest('chat_create_room', async (params) => {
+            return transport.handleRequest('host_chat_create_room', async (params) => {
                 const version = 'v1';
                 const error = new ChatRoomRegistrationErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(params, version, error)
@@ -175,7 +235,7 @@ export function createContainer(provider) {
         },
         handleChatBotRegistration(handler) {
             init();
-            return transport.handleRequest('chat_register_bot', async (params) => {
+            return transport.handleRequest('host_chat_register_bot', async (params) => {
                 const version = 'v1';
                 const error = new ChatBotRegistrationErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(params, version, error)
@@ -187,7 +247,7 @@ export function createContainer(provider) {
         },
         handleChatListSubscribe(handler) {
             init();
-            return transport.handleSubscription('chat_list_subscribe', (params, send, interrupt) => {
+            return transport.handleSubscription('host_chat_list_subscribe', (params, send, interrupt) => {
                 const version = 'v1';
                 return guardVersion(params, version, null)
                     .map(params => handler(params, payload => send(enumValue(version, payload)), interrupt))
@@ -199,7 +259,7 @@ export function createContainer(provider) {
         },
         handleChatPostMessage(handler) {
             init();
-            return transport.handleRequest('chat_post_message', async (params) => {
+            return transport.handleRequest('host_chat_post_message', async (params) => {
                 const version = 'v1';
                 const error = new ChatMessagePostingErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(params, version, error)
@@ -211,7 +271,7 @@ export function createContainer(provider) {
         },
         handleChatActionSubscribe(handler) {
             init();
-            return transport.handleSubscription('chat_action_subscribe', (params, send, interrupt) => {
+            return transport.handleSubscription('host_chat_action_subscribe', (params, send, interrupt) => {
                 const version = 'v1';
                 return guardVersion(params, version, null)
                     .map(params => handler(params, payload => send(enumValue(version, payload)), interrupt))
@@ -221,21 +281,17 @@ export function createContainer(provider) {
                 });
             });
         },
-        handleStatementStoreQuery(handler) {
+        renderChatCustomMessage(messageType, payload, callback) {
             init();
-            return transport.handleRequest('statement_store_query', async (params) => {
-                const version = 'v1';
-                const error = new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
-                return guardVersion(params, version, error)
-                    .asyncMap(async (params) => handler(params, { ok: (okAsync), err: (errAsync) }))
-                    .andThen(r => r.map(r => enumValue(version, resultOk(r))))
-                    .orElse(r => ok(enumValue(version, resultErr(r))))
-                    .unwrapOr(enumValue(version, resultErr(error)));
+            return transport.subscribe('product_chat_custom_message_render_subscribe', enumValue('v1', { messageType, payload }), value => {
+                if (value.tag === 'v1') {
+                    callback(value.value);
+                }
             });
         },
         handleStatementStoreSubscribe(handler) {
             init();
-            return transport.handleSubscription('statement_store_subscribe', (params, send, interrupt) => {
+            return transport.handleSubscription('remote_statement_store_subscribe', (params, send, interrupt) => {
                 const version = 'v1';
                 return guardVersion(params, version, null)
                     .map(params => handler(params, payload => send(enumValue(version, payload)), interrupt))
@@ -247,7 +303,7 @@ export function createContainer(provider) {
         },
         handleStatementStoreCreateProof(handler) {
             init();
-            return transport.handleRequest('statement_store_create_proof', async (params) => {
+            return transport.handleRequest('remote_statement_store_create_proof', async (params) => {
                 const version = 'v1';
                 const error = new StatementProofErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(params, version, error)
@@ -259,7 +315,7 @@ export function createContainer(provider) {
         },
         handleStatementStoreSubmit(handler) {
             init();
-            return transport.handleRequest('statement_store_submit', async (params) => {
+            return transport.handleRequest('remote_statement_store_submit', async (params) => {
                 const version = 'v1';
                 const error = new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
                 return guardVersion(params, version, error)
@@ -269,9 +325,33 @@ export function createContainer(provider) {
                     .unwrapOr(enumValue(version, resultErr(error)));
             });
         },
+        handlePreimageLookupSubscribe(handler) {
+            init();
+            return transport.handleSubscription('remote_preimage_lookup_subscribe', (params, send, interrupt) => {
+                const version = 'v1';
+                return guardVersion(params, version, null)
+                    .map(params => handler(params, payload => send(enumValue(version, payload)), interrupt))
+                    .orTee(interrupt)
+                    .unwrapOr(() => {
+                    /* empty */
+                });
+            });
+        },
+        handlePreimageSubmit(handler) {
+            init();
+            return transport.handleRequest('remote_preimage_submit', async (params) => {
+                const version = 'v1';
+                const error = new PreimageSubmitErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR });
+                return guardVersion(params, version, error)
+                    .asyncMap(async (params) => handler(params, { ok: (okAsync), err: (errAsync) }))
+                    .andThen(r => r.map(r => enumValue(version, resultOk(r))))
+                    .orElse(r => ok(enumValue(version, resultErr(r))))
+                    .unwrapOr(enumValue(version, resultErr(error)));
+            });
+        },
         handleChainConnection(factory) {
             init();
-            return transport.handleSubscription('jsonrpc_message_subscribe', (params, send) => {
+            return transport.handleSubscription('host_jsonrpc_message_subscribe', (params, send) => {
                 assertEnumVariant(params, 'v1', UNSUPPORTED_MESSAGE_FORMAT_ERROR);
                 const genesisHash = params.value;
                 const provider = factory(params.value);
@@ -286,7 +366,7 @@ export function createContainer(provider) {
                     unsubscribeDestroy();
                     connection.disconnect();
                 });
-                const unsubRequests = transport.handleRequest('jsonrpc_message_send', async (message) => {
+                const unsubRequests = transport.handleRequest('host_jsonrpc_message_send', async (message) => {
                     assertEnumVariant(message, 'v1', UNSUPPORTED_MESSAGE_FORMAT_ERROR);
                     const [requestedGenesisHash, payload] = message.value;
                     if (requestedGenesisHash === genesisHash) {

package/dist/types.d.ts

@@ -1,4 +1,5 @@
-import type { Codec, CodecType, ConnectionStatus, HexString, HostApiProtocol, VersionedProtocolRequest, VersionedProtocolSubscription } from '@novasamatech/host-api';
+import type { Codec, CodecType, ConnectionStatus, HexString, HostApiProtocol, Subscription, VersionedProtocolRequest, VersionedProtocolSubscription } from '@novasamatech/host-api';
+import { CustomRendererNode } from '@novasamatech/host-api';
 import type { JsonRpcProvider } from '@polkadot-api/json-rpc-provider';
 import type { ResultAsync, errAsync } from 'neverthrow';
 import { okAsync } from 'neverthrow';
@@ -50,27 +51,34 @@ type InferRequestHandler<V extends string, T extends VersionedProtocolRequest> =
 type InferSubscribeHandler<V extends string, T extends VersionedProtocolSubscription> = (callback: (params: WithVersion<V, Value<T['start']>>, send: (payload: WithVersion<V, Value<T['receive']>>) => void, interrupt: VoidFunction) => VoidFunction) => VoidFunction;
 type InferHandler<V extends string, T extends VersionedProtocolRequest | VersionedProtocolSubscription> = T extends VersionedProtocolRequest ? InferRequestHandler<V, T> : T extends VersionedProtocolSubscription ? InferSubscribeHandler<V, T> : never;
 export type Container = {
-    handleFeature: InferHandler<'v1', HostApiProtocol['feature']>;
-    handleLocalStorageRead: InferHandler<'v1', HostApiProtocol['local_storage_read']>;
-    handleLocalStorageWrite: InferHandler<'v1', HostApiProtocol['local_storage_write']>;
-    handleLocalStorageClear: InferHandler<'v1', HostApiProtocol['local_storage_clear']>;
-    handleAccountGet: InferHandler<'v1', HostApiProtocol['account_get']>;
-    handleAccountGetAlias: InferHandler<'v1', HostApiProtocol['account_get_alias']>;
-    handleAccountCreateProof: InferHandler<'v1', HostApiProtocol['account_create_proof']>;
-    handleGetNonProductAccounts: InferHandler<'v1', HostApiProtocol['get_non_product_accounts']>;
-    handleCreateTransaction: InferHandler<'v1', HostApiProtocol['create_transaction']>;
-    handleCreateTransactionWithNonProductAccount: InferHandler<'v1', HostApiProtocol['create_transaction_with_non_product_account']>;
-    handleSignRaw: InferHandler<'v1', HostApiProtocol['sign_raw']>;
-    handleSignPayload: InferHandler<'v1', HostApiProtocol['sign_payload']>;
-    handleChatCreateRoom: InferHandler<'v1', HostApiProtocol['chat_create_room']>;
-    handleChatBotRegistration: InferHandler<'v1', HostApiProtocol['chat_register_bot']>;
-    handleChatListSubscribe: InferHandler<'v1', HostApiProtocol['chat_list_subscribe']>;
-    handleChatPostMessage: InferHandler<'v1', HostApiProtocol['chat_post_message']>;
-    handleChatActionSubscribe: InferHandler<'v1', HostApiProtocol['chat_action_subscribe']>;
-    handleStatementStoreQuery: InferHandler<'v1', HostApiProtocol['statement_store_query']>;
-    handleStatementStoreSubscribe: InferHandler<'v1', HostApiProtocol['statement_store_subscribe']>;
-    handleStatementStoreCreateProof: InferHandler<'v1', HostApiProtocol['statement_store_create_proof']>;
-    handleStatementStoreSubmit: InferHandler<'v1', HostApiProtocol['statement_store_submit']>;
+    handleFeatureSupported: InferHandler<'v1', HostApiProtocol['host_feature_supported']>;
+    handleDevicePermission: InferHandler<'v1', HostApiProtocol['host_device_permission']>;
+    handlePermission: InferHandler<'v1', HostApiProtocol['remote_permission']>;
+    handlePushNotification: InferHandler<'v1', HostApiProtocol['host_push_notification']>;
+    handleNavigateTo: InferHandler<'v1', HostApiProtocol['host_navigate_to']>;
+    handleLocalStorageRead: InferHandler<'v1', HostApiProtocol['host_local_storage_read']>;
+    handleLocalStorageWrite: InferHandler<'v1', HostApiProtocol['host_local_storage_write']>;
+    handleLocalStorageClear: InferHandler<'v1', HostApiProtocol['host_local_storage_clear']>;
+    handleAccountConnectionStatusSubscribe: InferHandler<'v1', HostApiProtocol['host_account_connection_status_subscribe']>;
+    handleAccountGet: InferHandler<'v1', HostApiProtocol['host_account_get']>;
+    handleAccountGetAlias: InferHandler<'v1', HostApiProtocol['host_account_get_alias']>;
+    handleAccountCreateProof: InferHandler<'v1', HostApiProtocol['host_account_create_proof']>;
+    handleGetNonProductAccounts: InferHandler<'v1', HostApiProtocol['host_get_non_product_accounts']>;
+    handleCreateTransaction: InferHandler<'v1', HostApiProtocol['host_create_transaction']>;
+    handleCreateTransactionWithNonProductAccount: InferHandler<'v1', HostApiProtocol['host_create_transaction_with_non_product_account']>;
+    handleSignRaw: InferHandler<'v1', HostApiProtocol['host_sign_raw']>;
+    handleSignPayload: InferHandler<'v1', HostApiProtocol['host_sign_payload']>;
+    handleChatCreateRoom: InferHandler<'v1', HostApiProtocol['host_chat_create_room']>;
+    handleChatBotRegistration: InferHandler<'v1', HostApiProtocol['host_chat_register_bot']>;
+    handleChatListSubscribe: InferHandler<'v1', HostApiProtocol['host_chat_list_subscribe']>;
+    handleChatPostMessage: InferHandler<'v1', HostApiProtocol['host_chat_post_message']>;
+    handleChatActionSubscribe: InferHandler<'v1', HostApiProtocol['host_chat_action_subscribe']>;
+    renderChatCustomMessage(messageType: string, payload: Uint8Array, callback: (node: CodecType<typeof CustomRendererNode>) => void): Subscription;
+    handleStatementStoreSubscribe: InferHandler<'v1', HostApiProtocol['remote_statement_store_subscribe']>;
+    handleStatementStoreCreateProof: InferHandler<'v1', HostApiProtocol['remote_statement_store_create_proof']>;
+    handleStatementStoreSubmit: InferHandler<'v1', HostApiProtocol['remote_statement_store_submit']>;
+    handlePreimageLookupSubscribe: InferHandler<'v1', HostApiProtocol['remote_preimage_lookup_subscribe']>;
+    handlePreimageSubmit: InferHandler<'v1', HostApiProtocol['remote_preimage_submit']>;
     handleChainConnection: (factory: (genesisHash: HexString) => JsonRpcProvider | null) => VoidFunction;
     isReady(): Promise<boolean>;
     dispose(): void;

package/dist/types.js

@@ -1 +1,2 @@
+import { CustomRendererNode } from '@novasamatech/host-api';
 import { okAsync } from 'neverthrow';

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@novasamatech/host-container",
   "type": "module",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "description": "Host container for hosting and managing products within the Polkadot ecosystem.",
   "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",
@@ -28,7 +28,7 @@
   "dependencies": {
     "@polkadot-api/utils": "^0.2.0",
     "@polkadot-api/json-rpc-provider": "^0.0.4",
-    "@novasamatech/host-api": "0.5.4",
+    "@novasamatech/host-api": "0.6.0",
     "nanoid": "5.1.6"
   },
   "devDependencies": {