@novasamatech/host-container 0.7.5 → 0.7.7

package/dist/createContainer.js

@@ -1,4 +1,4 @@
-import { ChatBotRegistrationErr, ChatMessagePostingErr, ChatRoomRegistrationErr, CreateProofErr, CreateTransactionErr, DeriveEntropyErr, DevicePermission, GenericError, GetUserIdErr, LoginErr, NavigateToErr, PaymentBalanceErr, PaymentRequestErr, PaymentStatusErr, PaymentTopUpErr, PreimageSubmitErr, RemotePermission, RequestCredentialsErr, SigningErr, StatementProofErr, StorageErr, createTransport, enumValue, isEnumVariant, resultErr, resultOk, } from '@novasamatech/host-api';
+import { ChatBotRegistrationErr, ChatMessagePostingErr, ChatRoomRegistrationErr, CreateProofErr, CreateTransactionErr, DeriveEntropyErr, DevicePermission, GenericError, GetUserIdErr, LoginErr, NavigateToErr, PaymentBalanceErr, PaymentRequestErr, PaymentStatusErr, PaymentTopUpErr, PreimageSubmitErr, RemotePermission, RequestCredentialsErr, ResourceAllocationErr, 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';
@@ -183,10 +183,13 @@ export function createContainer(provider) {
     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 handleStatementStoreCreateProofAuthorizedSlot = makeNotImplementedSlot('remote_statement_store_create_proof_authorized', () => 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 }));
+    // resource allocation slot
+    const handleRequestResourceAllocationSlot = makeNotImplementedSlot('host_request_resource_allocation', () => new ResourceAllocationErr.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', () => enumValue('v1', undefined));
@@ -296,6 +299,9 @@ export function createContainer(provider) {
         handleStatementStoreCreateProof(handler) {
             return handleV1Request(handleStatementStoreCreateProofSlot, () => new StatementProofErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
+        handleStatementStoreCreateProofAuthorized(handler) {
+            return handleV1Request(handleStatementStoreCreateProofAuthorizedSlot, () => new StatementProofErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
+        },
         handleStatementStoreSubmit(handler) {
             return handleV1Request(handleStatementStoreSubmitSlot, () => new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
@@ -317,6 +323,9 @@ export function createContainer(provider) {
         handlePaymentStatusSubscribe(handler) {
             return handleV1Subscription(handlePaymentStatusSubscribeSlot, handler);
         },
+        handleRequestResourceAllocation(handler) {
+            return handleV1Request(handleRequestResourceAllocationSlot, () => new ResourceAllocationErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
+        },
         // chain interaction
         handleChainConnection(factory) {
             init();
@@ -544,26 +553,27 @@ export function createContainer(provider) {
                     return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
                 }
                 const { genesisHash, transaction } = message.value;
+                const permissionResponse = await handleRemotePermissionSlot.call(enumValue('v1', enumValue('ChainSubmit', undefined)));
+                const permissionGranted = isEnumVariant(permissionResponse, 'v1') &&
+                    permissionResponse.value.success === true &&
+                    permissionResponse.value.value === true;
+                if (!permissionGranted) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: 'Permission denied' })));
+                }
+                const entry = manager.getOrCreateChain(genesisHash);
+                if (!entry) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: 'Chain not supported' })));
+                }
                 try {
-                    const permissionResponse = await handleRemotePermissionSlot.call(enumValue('v1', enumValue('ChainSubmit', undefined)));
-                    const permissionGranted = isEnumVariant(permissionResponse, 'v1') &&
-                        permissionResponse.value.success === true &&
-                        permissionResponse.value.value === true;
-                    if (!permissionGranted) {
-                        return enumValue('v1', resultErr(new GenericError({ reason: 'Permission denied' })));
-                    }
-                    const entry = manager.getOrCreateChain(genesisHash);
-                    if (!entry) {
-                        return enumValue('v1', resultErr(new GenericError({ reason: 'Chain not supported' })));
-                    }
                     const result = await manager.sendRequest(genesisHash, 'transaction_v1_broadcast', [transaction]);
-                    manager.releaseChain(genesisHash);
                     return enumValue('v1', resultOk(result ?? null));
                 }
                 catch (e) {
-                    manager.releaseChain(genesisHash);
                     return enumValue('v1', resultErr(new GenericError({ reason: String(e) })));
                 }
+                finally {
+                    manager.releaseChain(genesisHash);
+                }
             }));
             // Transaction stop
             cleanups.push(transport.handleRequest('remote_chain_transaction_stop', async (message) => {

package/dist/createWebviewProvider.js

@@ -25,14 +25,17 @@ export function createWebviewProvider({ webview, logger, openDevTools }) {
             const portInitMessage = `HOST_API_PORT_INIT_${nanoid(12)}`;
             await webview
                 .executeJavaScript(`
-            window.addEventListener('message', e => {
-              if (e.data === '${portInitMessage}') {
+            (function() {
+              function handler(e) {
+                if (e.data !== '${portInitMessage}') return;
+                window.removeEventListener('message', handler);
                 const port = e.ports[0];
                 if (port) {
                   window['${WEBVIEW_HOST_PORT_NAME}'] = port;
                 }
               }
-            });
+              window.addEventListener('message', handler);
+            })();
          `)
                 .catch(reject);
             // @ts-expect-error contentWindow is undefined somehow

package/dist/types.d.ts

@@ -88,6 +88,7 @@ export type Container = {
     }, callback: (node: CodecType<typeof CustomRendererNode>) => void): Subscription;
     handleStatementStoreSubscribe: InferHandler<'v1', HostApiProtocol['remote_statement_store_subscribe']>;
     handleStatementStoreCreateProof: InferHandler<'v1', HostApiProtocol['remote_statement_store_create_proof']>;
+    handleStatementStoreCreateProofAuthorized: InferHandler<'v1', HostApiProtocol['remote_statement_store_create_proof_authorized']>;
     handleStatementStoreSubmit: InferHandler<'v1', HostApiProtocol['remote_statement_store_submit']>;
     handlePreimageLookupSubscribe: InferHandler<'v1', HostApiProtocol['remote_preimage_lookup_subscribe']>;
     handlePreimageSubmit: InferHandler<'v1', HostApiProtocol['remote_preimage_submit']>;
@@ -95,6 +96,7 @@ export type Container = {
     handlePaymentTopUp: InferHandler<'v1', HostApiProtocol['host_payment_top_up']>;
     handlePaymentRequest: InferHandler<'v1', HostApiProtocol['host_payment_request']>;
     handlePaymentStatusSubscribe: InferHandler<'v1', HostApiProtocol['host_payment_status_subscribe']>;
+    handleRequestResourceAllocation: InferHandler<'v1', HostApiProtocol['host_request_resource_allocation']>;
     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.7.5",
+  "version": "0.7.7",
   "description": "Host container for hosting and managing products within the Polkadot ecosystem.",
   "license": "Apache-2.0",
   "repository": {
@@ -28,7 +28,7 @@
     "@noble/hashes": "2.2.0",
     "polkadot-api": ">=2",
     "@polkadot-api/substrate-client": "^0.7.0",
-    "@novasamatech/host-api": "0.7.5",
+    "@novasamatech/host-api": "0.7.7",
     "nanoid": "5.1.9",
     "neverthrow": "^8.2.0"
   },