@novasamatech/host-container 0.6.18 → 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);
+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;
+      }
+    }
   }
-  if (request.tag === 'TransactionSubmit') {
-    return ok(true);
-  }
-  return ok(false);
+  return ok(true);
 });
 ```
 
@@ -102,6 +136,15 @@ container.handleNavigateTo(async (url, { ok, err }) => {
 });
 ```
 
+### handleDeriveEntropy
+
+```ts
+container.handleDeriveEntropy(async (key, { ok, err }) => {
+  const entropy = await deriveEntropy(key);
+  return ok(entropy);
+});
+```
+
 ### handleLocalStorageRead
 
 ```ts
@@ -143,6 +186,55 @@ container.handleAccountConnectionStatusSubscribe((_, send, interrupt) => {
 });
 ```
 
+### handleThemeSubscribe
+
+```ts
+container.handleThemeSubscribe((_, send, interrupt) => {
+  const listener = (theme: 'light' | 'dark') => send(theme);
+  themeService.on('change', listener);
+  send(themeService.getCurrentTheme());
+  return () => themeService.off('change', listener);
+});
+```
+
+### 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
@@ -180,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);
 });
 ```
@@ -202,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' });
@@ -303,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);
 });
 ```
 
@@ -359,6 +452,69 @@ container.handlePreimageSubmit(async (preimage, { ok, err }) => {
 });
 ```
 
+### handlePaymentBalanceSubscribe
+
+Called when a product subscribes to balance updates. Host should prompt for user consent on the first call; interrupt the subscription to communicate denial.
+
+```ts
+container.handlePaymentBalanceSubscribe((_params, send, interrupt) => {
+  const unsubscribe = balanceService.subscribe(balance => {
+    send({ available: balance.available, pending: balance.pending });
+  });
+
+  return () => unsubscribe();
+});
+```
+
+### handlePaymentTopUp
+
+Called when a product requests a balance top-up from a product-controlled source. Does not require user consent.
+
+```ts
+container.handlePaymentTopUp(async ({ amount, source }, { ok, err }) => {
+  if (source.tag === 'ProductAccount') {
+    const [dotNsIdentifier, derivationIndex] = source.value;
+    await transferFromProductAccount(dotNsIdentifier, derivationIndex, amount);
+    return ok(undefined);
+  }
+  if (source.tag === 'PrivateKey') {
+    await transferFromPrivateKey(source.value, amount);
+    return ok(undefined);
+  }
+  return err(new PaymentTopUpErr.InvalidSource());
+});
+```
+
+### handlePaymentRequest
+
+Called when a product requests a payment from the user's balance. Host MUST show a confirmation UI. Returns a receipt immediately; settlement is asynchronous.
+
+```ts
+container.handlePaymentRequest(async ({ amount, destination }, { ok, err }) => {
+  const approved = await showPaymentConfirmation({ amount, destination });
+  if (!approved) return err(new PaymentRequestErr.Denied());
+
+  const paymentId = await paymentService.submit(amount, destination);
+  return ok({ id: paymentId });
+});
+```
+
+### handlePaymentStatusSubscribe
+
+Called when a product subscribes to the status of a previously requested payment.
+
+```ts
+container.handlePaymentStatusSubscribe((paymentId, send, interrupt) => {
+  const unsubscribe = paymentService.trackStatus(paymentId, status => {
+    if (status === 'processing') send({ tag: 'Processing', value: undefined });
+    if (status === 'completed') send({ tag: 'Completed', value: undefined });
+    if (status === 'failed') send({ tag: 'Failed', value: 'settlement failed' });
+  });
+
+  return () => unsubscribe();
+});
+```
+
 ### handleChainConnection
 
 ```ts
@@ -374,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,9 +1,12 @@
-import { ChatBotRegistrationErr, ChatMessagePostingErr, ChatRoomRegistrationErr, CreateProofErr, CreateTransactionErr, GenericError, NavigateToErr, 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';
 const NOT_IMPLEMENTED = 'Not implemented';
 function guardVersion(value, tag, error) {
+    if (!value) {
+        return err(error);
+    }
     if (isEnumVariant(value, tag)) {
         return ok(value.value);
     }
@@ -51,393 +54,204 @@ export function createContainer(provider) {
             };
         };
     }
+    function makeNotImplementedSlot(method, makeError) {
+        // Cast needed: async () returns a fixed v1 error shape that TypeScript can't verify
+        // matches the generic Method's response type without evaluating template literal types.
+        const handler = async () => enumValue('v1', resultErr(makeError()));
+        return makeRequestSlot(method, handler);
+    }
+    function makeInterruptSlot(method) {
+        // Cast needed: the default handler ignores typed params/send which TypeScript can't verify
+        // matches the generic Method's subscription type without evaluating template literal types.
+        const defaultHandler = ((_params, _send, interrupt) => {
+            queueMicrotask(interrupt);
+            return () => {
+                /* nothing to clean up */
+            };
+        });
+        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';
+        return slot.update(async (params) => {
+            const error = makeError();
+            return guardVersion(params, version, error)
+                .asyncMap(async (p) => await handler(p, { ok: (okAsync), err: (errAsync) }))
+                .andThen(r => r.map(v => enumValue(version, resultOk(v))))
+                .orElse(r => ok(enumValue(version, resultErr(r))))
+                .unwrapOr(enumValue(version, resultErr(error)));
+        });
+    }
+    function handleV1Subscription(slot, handler) {
+        init();
+        const version = 'v1';
+        const slotHandler = ((params, send, interrupt) => {
+            return guardVersion(params, version, null)
+                .map(p => handler(p, ((payload) => send(enumValue(version, payload))), interrupt))
+                .orTee(interrupt)
+                .unwrapOr(() => {
+                /* empty */
+            });
+        });
+        return slot(slotHandler);
+    }
     // account slots
-    const handleAccountGetSlot = makeRequestSlot('host_account_get', async () => {
-        const error = new RequestCredentialsErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleAccountGetAliasSlot = makeRequestSlot('host_account_get_alias', async () => {
-        const error = new RequestCredentialsErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleGetNonProductAccountsSlot = makeRequestSlot('host_get_non_product_accounts', async () => {
-        const error = new RequestCredentialsErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleAccountCreateProofSlot = makeRequestSlot('host_account_create_proof', async () => {
-        const error = new CreateProofErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
+    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 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 }));
     // storage slots
-    const handleLocalStorageReadSlot = makeRequestSlot('host_local_storage_read', async () => {
-        const error = new StorageErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleLocalStorageWriteSlot = makeRequestSlot('host_local_storage_write', async () => {
-        const error = new StorageErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleLocalStorageClearSlot = makeRequestSlot('host_local_storage_clear', async () => {
-        const error = new StorageErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
+    const handleLocalStorageReadSlot = makeNotImplementedSlot('host_local_storage_read', () => new StorageErr.Unknown({ reason: NOT_IMPLEMENTED }));
+    const handleLocalStorageWriteSlot = makeNotImplementedSlot('host_local_storage_write', () => new StorageErr.Unknown({ reason: NOT_IMPLEMENTED }));
+    const handleLocalStorageClearSlot = makeNotImplementedSlot('host_local_storage_clear', () => new StorageErr.Unknown({ reason: NOT_IMPLEMENTED }));
     // signing slots
-    const handleSignRawSlot = makeRequestSlot('host_sign_raw', async () => {
-        const error = new SigningErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleSignPayloadSlot = makeRequestSlot('host_sign_payload', async () => {
-        const error = new SigningErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleCreateTransactionSlot = makeRequestSlot('host_create_transaction', async () => {
-        const error = new CreateTransactionErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleCreateTransactionWithNonProductAccountSlot = makeRequestSlot('host_create_transaction_with_non_product_account', async () => {
-        const error = new CreateTransactionErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleFeatureSupportedSlot = makeRequestSlot('host_feature_supported', async () => {
-        const error = new GenericError({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleDevicePermissionSlot = makeRequestSlot('host_device_permission', async () => {
-        const error = new GenericError({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleRemotePermissionSlot = makeRequestSlot('remote_permission', async () => {
-        const error = new GenericError({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handlePushNotificationSlot = makeRequestSlot('host_push_notification', async () => {
-        const error = new GenericError({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleNavigateToSlot = makeRequestSlot('host_navigate_to', async () => {
-        const error = new NavigateToErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleChatCreateRoomSlot = makeRequestSlot('host_chat_create_room', async () => {
-        const error = new ChatRoomRegistrationErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleChatBotRegistrationSlot = makeRequestSlot('host_chat_register_bot', async () => {
-        const error = new ChatBotRegistrationErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleChatPostMessageSlot = makeRequestSlot('host_chat_post_message', async () => {
-        const error = new ChatMessagePostingErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleStatementStoreSubmitSlot = makeRequestSlot('remote_statement_store_submit', async () => {
-        const error = new GenericError({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handleStatementStoreCreateProofSlot = makeRequestSlot('remote_statement_store_create_proof', async () => {
-        const error = new StatementProofErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
-    const handlePreimageSubmitSlot = makeRequestSlot('remote_preimage_submit', async () => {
-        const error = new PreimageSubmitErr.Unknown({ reason: NOT_IMPLEMENTED });
-        return enumValue('v1', resultErr(error));
-    });
+    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 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 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 }));
+    const handlePushNotificationSlot = makeNotImplementedSlot('host_push_notification', () => new GenericError({ reason: NOT_IMPLEMENTED }));
+    const handleNavigateToSlot = makeNotImplementedSlot('host_navigate_to', () => new NavigateToErr.Unknown({ reason: NOT_IMPLEMENTED }));
+    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 = 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 = 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 }));
     // subscription slots — default interrupts on next microtask so that
     // the caller has a chance to register an onInterrupt listener first
-    const handleAccountConnectionStatusSubscribeSlot = makeSubscriptionSlot('host_account_connection_status_subscribe', (_params, _send, interrupt) => {
-        queueMicrotask(interrupt);
-        return () => {
-            /* nothing to clean up */
-        };
-    });
-    const handleChatListSubscribeSlot = makeSubscriptionSlot('host_chat_list_subscribe', (_params, _send, interrupt) => {
-        queueMicrotask(interrupt);
-        return () => {
-            /* nothing to clean up */
-        };
-    });
-    const handleChatActionSubscribeSlot = makeSubscriptionSlot('host_chat_action_subscribe', (_params, _send, interrupt) => {
-        queueMicrotask(interrupt);
-        return () => {
-            /* nothing to clean up */
-        };
-    });
-    const handleStatementStoreSubscribeSlot = makeSubscriptionSlot('remote_statement_store_subscribe', (_params, _send, interrupt) => {
-        queueMicrotask(interrupt);
-        return () => {
-            /* nothing to clean up */
-        };
-    });
-    const handlePreimageLookupSubscribeSlot = makeSubscriptionSlot('remote_preimage_lookup_subscribe', (_params, _send, interrupt) => {
-        queueMicrotask(interrupt);
-        return () => {
-            /* nothing to clean up */
-        };
-    });
+    const handleThemeSubscribeSlot = makeInterruptSlot('host_theme_subscribe');
+    const handleAccountConnectionStatusSubscribeSlot = makeInterruptSlot('host_account_connection_status_subscribe');
+    const handleChatListSubscribeSlot = makeInterruptSlot('host_chat_list_subscribe');
+    const handleChatActionSubscribeSlot = makeInterruptSlot('host_chat_action_subscribe');
+    const handleStatementStoreSubscribeSlot = makeInterruptSlot('remote_statement_store_subscribe');
+    const handlePreimageLookupSubscribeSlot = makeInterruptSlot('remote_preimage_lookup_subscribe');
+    const handlePaymentBalanceSubscribeSlot = makeInterruptSlot('host_payment_balance_subscribe');
+    const handlePaymentStatusSubscribeSlot = makeInterruptSlot('host_payment_status_subscribe');
     return {
         handleFeatureSupported(handler) {
-            init();
-            return handleFeatureSupportedSlot.update(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)));
-            });
+            return handleV1Request(handleFeatureSupportedSlot, () => new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleDevicePermission(handler) {
-            init();
-            return handleDevicePermissionSlot.update(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)));
-            });
+            return handleV1Request(handleDevicePermissionSlot, () => new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handlePermission(handler) {
-            init();
-            return handleRemotePermissionSlot.update(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)));
-            });
+            return handleV1Request(handleRemotePermissionSlot, () => new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handlePushNotification(handler) {
-            init();
-            return handlePushNotificationSlot.update(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)));
-            });
+            return handleV1Request(handlePushNotificationSlot, () => new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleNavigateTo(handler) {
-            init();
-            return handleNavigateToSlot.update(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)));
-            });
+            return handleV1Request(handleNavigateToSlot, () => new NavigateToErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
+        },
+        handleDeriveEntropy(handler) {
+            return handleV1Request(handleDeriveEntropySlot, () => new DeriveEntropyErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleLocalStorageRead(handler) {
-            init();
-            return handleLocalStorageReadSlot.update(async (message) => {
-                const version = 'v1';
-                const error = new StorageErr.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)));
-            });
+            return handleV1Request(handleLocalStorageReadSlot, () => new StorageErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleLocalStorageWrite(handler) {
-            init();
-            return handleLocalStorageWriteSlot.update(async (message) => {
-                const version = 'v1';
-                const error = new StorageErr.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)));
-            });
+            return handleV1Request(handleLocalStorageWriteSlot, () => new StorageErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleLocalStorageClear(handler) {
-            init();
-            return handleLocalStorageClearSlot.update(async (message) => {
-                const version = 'v1';
-                const error = new StorageErr.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)));
-            });
+            return handleV1Request(handleLocalStorageClearSlot, () => new StorageErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
+        },
+        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) {
-            init();
-            return handleAccountConnectionStatusSubscribeSlot((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 */
-                });
-            });
+            return handleV1Subscription(handleAccountConnectionStatusSubscribeSlot, handler);
         },
         handleAccountGet(handler) {
-            init();
-            return handleAccountGetSlot.update(async (params) => {
-                const version = 'v1';
-                const error = new RequestCredentialsErr.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)));
-            });
+            return handleV1Request(handleAccountGetSlot, () => new RequestCredentialsErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleAccountGetAlias(handler) {
-            init();
-            return handleAccountGetAliasSlot.update(async (params) => {
-                const version = 'v1';
-                const error = new RequestCredentialsErr.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)));
-            });
+            return handleV1Request(handleAccountGetAliasSlot, () => new RequestCredentialsErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleAccountCreateProof(handler) {
-            init();
-            return handleAccountCreateProofSlot.update(async (params) => {
-                const version = 'v1';
-                const error = new CreateProofErr.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)));
-            });
+            return handleV1Request(handleAccountCreateProofSlot, () => new CreateProofErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
-        handleGetNonProductAccounts(handler) {
-            init();
-            return handleGetNonProductAccountsSlot.update(async (params) => {
-                const version = 'v1';
-                const error = new RequestCredentialsErr.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)));
-            });
+        handleGetLegacyAccounts(handler) {
+            return handleV1Request(handleGetLegacyAccountsSlot, () => new RequestCredentialsErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleCreateTransaction(handler) {
-            init();
-            return handleCreateTransactionSlot.update(async (params) => {
-                const version = 'v1';
-                const error = new CreateTransactionErr.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)));
-            });
+            return handleV1Request(handleCreateTransactionSlot, () => new CreateTransactionErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
-        handleCreateTransactionWithNonProductAccount(handler) {
-            init();
-            return handleCreateTransactionWithNonProductAccountSlot.update(async (params) => {
-                const version = 'v1';
-                const error = new CreateTransactionErr.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)));
-            });
+        handleCreateTransactionWithLegacyAccount(handler) {
+            return handleV1Request(handleCreateTransactionWithLegacyAccountSlot, () => new CreateTransactionErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleSignRaw(handler) {
-            init();
-            return handleSignRawSlot.update(async (params) => {
-                const version = 'v1';
-                const error = new SigningErr.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)));
-            });
+            return handleV1Request(handleSignRawSlot, () => new SigningErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleSignPayload(handler) {
-            init();
-            return handleSignPayloadSlot.update(async (params) => {
-                const version = 'v1';
-                const error = new SigningErr.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)));
-            });
+            return handleV1Request(handleSignPayloadSlot, () => new SigningErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
+        },
+        handleSignRawWithLegacyAccount(handler) {
+            return handleV1Request(handleSignRawWithLegacyAccountSlot, () => 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) {
-            init();
-            return handleChatCreateRoomSlot.update(async (params) => {
-                const version = 'v1';
-                const error = new ChatRoomRegistrationErr.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)));
-            });
+            return handleV1Request(handleChatCreateRoomSlot, () => new ChatRoomRegistrationErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleChatBotRegistration(handler) {
-            init();
-            return handleChatBotRegistrationSlot.update(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)));
-            });
+            return handleV1Request(handleChatBotRegistrationSlot, () => new ChatBotRegistrationErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleChatListSubscribe(handler) {
-            init();
-            return handleChatListSubscribeSlot((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 */
-                });
-            });
+            return handleV1Subscription(handleChatListSubscribeSlot, handler);
         },
         handleChatPostMessage(handler) {
-            init();
-            return handleChatPostMessageSlot.update(async (params) => {
-                const version = 'v1';
-                const error = new ChatMessagePostingErr.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)));
-            });
+            return handleV1Request(handleChatPostMessageSlot, () => new ChatMessagePostingErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleChatActionSubscribe(handler) {
-            init();
-            return handleChatActionSubscribeSlot((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 */
-                });
-            });
+            return handleV1Subscription(handleChatActionSubscribeSlot, handler);
         },
         renderChatCustomMessage({ messageId, messageType, payload }, callback) {
             init();
@@ -448,64 +262,31 @@ export function createContainer(provider) {
             });
         },
         handleStatementStoreSubscribe(handler) {
-            init();
-            return handleStatementStoreSubscribeSlot((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 */
-                });
-            });
+            return handleV1Subscription(handleStatementStoreSubscribeSlot, handler);
         },
         handleStatementStoreCreateProof(handler) {
-            init();
-            return handleStatementStoreCreateProofSlot.update(async (params) => {
-                const version = 'v1';
-                const error = new StatementProofErr.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)));
-            });
+            return handleV1Request(handleStatementStoreCreateProofSlot, () => new StatementProofErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleStatementStoreSubmit(handler) {
-            init();
-            return handleStatementStoreSubmitSlot.update(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 handleV1Request(handleStatementStoreSubmitSlot, () => new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handlePreimageLookupSubscribe(handler) {
-            init();
-            return handlePreimageLookupSubscribeSlot((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 */
-                });
-            });
+            return handleV1Subscription(handlePreimageLookupSubscribeSlot, handler);
         },
         handlePreimageSubmit(handler) {
-            init();
-            return handlePreimageSubmitSlot.update(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)));
-            });
+            return handleV1Request(handlePreimageSubmitSlot, () => new PreimageSubmitErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
+        },
+        handlePaymentBalanceSubscribe(handler) {
+            return handleV1Subscription(handlePaymentBalanceSubscribeSlot, handler);
+        },
+        handlePaymentTopUp(handler) {
+            return handleV1Request(handlePaymentTopUpSlot, () => new PaymentTopUpErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
+        },
+        handlePaymentRequest(handler) {
+            return handleV1Request(handlePaymentRequestSlot, () => new PaymentRequestErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
+        },
+        handlePaymentStatusSubscribe(handler) {
+            return handleV1Subscription(handlePaymentStatusSubscribeSlot, handler);
         },
         // chain interaction
         handleChainConnection(factory) {
@@ -744,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,6 +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/index.js

@@ -1,4 +1,5 @@
 export { createWebviewProvider } from './createWebviewProvider.js';
 export { createIframeProvider } from './createIframeProvider.js';
 export { createContainer } from './createContainer.js';
+export { deriveProductEntropy } from './deriveEntropy.js';
 export { createRateLimiter } 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,
@@ -25,7 +25,7 @@ function createQueueStrategy(config) {
             state.remainingTokens -= 1;
             try {
                 const result = task.execute();
-                if (result != null && typeof result.then === 'function') {
+                if (result instanceof Promise) {
                     result.then(task.resolve).catch(task.reject);
                 }
                 else {
@@ -51,7 +51,7 @@ function createQueueStrategy(config) {
             state.remainingTokens -= 1;
             try {
                 const result = execute();
-                if (result != null && typeof result.then === 'function') {
+                if (result instanceof Promise) {
                     return result;
                 }
                 return Promise.resolve(result);
@@ -103,7 +103,7 @@ function createDropStrategy(config) {
             state.remainingTokens -= 1;
             try {
                 const result = execute();
-                if (result != null && typeof result.then === 'function') {
+                if (result instanceof Promise) {
                     return result;
                 }
                 return Promise.resolve(result);

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;
@@ -11,23 +11,23 @@ type ErrorResponse<T> = T extends {
     success: false;
     value: infer U;
 } ? U : never;
-type Value<T extends Codec<any> | Codec<never>> = T extends Codec<any> ? CodecType<T> : unknown;
+export type CodecValue<T extends Codec<any> | Codec<never>> = T extends Codec<any> ? CodecType<T> : unknown;
 type OrPromise<T> = T | Promise<T>;
 type ExtractEnumValue<T> = T extends {
     tag: string;
     value: infer V;
 } ? V : never;
-type WithVersion<V extends string, T> = ExtractEnumValue<Extract<T, {
+export type WithVersion<V extends string, T> = ExtractEnumValue<Extract<T, {
     tag: V;
 }>>;
-type UnwrapSuccessResponse<V extends string, T> = T extends {
+export type UnwrapSuccessResponse<V extends string, T> = T extends {
     tag: infer Tag;
     value: infer Value;
 } ? WithVersion<V, {
     tag: Tag;
     value: SuccessResponse<Value>;
 }> : never;
-type UnwrapErrorResponse<V extends string, T> = T extends {
+export type UnwrapErrorResponse<V extends string, T> = T extends {
     tag: infer Tag;
     value: infer Value;
 } ? WithVersion<V, {
@@ -44,30 +44,38 @@ type UnwrapVersionedResult<V extends string, T> = T extends {
     tag: Tag;
     value: ErrorResponse<Value>;
 }>> : never;
-type InferRequestHandler<V extends string, T extends VersionedProtocolRequest> = (callback: (params: WithVersion<V, Value<T['request']>>, helpers: {
-    ok: typeof okAsync<UnwrapSuccessResponse<V, Value<T['response']>>>;
-    err: typeof errAsync<never, UnwrapErrorResponse<V, Value<T['response']>>>;
-}) => OrPromise<UnwrapVersionedResult<V, Value<T['response']>>>) => VoidFunction;
-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;
+export type ContainerRequestHandler<V extends string, T extends VersionedProtocolRequest> = (params: WithVersion<V, CodecValue<T['request']>>, helpers: {
+    ok: typeof okAsync<UnwrapSuccessResponse<V, CodecValue<T['response']>>>;
+    err: typeof errAsync<never, UnwrapErrorResponse<V, CodecValue<T['response']>>>;
+}) => OrPromise<UnwrapVersionedResult<V, CodecValue<T['response']>>>;
+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']>;
     handlePermission: InferHandler<'v1', HostApiProtocol['remote_permission']>;
     handlePushNotification: InferHandler<'v1', HostApiProtocol['host_push_notification']>;
     handleNavigateTo: InferHandler<'v1', HostApiProtocol['host_navigate_to']>;
+    handleDeriveEntropy: InferHandler<'v1', HostApiProtocol['host_derive_entropy']>;
     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']>;
+    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']>;
@@ -83,6 +91,10 @@ export type Container = {
     handleStatementStoreSubmit: InferHandler<'v1', HostApiProtocol['remote_statement_store_submit']>;
     handlePreimageLookupSubscribe: InferHandler<'v1', HostApiProtocol['remote_preimage_lookup_subscribe']>;
     handlePreimageSubmit: InferHandler<'v1', HostApiProtocol['remote_preimage_submit']>;
+    handlePaymentBalanceSubscribe: InferHandler<'v1', HostApiProtocol['host_payment_balance_subscribe']>;
+    handlePaymentTopUp: InferHandler<'v1', HostApiProtocol['host_payment_top_up']>;
+    handlePaymentRequest: InferHandler<'v1', HostApiProtocol['host_payment_request']>;
+    handlePaymentStatusSubscribe: InferHandler<'v1', HostApiProtocol['host_payment_status_subscribe']>;
     handleChainConnection: (factory: (genesisHash: HexString) => JsonRpcProvider | null) => VoidFunction;
     isReady(): Promise<boolean>;
     dispose(): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-container",
   "type": "module",
-  "version": "0.6.18",
+  "version": "0.7.0-1",
   "description": "Host container for hosting and managing products within the Polkadot ecosystem.",
   "license": "Apache-2.0",
   "repository": {
@@ -25,13 +25,13 @@
     "README.md"
   ],
   "dependencies": {
-    "@polkadot-api/utils": "^0.2.0",
-    "@polkadot-api/json-rpc-provider": "^0.0.4",
-    "@novasamatech/host-api": "0.6.18",
-    "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"