@novasamatech/host-container 0.5.4-9 → 0.5.5

package/README.md

@@ -15,6 +15,8 @@ npm install @novasamatech/host-container --save -E
 
 ### Basic Container Setup
 
+#### iframe
+
 ```ts
 import { createContainer, createIframeProvider } from '@novasamatech/host-container';
 
@@ -29,12 +31,28 @@ const container = createContainer(provider);
 document.body.appendChild(iframe);
 ```
 
+#### webview
+
+```ts
+import { createContainer, createWebviewProvider } from '@novasamatech/host-container';
+
+const webview = document.createElement('webview');
+
+const provider = createWebviewProvider({
+  webview,
+  openDevTools: false,
+});
+const container = createContainer(provider);
+
+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));
   }
@@ -42,32 +60,61 @@ container.handleFeature((params, { ok, err }) => {
 });
 ```
 
-### handlePermissionRequest
+### handleDevicePermission
 
 ```ts
-container.handlePermissionRequest(async (params, { ok, err }) => {
-  if (params.tag === 'ChainConnect') {
-    // Show permission dialog to user
-    const approved = await showPermissionDialog(params.value);
-    return approved ? ok(undefined) : err({ tag: 'Rejected' });
+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 err({ tag: 'Unknown', value: { reason: 'Unsupported permission type' } });
+  return ok(false);
+});
+```
+
+### handlePushNotification
+
+```ts
+container.handlePushNotification(async (notification, { ok, err }) => {
+  await showNotification(notification);
+  return ok(undefined);
 });
 ```
 
-### handleStorageRead
+### handleNavigateTo
 
 ```ts
-container.handleStorageRead(async (key, { ok, err }) => {
+container.handleNavigateTo(async (url, { ok, err }) => {
+  await navigate(url);
+  return ok(undefined);
+});
+```
+
+### handleLocalStorageRead
+
+```ts
+container.handleLocalStorageRead(async (key, { ok, err }) => {
   const value = await storage.get(key);
   return ok(value ?? null);
 });
 ```
 
-### handleStorageWrite
+### handleLocalStorageWrite
 
 ```ts
-container.handleStorageWrite(async ([key, value], { ok, err }) => {
+container.handleLocalStorageWrite(async ([key, value], { ok, err }) => {
   try {
     await storage.set(key, value);
     return ok(undefined);
@@ -77,10 +124,10 @@ container.handleStorageWrite(async ([key, value], { ok, err }) => {
 });
 ```
 
-### handleStorageClear
+### handleLocalStorageClear
 
 ```ts
-container.handleStorageClear(async (key, { ok, err }) => {
+container.handleLocalStorageClear(async (key, { ok, err }) => {
   await storage.delete(key);
   return ok(undefined);
 });
@@ -184,15 +231,34 @@ container.handleSignPayload(async (payload, { ok, err }) => {
 });
 ```
 
-### handleChatCreateContact
+### handleChatCreateRoom
 
 ```ts
-container.handleChatCreateContact(async (contact, { ok, err }) => {
-  await chatService.registerContact(contact);
+container.handleChatCreateRoom(async (room, { ok, err }) => {
+  await chatService.registerRoom(room);
   return ok(undefined);
 });
 ```
 
+### handleChatBotRegistration
+
+```ts
+container.handleChatBotRegistration(async (bot, { ok, err }) => {
+  await chatService.registerBot(bot);
+  return ok(undefined);
+});
+```
+
+### handleChatListSubscribe
+
+```ts
+container.handleChatListSubscribe((_, send, interrupt) => {
+  const listener = (rooms) => send(rooms);
+  chatService.on('roomsUpdate', listener);
+  return () => chatService.off('roomsUpdate', listener);
+});
+```
+
 ### handleChatPostMessage
 
 ```ts
@@ -212,6 +278,16 @@ container.handleChatActionSubscribe((_, send, interrupt) => {
 });
 ```
 
+### handleStatementStoreSubscribe
+
+```ts
+container.handleStatementStoreSubscribe((query, send, interrupt) => {
+  const listener = (statements) => send(statements);
+  statementStore.subscribe(query, listener);
+  return () => statementStore.unsubscribe(query, listener);
+});
+```
+
 ### handleStatementStoreCreateProof
 
 ```ts
@@ -225,66 +301,80 @@ container.handleStatementStoreCreateProof(async ([[dotnsId, derivationIndex], st
 });
 ```
 
-### handleJsonRpcMessageSubscribe
+### handleStatementStoreSubmit
 
 ```ts
-import { getWsProvider } from 'polkadot-api/ws-provider';
-
-const provider = getWsProvider('wss://rpc.polkadot.io');
-container.handleJsonRpcMessageSubscribe(
-  { genesisHash: '0x...' },
-  provider
-);
+container.handleStatementStoreSubmit(async (statement, { ok, err }) => {
+  try {
+    await statementStore.submit(statement);
+    return ok(undefined);
+  } catch (e) {
+    return err({ tag: 'Unknown', value: { reason: e.message } });
+  }
+});
 ```
 
-### isReady
+### handlePreimageLookupSubscribe
 
 ```ts
-const ready = await container.isReady();
-if (ready) {
-  console.log('Container is ready');
-}
+container.handlePreimageLookupSubscribe((key, send, interrupt) => {
+  const listener = (value) => send(value);
+  preimageService.subscribe(key, listener);
+  return () => preimageService.unsubscribe(key, listener);
+});
 ```
 
-### dispose
+### handlePreimageSubmit
 
 ```ts
-container.dispose();
+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 } });
+  }
+});
 ```
 
-### subscribeConnectionStatus
+### handleChainConnection
 
 ```ts
-const unsubscribe = container.subscribeConnectionStatus((status) => {
-  console.log('Connection status:', status);
-});
-```
+import { getWsProvider } from 'polkadot-api/ws-provider';
 
-## PAPI provider support
+const chains = new Map([
+  ['0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3', 'wss://rpc.polkadot.io'],
+  ['0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe', 'wss://kusama-rpc.polkadot.io'],
+]);
 
-Host container supports [PAPI](https://papi.how/) request redirection from product to host container.
-It can be useful to deduplicate socket connections or light client instances between multiple dapps.
+container.handleChainConnection((genesisHash) => {
+  const endpoint = chains.get(genesisHash);
+  if (!endpoint) return null;
+  return getWsProvider(endpoint);
+});
+```
 
-To support this feature, you should add two additional handlers to the container:
+### isReady
 
-### Chain support check
 ```ts
-const genesisHash = '0x...';
-
-container.handleFeature(async (feature) => {
-  return feature.tag === 'Chain' && feature.value === genesisHash;
-});
+const ready = await container.isReady();
+if (ready) {
+  console.log('Container is ready');
+}
 ```
 
-### Provider implementation
+### dispose
 
 ```ts
-import { getWsProvider } from 'polkadot-api/ws-provider';
+container.dispose();
+```
 
-const genesisHash = '0x...';
-const provider = getWsProvider('wss://...');
+### subscribeProductConnectionStatus
 
-container.connectToPapiProvider(genesisHash, provider);
+```ts
+const unsubscribe = container.subscribeProductConnectionStatus((status) => {
+  console.log('Connection status:', status);
+});
 ```
 
 ## Known pitfalls

package/dist/createContainer.js

@@ -1,4 +1,4 @@
-import { 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)
@@ -67,7 +115,7 @@ export function createContainer(provider) {
         },
         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 +127,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 +139,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 +151,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 +163,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 +175,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 +187,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 +199,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 +211,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)
@@ -173,9 +221,21 @@ export function createContainer(provider) {
                     .unwrapOr(enumValue(version, resultErr(error)));
             });
         },
+        handleChatBotRegistration(handler) {
+            init();
+            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)
+                    .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)));
+            });
+        },
         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))
@@ -187,7 +247,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)
@@ -199,7 +259,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))
@@ -209,21 +269,9 @@ export function createContainer(provider) {
                 });
             });
         },
-        handleStatementStoreQuery(handler) {
-            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)));
-            });
-        },
         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))
@@ -235,7 +283,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)
@@ -247,7 +295,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)
@@ -257,9 +305,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);
@@ -274,7 +346,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

@@ -50,26 +50,32 @@ 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']>;
-    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']>;
+    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']>;
+    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/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@novasamatech/host-container",
   "type": "module",
-  "version": "0.5.4-9",
+  "version": "0.5.5",
   "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-9",
+    "@novasamatech/host-api": "0.5.5",
     "nanoid": "5.1.6"
   },
   "devDependencies": {