@novasamatech/host-container 0.7.4-0 → 0.7.5-0

package/README.md

@@ -181,23 +181,25 @@ container.handleThemeSubscribe((_, send, interrupt) => {
 });
 ```
 
-### handleAccountGetRoot
+### handleGetUserId
 
-Called when a product requests the user's root (primary) account. Show a permission prompt on first call; cache the grant for the session. Return `NotFound` if the user has no DotNS username.
+Called when a product requests the user's primary DotNS username (RFC-0014). Show a disclosure prompt on first call; the host decides what counts as "primary" for the calling product. Return `NotConnected` without prompting if no user is connected; return `PermissionDenied` if the user denies disclosure.
 
 ```ts
-import { RequestCredentialsErr } from '@novasamatech/host-api';
+import { GetUserIdErr } from '@novasamatech/host-api';
 
-container.handleAccountGetRoot(async (_, { ok, err }) => {
-  const granted = await promptUserForRootAccountAccess();
-  if (!granted) {
-    return err(new RequestCredentialsErr.Rejected());
+container.handleGetUserId(async (_, { ok, err }) => {
+  const username = await pickPrimaryUsernameForCallingProduct();
+  if (!username) {
+    return err(new GetUserIdErr.NotConnected());
   }
-  const rootAccount = await getRootAccount();
-  if (!rootAccount) {
-    return err(new RequestCredentialsErr.NotConnected());
+
+  const granted = await promptUserForUsernameDisclosure();
+  if (!granted) {
+    return err(new GetUserIdErr.PermissionDenied());
   }
-  return ok({ publicKey: rootAccount.publicKey, name: rootAccount.name ?? undefined });
+
+  return ok({ primaryUsername: username });
 });
 ```
 
@@ -225,7 +227,7 @@ container.handleRequestLogin(async (reason, { ok, err }) => {
 container.handleAccountGet(async ([dotnsId, derivationIndex], { ok, err }) => {
   const account = await getProductAccount(dotnsId, derivationIndex);
   if (account) {
-    return ok({ publicKey: account.publicKey, name: account.name ?? null });
+    return ok({ publicKey: account.publicKey });
   }
   return err({ tag: 'NotConnected' });
 });

package/dist/chainConnectionManager.d.ts

@@ -1,113 +1,104 @@
 import type { HexString } from '@novasamatech/host-api';
 import type { JsonRpcProvider } from 'polkadot-api';
-type JsonRpcConnection = ReturnType<JsonRpcProvider>;
-type PendingRequest = {
-    resolve: (result: unknown) => void;
-    reject: (error: unknown) => void;
-};
-type FollowSubscription = {
-    chainSubId: string;
-    eventListener: (event: unknown) => void;
-    pendingRequestId?: string;
-};
-type ChainEntry = {
-    connection: JsonRpcConnection;
-    pendingRequests: Map<string, PendingRequest>;
-    followSubscriptions: Map<string, FollowSubscription>;
-    refCount: number;
-};
+type FollowEvent = Record<string, unknown>;
 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) => {
+export declare function createChainConnectionManager(factory: (genesisHash: HexString) => JsonRpcProvider | null, options?: {
+    refollowTimeoutMs?: number;
+}): {
+    getOrCreateChain(genesisHash: HexString): boolean;
+    startFollow(genesisHash: HexString, withRuntime: boolean, onEvent: (event: FollowEvent) => 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;
+    stopFollow(genesisHash: HexString, followId: string): void;
+    hasActiveFollow(genesisHash: HexString): boolean;
+    chainHeadOp(genesisHash: HexString, method: string, params: unknown[]): Promise<unknown>;
+    sendRequest(genesisHash: HexString, method: string, params: unknown[]): Promise<unknown>;
+    releaseChain(genesisHash: HexString): void;
+    dispose(): void;
+    convertJsonRpcEventToTyped: typeof convertJsonRpcEventToTyped;
+    convertOperationStartedResult: typeof convertOperationStartedResult;
+    convertStorageQueryTypeToJsonRpc: typeof convertStorageQueryTypeToJsonRpc;
+};
+export declare function 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[];
     };
-    convertOperationStartedResult: (result: unknown) => {
-        tag: "Started";
-        value: {
-            readonly operationId: string;
-        };
-    } | {
-        tag: "LimitReached";
-        value: undefined;
+} | {
+    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;
+};
+export declare function convertOperationStartedResult(result: unknown): {
+    tag: "Started";
+    value: {
+        readonly operationId: string;
     };
-    convertStorageQueryTypeToJsonRpc: (type: string) => string;
+} | {
+    tag: "LimitReached";
+    value: undefined;
 };
+export declare function convertStorageQueryTypeToJsonRpc(type: string): string;
 export {};

package/dist/chainConnectionManager.js

@@ -1,310 +1,277 @@
 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 => {
-            // Response: has 'id' but no 'method'
-            if ('id' in message && message.id != null && !('method' in message)) {
-                const pending = pendingRequests.get(String(message.id));
-                if (pending) {
-                    pendingRequests.delete(String(message.id));
-                    if ('error' in message) {
-                        pending.reject(message.error);
-                    }
-                    else {
-                        pending.resolve(message.result);
-                    }
-                    return;
-                }
-            }
-            // Subscription notification: has 'method' and 'params'
-            if ('method' in message && 'params' in message) {
-                const params = message.params;
-                if (params?.subscription) {
-                    const subId = String(params.subscription);
-                    for (const follow of followSubscriptions.values()) {
-                        if (follow.chainSubId === subId) {
-                            follow.eventListener(params.result);
-                            break;
-                        }
-                    }
+import { StopError, createClient as createSubstrateClient } from '@polkadot-api/substrate-client';
+// Operation events that signal a chain-head op is finished and its
+// per-operation subscription can be torn down.
+const TERMINAL_OPERATION_EVENTS = new Set([
+    'operationBodyDone',
+    'operationCallDone',
+    'operationStorageDone',
+    'operationError',
+    'operationInaccessible',
+]);
+// How long to hold a chain-head op when there's no active follow, waiting for
+// the papp to issue a fresh Follow after a Stop. Long enough to absorb a
+// realistic round-trip; short enough that a never-issuing papp fails fast.
+const REFOLLOW_TIMEOUT_MS = 5_000;
+function executeChainHeadOp(response, onEvent, method, params) {
+    return new Promise((resolve, reject) => {
+        response._request(method, params, {
+            onSuccess: (result, onSubscribeOperation) => {
+                const operationId = result?.operationId;
+                if (operationId) {
+                    let unsub = () => undefined;
+                    unsub = onSubscribeOperation(operationId, {
+                        next: e => {
+                            onEvent(e);
+                            if (TERMINAL_OPERATION_EVENTS.has(e.event))
+                                unsub();
+                        },
+                        error: () => unsub(),
+                    });
                 }
-            }
-        });
-        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({ 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);
+                resolve(result);
             },
+            onError: reject,
         });
-        entry.connection.send({
-            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({
-                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({
-                            jsonrpc: '2.0',
-                            id: unfollowId,
-                            method: 'chainHead_v1_unfollow',
-                            params: [chainSubId],
-                        });
-                    }
-                },
-                reject: () => {
-                    /* follow already cleaned up */
-                },
-            });
+    });
+}
+export function createChainConnectionManager(factory, options = {}) {
+    const refollowTimeoutMs = options.refollowTimeoutMs ?? REFOLLOW_TIMEOUT_MS;
+    const chains = new Map();
+    let nextFollowId = 0;
+    function teardown(entry) {
+        for (const follow of entry.follows.values())
+            follow.response?.unfollow();
+        entry.follows.clear();
+        for (const op of entry.pendingOps) {
+            clearTimeout(op.timer);
+            op.reject(new Error('Chain disposed'));
         }
+        entry.pendingOps = [];
+        entry.client.destroy();
     }
-    function getChainFollowSubId(genesisHash) {
+    function activeFollow(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;
+        for (const follow of entry.follows.values()) {
+            if (follow.response)
+                return follow;
         }
         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({
-                        jsonrpc: '2.0',
-                        id,
-                        method: 'chainHead_v1_unfollow',
-                        params: [follow.chainSubId],
-                    });
-                }
+    return {
+        getOrCreateChain(genesisHash) {
+            const existing = chains.get(genesisHash);
+            if (existing) {
+                existing.refCount++;
+                return true;
             }
-            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({
-                        jsonrpc: '2.0',
-                        id,
-                        method: 'chainHead_v1_unfollow',
-                        params: [follow.chainSubId],
-                    });
+            const provider = factory(genesisHash);
+            if (!provider)
+                return false;
+            chains.set(genesisHash, {
+                client: createSubstrateClient(provider),
+                follows: new Map(),
+                pendingOps: [],
+                recoveringSince: null,
+                refCount: 1,
+            });
+            return true;
+        },
+        startFollow(genesisHash, withRuntime, onEvent) {
+            const entry = chains.get(genesisHash);
+            if (!entry)
+                throw new Error(`No connection for chain ${genesisHash}`);
+            const followId = `f${nextFollowId++}`;
+            const follow = { response: null, onEvent };
+            entry.follows.set(followId, follow);
+            const response = entry.client.chainHead(withRuntime, 
+            // substrate-client renames the spec's `event` field to `type`. Restore it.
+            ({ type, ...rest }) => onEvent({ event: type, ...rest }), error => {
+                // The follow is dead. Drop the entry so it doesn't accumulate as a
+                // tombstone; clear the response field on the (now-detached)
+                // FollowEntry for any handle still holding it. For a spec stop,
+                // surface the event to the papp and open the recovery window so
+                // chain-head ops issued before the papp refollows queue rather
+                // than fail. Non-Stop errors get no recovery window — those are
+                // genuine failures, not protocol-driven restarts.
+                entry.follows.delete(followId);
+                follow.response = null;
+                if (error instanceof StopError) {
+                    onEvent({ event: 'stop' });
+                    entry.recoveringSince = Date.now();
+                }
+            });
+            follow.response = response;
+            // Fresh follow ends any in-flight recovery window. Drain ops queued
+            // during the gap through this follow's onEvent so operation events
+            // still reach the papp.
+            entry.recoveringSince = null;
+            if (entry.pendingOps.length > 0) {
+                const queued = entry.pendingOps;
+                entry.pendingOps = [];
+                for (const op of queued) {
+                    clearTimeout(op.timer);
+                    executeChainHeadOp(response, onEvent, op.method, op.params).then(op.resolve, op.reject);
                 }
             }
-            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]) : [],
+            return { followId };
+        },
+        stopFollow(genesisHash, followId) {
+            const entry = chains.get(genesisHash);
+            if (!entry)
+                return;
+            const follow = entry.follows.get(followId);
+            if (!follow)
+                return;
+            entry.follows.delete(followId);
+            follow.response?.unfollow();
+        },
+        hasActiveFollow(genesisHash) {
+            return activeFollow(genesisHash) !== null;
+        },
+        chainHeadOp(genesisHash, method, params) {
+            const follow = activeFollow(genesisHash);
+            if (follow?.response)
+                return executeChainHeadOp(follow.response, follow.onEvent, method, params);
+            // No active follow. If we're inside a recovery window opened by a
+            // recent Stop, hold the op so the brief gap before the papp's refollow
+            // doesn't surface as an error. Otherwise fail fast — no Stop, no
+            // expected refollow.
+            const entry = chains.get(genesisHash);
+            if (!entry || entry.recoveringSince === null) {
+                return Promise.reject(new Error('No active follow for this chain'));
+            }
+            if (Date.now() - entry.recoveringSince > refollowTimeoutMs) {
+                entry.recoveringSince = null;
+                return Promise.reject(new Error('No active follow for this chain'));
+            }
+            return new Promise((resolve, reject) => {
+                const op = {
+                    method,
+                    params,
+                    resolve,
+                    reject,
+                    timer: setTimeout(() => {
+                        const idx = entry.pendingOps.indexOf(op);
+                        if (idx !== -1)
+                            entry.pendingOps.splice(idx, 1);
+                        reject(new Error('No active follow for this chain'));
+                    }, refollowTimeoutMs),
+                };
+                entry.pendingOps.push(op);
             });
-        }
-        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 });
+        },
+        sendRequest(genesisHash, method, params) {
+            const entry = chains.get(genesisHash);
+            if (!entry)
+                return Promise.reject(new Error(`No connection for chain ${genesisHash}`));
+            return entry.client.request(method, params);
+        },
+        releaseChain(genesisHash) {
+            const entry = chains.get(genesisHash);
+            if (!entry)
+                return;
+            if (--entry.refCount <= 0) {
+                teardown(entry);
+                chains.delete(genesisHash);
             }
-        }
-        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,
+        },
+        dispose() {
+            for (const entry of chains.values())
+                teardown(entry);
+            chains.clear();
+        },
         convertJsonRpcEventToTyped,
         convertOperationStartedResult,
         convertStorageQueryTypeToJsonRpc,
     };
 }
+// === JSON-RPC ↔ typed conversion (pure, no closure state) ===
+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;
+}
+export function convertJsonRpcEventToTyped(event) {
+    switch (event.event) {
+        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':
+        default:
+            return enumValue('Stop', undefined);
+    }
+}
+export function convertOperationStartedResult(result) {
+    const r = result;
+    return r?.result === 'started'
+        ? enumValue('Started', { operationId: r.operationId })
+        : enumValue('LimitReached', undefined);
+}
+// 'Value' → 'value', 'ClosestDescendantMerkleValue' → 'closestDescendantMerkleValue', …
+export function convertStorageQueryTypeToJsonRpc(type) {
+    return type.charAt(0).toLowerCase() + type.slice(1);
+}

package/dist/chainConnectionManager.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/chainConnectionManager.spec.js

@@ -0,0 +1,317 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createChainConnectionManager } from './chainConnectionManager.js';
+const GENESIS = '0xabc';
+const createMockProvider = () => {
+    const send = vi.fn();
+    const disconnect = vi.fn();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let onMessage = null;
+    const provider = cb => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        onMessage = cb;
+        return { send, disconnect };
+    };
+    return {
+        provider,
+        send,
+        disconnect,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        simulateMessage: (msg) => onMessage?.(msg),
+    };
+};
+const sentMessages = (mock) => mock.send.mock.calls.map(([msg]) => msg);
+const findCallId = (mock, method) => {
+    const match = sentMessages(mock).find(msg => msg.method === method);
+    if (!match)
+        throw new Error(`no '${method}' call found`);
+    return match.id;
+};
+describe('chainConnectionManager', () => {
+    describe('startFollow / stop event handling', () => {
+        it('sends chainHead_v1_follow on startFollow', () => {
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider);
+            manager.getOrCreateChain(GENESIS);
+            manager.startFollow(GENESIS, true, vi.fn());
+            const calls = sentMessages(mock);
+            expect(calls).toHaveLength(1);
+            expect(calls[0]).toMatchObject({ method: 'chainHead_v1_follow', params: [true] });
+        });
+        it('hasActiveFollow becomes true on startFollow and stays true through the server confirmation', () => {
+            // The follow lifecycle is owned by substrate-client's chainHead, which
+            // queues chain-head ops on the underlying followSubscription Promise
+            // until the server assigns a chainSubId. So a follow is "active" from
+            // the moment startFollow returns; ops issued in the setup window are
+            // not rejected — they queue and fire once the chainSubId arrives.
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider);
+            manager.getOrCreateChain(GENESIS);
+            manager.startFollow(GENESIS, true, vi.fn());
+            expect(manager.hasActiveFollow(GENESIS)).toBe(true);
+            mock.simulateMessage({ jsonrpc: '2.0', id: findCallId(mock, 'chainHead_v1_follow'), result: 'sub-id-1' });
+            expect(manager.hasActiveFollow(GENESIS)).toBe(true);
+        });
+        it('forwards a synthetic stop event to the listener and clears hasActiveFollow', () => {
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider);
+            const events = [];
+            manager.getOrCreateChain(GENESIS);
+            manager.startFollow(GENESIS, true, e => events.push(e));
+            mock.simulateMessage({ jsonrpc: '2.0', id: findCallId(mock, 'chainHead_v1_follow'), result: 'sub-id-1' });
+            mock.simulateMessage({
+                jsonrpc: '2.0',
+                method: 'chainHead_v1_followEvent',
+                params: { subscription: 'sub-id-1', result: { event: 'stop' } },
+            });
+            expect(events).toEqual([{ event: 'stop' }]);
+            expect(manager.hasActiveFollow(GENESIS)).toBe(false);
+        });
+        it('forwards initialized/newBlock follow events with the spec-shape `event` field restored', () => {
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider);
+            const events = [];
+            manager.getOrCreateChain(GENESIS);
+            manager.startFollow(GENESIS, true, e => events.push(e));
+            mock.simulateMessage({ jsonrpc: '2.0', id: findCallId(mock, 'chainHead_v1_follow'), result: 'sub-id-1' });
+            mock.simulateMessage({
+                jsonrpc: '2.0',
+                method: 'chainHead_v1_followEvent',
+                params: {
+                    subscription: 'sub-id-1',
+                    result: {
+                        event: 'initialized',
+                        finalizedBlockHashes: ['0xdead'],
+                        finalizedBlockRuntime: {
+                            type: 'valid',
+                            spec: { specName: 'x', implName: 'y', specVersion: 1, implVersion: 1, apis: {} },
+                        },
+                    },
+                },
+            });
+            expect(events).toEqual([
+                expect.objectContaining({
+                    event: 'initialized',
+                    finalizedBlockHashes: ['0xdead'],
+                }),
+            ]);
+        });
+        it('drops the dead follow entry on stop so it does not leak as a tombstone', () => {
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider);
+            manager.getOrCreateChain(GENESIS);
+            const { followId } = manager.startFollow(GENESIS, true, vi.fn());
+            mock.simulateMessage({ jsonrpc: '2.0', id: findCallId(mock, 'chainHead_v1_follow'), result: 'sub-id-1' });
+            mock.simulateMessage({
+                jsonrpc: '2.0',
+                method: 'chainHead_v1_followEvent',
+                params: { subscription: 'sub-id-1', result: { event: 'stop' } },
+            });
+            // stopFollow on the now-dead followId is a no-op (entry already cleaned
+            // up). The unfollow RPC must NOT be sent — the follow is already gone.
+            const beforeStop = sentMessages(mock).length;
+            manager.stopFollow(GENESIS, followId);
+            expect(sentMessages(mock)).toHaveLength(beforeStop);
+        });
+        it('a fresh follow after a stop is tracked under its new chainSubId', () => {
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider);
+            manager.getOrCreateChain(GENESIS);
+            manager.startFollow(GENESIS, true, vi.fn());
+            mock.simulateMessage({ jsonrpc: '2.0', id: findCallId(mock, 'chainHead_v1_follow'), result: 'sub-id-1' });
+            mock.simulateMessage({
+                jsonrpc: '2.0',
+                method: 'chainHead_v1_followEvent',
+                params: { subscription: 'sub-id-1', result: { event: 'stop' } },
+            });
+            expect(manager.hasActiveFollow(GENESIS)).toBe(false);
+            manager.startFollow(GENESIS, true, vi.fn());
+            const followCalls = sentMessages(mock).filter(m => m.method === 'chainHead_v1_follow');
+            expect(followCalls).toHaveLength(2);
+            mock.simulateMessage({ jsonrpc: '2.0', id: followCalls[1].id, result: 'sub-id-2' });
+            expect(manager.hasActiveFollow(GENESIS)).toBe(true);
+        });
+    });
+    describe('chainHeadOp', () => {
+        it('rejects with "No active follow for this chain" when no follow is active', async () => {
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider);
+            manager.getOrCreateChain(GENESIS);
+            // No startFollow.
+            await expect(manager.chainHeadOp(GENESIS, 'chainHead_v1_header', ['0xhash'])).rejects.toThrow('No active follow for this chain');
+        });
+        it('rejects after the refollow timeout elapses with no fresh Follow', async () => {
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider, { refollowTimeoutMs: 30 });
+            manager.getOrCreateChain(GENESIS);
+            manager.startFollow(GENESIS, true, vi.fn());
+            mock.simulateMessage({ jsonrpc: '2.0', id: findCallId(mock, 'chainHead_v1_follow'), result: 'sub-id-1' });
+            mock.simulateMessage({
+                jsonrpc: '2.0',
+                method: 'chainHead_v1_followEvent',
+                params: { subscription: 'sub-id-1', result: { event: 'stop' } },
+            });
+            await expect(manager.chainHeadOp(GENESIS, 'chainHead_v1_header', ['0xhash'])).rejects.toThrow('No active follow for this chain');
+        });
+        it('still queues when the papp closes its dead subscription before opening a new one', async () => {
+            // Recovery window is gated on the most recent Stop, not on whether an
+            // entry happens to remain in the follows map. So even if the papp's
+            // pattern is "stopFollow on the old subscription, then startFollow on
+            // a new one", ops issued in the gap still queue.
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider, { refollowTimeoutMs: 1_000 });
+            manager.getOrCreateChain(GENESIS);
+            const { followId } = manager.startFollow(GENESIS, true, vi.fn());
+            mock.simulateMessage({ jsonrpc: '2.0', id: findCallId(mock, 'chainHead_v1_follow'), result: 'sub-id-1' });
+            mock.simulateMessage({
+                jsonrpc: '2.0',
+                method: 'chainHead_v1_followEvent',
+                params: { subscription: 'sub-id-1', result: { event: 'stop' } },
+            });
+            // Papp closes its OLD subscription on Stop, BEFORE opening NEW.
+            manager.stopFollow(GENESIS, followId);
+            // Op issued in the gap must queue, not fail fast.
+            const opPromise = manager.chainHeadOp(GENESIS, 'chainHead_v1_header', ['0xhash']);
+            expect(sentMessages(mock).find(m => m.method === 'chainHead_v1_header')).toBeUndefined();
+            manager.startFollow(GENESIS, true, vi.fn());
+            const newFollowId = sentMessages(mock).filter(m => m.method === 'chainHead_v1_follow')[1].id;
+            mock.simulateMessage({ jsonrpc: '2.0', id: newFollowId, result: 'sub-id-2' });
+            await Promise.resolve();
+            const headerCall = sentMessages(mock).find(m => m.method === 'chainHead_v1_header');
+            expect(headerCall?.params).toEqual(['sub-id-2', '0xhash']);
+            mock.simulateMessage({ jsonrpc: '2.0', id: headerCall.id, result: '0xheader' });
+            await expect(opPromise).resolves.toBe('0xheader');
+        });
+        it('queues a chain-head op issued in the stop→refollow gap and drains it into the new follow', async () => {
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider, { refollowTimeoutMs: 1_000 });
+            manager.getOrCreateChain(GENESIS);
+            manager.startFollow(GENESIS, true, vi.fn());
+            const firstFollowId = findCallId(mock, 'chainHead_v1_follow');
+            mock.simulateMessage({ jsonrpc: '2.0', id: firstFollowId, result: 'sub-id-1' });
+            // Stop invalidates the first follow but leaves the entry around so ops can queue.
+            mock.simulateMessage({
+                jsonrpc: '2.0',
+                method: 'chainHead_v1_followEvent',
+                params: { subscription: 'sub-id-1', result: { event: 'stop' } },
+            });
+            // Op issued while no follow is active — should not fail immediately.
+            const opPromise = manager.chainHeadOp(GENESIS, 'chainHead_v1_header', ['0xhash']);
+            // No header request hit the wire yet (still queued).
+            expect(sentMessages(mock).find(m => m.method === 'chainHead_v1_header')).toBeUndefined();
+            // Papp issues a fresh Follow.
+            manager.startFollow(GENESIS, true, vi.fn());
+            const secondFollowId = sentMessages(mock).filter(m => m.method === 'chainHead_v1_follow')[1].id;
+            mock.simulateMessage({ jsonrpc: '2.0', id: secondFollowId, result: 'sub-id-2' });
+            // The queued op drains into the new follow on the next microtask
+            // (substrate-client's fRequest waits on the followSubscription Promise).
+            await Promise.resolve();
+            const headerCall = sentMessages(mock).find(m => m.method === 'chainHead_v1_header');
+            expect(headerCall?.params).toEqual(['sub-id-2', '0xhash']);
+            mock.simulateMessage({ jsonrpc: '2.0', id: headerCall.id, result: '0xheader' });
+            await expect(opPromise).resolves.toBe('0xheader');
+        });
+        it('rejects queued ops when the chain is disposed before a refollow', async () => {
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider, { refollowTimeoutMs: 1_000 });
+            manager.getOrCreateChain(GENESIS);
+            manager.startFollow(GENESIS, true, vi.fn());
+            mock.simulateMessage({ jsonrpc: '2.0', id: findCallId(mock, 'chainHead_v1_follow'), result: 'sub-id-1' });
+            mock.simulateMessage({
+                jsonrpc: '2.0',
+                method: 'chainHead_v1_followEvent',
+                params: { subscription: 'sub-id-1', result: { event: 'stop' } },
+            });
+            const opPromise = manager.chainHeadOp(GENESIS, 'chainHead_v1_header', ['0xhash']);
+            manager.releaseChain(GENESIS);
+            await expect(opPromise).rejects.toThrow('Chain disposed');
+        });
+        it('auto-prepends the chainSubId when forwarding a chain-head op to the provider', async () => {
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider);
+            manager.getOrCreateChain(GENESIS);
+            manager.startFollow(GENESIS, true, vi.fn());
+            mock.simulateMessage({ jsonrpc: '2.0', id: findCallId(mock, 'chainHead_v1_follow'), result: 'sub-id-1' });
+            const promise = manager.chainHeadOp(GENESIS, 'chainHead_v1_header', ['0xblockHash']);
+            const headerCall = sentMessages(mock).find(m => m.method === 'chainHead_v1_header');
+            expect(headerCall?.params).toEqual(['sub-id-1', '0xblockHash']);
+            mock.simulateMessage({ jsonrpc: '2.0', id: headerCall.id, result: '0xheader' });
+            await expect(promise).resolves.toBe('0xheader');
+        });
+        it('forwards operation events streamed against the started operationId to the follow listener', async () => {
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider);
+            const events = [];
+            manager.getOrCreateChain(GENESIS);
+            manager.startFollow(GENESIS, true, e => events.push(e));
+            mock.simulateMessage({ jsonrpc: '2.0', id: findCallId(mock, 'chainHead_v1_follow'), result: 'sub-id-1' });
+            const promise = manager.chainHeadOp(GENESIS, 'chainHead_v1_storage', ['0xhash', [], null]);
+            const storageCall = sentMessages(mock).find(m => m.method === 'chainHead_v1_storage');
+            mock.simulateMessage({
+                jsonrpc: '2.0',
+                id: storageCall.id,
+                result: { result: 'started', operationId: 'op-1', discardedItems: 0 },
+            });
+            await expect(promise).resolves.toMatchObject({ result: 'started', operationId: 'op-1' });
+            // Now operation events streamed via the follow notification must reach the listener.
+            const items = { event: 'operationStorageItems', operationId: 'op-1', items: [] };
+            mock.simulateMessage({
+                jsonrpc: '2.0',
+                method: 'chainHead_v1_followEvent',
+                params: { subscription: 'sub-id-1', result: items },
+            });
+            const done = { event: 'operationStorageDone', operationId: 'op-1' };
+            mock.simulateMessage({
+                jsonrpc: '2.0',
+                method: 'chainHead_v1_followEvent',
+                params: { subscription: 'sub-id-1', result: done },
+            });
+            expect(events).toContainEqual(items);
+            expect(events).toContainEqual(done);
+        });
+    });
+    describe('basic flows', () => {
+        it('sendRequest forwards a non-chainHead JSON-RPC and resolves on response', async () => {
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider);
+            manager.getOrCreateChain(GENESIS);
+            const promise = manager.sendRequest(GENESIS, 'chainSpec_v1_genesisHash', []);
+            const call = sentMessages(mock).find(m => m.method === 'chainSpec_v1_genesisHash');
+            mock.simulateMessage({ jsonrpc: '2.0', id: call.id, result: '0xgenesis' });
+            await expect(promise).resolves.toBe('0xgenesis');
+        });
+        it('sendRequest rejects on error response', async () => {
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider);
+            manager.getOrCreateChain(GENESIS);
+            const promise = manager.sendRequest(GENESIS, 'chainSpec_v1_genesisHash', []);
+            const call = sentMessages(mock).find(m => m.method === 'chainSpec_v1_genesisHash');
+            mock.simulateMessage({
+                jsonrpc: '2.0',
+                id: call.id,
+                error: { code: -32000, message: 'unsupported' },
+            });
+            await expect(promise).rejects.toBeInstanceOf(Error);
+        });
+        it('releaseChain only disconnects when refCount drops to zero', () => {
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider);
+            manager.getOrCreateChain(GENESIS);
+            manager.getOrCreateChain(GENESIS);
+            manager.releaseChain(GENESIS);
+            expect(mock.disconnect).not.toHaveBeenCalled();
+            manager.releaseChain(GENESIS);
+            expect(mock.disconnect).toHaveBeenCalledTimes(1);
+        });
+        it('stopFollow sends chainHead_v1_unfollow with the current chainSubId', () => {
+            const mock = createMockProvider();
+            const manager = createChainConnectionManager(() => mock.provider);
+            manager.getOrCreateChain(GENESIS);
+            const { followId } = manager.startFollow(GENESIS, true, vi.fn());
+            mock.simulateMessage({ jsonrpc: '2.0', id: findCallId(mock, 'chainHead_v1_follow'), result: 'sub-id-1' });
+            manager.stopFollow(GENESIS, followId);
+            const unfollowCall = sentMessages(mock).find(m => m.method === 'chainHead_v1_unfollow');
+            expect(unfollowCall?.params).toEqual(['sub-id-1']);
+            expect(manager.hasActiveFollow(GENESIS)).toBe(false);
+        });
+    });
+});

package/dist/createContainer.js

@@ -1,4 +1,4 @@
-import { ChatBotRegistrationErr, ChatMessagePostingErr, ChatRoomRegistrationErr, CreateProofErr, CreateTransactionErr, DeriveEntropyErr, DevicePermission, GenericError, 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, 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';
@@ -154,7 +154,7 @@ export function createContainer(provider) {
         return slot.update(slotHandler);
     }
     // account slots
-    const handleAccountGetRootSlot = makeNotImplementedSlot('host_account_get_root', () => new RequestCredentialsErr.Unknown({ reason: NOT_IMPLEMENTED }));
+    const handleGetUserIdSlot = makeNotImplementedSlot('host_get_user_id', () => new GetUserIdErr.Unknown({ reason: NOT_IMPLEMENTED }));
     const handleRequestLoginSlot = makeNotImplementedSlot('host_request_login', () => new LoginErr.Unknown({ reason: NOT_IMPLEMENTED }));
     const handleAccountGetSlot = makeNotImplementedSlot('host_account_get', () => new RequestCredentialsErr.Unknown({ reason: NOT_IMPLEMENTED }));
     const handleAccountGetAliasSlot = makeNotImplementedSlot('host_account_get_alias', () => new RequestCredentialsErr.Unknown({ reason: NOT_IMPLEMENTED }));
@@ -228,8 +228,8 @@ export function createContainer(provider) {
         handleThemeSubscribe(handler) {
             return handleV1Subscription(handleThemeSubscribeSlot, handler);
         },
-        handleAccountGetRoot(handler) {
-            return handleV1Request(handleAccountGetRootSlot, () => new RequestCredentialsErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
+        handleGetUserId(handler) {
+            return handleV1Request(handleGetUserIdSlot, () => new GetUserIdErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
         },
         handleRequestLogin(handler) {
             return handleV1Request(handleRequestLoginSlot, () => new LoginErr.Unknown({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR }), handler);
@@ -353,12 +353,11 @@ export function createContainer(provider) {
                     return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
                 }
                 const { genesisHash, hash } = message.value;
-                const realSubId = manager.getChainFollowSubId(genesisHash);
-                if (!realSubId) {
+                if (!manager.hasActiveFollow(genesisHash)) {
                     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]);
+                    const result = await manager.chainHeadOp(genesisHash, 'chainHead_v1_header', [hash]);
                     return enumValue('v1', resultOk(result));
                 }
                 catch (e) {
@@ -371,12 +370,11 @@ export function createContainer(provider) {
                     return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
                 }
                 const { genesisHash, hash } = message.value;
-                const realSubId = manager.getChainFollowSubId(genesisHash);
-                if (!realSubId) {
+                if (!manager.hasActiveFollow(genesisHash)) {
                     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]);
+                    const result = await manager.chainHeadOp(genesisHash, 'chainHead_v1_body', [hash]);
                     return enumValue('v1', resultOk(manager.convertOperationStartedResult(result)));
                 }
                 catch (e) {
@@ -389,8 +387,7 @@ export function createContainer(provider) {
                     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) {
+                if (!manager.hasActiveFollow(genesisHash)) {
                     return enumValue('v1', resultErr(new GenericError({ reason: 'No active follow for this chain' })));
                 }
                 const jsonRpcItems = items.map((item) => ({
@@ -398,8 +395,7 @@ export function createContainer(provider) {
                     type: manager.convertStorageQueryTypeToJsonRpc(item.type),
                 }));
                 try {
-                    const result = await manager.sendRequest(genesisHash, 'chainHead_v1_storage', [
-                        realSubId,
+                    const result = await manager.chainHeadOp(genesisHash, 'chainHead_v1_storage', [
                         hash,
                         jsonRpcItems,
                         childTrie,
@@ -416,13 +412,11 @@ export function createContainer(provider) {
                     return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
                 }
                 const params = message.value;
-                const realSubId = manager.getChainFollowSubId(params.genesisHash);
-                if (!realSubId) {
+                if (!manager.hasActiveFollow(params.genesisHash)) {
                     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,
+                    const result = await manager.chainHeadOp(params.genesisHash, 'chainHead_v1_call', [
                         params.hash,
                         params.function,
                         params.callParameters,
@@ -439,12 +433,11 @@ export function createContainer(provider) {
                     return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
                 }
                 const { genesisHash, hashes } = message.value;
-                const realSubId = manager.getChainFollowSubId(genesisHash);
-                if (!realSubId) {
+                if (!manager.hasActiveFollow(genesisHash)) {
                     return enumValue('v1', resultErr(new GenericError({ reason: 'No active follow for this chain' })));
                 }
                 try {
-                    await manager.sendRequest(genesisHash, 'chainHead_v1_unpin', [realSubId, hashes]);
+                    await manager.chainHeadOp(genesisHash, 'chainHead_v1_unpin', [hashes]);
                     return enumValue('v1', resultOk(undefined));
                 }
                 catch (e) {
@@ -457,12 +450,11 @@ export function createContainer(provider) {
                     return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
                 }
                 const { genesisHash, operationId } = message.value;
-                const realSubId = manager.getChainFollowSubId(genesisHash);
-                if (!realSubId) {
+                if (!manager.hasActiveFollow(genesisHash)) {
                     return enumValue('v1', resultErr(new GenericError({ reason: 'No active follow for this chain' })));
                 }
                 try {
-                    await manager.sendRequest(genesisHash, 'chainHead_v1_continue', [realSubId, operationId]);
+                    await manager.chainHeadOp(genesisHash, 'chainHead_v1_continue', [operationId]);
                     return enumValue('v1', resultOk(undefined));
                 }
                 catch (e) {
@@ -475,12 +467,11 @@ export function createContainer(provider) {
                     return enumValue('v1', resultErr(new GenericError({ reason: UNSUPPORTED_MESSAGE_FORMAT_ERROR })));
                 }
                 const { genesisHash, operationId } = message.value;
-                const realSubId = manager.getChainFollowSubId(genesisHash);
-                if (!realSubId) {
+                if (!manager.hasActiveFollow(genesisHash)) {
                     return enumValue('v1', resultErr(new GenericError({ reason: 'No active follow for this chain' })));
                 }
                 try {
-                    await manager.sendRequest(genesisHash, 'chainHead_v1_stopOperation', [realSubId, operationId]);
+                    await manager.chainHeadOp(genesisHash, 'chainHead_v1_stopOperation', [operationId]);
                     return enumValue('v1', resultOk(undefined));
                 }
                 catch (e) {

package/dist/types.d.ts

@@ -62,7 +62,7 @@ export type Container = {
     handleLocalStorageRead: InferHandler<'v1', HostApiProtocol['host_local_storage_read']>;
     handleLocalStorageWrite: InferHandler<'v1', HostApiProtocol['host_local_storage_write']>;
     handleLocalStorageClear: InferHandler<'v1', HostApiProtocol['host_local_storage_clear']>;
-    handleAccountGetRoot: InferHandler<'v1', HostApiProtocol['host_account_get_root']>;
+    handleGetUserId: InferHandler<'v1', HostApiProtocol['host_get_user_id']>;
     handleRequestLogin: InferHandler<'v1', HostApiProtocol['host_request_login']>;
     handleAccountConnectionStatusSubscribe: InferHandler<'v1', HostApiProtocol['host_account_connection_status_subscribe']>;
     handleThemeSubscribe: InferHandler<'v1', HostApiProtocol['host_theme_subscribe']>;

package/package.json

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