@novasamatech/host-container 0.7.1-0 → 0.7.1

package/README.md

@@ -74,9 +74,9 @@ container.handleDevicePermission(async (request, { ok, err }) => {
 
 ### handlePermission
 
-The `request` parameter is an **array** of `RemotePermission` items. Return `ok(true)` only when **all** permissions in the batch are granted.
+The `request` parameter is a single `RemotePermission` item. Return `ok(true)` when the permission is granted, `ok(false)` when denied.
 
-Each item has one of these shapes:
+The 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`
@@ -84,37 +84,19 @@ Each item has one of these shapes:
 - `{ 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;
-      }
-    }
+container.handlePermission(async (permission, { ok, err }) => {
+  switch (permission.tag) {
+    case 'Remote':
+      return ok(await checkDomainPermissions(permission.value));
+    case 'WebRTC':
+      return ok(await promptWebRTCPermission());
+    case 'ChainSubmit':
+      return ok(await promptChainSubmitPermission());
+    case 'PreimageSubmit':
+      return ok(await promptPreimageSubmitPermission());
+    case 'StatementSubmit':
+      return ok(await promptStatementSubmitPermission());
   }
-  return ok(true);
 });
 ```
 

package/dist/createContainer.js

@@ -1,4 +1,4 @@
-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 { ChatBotRegistrationErr, ChatMessagePostingErr, ChatRoomRegistrationErr, CreateProofErr, CreateTransactionErr, DeriveEntropyErr, GenericError, LoginErr, NavigateToErr, PaymentBalanceErr, PaymentRequestErr, PaymentStatusErr, 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';
@@ -60,23 +60,24 @@ export function createContainer(provider) {
         const handler = async () => enumValue('v1', resultErr(makeError()));
         return makeRequestSlot(method, handler);
     }
-    function makeInterruptSlot(method) {
+    function makeInterruptSlot(method, makeDefaultInterrupt) {
         // 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);
+            queueMicrotask(() => interrupt(makeDefaultInterrupt()));
             return () => {
                 /* nothing to clean up */
             };
         });
-        return makeSubscriptionSlot(method, defaultHandler);
+        const update = makeSubscriptionSlot(method, defaultHandler);
+        return { update, makeDefaultInterrupt };
     }
     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 permissionResponse = await handleRemotePermissionSlot.call(enumValue('v1', enumValue(permissionVariant, undefined)));
             const permissionGranted = isEnumVariant(permissionResponse, 'v1') &&
                 permissionResponse.value.success === true &&
                 permissionResponse.value.value === true;
@@ -116,13 +117,13 @@ export function createContainer(provider) {
         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)
+                .map(p => handler(p, ((payload) => send(enumValue(version, payload))), ((payload) => interrupt(enumValue(version, payload)))))
+                .orTee(() => interrupt(slot.makeDefaultInterrupt()))
                 .unwrapOr(() => {
                 /* empty */
             });
         });
-        return slot(slotHandler);
+        return slot.update(slotHandler);
     }
     // account slots
     const handleAccountGetRootSlot = makeNotImplementedSlot('host_account_get_root', () => new RequestCredentialsErr.Unknown({ reason: NOT_IMPLEMENTED }));
@@ -160,14 +161,14 @@ export function createContainer(provider) {
     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 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');
+    const handleThemeSubscribeSlot = makeInterruptSlot('host_theme_subscribe', () => enumValue('v1', undefined));
+    const handleAccountConnectionStatusSubscribeSlot = makeInterruptSlot('host_account_connection_status_subscribe', () => enumValue('v1', undefined));
+    const handleChatListSubscribeSlot = makeInterruptSlot('host_chat_list_subscribe', () => enumValue('v1', undefined));
+    const handleChatActionSubscribeSlot = makeInterruptSlot('host_chat_action_subscribe', () => enumValue('v1', undefined));
+    const handleStatementStoreSubscribeSlot = makeInterruptSlot('remote_statement_store_subscribe', () => enumValue('v1', undefined));
+    const handlePreimageLookupSubscribeSlot = makeInterruptSlot('remote_preimage_lookup_subscribe', () => enumValue('v1', undefined));
+    const handlePaymentBalanceSubscribeSlot = makeInterruptSlot('host_payment_balance_subscribe', () => enumValue('v1', new PaymentBalanceErr.Unknown({ reason: NOT_IMPLEMENTED })));
+    const handlePaymentStatusSubscribeSlot = makeInterruptSlot('host_payment_status_subscribe', () => enumValue('v1', new PaymentStatusErr.Unknown({ reason: NOT_IMPLEMENTED })));
     return {
         handleFeatureSupported(handler) {
             return handleV1Request(handleFeatureSupportedSlot, () => new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
@@ -296,7 +297,7 @@ export function createContainer(provider) {
             // Follow subscription
             cleanups.push(transport.handleSubscription('remote_chain_head_follow', (params, send, interrupt) => {
                 if (!isEnumVariant(params, 'v1')) {
-                    interrupt();
+                    interrupt(enumValue('v1', undefined));
                     return () => {
                         /* unsupported version */
                     };
@@ -304,7 +305,7 @@ export function createContainer(provider) {
                 const { genesisHash, withRuntime } = params.value;
                 const entry = manager.getOrCreateChain(genesisHash);
                 if (!entry) {
-                    interrupt();
+                    interrupt(enumValue('v1', undefined));
                     return () => {
                         /* no chain provider available */
                     };
@@ -525,7 +526,7 @@ export function createContainer(provider) {
                 }
                 const { genesisHash, transaction } = message.value;
                 try {
-                    const permissionResponse = await handleRemotePermissionSlot.call(enumValue('v1', [enumValue('ChainSubmit', 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/types.d.ts

@@ -49,7 +49,7 @@ export type ContainerRequestHandler<V extends string, T extends VersionedProtoco
     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 InferSubscribeHandler<V extends string, T extends VersionedProtocolSubscription> = (callback: (params: WithVersion<V, CodecValue<T['start']>>, send: (payload: WithVersion<V, CodecValue<T['receive']>>) => void, interrupt: (payload: WithVersion<V, CodecValue<T['interrupt']>>) => void) => 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 = {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-container",
   "type": "module",
-  "version": "0.7.1-0",
+  "version": "0.7.1",
   "description": "Host container for hosting and managing products within the Polkadot ecosystem.",
   "license": "Apache-2.0",
   "repository": {
@@ -27,7 +27,7 @@
   "dependencies": {
     "@noble/hashes": "2.2.0",
     "polkadot-api": ">=2",
-    "@novasamatech/host-api": "0.7.1-0",
+    "@novasamatech/host-api": "0.7.1",
     "nanoid": "5.1.9",
     "neverthrow": "^8.2.0"
   },