@novasamatech/host-container 0.6.1 → 0.6.3

package/dist/chainConnectionManager.d.ts

@@ -0,0 +1,115 @@
+import type { HexString } from '@novasamatech/host-api';
+import type { JsonRpcProvider } from '@polkadot-api/json-rpc-provider';
+type PendingRequest = {
+    resolve: (result: unknown) => void;
+    reject: (error: unknown) => void;
+};
+type FollowSubscription = {
+    chainSubId: string;
+    eventListener: (event: unknown) => void;
+    pendingRequestId?: string;
+};
+type ChainEntry = {
+    connection: {
+        send: (msg: string) => void;
+        disconnect: () => void;
+    };
+    pendingRequests: Map<string, PendingRequest>;
+    followSubscriptions: Map<string, FollowSubscription>;
+    refCount: number;
+};
+export type ChainConnectionManager = ReturnType<typeof createChainConnectionManager>;
+export declare function createChainConnectionManager(factory: (genesisHash: HexString) => JsonRpcProvider | null): {
+    getOrCreateChain: (genesisHash: HexString) => ChainEntry | null;
+    sendRequest: (genesisHash: HexString, method: string, params: unknown[]) => Promise<unknown>;
+    startFollow: (genesisHash: HexString, withRuntime: boolean, onEvent: (event: unknown) => void) => {
+        followId: string;
+    };
+    stopFollow: (genesisHash: HexString, followId: string) => void;
+    getChainFollowSubId: (genesisHash: HexString) => string | null;
+    releaseChain: (genesisHash: HexString) => void;
+    dispose: () => void;
+    convertJsonRpcEventToTyped: (event: Record<string, unknown>) => {
+        tag: "Initialized";
+        value: {
+            readonly finalizedBlockHashes: HexString[];
+            readonly finalizedBlockRuntime: unknown;
+        };
+    } | {
+        tag: "NewBlock";
+        value: {
+            readonly blockHash: HexString;
+            readonly parentBlockHash: HexString;
+            readonly newRuntime: unknown;
+        };
+    } | {
+        tag: "BestBlockChanged";
+        value: {
+            readonly bestBlockHash: HexString;
+        };
+    } | {
+        tag: "Finalized";
+        value: {
+            readonly finalizedBlockHashes: HexString[];
+            readonly prunedBlockHashes: HexString[];
+        };
+    } | {
+        tag: "OperationBodyDone";
+        value: {
+            readonly operationId: string;
+            readonly value: HexString[];
+        };
+    } | {
+        tag: "OperationCallDone";
+        value: {
+            readonly operationId: string;
+            readonly output: HexString;
+        };
+    } | {
+        tag: "OperationStorageItems";
+        value: {
+            readonly operationId: string;
+            readonly items: {
+                key: HexString;
+                value: `0x${string}`;
+                hash: `0x${string}`;
+                closestDescendantMerkleValue: `0x${string}`;
+            }[];
+        };
+    } | {
+        tag: "OperationStorageDone";
+        value: {
+            readonly operationId: string;
+        };
+    } | {
+        tag: "OperationWaitingForContinue";
+        value: {
+            readonly operationId: string;
+        };
+    } | {
+        tag: "OperationInaccessible";
+        value: {
+            readonly operationId: string;
+        };
+    } | {
+        tag: "OperationError";
+        value: {
+            readonly operationId: string;
+            readonly error: string;
+        };
+    } | {
+        tag: "Stop";
+        value: undefined;
+    };
+    convertOperationStartedResult: (result: unknown) => {
+        tag: "Started";
+        value: {
+            readonly operationId: string;
+        };
+    } | {
+        tag: "LimitReached";
+        value: undefined;
+    };
+    convertStorageQueryTypeToJsonRpc: (type: string) => string;
+};
+export {};

package/dist/chainConnectionManager.js

@@ -0,0 +1,290 @@
+import { enumValue } from '@novasamatech/host-api';
+let instanceCounter = 0;
+export function createChainConnectionManager(factory) {
+    const chains = new Map();
+    const instanceId = instanceCounter++;
+    let nextId = 0;
+    function getNextId() {
+        return `ccm_${instanceId}_${nextId++}`;
+    }
+    function getOrCreateChain(genesisHash) {
+        const existing = chains.get(genesisHash);
+        if (existing) {
+            existing.refCount++;
+            return existing;
+        }
+        const provider = factory(genesisHash);
+        if (!provider)
+            return null;
+        const pendingRequests = new Map();
+        const followSubscriptions = new Map();
+        const entry = {
+            connection: null,
+            pendingRequests,
+            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));
+                if (pending) {
+                    pendingRequests.delete(String(parsed.id));
+                    if ('error' in parsed) {
+                        pending.reject(parsed.error);
+                    }
+                    else {
+                        pending.resolve(parsed.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;
+                    }
+                }
+            }
+        });
+        chains.set(genesisHash, entry);
+        return entry;
+    }
+    function sendRequest(genesisHash, method, params) {
+        const entry = chains.get(genesisHash);
+        if (!entry)
+            return Promise.reject(new Error(`No connection for chain ${genesisHash}`));
+        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 }));
+        });
+    }
+    function startFollow(genesisHash, withRuntime, onEvent) {
+        const entry = chains.get(genesisHash);
+        if (!entry)
+            throw new Error(`No connection for chain ${genesisHash}`);
+        const followId = getNextId();
+        const requestId = getNextId();
+        const follow = {
+            chainSubId: '', // will be set synchronously when response arrives
+            eventListener: onEvent,
+            pendingRequestId: requestId,
+        };
+        entry.followSubscriptions.set(followId, follow);
+        // Bypass sendRequest to avoid Promise microtask deferral.
+        // The response handler sets chainSubId synchronously, so when the next
+        // message (the notification) is processed, chainSubId is already set.
+        entry.pendingRequests.set(requestId, {
+            resolve: result => {
+                follow.chainSubId = result;
+                follow.pendingRequestId = undefined;
+            },
+            reject: () => {
+                follow.pendingRequestId = undefined;
+                entry.followSubscriptions.delete(followId);
+            },
+        });
+        entry.connection.send(JSON.stringify({ jsonrpc: '2.0', id: requestId, method: 'chainHead_v1_follow', params: [withRuntime] }));
+        return { followId };
+    }
+    function stopFollow(genesisHash, followId) {
+        const entry = chains.get(genesisHash);
+        if (!entry)
+            return;
+        const follow = entry.followSubscriptions.get(followId);
+        if (!follow)
+            return;
+        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] }));
+        }
+        else if (follow.pendingRequestId) {
+            // Follow response hasn't arrived yet — replace the pending resolve to send unfollow when it does
+            entry.pendingRequests.set(follow.pendingRequestId, {
+                resolve: result => {
+                    const chainSubId = result;
+                    if (chainSubId) {
+                        const unfollowId = getNextId();
+                        entry.connection.send(JSON.stringify({ jsonrpc: '2.0', id: unfollowId, method: 'chainHead_v1_unfollow', params: [chainSubId] }));
+                    }
+                },
+                reject: () => {
+                    /* follow already cleaned up */
+                },
+            });
+        }
+    }
+    function getChainFollowSubId(genesisHash) {
+        const entry = chains.get(genesisHash);
+        if (!entry)
+            return null;
+        // Return the first active follow subscription ID for this chain
+        for (const follow of entry.followSubscriptions.values()) {
+            if (follow.chainSubId)
+                return follow.chainSubId;
+        }
+        return null;
+    }
+    function releaseChain(genesisHash) {
+        const entry = chains.get(genesisHash);
+        if (!entry)
+            return;
+        entry.refCount--;
+        if (entry.refCount <= 0) {
+            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.followSubscriptions.clear();
+            entry.connection.disconnect();
+            chains.delete(genesisHash);
+        }
+    }
+    function dispose() {
+        for (const entry of chains.values()) {
+            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.followSubscriptions.clear();
+            entry.connection.disconnect();
+        }
+        chains.clear();
+    }
+    // === JSON RPC ↔ typed conversion helpers ===
+    function convertJsonRpcEventToTyped(event) {
+        const eventType = event.event;
+        switch (eventType) {
+            case 'initialized':
+                return enumValue('Initialized', {
+                    finalizedBlockHashes: event.finalizedBlockHashes,
+                    finalizedBlockRuntime: convertRuntime(event.finalizedBlockRuntime),
+                });
+            case 'newBlock':
+                return enumValue('NewBlock', {
+                    blockHash: event.blockHash,
+                    parentBlockHash: event.parentBlockHash,
+                    newRuntime: convertRuntime(event.newRuntime),
+                });
+            case 'bestBlockChanged':
+                return enumValue('BestBlockChanged', {
+                    bestBlockHash: event.bestBlockHash,
+                });
+            case 'finalized':
+                return enumValue('Finalized', {
+                    finalizedBlockHashes: event.finalizedBlockHashes,
+                    prunedBlockHashes: event.prunedBlockHashes,
+                });
+            case 'operationBodyDone':
+                return enumValue('OperationBodyDone', {
+                    operationId: event.operationId,
+                    value: event.value,
+                });
+            case 'operationCallDone':
+                return enumValue('OperationCallDone', {
+                    operationId: event.operationId,
+                    output: event.output,
+                });
+            case 'operationStorageItems':
+                return enumValue('OperationStorageItems', {
+                    operationId: event.operationId,
+                    items: event.items.map(item => ({
+                        key: item.key,
+                        value: item.value ?? null,
+                        hash: item.hash ?? null,
+                        closestDescendantMerkleValue: item.closestDescendantMerkleValue ?? null,
+                    })),
+                });
+            case 'operationStorageDone':
+                return enumValue('OperationStorageDone', {
+                    operationId: event.operationId,
+                });
+            case 'operationWaitingForContinue':
+                return enumValue('OperationWaitingForContinue', {
+                    operationId: event.operationId,
+                });
+            case 'operationInaccessible':
+                return enumValue('OperationInaccessible', {
+                    operationId: event.operationId,
+                });
+            case 'operationError':
+                return enumValue('OperationError', {
+                    operationId: event.operationId,
+                    error: event.error,
+                });
+            case 'stop':
+                return enumValue('Stop', undefined);
+            default:
+                return enumValue('Stop', undefined);
+        }
+    }
+    function convertRuntime(runtime) {
+        if (!runtime || typeof runtime !== 'object')
+            return undefined;
+        const rt = runtime;
+        if (rt.type === 'valid') {
+            const spec = rt.spec;
+            const apis = spec.apis;
+            return enumValue('Valid', {
+                specName: spec.specName,
+                implName: spec.implName,
+                specVersion: spec.specVersion,
+                implVersion: spec.implVersion,
+                transactionVersion: spec.transactionVersion,
+                apis: apis ? Object.entries(apis).map(([name, version]) => [name, version]) : [],
+            });
+        }
+        if (rt.type === 'invalid') {
+            return enumValue('Invalid', { error: rt.error });
+        }
+        return undefined;
+    }
+    function convertOperationStartedResult(result) {
+        if (typeof result === 'object' && result !== null) {
+            const r = result;
+            if (r.result === 'started') {
+                return enumValue('Started', { operationId: r.operationId });
+            }
+        }
+        return enumValue('LimitReached', undefined);
+    }
+    function convertStorageQueryTypeToJsonRpc(type) {
+        const map = {
+            Value: 'value',
+            Hash: 'hash',
+            ClosestDescendantMerkleValue: 'closestDescendantMerkleValue',
+            DescendantsValues: 'descendantsValues',
+            DescendantsHashes: 'descendantsHashes',
+        };
+        return map[type] ?? 'value';
+    }
+    return {
+        getOrCreateChain,
+        sendRequest,
+        startFollow,
+        stopFollow,
+        getChainFollowSubId,
+        releaseChain,
+        dispose,
+        convertJsonRpcEventToTyped,
+        convertOperationStartedResult,
+        convertStorageQueryTypeToJsonRpc,
+    };
+}

package/dist/createContainer.js

@@ -1,5 +1,6 @@
-import { ChatBotRegistrationErr, ChatMessagePostingErr, ChatRoomRegistrationErr, CreateProofErr, CreateTransactionErr, GenericError, NavigateToErr, PreimageSubmitErr, RequestCredentialsErr, SigningErr, StatementProofErr, StorageErr, assertEnumVariant, createTransport, enumValue, isEnumVariant, resultErr, resultOk, } from '@novasamatech/host-api';
+import { ChatBotRegistrationErr, ChatMessagePostingErr, ChatRoomRegistrationErr, CreateProofErr, CreateTransactionErr, GenericError, NavigateToErr, 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';
 function guardVersion(value, tag, error) {
     if (isEnumVariant(value, tag)) {
@@ -281,9 +282,9 @@ export function createContainer(provider) {
                 });
             });
         },
-        renderChatCustomMessage(messageType, payload, callback) {
+        renderChatCustomMessage({ messageId, messageType, payload }, callback) {
             init();
-            return transport.subscribe('product_chat_custom_message_render_subscribe', enumValue('v1', { messageType, payload }), value => {
+            return transport.subscribe('product_chat_custom_message_render_subscribe', enumValue('v1', { messageId, messageType, payload }), value => {
                 if (value.tag === 'v1') {
                     callback(value.value);
                 }
@@ -349,37 +350,288 @@ export function createContainer(provider) {
                     .unwrapOr(enumValue(version, resultErr(error)));
             });
         },
+        // chain interaction
         handleChainConnection(factory) {
             init();
-            return transport.handleSubscription('host_jsonrpc_message_subscribe', (params, send) => {
-                assertEnumVariant(params, 'v1', UNSUPPORTED_MESSAGE_FORMAT_ERROR);
-                const genesisHash = params.value;
-                const provider = factory(params.value);
-                if (provider === null) {
+            const manager = createChainConnectionManager(factory);
+            const cleanups = [];
+            // Follow subscription
+            cleanups.push(transport.handleSubscription('remote_chain_head_follow', (params, send, interrupt) => {
+                if (!isEnumVariant(params, 'v1')) {
+                    interrupt();
                     return () => {
-                        // empty subscription, we don't want to react to foreign chain subscription request
+                        /* unsupported version */
                     };
                 }
-                const connection = provider(message => send(enumValue('v1', message)));
-                const unsubscribeDestroy = transport.onDestroy(() => {
-                    unsubRequests();
-                    unsubscribeDestroy();
-                    connection.disconnect();
-                });
-                const unsubRequests = transport.handleRequest('host_jsonrpc_message_send', async (message) => {
-                    assertEnumVariant(message, 'v1', UNSUPPORTED_MESSAGE_FORMAT_ERROR);
-                    const [requestedGenesisHash, payload] = message.value;
-                    if (requestedGenesisHash === genesisHash) {
-                        connection.send(payload);
-                    }
-                    return enumValue('v1', resultOk(undefined));
+                const { genesisHash, withRuntime } = params.value;
+                const entry = manager.getOrCreateChain(genesisHash);
+                if (!entry) {
+                    interrupt();
+                    return () => {
+                        /* no chain provider available */
+                    };
+                }
+                const { followId } = manager.startFollow(genesisHash, withRuntime, (event) => {
+                    const typedEvent = manager.convertJsonRpcEventToTyped(event);
+                    send(enumValue('v1', typedEvent));
                 });
                 return () => {
-                    unsubRequests();
-                    unsubscribeDestroy();
-                    connection.disconnect();
+                    manager.stopFollow(genesisHash, followId);
+                    manager.releaseChain(genesisHash);
                 };
-            });
+            }));
+            // Header request
+            cleanups.push(transport.handleRequest('remote_chain_head_header', async (message) => {
+                if (!isEnumVariant(message, 'v1')) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
+                }
+                const { genesisHash, hash } = message.value;
+                const realSubId = manager.getChainFollowSubId(genesisHash);
+                if (!realSubId) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: 'No active follow for this chain' })));
+                }
+                try {
+                    const result = await manager.sendRequest(genesisHash, 'chainHead_v1_header', [realSubId, hash]);
+                    return enumValue('v1', resultOk(result));
+                }
+                catch (e) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: String(e) })));
+                }
+            }));
+            // Body request
+            cleanups.push(transport.handleRequest('remote_chain_head_body', async (message) => {
+                if (!isEnumVariant(message, 'v1')) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
+                }
+                const { genesisHash, hash } = message.value;
+                const realSubId = manager.getChainFollowSubId(genesisHash);
+                if (!realSubId) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: 'No active follow for this chain' })));
+                }
+                try {
+                    const result = await manager.sendRequest(genesisHash, 'chainHead_v1_body', [realSubId, hash]);
+                    return enumValue('v1', resultOk(manager.convertOperationStartedResult(result)));
+                }
+                catch (e) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: String(e) })));
+                }
+            }));
+            // Storage request
+            cleanups.push(transport.handleRequest('remote_chain_head_storage', async (message) => {
+                if (!isEnumVariant(message, 'v1')) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
+                }
+                const { genesisHash, hash, items, childTrie } = message.value;
+                const realSubId = manager.getChainFollowSubId(genesisHash);
+                if (!realSubId) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: 'No active follow for this chain' })));
+                }
+                const jsonRpcItems = items.map((item) => ({
+                    key: item.key,
+                    type: manager.convertStorageQueryTypeToJsonRpc(item.type),
+                }));
+                try {
+                    const result = await manager.sendRequest(genesisHash, 'chainHead_v1_storage', [
+                        realSubId,
+                        hash,
+                        jsonRpcItems,
+                        childTrie,
+                    ]);
+                    return enumValue('v1', resultOk(manager.convertOperationStartedResult(result)));
+                }
+                catch (e) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: String(e) })));
+                }
+            }));
+            // Call request
+            cleanups.push(transport.handleRequest('remote_chain_head_call', async (message) => {
+                if (!isEnumVariant(message, 'v1')) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
+                }
+                const params = message.value;
+                const realSubId = manager.getChainFollowSubId(params.genesisHash);
+                if (!realSubId) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: 'No active follow for this chain' })));
+                }
+                try {
+                    const result = await manager.sendRequest(params.genesisHash, 'chainHead_v1_call', [
+                        realSubId,
+                        params.hash,
+                        params.function,
+                        params.callParameters,
+                    ]);
+                    return enumValue('v1', resultOk(manager.convertOperationStartedResult(result)));
+                }
+                catch (e) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: String(e) })));
+                }
+            }));
+            // Unpin request
+            cleanups.push(transport.handleRequest('remote_chain_head_unpin', async (message) => {
+                if (!isEnumVariant(message, 'v1')) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
+                }
+                const { genesisHash, hashes } = message.value;
+                const realSubId = manager.getChainFollowSubId(genesisHash);
+                if (!realSubId) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: 'No active follow for this chain' })));
+                }
+                try {
+                    await manager.sendRequest(genesisHash, 'chainHead_v1_unpin', [realSubId, hashes]);
+                    return enumValue('v1', resultOk(undefined));
+                }
+                catch (e) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: String(e) })));
+                }
+            }));
+            // Continue request
+            cleanups.push(transport.handleRequest('remote_chain_head_continue', async (message) => {
+                if (!isEnumVariant(message, 'v1')) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
+                }
+                const { genesisHash, operationId } = message.value;
+                const realSubId = manager.getChainFollowSubId(genesisHash);
+                if (!realSubId) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: 'No active follow for this chain' })));
+                }
+                try {
+                    await manager.sendRequest(genesisHash, 'chainHead_v1_continue', [realSubId, operationId]);
+                    return enumValue('v1', resultOk(undefined));
+                }
+                catch (e) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: String(e) })));
+                }
+            }));
+            // StopOperation request
+            cleanups.push(transport.handleRequest('remote_chain_head_stop_operation', async (message) => {
+                if (!isEnumVariant(message, 'v1')) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
+                }
+                const { genesisHash, operationId } = message.value;
+                const realSubId = manager.getChainFollowSubId(genesisHash);
+                if (!realSubId) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: 'No active follow for this chain' })));
+                }
+                try {
+                    await manager.sendRequest(genesisHash, 'chainHead_v1_stopOperation', [realSubId, operationId]);
+                    return enumValue('v1', resultOk(undefined));
+                }
+                catch (e) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: String(e) })));
+                }
+            }));
+            // ChainSpec: genesis hash
+            cleanups.push(transport.handleRequest('remote_chain_spec_genesis_hash', async (message) => {
+                if (!isEnumVariant(message, 'v1')) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
+                }
+                const genesisHash = message.value;
+                const entry = manager.getOrCreateChain(genesisHash);
+                if (!entry) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: 'Chain not supported' })));
+                }
+                try {
+                    const result = await manager.sendRequest(genesisHash, 'chainSpec_v1_genesisHash', []);
+                    manager.releaseChain(genesisHash);
+                    return enumValue('v1', resultOk(result));
+                }
+                catch (e) {
+                    manager.releaseChain(genesisHash);
+                    return enumValue('v1', resultErr(new GenericError({ reason: String(e) })));
+                }
+            }));
+            // ChainSpec: chain name
+            cleanups.push(transport.handleRequest('remote_chain_spec_chain_name', async (message) => {
+                if (!isEnumVariant(message, 'v1')) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
+                }
+                const genesisHash = message.value;
+                const entry = manager.getOrCreateChain(genesisHash);
+                if (!entry) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: 'Chain not supported' })));
+                }
+                try {
+                    const result = await manager.sendRequest(genesisHash, 'chainSpec_v1_chainName', []);
+                    manager.releaseChain(genesisHash);
+                    return enumValue('v1', resultOk(result));
+                }
+                catch (e) {
+                    manager.releaseChain(genesisHash);
+                    return enumValue('v1', resultErr(new GenericError({ reason: String(e) })));
+                }
+            }));
+            // ChainSpec: properties
+            cleanups.push(transport.handleRequest('remote_chain_spec_properties', async (message) => {
+                if (!isEnumVariant(message, 'v1')) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
+                }
+                const genesisHash = message.value;
+                const entry = manager.getOrCreateChain(genesisHash);
+                if (!entry) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: 'Chain not supported' })));
+                }
+                try {
+                    const result = await manager.sendRequest(genesisHash, 'chainSpec_v1_properties', []);
+                    manager.releaseChain(genesisHash);
+                    return enumValue('v1', resultOk(typeof result === 'string' ? result : JSON.stringify(result)));
+                }
+                catch (e) {
+                    manager.releaseChain(genesisHash);
+                    return enumValue('v1', resultErr(new GenericError({ reason: String(e) })));
+                }
+            }));
+            // Transaction broadcast
+            cleanups.push(transport.handleRequest('remote_chain_transaction_broadcast', async (message) => {
+                if (!isEnumVariant(message, 'v1')) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
+                }
+                const { genesisHash, transaction } = message.value;
+                const entry = manager.getOrCreateChain(genesisHash);
+                if (!entry) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: 'Chain not supported' })));
+                }
+                try {
+                    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) })));
+                }
+            }));
+            // Transaction stop
+            cleanups.push(transport.handleRequest('remote_chain_transaction_stop', async (message) => {
+                if (!isEnumVariant(message, 'v1')) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
+                }
+                const { genesisHash, operationId } = message.value;
+                const entry = manager.getOrCreateChain(genesisHash);
+                if (!entry) {
+                    return enumValue('v1', resultErr(new GenericError({ reason: 'Chain not supported' })));
+                }
+                try {
+                    await manager.sendRequest(genesisHash, 'transaction_v1_stop', [operationId]);
+                    manager.releaseChain(genesisHash);
+                    return enumValue('v1', resultOk(undefined));
+                }
+                catch (e) {
+                    manager.releaseChain(genesisHash);
+                    return enumValue('v1', resultErr(new GenericError({ reason: String(e) })));
+                }
+            }));
+            let disposed = false;
+            const dispose = () => {
+                if (disposed)
+                    return;
+                disposed = true;
+                unsubscribeDestroy();
+                for (const fn of cleanups)
+                    fn();
+                manager.dispose();
+            };
+            const unsubscribeDestroy = transport.onDestroy(dispose);
+            return dispose;
         },
         isReady() {
             return transport.isReady();

package/dist/types.d.ts

@@ -73,7 +73,11 @@ export type Container = {
     handleChatListSubscribe: InferHandler<'v1', HostApiProtocol['host_chat_list_subscribe']>;
     handleChatPostMessage: InferHandler<'v1', HostApiProtocol['host_chat_post_message']>;
     handleChatActionSubscribe: InferHandler<'v1', HostApiProtocol['host_chat_action_subscribe']>;
-    renderChatCustomMessage(messageType: string, payload: Uint8Array, callback: (node: CodecType<typeof CustomRendererNode>) => void): Subscription;
+    renderChatCustomMessage(params: {
+        messageId: string;
+        messageType: string;
+        payload: Uint8Array;
+    }, callback: (node: CodecType<typeof CustomRendererNode>) => void): Subscription;
     handleStatementStoreSubscribe: InferHandler<'v1', HostApiProtocol['remote_statement_store_subscribe']>;
     handleStatementStoreCreateProof: InferHandler<'v1', HostApiProtocol['remote_statement_store_create_proof']>;
     handleStatementStoreSubmit: InferHandler<'v1', HostApiProtocol['remote_statement_store_submit']>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-container",
   "type": "module",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Host container for hosting and managing products within the Polkadot ecosystem.",
   "license": "Apache-2.0",
   "repository": {
@@ -28,7 +28,7 @@
   "dependencies": {
     "@polkadot-api/utils": "^0.2.0",
     "@polkadot-api/json-rpc-provider": "^0.0.4",
-    "@novasamatech/host-api": "0.6.1",
+    "@novasamatech/host-api": "0.6.3",
     "nanoid": "5.1.6"
   },
   "devDependencies": {