@novasamatech/host-container 0.7.0-0 → 0.7.0-1

package/README.md

@@ -62,25 +62,59 @@ container.handleFeatureSupported((params, { ok, err }) => {
 
 ### handleDevicePermission
 
+The `request` parameter is one of: `'Notifications'`, `'Camera'`, `'Microphone'`, `'Bluetooth'`, `'NFC'`, `'Location'`, `'Clipboard'`, `'OpenUrl'`, `'Biometrics'`.
+
 ```ts
 container.handleDevicePermission(async (request, { ok, err }) => {
-  const granted = await requestDevicePermission(request);
+  // request is a string literal: 'Notifications' | 'Camera' | 'Microphone' | ...
+  const granted = await promptDevicePermission(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);
+The `request` parameter is an **array** of `RemotePermission` items. Return `ok(true)` only when **all** permissions in the batch are granted.
+
+Each item has one of these shapes:
+- `{ tag: 'Remote', value: string[] }` — HTTP/WS domain patterns (exact or `*.wildcard`)
+- `{ tag: 'WebRTC', value: undefined }` — WebRTC access (may expose user IP)
+- `{ tag: 'ChainSubmit', value: undefined }` — broadcast transactions via `remote_chain_transaction_broadcast`
+- `{ tag: 'PreimageSubmit', value: undefined }` — submit preimages via `remote_preimage_submit`
+- `{ tag: 'StatementSubmit', value: undefined }` — submit statements via `remote_statement_store_submit`
+
+```ts
+container.handlePermission(async (permissions, { ok, err }) => {
+  for (const permission of permissions) {
+    switch (permission.tag) {
+      case 'Remote': {
+        const allowed = await checkDomainPermissions(permission.value);
+        if (!allowed) return ok(false);
+        break;
+      }
+      case 'WebRTC': {
+        const allowed = await promptWebRTCPermission();
+        if (!allowed) return ok(false);
+        break;
+      }
+      case 'ChainSubmit': {
+        const allowed = await promptChainSubmitPermission();
+        if (!allowed) return ok(false);
+        break;
+      }
+      case 'PreimageSubmit': {
+        const allowed = await promptPreimageSubmitPermission();
+        if (!allowed) return ok(false);
+        break;
+      }
+      case 'StatementSubmit': {
+        const allowed = await promptStatementSubmitPermission();
+        if (!allowed) return ok(false);
+        break;
+      }
+    }
   }
-  return ok(false);
+  return ok(true);
 });
 ```
 
@@ -163,6 +197,44 @@ container.handleThemeSubscribe((_, send, interrupt) => {
 });
 ```
 
+### handleAccountGetRoot
+
+Called when a product requests the user's root (primary) account. Show a permission prompt on first call; cache the grant for the session. Return `NotFound` if the user has no DotNS username.
+
+```ts
+import { RequestCredentialsErr } from '@novasamatech/host-api';
+
+container.handleAccountGetRoot(async (_, { ok, err }) => {
+  const granted = await promptUserForRootAccountAccess();
+  if (!granted) {
+    return err(new RequestCredentialsErr.Rejected());
+  }
+  const rootAccount = await getRootAccount();
+  if (!rootAccount) {
+    return err(new RequestCredentialsErr.NotConnected());
+  }
+  return ok({ publicKey: rootAccount.publicKey, name: rootAccount.name ?? undefined });
+});
+```
+
+### handleRequestLogin
+
+Called when a product requests the host login UI. Present the sign-in flow and return the outcome. `reason` is an optional human-readable string the product provides to explain why login is needed.
+
+```ts
+import { LoginErr } from '@novasamatech/host-api';
+
+container.handleRequestLogin(async (reason, { ok, err }) => {
+  const alreadyConnected = await checkIfConnected();
+  if (alreadyConnected) return ok('alreadyConnected');
+
+  const result = await presentLoginUI(reason);
+  if (!result.success) return ok('rejected');
+
+  return ok('success');
+});
+```
+
 ### handleAccountGet
 
 ```ts
@@ -200,11 +272,11 @@ container.handleAccountCreateProof(async ([[dotnsId, derivationIndex], ringLocat
 });
 ```
 
-### handleGetNonProductAccounts
+### handleGetLegacyAccounts
 
 ```ts
-container.handleGetNonProductAccounts(async (_, { ok, err }) => {
-  const accounts = await getNonProductAccounts();
+container.handleGetLegacyAccounts(async (_, { ok, err }) => {
+  const accounts = await getLegacyAccounts();
   return ok(accounts);
 });
 ```
@@ -222,12 +294,12 @@ container.handleCreateTransaction(async ([productAccountId, payload], { ok, err
 });
 ```
 
-### handleCreateTransactionWithNonProductAccount
+### handleCreateTransactionWithLegacyAccount
 
 ```ts
-container.handleCreateTransactionWithNonProductAccount(async (payload, { ok, err }) => {
+container.handleCreateTransactionWithLegacyAccount(async (payload, { ok, err }) => {
   try {
-    const signedTx = await createTransactionWithNonProductAccount(payload);
+    const signedTx = await createTransactionWithLegacyAccount(payload);
     return ok(signedTx);
   } catch (e) {
     return err({ tag: 'Rejected' });
@@ -323,10 +395,11 @@ subscription.unsubscribe();
 ### handleStatementStoreSubscribe
 
 ```ts
-container.handleStatementStoreSubscribe((query, send, interrupt) => {
-  const listener = (statements) => send(statements);
-  statementStore.subscribe(query, listener);
-  return () => statementStore.unsubscribe(query, listener);
+container.handleStatementStoreSubscribe((filter, send, interrupt) => {
+  // filter is { tag: 'MatchAll', value: Uint8Array[] } | { tag: 'MatchAny', value: Uint8Array[] }
+  const listener = (page) => send(page);
+  statementStore.subscribe(filter, listener);
+  return () => statementStore.unsubscribe(filter, listener);
 });
 ```
 
@@ -457,10 +530,6 @@ container.handleChainConnection({
     const endpoint = chains.get(genesisHash);
     if (!endpoint) return null;
     return getWsProvider(endpoint);
-  },
-  async submitPermission(transaction) {
-    if (hasPermission(transaction)) return true;
-    return false;
   }
 });
 ```

package/dist/chainConnectionManager.d.ts

@@ -1,5 +1,6 @@
 import type { HexString } from '@novasamatech/host-api';
-import type { JsonRpcProvider } from '@polkadot-api/json-rpc-provider';
+import type { JsonRpcProvider } from 'polkadot-api';
+type JsonRpcConnection = ReturnType<JsonRpcProvider>;
 type PendingRequest = {
     resolve: (result: unknown) => void;
     reject: (error: unknown) => void;
@@ -10,10 +11,7 @@ type FollowSubscription = {
     pendingRequestId?: string;
 };
 type ChainEntry = {
-    connection: {
-        send: (msg: string) => void;
-        disconnect: () => void;
-    };
+    connection: JsonRpcConnection;
     pendingRequests: Map<string, PendingRequest>;
     followSubscriptions: Map<string, FollowSubscription>;
     refCount: number;

package/dist/chainConnectionManager.js

@@ -24,36 +24,31 @@ export function createChainConnectionManager(factory) {
             followSubscriptions,
             refCount: 1,
         };
-        entry.connection = provider((message) => {
-            let parsed;
-            try {
-                parsed = JSON.parse(message);
-            }
-            catch {
-                return;
-            }
-            // Request-response (has 'id' field)
-            if ('id' in parsed && parsed.id != null) {
-                const pending = pendingRequests.get(String(parsed.id));
+        entry.connection = provider(message => {
+            // Response: has 'id' but no 'method'
+            if ('id' in message && message.id != null && !('method' in message)) {
+                const pending = pendingRequests.get(String(message.id));
                 if (pending) {
-                    pendingRequests.delete(String(parsed.id));
-                    if ('error' in parsed) {
-                        pending.reject(parsed.error);
+                    pendingRequests.delete(String(message.id));
+                    if ('error' in message) {
+                        pending.reject(message.error);
                     }
                     else {
-                        pending.resolve(parsed.result);
+                        pending.resolve(message.result);
                     }
                     return;
                 }
             }
-            // Subscription notification (has params.subscription)
-            const params = parsed.params;
-            if (params?.subscription) {
-                const subId = String(params.subscription);
-                for (const follow of followSubscriptions.values()) {
-                    if (follow.chainSubId === subId) {
-                        follow.eventListener(params.result);
-                        break;
+            // Subscription notification: has 'method' and 'params'
+            if ('method' in message && 'params' in message) {
+                const params = message.params;
+                if (params?.subscription) {
+                    const subId = String(params.subscription);
+                    for (const follow of followSubscriptions.values()) {
+                        if (follow.chainSubId === subId) {
+                            follow.eventListener(params.result);
+                            break;
+                        }
                     }
                 }
             }
@@ -68,7 +63,7 @@ export function createChainConnectionManager(factory) {
         const id = getNextId();
         return new Promise((resolve, reject) => {
             entry.pendingRequests.set(id, { resolve, reject });
-            entry.connection.send(JSON.stringify({ jsonrpc: '2.0', id, method, params }));
+            entry.connection.send({ jsonrpc: '2.0', id, method, params });
         });
     }
     function startFollow(genesisHash, withRuntime, onEvent) {
@@ -96,7 +91,12 @@ export function createChainConnectionManager(factory) {
                 entry.followSubscriptions.delete(followId);
             },
         });
-        entry.connection.send(JSON.stringify({ jsonrpc: '2.0', id: requestId, method: 'chainHead_v1_follow', params: [withRuntime] }));
+        entry.connection.send({
+            jsonrpc: '2.0',
+            id: requestId,
+            method: 'chainHead_v1_follow',
+            params: [withRuntime],
+        });
         return { followId };
     }
     function stopFollow(genesisHash, followId) {
@@ -109,7 +109,12 @@ export function createChainConnectionManager(factory) {
         entry.followSubscriptions.delete(followId);
         if (follow.chainSubId) {
             const id = getNextId();
-            entry.connection.send(JSON.stringify({ jsonrpc: '2.0', id, method: 'chainHead_v1_unfollow', params: [follow.chainSubId] }));
+            entry.connection.send({
+                jsonrpc: '2.0',
+                id,
+                method: 'chainHead_v1_unfollow',
+                params: [follow.chainSubId],
+            });
         }
         else if (follow.pendingRequestId) {
             // Follow response hasn't arrived yet — replace the pending resolve to send unfollow when it does
@@ -118,7 +123,12 @@ export function createChainConnectionManager(factory) {
                     const chainSubId = result;
                     if (chainSubId) {
                         const unfollowId = getNextId();
-                        entry.connection.send(JSON.stringify({ jsonrpc: '2.0', id: unfollowId, method: 'chainHead_v1_unfollow', params: [chainSubId] }));
+                        entry.connection.send({
+                            jsonrpc: '2.0',
+                            id: unfollowId,
+                            method: 'chainHead_v1_unfollow',
+                            params: [chainSubId],
+                        });
                     }
                 },
                 reject: () => {
@@ -147,7 +157,12 @@ export function createChainConnectionManager(factory) {
             for (const follow of entry.followSubscriptions.values()) {
                 if (follow.chainSubId) {
                     const id = getNextId();
-                    entry.connection.send(JSON.stringify({ jsonrpc: '2.0', id, method: 'chainHead_v1_unfollow', params: [follow.chainSubId] }));
+                    entry.connection.send({
+                        jsonrpc: '2.0',
+                        id,
+                        method: 'chainHead_v1_unfollow',
+                        params: [follow.chainSubId],
+                    });
                 }
             }
             entry.followSubscriptions.clear();
@@ -160,7 +175,12 @@ export function createChainConnectionManager(factory) {
             for (const follow of entry.followSubscriptions.values()) {
                 if (follow.chainSubId) {
                     const id = getNextId();
-                    entry.connection.send(JSON.stringify({ jsonrpc: '2.0', id, method: 'chainHead_v1_unfollow', params: [follow.chainSubId] }));
+                    entry.connection.send({
+                        jsonrpc: '2.0',
+                        id,
+                        method: 'chainHead_v1_unfollow',
+                        params: [follow.chainSubId],
+                    });
                 }
             }
             entry.followSubscriptions.clear();

package/dist/createContainer.js

@@ -1,4 +1,4 @@
-import { ChatBotRegistrationErr, ChatMessagePostingErr, ChatRoomRegistrationErr, CreateProofErr, CreateTransactionErr, DeriveEntropyErr, GenericError, NavigateToErr, PaymentRequestErr, PaymentTopUpErr, PreimageSubmitErr, RequestCredentialsErr, SigningErr, StatementProofErr, StorageErr, createTransport, enumValue, isEnumVariant, resultErr, resultOk, } from '@novasamatech/host-api';
+import { ChatBotRegistrationErr, ChatMessagePostingErr, ChatRoomRegistrationErr, CreateProofErr, CreateTransactionErr, DeriveEntropyErr, GenericError, LoginErr, NavigateToErr, PaymentRequestErr, PaymentTopUpErr, PreimageSubmitErr, RemotePermission, RequestCredentialsErr, SigningErr, StatementProofErr, StorageErr, createTransport, enumValue, isEnumVariant, resultErr, resultOk, } from '@novasamatech/host-api';
 import { err, errAsync, ok, okAsync } from 'neverthrow';
 import { createChainConnectionManager } from './chainConnectionManager.js';
 const UNSUPPORTED_MESSAGE_FORMAT_ERROR = 'Unsupported message format';
@@ -71,6 +71,34 @@ export function createContainer(provider) {
         });
         return makeSubscriptionSlot(method, defaultHandler);
     }
+    function makePermissionGatedRequestSlot(method, permissionVariant, makeError) {
+        const defaultHandler = async () => enumValue('v1', resultErr(makeError()));
+        let current = defaultHandler;
+        let version = 0;
+        transport.handleRequest(method, async (params) => {
+            const permissionResponse = await handleRemotePermissionSlot.call(enumValue('v1', [enumValue(permissionVariant, undefined)]));
+            const permissionGranted = isEnumVariant(permissionResponse, 'v1') &&
+                permissionResponse.value.success === true &&
+                permissionResponse.value.value === true;
+            if (!permissionGranted) {
+                return enumValue('v1', resultErr(makeError()));
+            }
+            return current(params);
+        });
+        return {
+            update: handler => {
+                current = handler;
+                const myVersion = ++version;
+                return () => {
+                    if (myVersion !== version)
+                        return;
+                    version++;
+                    current = defaultHandler;
+                };
+            },
+            call: (...args) => current(...args),
+        };
+    }
     function handleV1Request(slot, makeError, handler) {
         init();
         const version = 'v1';
@@ -97,9 +125,11 @@ export function createContainer(provider) {
         return slot(slotHandler);
     }
     // account slots
+    const handleAccountGetRootSlot = makeNotImplementedSlot('host_account_get_root', () => new RequestCredentialsErr.Unknown({ reason: NOT_IMPLEMENTED }));
+    const handleRequestLoginSlot = makeNotImplementedSlot('host_request_login', () => new LoginErr.Unknown({ reason: NOT_IMPLEMENTED }));
     const handleAccountGetSlot = makeNotImplementedSlot('host_account_get', () => new RequestCredentialsErr.Unknown({ reason: NOT_IMPLEMENTED }));
     const handleAccountGetAliasSlot = makeNotImplementedSlot('host_account_get_alias', () => new RequestCredentialsErr.Unknown({ reason: NOT_IMPLEMENTED }));
-    const handleGetNonProductAccountsSlot = makeNotImplementedSlot('host_get_non_product_accounts', () => new RequestCredentialsErr.Unknown({ reason: NOT_IMPLEMENTED }));
+    const handleGetLegacyAccountsSlot = makeNotImplementedSlot('host_get_legacy_accounts', () => new RequestCredentialsErr.Unknown({ reason: NOT_IMPLEMENTED }));
     const handleAccountCreateProofSlot = makeNotImplementedSlot('host_account_create_proof', () => new CreateProofErr.Unknown({ reason: NOT_IMPLEMENTED }));
     // entropy derivation slot
     const handleDeriveEntropySlot = makeNotImplementedSlot('host_derive_entropy', () => new DeriveEntropyErr.Unknown({ reason: NOT_IMPLEMENTED }));
@@ -110,10 +140,10 @@ export function createContainer(provider) {
     // signing slots
     const handleSignRawSlot = makeNotImplementedSlot('host_sign_raw', () => new SigningErr.Unknown({ reason: NOT_IMPLEMENTED }));
     const handleSignPayloadSlot = makeNotImplementedSlot('host_sign_payload', () => new SigningErr.Unknown({ reason: NOT_IMPLEMENTED }));
-    const handleSignRawWithNonProductAccountSlot = makeNotImplementedSlot('host_sign_raw_with_non_product_account', () => new SigningErr.Unknown({ reason: NOT_IMPLEMENTED }));
-    const handleSignPayloadWithNonProductAccountSlot = makeNotImplementedSlot('host_sign_payload_with_non_product_account', () => new SigningErr.Unknown({ reason: NOT_IMPLEMENTED }));
+    const handleSignRawWithLegacyAccountSlot = makeNotImplementedSlot('host_sign_raw_with_legacy_account', () => new SigningErr.Unknown({ reason: NOT_IMPLEMENTED }));
+    const handleSignPayloadWithLegacyAccountSlot = makeNotImplementedSlot('host_sign_payload_with_legacy_account', () => new SigningErr.Unknown({ reason: NOT_IMPLEMENTED }));
     const handleCreateTransactionSlot = makeNotImplementedSlot('host_create_transaction', () => new CreateTransactionErr.Unknown({ reason: NOT_IMPLEMENTED }));
-    const handleCreateTransactionWithNonProductAccountSlot = makeNotImplementedSlot('host_create_transaction_with_non_product_account', () => new CreateTransactionErr.Unknown({ reason: NOT_IMPLEMENTED }));
+    const handleCreateTransactionWithLegacyAccountSlot = makeNotImplementedSlot('host_create_transaction_with_legacy_account', () => new CreateTransactionErr.Unknown({ reason: NOT_IMPLEMENTED }));
     const handleFeatureSupportedSlot = makeNotImplementedSlot('host_feature_supported', () => new GenericError({ reason: NOT_IMPLEMENTED }));
     const handleDevicePermissionSlot = makeNotImplementedSlot('host_device_permission', () => new GenericError({ reason: NOT_IMPLEMENTED }));
     const handleRemotePermissionSlot = makeNotImplementedSlot('remote_permission', () => new GenericError({ reason: NOT_IMPLEMENTED }));
@@ -122,9 +152,9 @@ export function createContainer(provider) {
     const handleChatCreateRoomSlot = makeNotImplementedSlot('host_chat_create_room', () => new ChatRoomRegistrationErr.Unknown({ reason: NOT_IMPLEMENTED }));
     const handleChatBotRegistrationSlot = makeNotImplementedSlot('host_chat_register_bot', () => new ChatBotRegistrationErr.Unknown({ reason: NOT_IMPLEMENTED }));
     const handleChatPostMessageSlot = makeNotImplementedSlot('host_chat_post_message', () => new ChatMessagePostingErr.Unknown({ reason: NOT_IMPLEMENTED }));
-    const handleStatementStoreSubmitSlot = makeNotImplementedSlot('remote_statement_store_submit', () => new GenericError({ reason: NOT_IMPLEMENTED }));
+    const handleStatementStoreSubmitSlot = makePermissionGatedRequestSlot('remote_statement_store_submit', 'StatementSubmit', () => new GenericError({ reason: NOT_IMPLEMENTED }));
     const handleStatementStoreCreateProofSlot = makeNotImplementedSlot('remote_statement_store_create_proof', () => new StatementProofErr.Unknown({ reason: NOT_IMPLEMENTED }));
-    const handlePreimageSubmitSlot = makeNotImplementedSlot('remote_preimage_submit', () => new PreimageSubmitErr.Unknown({ reason: NOT_IMPLEMENTED }));
+    const handlePreimageSubmitSlot = makePermissionGatedRequestSlot('remote_preimage_submit', 'PreimageSubmit', () => new PreimageSubmitErr.Unknown({ reason: NOT_IMPLEMENTED }));
     // payment request slots
     const handlePaymentTopUpSlot = makeNotImplementedSlot('host_payment_top_up', () => new PaymentTopUpErr.Unknown({ reason: NOT_IMPLEMENTED }));
     const handlePaymentRequestSlot = makeNotImplementedSlot('host_payment_request', () => new PaymentRequestErr.Unknown({ reason: NOT_IMPLEMENTED }));
@@ -169,6 +199,12 @@ export function createContainer(provider) {
         handleThemeSubscribe(handler) {
             return handleV1Subscription(handleThemeSubscribeSlot, handler);
         },
+        handleAccountGetRoot(handler) {
+            return handleV1Request(handleAccountGetRootSlot, () => new RequestCredentialsErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
+        },
+        handleRequestLogin(handler) {
+            return handleV1Request(handleRequestLoginSlot, () => new LoginErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
+        },
         handleAccountConnectionStatusSubscribe(handler) {
             return handleV1Subscription(handleAccountConnectionStatusSubscribeSlot, handler);
         },
@@ -181,14 +217,14 @@ export function createContainer(provider) {
         handleAccountCreateProof(handler) {
             return handleV1Request(handleAccountCreateProofSlot, () => new CreateProofErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
-        handleGetNonProductAccounts(handler) {
-            return handleV1Request(handleGetNonProductAccountsSlot, () => new RequestCredentialsErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
+        handleGetLegacyAccounts(handler) {
+            return handleV1Request(handleGetLegacyAccountsSlot, () => new RequestCredentialsErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleCreateTransaction(handler) {
             return handleV1Request(handleCreateTransactionSlot, () => new CreateTransactionErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
-        handleCreateTransactionWithNonProductAccount(handler) {
-            return handleV1Request(handleCreateTransactionWithNonProductAccountSlot, () => new CreateTransactionErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
+        handleCreateTransactionWithLegacyAccount(handler) {
+            return handleV1Request(handleCreateTransactionWithLegacyAccountSlot, () => new CreateTransactionErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleSignRaw(handler) {
             return handleV1Request(handleSignRawSlot, () => new SigningErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
@@ -196,11 +232,11 @@ export function createContainer(provider) {
         handleSignPayload(handler) {
             return handleV1Request(handleSignPayloadSlot, () => new SigningErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
-        handleSignRawWithNonProductAccount(handler) {
-            return handleV1Request(handleSignRawWithNonProductAccountSlot, () => new SigningErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
+        handleSignRawWithLegacyAccount(handler) {
+            return handleV1Request(handleSignRawWithLegacyAccountSlot, () => new SigningErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
-        handleSignPayloadWithNonProductAccount(handler) {
-            return handleV1Request(handleSignPayloadWithNonProductAccountSlot, () => new SigningErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
+        handleSignPayloadWithLegacyAccount(handler) {
+            return handleV1Request(handleSignPayloadWithLegacyAccountSlot, () => new SigningErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleChatCreateRoom(handler) {
             return handleV1Request(handleChatCreateRoomSlot, () => new ChatRoomRegistrationErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
@@ -489,7 +525,7 @@ export function createContainer(provider) {
                 }
                 const { genesisHash, transaction } = message.value;
                 try {
-                    const permissionResponse = await handleRemotePermissionSlot.call(enumValue('v1', enumValue('TransactionSubmit', undefined)));
+                    const permissionResponse = await handleRemotePermissionSlot.call(enumValue('v1', [enumValue('ChainSubmit', undefined)]));
                     const permissionGranted = isEnumVariant(permissionResponse, 'v1') &&
                         permissionResponse.value.success === true &&
                         permissionResponse.value.value === true;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { createWebviewProvider } from './createWebviewProvider.js';
 export { createIframeProvider } from './createIframeProvider.js';
 export { createContainer } from './createContainer.js';
-export type { Container } from './types.js';
+export type { Container, ContainerHandlerOf } from './types.js';
 export { deriveProductEntropy } from './deriveEntropy.js';
 export { createRateLimiter } from './rateLimiter.js';
 export type { CreateRateLimiterConfig, RateLimiter, RateLimiterConfig, RateLimiterStrategy } from './rateLimiter.js';

package/dist/rateLimiter.d.ts

@@ -1,4 +1,3 @@
-export declare const RATE_LIMITED_MESSAGE = "Request rate limited";
 export type RateLimiterConfig = {
     maxRequestsPerInterval: number;
     intervalMs: number;

package/dist/rateLimiter.js

@@ -1,5 +1,5 @@
 import { GenericError } from '@novasamatech/host-api';
-export const RATE_LIMITED_MESSAGE = 'Request rate limited';
+const RATE_LIMITED_MESSAGE = 'Request rate limited';
 function createQueueStrategy(config) {
     const state = {
         remainingTokens: config.maxRequestsPerInterval,

package/dist/types.d.ts

@@ -1,8 +1,8 @@
 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';
+import type { JsonRpcProvider } from 'polkadot-api';
 type SuccessResponse<T> = T extends {
     success: true;
     value: infer U;
@@ -51,6 +51,7 @@ export type ContainerRequestHandler<V extends string, T extends VersionedProtoco
 type InferRequestHandler<V extends string, T extends VersionedProtocolRequest> = (callback: ContainerRequestHandler<V, T>) => VoidFunction;
 type InferSubscribeHandler<V extends string, T extends VersionedProtocolSubscription> = (callback: (params: WithVersion<V, CodecValue<T['start']>>, send: (payload: WithVersion<V, CodecValue<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 ContainerHandlerOf<T extends (...args: any[]) => any> = Parameters<T>[0];
 export type Container = {
     handleFeatureSupported: InferHandler<'v1', HostApiProtocol['host_feature_supported']>;
     handleDevicePermission: InferHandler<'v1', HostApiProtocol['host_device_permission']>;
@@ -61,18 +62,20 @@ export type Container = {
     handleLocalStorageRead: InferHandler<'v1', HostApiProtocol['host_local_storage_read']>;
     handleLocalStorageWrite: InferHandler<'v1', HostApiProtocol['host_local_storage_write']>;
     handleLocalStorageClear: InferHandler<'v1', HostApiProtocol['host_local_storage_clear']>;
+    handleAccountGetRoot: InferHandler<'v1', HostApiProtocol['host_account_get_root']>;
+    handleRequestLogin: InferHandler<'v1', HostApiProtocol['host_request_login']>;
     handleAccountConnectionStatusSubscribe: InferHandler<'v1', HostApiProtocol['host_account_connection_status_subscribe']>;
     handleThemeSubscribe: InferHandler<'v1', HostApiProtocol['host_theme_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']>;
+    handleGetLegacyAccounts: InferHandler<'v1', HostApiProtocol['host_get_legacy_accounts']>;
     handleCreateTransaction: InferHandler<'v1', HostApiProtocol['host_create_transaction']>;
-    handleCreateTransactionWithNonProductAccount: InferHandler<'v1', HostApiProtocol['host_create_transaction_with_non_product_account']>;
+    handleCreateTransactionWithLegacyAccount: InferHandler<'v1', HostApiProtocol['host_create_transaction_with_legacy_account']>;
     handleSignRaw: InferHandler<'v1', HostApiProtocol['host_sign_raw']>;
     handleSignPayload: InferHandler<'v1', HostApiProtocol['host_sign_payload']>;
-    handleSignRawWithNonProductAccount: InferHandler<'v1', HostApiProtocol['host_sign_raw_with_non_product_account']>;
-    handleSignPayloadWithNonProductAccount: InferHandler<'v1', HostApiProtocol['host_sign_payload_with_non_product_account']>;
+    handleSignRawWithLegacyAccount: InferHandler<'v1', HostApiProtocol['host_sign_raw_with_legacy_account']>;
+    handleSignPayloadWithLegacyAccount: InferHandler<'v1', HostApiProtocol['host_sign_payload_with_legacy_account']>;
     handleChatCreateRoom: InferHandler<'v1', HostApiProtocol['host_chat_create_room']>;
     handleChatBotRegistration: InferHandler<'v1', HostApiProtocol['host_chat_register_bot']>;
     handleChatListSubscribe: InferHandler<'v1', HostApiProtocol['host_chat_list_subscribe']>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-container",
   "type": "module",
-  "version": "0.7.0-0",
+  "version": "0.7.0-1",
   "description": "Host container for hosting and managing products within the Polkadot ecosystem.",
   "license": "Apache-2.0",
   "repository": {
@@ -25,14 +25,13 @@
     "README.md"
   ],
   "dependencies": {
-    "@noble/hashes": "2.0.1",
-    "@polkadot-api/utils": "^0.2.0",
-    "@polkadot-api/json-rpc-provider": "^0.0.4",
-    "@novasamatech/host-api": "0.7.0-0",
-    "nanoid": "5.1.7"
+    "@noble/hashes": "2.2.0",
+    "polkadot-api": ">=2",
+    "@novasamatech/host-api": "0.7.0-1",
+    "nanoid": "5.1.9"
   },
   "devDependencies": {
-    "electron": "^41.1.0"
+    "electron": "^41.2.0"
   },
   "publishConfig": {
     "access": "public"