@novasamatech/host-container 0.6.16 → 0.7.0-0

package/README.md

@@ -102,6 +102,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 +152,17 @@ 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);
+});
+```
+
 ### handleAccountGet
 
 ```ts
@@ -359,6 +379,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

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, NavigateToErr, PaymentRequestErr, PaymentTopUpErr, PreimageSubmitErr, 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,168 @@ 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 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 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 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 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 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 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 = makeNotImplementedSlot('remote_statement_store_submit', () => 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 }));
+    // 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);
         },
         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)));
-            });
+            return handleV1Request(handleGetNonProductAccountsSlot, () => 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)));
-            });
+            return handleV1Request(handleCreateTransactionWithNonProductAccountSlot, () => 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);
+        },
+        handleSignRawWithNonProductAccount(handler) {
+            return handleV1Request(handleSignRawWithNonProductAccountSlot, () => new SigningErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
+        },
+        handleSignPayloadWithNonProductAccount(handler) {
+            return handleV1Request(handleSignPayloadWithNonProductAccountSlot, () => 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 +226,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) {

package/dist/index.d.ts

@@ -2,5 +2,6 @@ export { createWebviewProvider } from './createWebviewProvider.js';
 export { createIframeProvider } from './createIframeProvider.js';
 export { createContainer } from './createContainer.js';
 export type { Container } 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.js

@@ -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

@@ -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,11 +44,12 @@ 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 Container = {
     handleFeatureSupported: InferHandler<'v1', HostApiProtocol['host_feature_supported']>;
@@ -56,10 +57,12 @@ export type Container = {
     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']>;
     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']>;
@@ -68,6 +71,8 @@ export type Container = {
     handleCreateTransactionWithNonProductAccount: InferHandler<'v1', HostApiProtocol['host_create_transaction_with_non_product_account']>;
     handleSignRaw: InferHandler<'v1', HostApiProtocol['host_sign_raw']>;
     handleSignPayload: InferHandler<'v1', HostApiProtocol['host_sign_payload']>;
+    handleSignRawWithNonProductAccount: InferHandler<'v1', HostApiProtocol['host_sign_raw_with_non_product_account']>;
+    handleSignPayloadWithNonProductAccount: InferHandler<'v1', HostApiProtocol['host_sign_payload_with_non_product_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 +88,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.16",
+  "version": "0.7.0-0",
   "description": "Host container for hosting and managing products within the Polkadot ecosystem.",
   "license": "Apache-2.0",
   "repository": {
@@ -25,9 +25,10 @@
     "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.6.16",
+    "@novasamatech/host-api": "0.7.0-0",
     "nanoid": "5.1.7"
   },
   "devDependencies": {