@useragent-kit/sdk 0.0.0 → 0.0.1

package/dist/runtime-chain-service.js

@@ -0,0 +1,846 @@
+import { ChainReadinessTimeoutError, SmoldotDriver, } from "./chain.js";
+export const STALE_PENDING_SUBSCRIPTION_TTL_MS = 60000;
+const PARA_DB_SAVE_RESPONSE_ID = "18446744073709551614";
+const RELAY_DB_SAVE_RESPONSE_ID = "18446744073709551615";
+export const AUDITED_SUBSCRIPTION_STOP_METHODS = Object.freeze({
+    chainHead_v1_follow: "chainHead_v1_unfollow",
+    chain_subscribeAllHeads: "chain_unsubscribeAllHeads",
+    chain_subscribeFinalizedHeads: "chain_unsubscribeFinalizedHeads",
+    chain_subscribeNewHeads: "chain_unsubscribeNewHeads",
+    state_subscribeRuntimeVersion: "state_unsubscribeRuntimeVersion",
+    state_subscribeStorage: "state_unsubscribeStorage",
+    statement_subscribeStatement: "statement_unsubscribeStatement",
+    transactionWatch_v1_submitAndWatch: "transactionWatch_v1_unwatch",
+});
+function summarizeBridgePayload(text) {
+    try {
+        const parsed = JSON.parse(text);
+        const id = typeof parsed.id === "number" ? parsed.id : "?";
+        if (typeof parsed.method === "string") {
+            return `${parsed.method}#${id}`;
+        }
+        if (typeof parsed.result === "string") {
+            return `result(${parsed.result})#${id}`;
+        }
+        const params = parsed.params;
+        if (typeof params === "object" && params != null) {
+            const result = params.result;
+            if (typeof result === "object" &&
+                result != null &&
+                typeof result.event === "string") {
+                return `event(${String(result.event)})`;
+            }
+            const subscription = params.subscription;
+            if (typeof subscription === "string") {
+                return `subscription(${subscription})`;
+            }
+        }
+    }
+    catch {
+        // Best-effort debug logging only.
+    }
+    return "unknown";
+}
+function normalizeRuntimeSpec(spec) {
+    if (!isJsonRecord(spec)) {
+        return spec;
+    }
+    const apis = spec.apis;
+    if (Array.isArray(apis) || !isJsonRecord(apis)) {
+        return spec;
+    }
+    return {
+        ...spec,
+        apis: Object.entries(apis)
+            .filter((entry) => typeof entry[1] === "number")
+            .map(([name, version]) => [name, version]),
+    };
+}
+function normalizeChainHeadFollowEvent(message) {
+    const parsed = safeParseJson(message);
+    if (!isJsonRecord(parsed) ||
+        parsed.method !== "chainHead_v1_followEvent" ||
+        !isJsonRecord(parsed.params) ||
+        !isJsonRecord(parsed.params.result)) {
+        return message;
+    }
+    const result = parsed.params.result;
+    const event = result.event;
+    if (event === "initialized" && isJsonRecord(result.finalizedBlockRuntime)) {
+        const runtime = result.finalizedBlockRuntime;
+        if (!isJsonRecord(runtime.spec)) {
+            return message;
+        }
+        return JSON.stringify({
+            ...parsed,
+            params: {
+                ...parsed.params,
+                result: {
+                    ...result,
+                    finalizedBlockRuntime: {
+                        ...runtime,
+                        spec: normalizeRuntimeSpec(runtime.spec),
+                    },
+                },
+            },
+        });
+    }
+    if (event === "newBlock" && isJsonRecord(result.newRuntime)) {
+        const runtime = result.newRuntime;
+        if (!isJsonRecord(runtime.spec)) {
+            return message;
+        }
+        return JSON.stringify({
+            ...parsed,
+            params: {
+                ...parsed.params,
+                result: {
+                    ...result,
+                    newRuntime: {
+                        ...runtime,
+                        spec: normalizeRuntimeSpec(runtime.spec),
+                    },
+                },
+            },
+        });
+    }
+    return message;
+}
+function normalizeJsonRpcMessage(message) {
+    return normalizeChainHeadFollowEvent(message);
+}
+function createResponseMultiplexer(driver, chainName) {
+    const consumers = new Set();
+    driver.registerResponseInterceptor(chainName, (text) => {
+        for (const handler of consumers) {
+            if (handler(text)) {
+                return true;
+            }
+        }
+        return false;
+    });
+    return {
+        addConsumer(handler) {
+            consumers.add(handler);
+            return () => {
+                consumers.delete(handler);
+            };
+        },
+        dispose() {
+            consumers.clear();
+            driver.unregisterResponseInterceptor(chainName);
+        },
+    };
+}
+function createBridgedConnection(multiplexer, chain, onMessage) {
+    const pendingRequests = new Set();
+    const activeSubscriptions = new Set();
+    const pendingSubscriptionMessages = new Map();
+    const pendingUnsubscribes = new Map();
+    const unregister = multiplexer.addConsumer((text) => {
+        const normalizedText = normalizeJsonRpcMessage(text);
+        const parsed = safeParseJson(normalizedText);
+        if (!isJsonRecord(parsed)) {
+            return false;
+        }
+        if ((typeof parsed.id === "string" && parsed.id.startsWith("host-sdk-")) ||
+            parsed.method === "chainHead_v1_followEvent") {
+            console.info(`[runtime-chain] mux recv ${summarizeBridgePayload(normalizedText)}`);
+        }
+        if ("id" in parsed && typeof parsed.id === "string" && pendingRequests.has(parsed.id)) {
+            pendingRequests.delete(parsed.id);
+            if (typeof parsed.result === "string" && parsed.result !== "") {
+                activeSubscriptions.add(parsed.result);
+                const bufferedMessages = pendingSubscriptionMessages.get(parsed.result);
+                if (bufferedMessages !== undefined) {
+                    pendingSubscriptionMessages.delete(parsed.result);
+                    for (const bufferedMessage of bufferedMessages) {
+                        onMessage(bufferedMessage);
+                    }
+                }
+            }
+            const unsubId = pendingUnsubscribes.get(parsed.id);
+            if (unsubId !== undefined) {
+                activeSubscriptions.delete(unsubId);
+                pendingUnsubscribes.delete(parsed.id);
+            }
+            onMessage(normalizedText);
+            return true;
+        }
+        const params = parsed.params;
+        if (isJsonRecord(params) && typeof params.subscription === "string") {
+            if (activeSubscriptions.has(params.subscription)) {
+                onMessage(normalizedText);
+                return true;
+            }
+            const buffered = pendingSubscriptionMessages.get(params.subscription) ?? [];
+            buffered.push(normalizedText);
+            if (buffered.length > 32) {
+                buffered.splice(0, buffered.length - 32);
+            }
+            pendingSubscriptionMessages.set(params.subscription, buffered);
+        }
+        return false;
+    });
+    return {
+        send(message) {
+            const parsed = safeParseJson(message);
+            if (isJsonRecord(parsed) && typeof parsed.id === "string") {
+                pendingRequests.add(parsed.id);
+                if (typeof parsed.method === "string" &&
+                    parsed.method.includes("unfollow") &&
+                    Array.isArray(parsed.params) &&
+                    typeof parsed.params[0] === "string") {
+                    pendingUnsubscribes.set(parsed.id, parsed.params[0]);
+                }
+            }
+            if (isJsonRecord(parsed) &&
+                typeof parsed.id === "string" &&
+                typeof parsed.method === "string") {
+                console.info(`[runtime-chain] mux send ${parsed.method}#${parsed.id}`);
+            }
+            chain.sendJsonRpc(message);
+        },
+        disconnect() {
+            unregister();
+            pendingRequests.clear();
+            activeSubscriptions.clear();
+            pendingSubscriptionMessages.clear();
+            pendingUnsubscribes.clear();
+        },
+    };
+}
+export class RuntimeChainBridge {
+    constructor(driver) {
+        this.driver = driver;
+        // Start above IDs used by internal WASM subscriptions (1=newHeads, 2=finalizedHeads).
+        this.nextRequestId = 100;
+        this.pendingRequests = new Map();
+        this.pendingSubscriptions = new Map();
+        this.activeSubscriptions = new Map();
+    }
+    registerInterceptor(chainName) {
+        this.driver.registerResponseInterceptor(chainName, (text) => this.handleResponse(chainName, text));
+    }
+    unregisterInterceptor(chainName) {
+        this.pruneStalePendingSubscriptions();
+        this.driver.unregisterResponseInterceptor(chainName);
+        const reason = `chain disconnected: ${chainName}`;
+        for (const [requestId, pending] of this.pendingRequests) {
+            if (pending.chainName === chainName) {
+                pending.reject(new Error(reason));
+                this.pendingRequests.delete(requestId);
+            }
+        }
+        for (const pending of this.pendingSubscriptions.values()) {
+            if (pending.chainName === chainName && !pending.cancelled) {
+                pending.cancelled = true;
+                pending.cancelledAt = Date.now();
+                pending.onAbort(reason);
+            }
+        }
+        for (const [subscriptionId, active] of this.activeSubscriptions) {
+            if (active.chainName === chainName) {
+                this.sendStopRequest(chainName, active.stopMethod, subscriptionId);
+                active.onAbort(reason);
+                this.activeSubscriptions.delete(subscriptionId);
+            }
+        }
+    }
+    async sendRpc(chainName, method, paramsJson, options) {
+        const chain = this.requireChain(chainName);
+        const requestId = this.nextJsonRpcId();
+        const payload = buildJsonRpcRequest(requestId, method, paramsJson);
+        this.pruneStalePendingSubscriptions();
+        return await new Promise((resolve, reject) => {
+            const timeoutMs = options?.timeoutMs ?? null;
+            const timeoutHandle = timeoutMs != null
+                ? setTimeout(() => {
+                    this.pendingRequests.delete(requestId);
+                    reject(new Error(`RPC timeout for ${method} on ${chainName} after ${timeoutMs}ms`));
+                }, timeoutMs)
+                : null;
+            const settleResolve = (jsonRpc) => {
+                if (timeoutHandle != null) {
+                    clearTimeout(timeoutHandle);
+                }
+                resolve(jsonRpc);
+            };
+            const settleReject = (error) => {
+                if (timeoutHandle != null) {
+                    clearTimeout(timeoutHandle);
+                }
+                reject(error);
+            };
+            this.pendingRequests.set(requestId, {
+                chainName,
+                resolve: settleResolve,
+                reject: settleReject,
+            });
+            try {
+                chain.sendJsonRpc(payload);
+            }
+            catch (error) {
+                this.pendingRequests.delete(requestId);
+                settleReject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    startSubscription(chainName, method, paramsJson, onMessage, onAbort) {
+        const chain = this.requireChain(chainName);
+        const requestId = this.nextJsonRpcId();
+        const payload = buildJsonRpcRequest(requestId, method, paramsJson);
+        const token = Symbol(`${chainName}:${requestId}`);
+        const stopMethod = deriveAuditedStopMethod(method);
+        this.pruneStalePendingSubscriptions();
+        this.pendingSubscriptions.set(requestId, {
+            token,
+            chainName,
+            stopMethod,
+            cancelled: false,
+            cancelledAt: null,
+            onMessage,
+            onAbort,
+        });
+        console.info(`[runtime-chain] start subscription ${String(chainName)} ${method} request=${requestId}`);
+        try {
+            chain.sendJsonRpc(payload);
+        }
+        catch {
+            this.pendingSubscriptions.delete(requestId);
+            throw new Error(`failed to start subscription on ${chainName}`);
+        }
+        return () => {
+            const pending = this.pendingSubscriptions.get(requestId);
+            if (pending?.token === token) {
+                pending.cancelled = true;
+                pending.cancelledAt = Date.now();
+            }
+            for (const [subscriptionId, active] of this.activeSubscriptions) {
+                if (active.token === token) {
+                    this.sendStopRequest(active.chainName, active.stopMethod, subscriptionId);
+                    this.activeSubscriptions.delete(subscriptionId);
+                }
+            }
+        };
+    }
+    handleResponse(chainName, text) {
+        this.pruneStalePendingSubscriptions();
+        const parsed = safeParseJson(text);
+        if (!isJsonRecord(parsed)) {
+            return false;
+        }
+        const requestId = parseJsonRpcId(parsed);
+        if (requestId !== null) {
+            const pending = this.pendingRequests.get(requestId);
+            if (pending) {
+                this.pendingRequests.delete(requestId);
+                console.info(`[runtime-chain] rpc response ${String(chainName)} request=${requestId} ${summarizeBridgePayload(text)}`);
+                pending.resolve(text);
+                return true;
+            }
+            const pendingSubscription = this.pendingSubscriptions.get(requestId);
+            if (pendingSubscription) {
+                this.pendingSubscriptions.delete(requestId);
+                const subscriptionId = parseSubscriptionStartResult(parsed);
+                console.info(`[runtime-chain] subscription ack ${String(chainName)} request=${requestId} subscription=${subscriptionId ?? "null"} ${summarizeBridgePayload(text)}`);
+                if (subscriptionId !== null) {
+                    if (pendingSubscription.cancelled) {
+                        this.sendStopRequest(chainName, pendingSubscription.stopMethod, subscriptionId);
+                    }
+                    else {
+                        this.activeSubscriptions.set(subscriptionId, {
+                            token: pendingSubscription.token,
+                            chainName,
+                            stopMethod: pendingSubscription.stopMethod,
+                            onMessage: pendingSubscription.onMessage,
+                            onAbort: pendingSubscription.onAbort,
+                        });
+                    }
+                }
+                if (!pendingSubscription.cancelled) {
+                    pendingSubscription.onMessage(text);
+                }
+                return true;
+            }
+        }
+        const subscriptionId = parseSubscriptionNotificationId(parsed);
+        if (subscriptionId !== null) {
+            const active = this.activeSubscriptions.get(subscriptionId);
+            if (active) {
+                console.info(`[runtime-chain] subscription event ${String(chainName)} subscription=${subscriptionId} ${summarizeBridgePayload(text)}`);
+                active.onMessage(text);
+                return true;
+            }
+            console.warn(`[runtime-chain] dropped subscription event ${String(chainName)} subscription=${subscriptionId} ${summarizeBridgePayload(text)}`);
+        }
+        return false;
+    }
+    requireChain(chainName) {
+        const chain = this.driver.getParaChain(chainName);
+        if (chain === null) {
+            throw new Error(`chain not connected: ${chainName}`);
+        }
+        return chain;
+    }
+    nextJsonRpcId() {
+        const requestId = this.nextRequestId;
+        this.nextRequestId += 1;
+        return `host-sdk-${requestId}`;
+    }
+    pruneStalePendingSubscriptions(now = Date.now()) {
+        for (const [requestId, pending] of this.pendingSubscriptions) {
+            if (pending.cancelled &&
+                pending.cancelledAt !== null &&
+                now - pending.cancelledAt >= STALE_PENDING_SUBSCRIPTION_TTL_MS) {
+                this.pendingSubscriptions.delete(requestId);
+            }
+        }
+    }
+    sendStopRequest(chainName, stopMethod, subscriptionId) {
+        if (stopMethod === null) {
+            return;
+        }
+        const chain = this.driver.getParaChain(chainName);
+        if (chain === null) {
+            return;
+        }
+        try {
+            chain.sendJsonRpc(buildJsonRpcRequest(this.nextJsonRpcId(), stopMethod, JSON.stringify([subscriptionId])));
+        }
+        catch {
+            // Best-effort cleanup only.
+        }
+    }
+}
+export class SmoldotRuntimeChainService {
+    constructor(driver, chainNames, hexEncode, hexDecode) {
+        this.driver = driver;
+        this.chainNames = chainNames;
+        this.hexEncode = hexEncode;
+        this.hexDecode = hexDecode;
+        this.routing = new Map();
+        this.multiplexers = new Map();
+        this.pendingConnect = new Map();
+        this.pendingReady = new Map();
+        this.nextRelayRequestId = 10000;
+    }
+    async connect(chainName) {
+        const existing = this.pendingConnect.get(chainName);
+        if (existing != null) {
+            await existing;
+            return;
+        }
+        const connectPromise = (async () => {
+            this.multiplexers.get(chainName)?.dispose();
+            this.multiplexers.delete(chainName);
+            await this.driver.connect(chainName);
+            this.multiplexers.set(chainName, createResponseMultiplexer(this.driver, chainName));
+            // Fast-path: skip genesis hash RPC if known at compile time.
+            const knownHash = typeof this.driver.chainHandle.knownGenesisHash === "function"
+                ? (this.driver.chainHandle.knownGenesisHash(chainName) ?? null)
+                : null;
+            if (knownHash !== null) {
+                for (const [existingHash, existingChain] of this.routing) {
+                    if (existingChain === chainName) {
+                        this.routing.delete(existingHash);
+                    }
+                }
+                this.routing.set(knownHash, chainName);
+            }
+            else {
+                await this.refreshRouting([chainName]);
+            }
+        })().finally(() => {
+            this.pendingConnect.delete(chainName);
+        });
+        this.pendingConnect.set(chainName, connectPromise);
+        await connectPromise;
+    }
+    waitUntilReady(chainName, options) {
+        const existing = this.pendingReady.get(chainName);
+        if (existing != null) {
+            return existing;
+        }
+        const readyPromise = this.waitUntilReadyInternal(chainName, options).finally(() => {
+            this.pendingReady.delete(chainName);
+        });
+        this.pendingReady.set(chainName, readyPromise);
+        return readyPromise;
+    }
+    async waitUntilReadyInternal(chainName, options) {
+        const timeoutMs = options?.timeoutMs ?? 120000;
+        const pollIntervalMs = options?.pollIntervalMs ?? 500;
+        const deadline = Date.now() + timeoutMs;
+        this.driver.persistState(chainName);
+        let relaySnapshotSaved = false;
+        while (Date.now() < deadline) {
+            const status = this.driver.chainHandle.status(chainName);
+            if (status.state === "Error") {
+                throw new Error(`chain ${chainName} entered error state: ${status.error ?? "unknown"}`);
+            }
+            if (status.state === "Disconnected") {
+                throw new Error(`chain ${chainName} is disconnected`);
+            }
+            const remainingMs = deadline - Date.now();
+            const rpcTimeoutMs = Math.max(1000, Math.min(remainingMs, pollIntervalMs * 8));
+            if (status.finalizedBlock !== null && status.finalizedBlock !== undefined) {
+                try {
+                    await this.sendRpc(chainName, "chain_getFinalizedHead", "[]", {
+                        timeoutMs: rpcTimeoutMs,
+                    });
+                    return;
+                }
+                catch {
+                    // The chain reports a finalized head, but the consumer-visible RPC path is still
+                    // not usable. Keep polling until that path succeeds or the outer timeout expires.
+                }
+                await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+                continue;
+            }
+            if (!relaySnapshotSaved) {
+                try {
+                    const relayResponse = await this.sendRelayRpc(chainName, "chainHead_unstable_finalizedDatabase", "[]", rpcTimeoutMs);
+                    const relayDatabase = extractJsonRpcStringResult(relayResponse);
+                    if (relayDatabase !== null) {
+                        this.driver.chainHandle.processRelayResponse(chainName, buildStringResultResponse(RELAY_DB_SAVE_RESPONSE_ID, relayDatabase));
+                        relaySnapshotSaved = true;
+                    }
+                }
+                catch {
+                    // Keep polling until the relay finalized database is ready.
+                }
+            }
+            try {
+                const response = await this.sendRpc(chainName, "chainHead_unstable_finalizedDatabase", "[]", { timeoutMs: rpcTimeoutMs });
+                const databaseContent = extractJsonRpcStringResult(response);
+                if (databaseContent !== null && relaySnapshotSaved) {
+                    this.driver.chainHandle.processResponse(chainName, buildStringResultResponse(PARA_DB_SAVE_RESPONSE_ID, databaseContent));
+                }
+            }
+            catch {
+                // Keep polling until the chain becomes query-ready or the outer timeout expires.
+            }
+            const refreshedStatus = this.driver.chainHandle.status(chainName);
+            if (refreshedStatus.finalizedBlock !== null && refreshedStatus.finalizedBlock !== undefined) {
+                try {
+                    await this.sendRpc(chainName, "chain_getFinalizedHead", "[]", {
+                        timeoutMs: rpcTimeoutMs,
+                    });
+                    return;
+                }
+                catch {
+                    // Readiness must prove that ordinary bridged RPCs are usable, not just that the
+                    // finalized snapshot path or status field has advanced.
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        }
+        throw new ChainReadinessTimeoutError(chainName, timeoutMs);
+    }
+    async sendRelayRpc(chainName, method, paramsJson, timeoutMs) {
+        const relay = this.driver.getRelayChain(chainName);
+        if (relay === null) {
+            throw new Error(`relay chain not connected: ${chainName}`);
+        }
+        const requestId = String(this.nextRelayRequestId);
+        this.nextRelayRequestId += 1;
+        const payload = buildJsonRpcRequest(requestId, method, paramsJson);
+        return await new Promise((resolve, reject) => {
+            const cleanup = () => {
+                this.driver.unregisterRelayResponseInterceptor(chainName);
+                clearTimeout(timer);
+            };
+            const timer = setTimeout(() => {
+                cleanup();
+                reject(new Error(`RPC timeout for ${method} on relay ${chainName} after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.driver.registerRelayResponseInterceptor(chainName, (text) => {
+                const parsed = safeParseJson(text);
+                if (!isJsonRecord(parsed) || parseJsonRpcId(parsed) !== requestId) {
+                    return false;
+                }
+                cleanup();
+                resolve(text);
+                return true;
+            });
+            try {
+                relay.sendJsonRpc(payload);
+            }
+            catch (error) {
+                cleanup();
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    setBootDiagnostics(chainName, callback) {
+        this.driver.setBootDiagnostics(chainName, callback);
+    }
+    persistState(chainNames = this.chainNames) {
+        for (const chainName of chainNames) {
+            this.driver.persistState(chainName);
+        }
+    }
+    disconnect(chainName) {
+        this.multiplexers.get(chainName)?.dispose();
+        this.multiplexers.delete(chainName);
+        this.driver.disconnect(chainName);
+        for (const [genesisHash, currentChain] of this.routing) {
+            if (currentChain === chainName) {
+                this.routing.delete(genesisHash);
+            }
+        }
+    }
+    statuses() {
+        return this.driver.allStatuses();
+    }
+    async refreshRouting(chainNames = this.chainNames) {
+        for (const chainName of chainNames) {
+            let nextHash = null;
+            try {
+                const response = await this.sendRpc(chainName, "chainSpec_v1_genesisHash", "[]");
+                const genesisHash = parseGenesisHashResult(response, this.hexDecode);
+                if (genesisHash !== null) {
+                    nextHash = this.hexEncode(genesisHash);
+                }
+            }
+            catch {
+                // Ignore disconnected or not-yet-live chains.
+            }
+            for (const [existingHash, existingChain] of this.routing) {
+                if (existingChain === chainName && existingHash !== nextHash) {
+                    this.routing.delete(existingHash);
+                }
+            }
+            if (nextHash !== null) {
+                this.routing.set(nextHash, chainName);
+            }
+        }
+        return new Map(this.routing);
+    }
+    routingTable() {
+        return new Map(this.routing);
+    }
+    supportedGenesisHashes() {
+        return [...this.routing.keys()].map((genesisHash) => this.hexDecode(genesisHash));
+    }
+    routeChainByGenesisHash(genesisHash) {
+        return this.routing.get(this.hexEncode(genesisHash)) ?? null;
+    }
+    sendRpc(chainName, method, paramsJson, options) {
+        const requestId = `host-sdk-rpc-${crypto.randomUUID()}`;
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const timeoutHandle = options?.timeoutMs != null
+                ? setTimeout(() => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
+                    rpcConnection.disconnect();
+                    reject(new Error(`RPC timeout for ${method} on ${chainName} after ${options.timeoutMs}ms`));
+                }, options.timeoutMs)
+                : null;
+            const onMessage = (message) => {
+                const parsed = safeParseJson(message);
+                if (!isJsonRecord(parsed) || parsed.id !== requestId || settled) {
+                    return;
+                }
+                settled = true;
+                if (timeoutHandle != null) {
+                    clearTimeout(timeoutHandle);
+                }
+                rpcConnection.disconnect();
+                console.info(`[runtime-chain] rpc response ${String(chainName)} request=${requestId} ${summarizeBridgePayload(message)}`);
+                if (isJsonRecord(parsed.error)) {
+                    reject(new Error(typeof parsed.error.message === "string"
+                        ? parsed.error.message
+                        : "unknown json-rpc error"));
+                    return;
+                }
+                resolve(message);
+            };
+            const rpcConnection = this.openConnection(chainName, onMessage);
+            try {
+                console.info(`[runtime-chain] rpc send ${String(chainName)} request=${requestId} method=${method}`);
+                rpcConnection.send(JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: requestId,
+                    method,
+                    params: JSON.parse(paramsJson),
+                }));
+            }
+            catch (error) {
+                settled = true;
+                if (timeoutHandle != null) {
+                    clearTimeout(timeoutHandle);
+                }
+                rpcConnection.disconnect();
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    startSubscription(chainName, method, paramsJson, onMessage, onAbort) {
+        const requestId = `host-sdk-sub-${crypto.randomUUID()}`;
+        let stopped = false;
+        let subscriptionId = null;
+        console.info(`[runtime-chain] start subscription ${String(chainName)} ${method} request=${requestId}`);
+        const connection = this.openConnection(chainName, (message) => {
+            const parsed = safeParseJson(message);
+            if (!isJsonRecord(parsed)) {
+                return;
+            }
+            if (parsed.id === requestId) {
+                if (typeof parsed.result === "string" && parsed.result !== "") {
+                    subscriptionId = parsed.result;
+                    console.info(`[runtime-chain] subscription ack ${String(chainName)} request=${requestId} subscription=${subscriptionId} ${summarizeBridgePayload(message)}`);
+                    onMessage(message);
+                    return;
+                }
+                connection.disconnect();
+                onAbort(isJsonRecord(parsed.error) && typeof parsed.error.message === "string"
+                    ? parsed.error.message
+                    : "subscription start failed");
+                return;
+            }
+            if (subscriptionId !== null &&
+                isJsonRecord(parsed.params) &&
+                parsed.params.subscription === subscriptionId) {
+                console.info(`[runtime-chain] subscription event ${String(chainName)} subscription=${subscriptionId} ${summarizeBridgePayload(message)}`);
+                onMessage(message);
+            }
+        });
+        try {
+            connection.send(JSON.stringify({
+                jsonrpc: "2.0",
+                id: requestId,
+                method,
+                params: JSON.parse(paramsJson),
+            }));
+        }
+        catch (error) {
+            connection.disconnect();
+            throw error instanceof Error ? error : new Error(String(error));
+        }
+        return () => {
+            if (stopped) {
+                return;
+            }
+            stopped = true;
+            if (subscriptionId !== null) {
+                const stopMethod = deriveAuditedStopMethod(method);
+                if (stopMethod !== null) {
+                    try {
+                        connection.send(JSON.stringify({
+                            jsonrpc: "2.0",
+                            id: `host-sdk-unsub-${crypto.randomUUID()}`,
+                            method: stopMethod,
+                            params: [subscriptionId],
+                        }));
+                    }
+                    catch {
+                        // Best-effort cleanup only.
+                    }
+                }
+            }
+            connection.disconnect();
+        };
+    }
+    destroy() {
+        for (const multiplexer of this.multiplexers.values()) {
+            multiplexer.dispose();
+        }
+        this.multiplexers.clear();
+        return this.driver.destroy();
+    }
+    openConnection(chainName, onMessage) {
+        const multiplexer = this.multiplexers.get(chainName);
+        if (multiplexer == null) {
+            throw new Error(`chain not connected: ${chainName}`);
+        }
+        const chain = this.driver.getParaChain(chainName);
+        if (chain == null) {
+            throw new Error(`chain not connected: ${chainName}`);
+        }
+        return createBridgedConnection(multiplexer, chain, onMessage);
+    }
+}
+export function createSmoldotRuntimeChainService(options) {
+    const driver = new SmoldotDriver(options.sdk.chainClient, options.smoldotClient);
+    return new SmoldotRuntimeChainService(driver, options.chainNames, options.sdk.hexEncode.bind(options.sdk), options.sdk.hexDecode.bind(options.sdk));
+}
+function deriveAuditedStopMethod(method) {
+    return AUDITED_SUBSCRIPTION_STOP_METHODS[method] ?? null;
+}
+function buildJsonRpcRequest(id, method, paramsJson) {
+    const params = safeParseJson(paramsJson);
+    if (params === null) {
+        throw new Error("invalid params JSON");
+    }
+    return JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        method,
+        params,
+    });
+}
+function safeParseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function isJsonRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function parseJsonRpcId(value) {
+    const id = value.id;
+    if (typeof id === "number") {
+        return String(id);
+    }
+    if (typeof id === "string" && id !== "") {
+        return id;
+    }
+    return null;
+}
+function parseSubscriptionStartResult(value) {
+    const result = value.result;
+    return typeof result === "string" ? result : null;
+}
+function parseSubscriptionNotificationId(value) {
+    const params = value.params;
+    if (!isJsonRecord(params)) {
+        return null;
+    }
+    const subscription = params.subscription;
+    return typeof subscription === "string" ? subscription : null;
+}
+function parseGenesisHashResult(response, hexDecode) {
+    const parsed = safeParseJson(response);
+    if (!isJsonRecord(parsed)) {
+        return null;
+    }
+    const result = parsed.result;
+    if (typeof result !== "string") {
+        return null;
+    }
+    try {
+        return hexDecode(result);
+    }
+    catch {
+        return null;
+    }
+}
+function extractJsonRpcStringResult(response) {
+    const parsed = safeParseJson(response);
+    if (!isJsonRecord(parsed)) {
+        return null;
+    }
+    return typeof parsed.result === "string" && parsed.result.length > 0 ? parsed.result : null;
+}
+function buildStringResultResponse(id, result) {
+    return `{"jsonrpc":"2.0","id":${id},"result":${JSON.stringify(result)}}`;
+}
+//# sourceMappingURL=runtime-chain-service.js.map