@useragent-kit/sdk 0.0.0 → 0.0.1

package/dist/remote-runtime-provider.js

@@ -0,0 +1,1002 @@
+import { AUDITED_SUBSCRIPTION_STOP_METHODS } from "./runtime-chain-service.js";
+const SUBSCRIPTION_STOP_METHODS = new Set(Object.values(AUDITED_SUBSCRIPTION_STOP_METHODS));
+const FOLLOW_START_METHOD = "chainHead_v1_follow";
+const FOLLOW_STOP_METHOD = "chainHead_v1_unfollow";
+const FOLLOW_BOUND_RPC_METHODS = new Set([
+    "chainHead_v1_body",
+    "chainHead_v1_call",
+    "chainHead_v1_continue",
+    "chainHead_v1_header",
+    "chainHead_v1_stopOperation",
+    "chainHead_v1_storage",
+]);
+const sharedFollowBridges = new WeakMap();
+function toErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function recordRemoteProviderTrace(entry) {
+    if (typeof window === "undefined") {
+        return;
+    }
+    if (!window.location.hostname.endsWith(".localhost")) {
+        return;
+    }
+    const key = "__hostSdkRemoteProviderTrace";
+    const target = window;
+    const trace = target[key] ?? [];
+    trace.push(entry);
+    if (trace.length > 200) {
+        trace.splice(0, trace.length - 200);
+    }
+    target[key] = trace;
+}
+function safeParseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function isJsonRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function parseJsonRpcId(value) {
+    if (typeof value === "string" || typeof value === "number") {
+        return value;
+    }
+    return null;
+}
+function parseSubscriptionResultId(message) {
+    const parsed = safeParseJson(message);
+    if (!isJsonRecord(parsed) || typeof parsed.result !== "string") {
+        return null;
+    }
+    return parsed.result;
+}
+function remapJsonRpcResponseId(message, id) {
+    const parsed = safeParseJson(message);
+    if (!isJsonRecord(parsed)) {
+        return message;
+    }
+    return JSON.stringify({
+        ...parsed,
+        id,
+    });
+}
+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 buildJsonRpcSuccess(id, result) {
+    return JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        result,
+    });
+}
+function buildJsonRpcError(id, reason) {
+    return JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        error: {
+            code: -32000,
+            message: reason,
+        },
+    });
+}
+function parseHeaderParentHashFromResponse(message) {
+    const parsed = safeParseJson(message);
+    if (!isJsonRecord(parsed)) {
+        return null;
+    }
+    if (isJsonRecord(parsed.result) && typeof parsed.result.parentHash === "string") {
+        return parsed.result.parentHash;
+    }
+    if (typeof parsed.result !== "string") {
+        return null;
+    }
+    const headerHex = parsed.result.startsWith("0x") ? parsed.result.slice(2) : parsed.result;
+    if (headerHex.length < 64) {
+        return null;
+    }
+    return `0x${headerHex.slice(0, 64)}`;
+}
+function buildSyntheticNewBlockEvent(subscriptionId, blockHash, parentBlockHash) {
+    return JSON.stringify({
+        jsonrpc: "2.0",
+        method: "chainHead_v1_followEvent",
+        params: {
+            subscription: subscriptionId,
+            result: {
+                event: "newBlock",
+                blockHash,
+                parentBlockHash,
+                newRuntime: null,
+            },
+        },
+    });
+}
+function parseFollowEventMessage(message) {
+    const parsed = safeParseJson(message);
+    if (!isJsonRecord(parsed) ||
+        parsed.method !== "chainHead_v1_followEvent" ||
+        !isJsonRecord(parsed.params) ||
+        !isJsonRecord(parsed.params.result) ||
+        typeof parsed.params.subscription !== "string") {
+        return null;
+    }
+    const event = parsed.params.result.event;
+    if (typeof event !== "string") {
+        return null;
+    }
+    return {
+        event,
+        operationId: typeof parsed.params.result.operationId === "string"
+            ? parsed.params.result.operationId
+            : null,
+    };
+}
+function parseInitializedFinalizedHashes(message) {
+    const parsed = safeParseJson(message);
+    if (!isJsonRecord(parsed) ||
+        parsed.method !== "chainHead_v1_followEvent" ||
+        !isJsonRecord(parsed.params) ||
+        !isJsonRecord(parsed.params.result) ||
+        parsed.params.result.event !== "initialized" ||
+        !Array.isArray(parsed.params.result.finalizedBlockHashes)) {
+        return null;
+    }
+    return parsed.params.result.finalizedBlockHashes.filter((value) => typeof value === "string" && value !== "");
+}
+function parseNewBlockEvent(message) {
+    const parsed = safeParseJson(message);
+    if (!isJsonRecord(parsed) ||
+        parsed.method !== "chainHead_v1_followEvent" ||
+        !isJsonRecord(parsed.params) ||
+        !isJsonRecord(parsed.params.result) ||
+        parsed.params.result.event !== "newBlock" ||
+        typeof parsed.params.result.blockHash !== "string" ||
+        typeof parsed.params.result.parentBlockHash !== "string") {
+        return null;
+    }
+    return {
+        blockHash: parsed.params.result.blockHash,
+        parentBlockHash: parsed.params.result.parentBlockHash,
+    };
+}
+function parseBestBlockChangedHash(message) {
+    const parsed = safeParseJson(message);
+    if (!isJsonRecord(parsed) ||
+        parsed.method !== "chainHead_v1_followEvent" ||
+        !isJsonRecord(parsed.params) ||
+        !isJsonRecord(parsed.params.result) ||
+        parsed.params.result.event !== "bestBlockChanged" ||
+        typeof parsed.params.result.bestBlockHash !== "string") {
+        return null;
+    }
+    return parsed.params.result.bestBlockHash;
+}
+function parseFinalizedEventHashes(message) {
+    const parsed = safeParseJson(message);
+    if (!isJsonRecord(parsed) ||
+        parsed.method !== "chainHead_v1_followEvent" ||
+        !isJsonRecord(parsed.params) ||
+        !isJsonRecord(parsed.params.result) ||
+        parsed.params.result.event !== "finalized" ||
+        !Array.isArray(parsed.params.result.finalizedBlockHashes)) {
+        return null;
+    }
+    return parsed.params.result.finalizedBlockHashes.filter((value) => typeof value === "string" && value !== "");
+}
+function rewriteSubscriptionId(message, subscriptionId) {
+    const parsed = safeParseJson(message);
+    if (!isJsonRecord(parsed) ||
+        !isJsonRecord(parsed.params) ||
+        typeof parsed.params.subscription !== "string") {
+        return message;
+    }
+    return JSON.stringify({
+        ...parsed,
+        params: {
+            ...parsed.params,
+            subscription: subscriptionId,
+        },
+    });
+}
+function parseOperationIdFromResponse(message) {
+    const parsed = safeParseJson(message);
+    if (!isJsonRecord(parsed) ||
+        !isJsonRecord(parsed.result) ||
+        typeof parsed.result.operationId !== "string") {
+        return null;
+    }
+    return parsed.result.operationId;
+}
+class SharedFollowBridge {
+    constructor(service, chainName) {
+        this.nextClientId = 1;
+        this.upstreamSubscriptionId = null;
+        this.startPromise = null;
+        this.clients = new Map();
+        this.operationOwners = new Map();
+        this.pendingOperationMessages = new Map();
+        this.lastInitializedMessage = null;
+        this.replayMessages = [];
+        this.rootedBlockHashes = new Set();
+        this.pendingNewBlocks = new Map();
+        this.pendingBestBlockChanged = new Map();
+        this.pendingFinalized = new Map();
+        this.hydrationPromises = new Map();
+        this.service = service;
+        this.chainName = chainName;
+    }
+    async attachClient(onMessage) {
+        await this.ensureStarted();
+        const clientSubscriptionId = `host-sdk-remote-follow-${String(this.nextClientId++)}`;
+        this.clients.set(clientSubscriptionId, {
+            onMessage,
+            ready: false,
+            pendingMessages: [],
+        });
+        return clientSubscriptionId;
+    }
+    replayClient(clientSubscriptionId) {
+        const client = this.clients.get(clientSubscriptionId);
+        if (client === undefined) {
+            return;
+        }
+        if (this.lastInitializedMessage !== null) {
+            client.onMessage(rewriteSubscriptionId(this.lastInitializedMessage, clientSubscriptionId));
+        }
+        for (const message of this.replayMessages) {
+            client.onMessage(rewriteSubscriptionId(message, clientSubscriptionId));
+        }
+        client.ready = true;
+        const pendingMessages = client.pendingMessages.splice(0);
+        for (const message of pendingMessages) {
+            client.onMessage(rewriteSubscriptionId(message, clientSubscriptionId));
+        }
+    }
+    detachClient(clientSubscriptionId) {
+        this.clients.delete(clientSubscriptionId);
+        for (const [operationId, owner] of this.operationOwners) {
+            if (owner === clientSubscriptionId) {
+                this.operationOwners.delete(operationId);
+            }
+        }
+    }
+    rememberReplayMessage(message) {
+        if (this.lastInitializedMessage === null || message === this.lastInitializedMessage) {
+            return;
+        }
+        this.replayMessages.push(message);
+        if (this.replayMessages.length > 512) {
+            this.replayMessages.splice(0, this.replayMessages.length - 512);
+        }
+    }
+    deliverToClient(clientSubscriptionId, client, message) {
+        if (!client.ready) {
+            client.pendingMessages.push(message);
+            if (client.pendingMessages.length > 512) {
+                client.pendingMessages.splice(0, client.pendingMessages.length - 512);
+            }
+            return;
+        }
+        client.onMessage(rewriteSubscriptionId(message, clientSubscriptionId));
+    }
+    bufferOperationMessage(operationId, message) {
+        const pending = this.pendingOperationMessages.get(operationId) ?? [];
+        pending.push(message);
+        if (pending.length > 64) {
+            pending.splice(0, pending.length - 64);
+        }
+        this.pendingOperationMessages.set(operationId, pending);
+    }
+    flushPendingOperationMessages(operationId, clientSubscriptionId) {
+        const pending = this.pendingOperationMessages.get(operationId);
+        if (pending === undefined) {
+            return;
+        }
+        this.pendingOperationMessages.delete(operationId);
+        const client = this.clients.get(clientSubscriptionId);
+        if (client === undefined) {
+            return;
+        }
+        let sawTerminalEvent = false;
+        for (const message of pending) {
+            const followEvent = parseFollowEventMessage(message);
+            if (followEvent?.event === "operationStorageDone" ||
+                followEvent?.event === "operationCallDone" ||
+                followEvent?.event === "operationBodyDone" ||
+                followEvent?.event === "operationInaccessible" ||
+                followEvent?.event === "operationError") {
+                sawTerminalEvent = true;
+            }
+            this.deliverToClient(clientSubscriptionId, client, message);
+        }
+        if (sawTerminalEvent) {
+            this.operationOwners.delete(operationId);
+        }
+    }
+    broadcast(message) {
+        this.rememberReplayMessage(message);
+        recordRemoteProviderTrace({
+            direction: "recv",
+            method: "sharedFollow.broadcast",
+            message,
+        });
+        for (const [clientSubscriptionId, client] of this.clients) {
+            this.deliverToClient(clientSubscriptionId, client, message);
+        }
+    }
+    markRooted(blockHash) {
+        if (this.rootedBlockHashes.has(blockHash)) {
+            return;
+        }
+        this.rootedBlockHashes.add(blockHash);
+        const pendingBest = this.pendingBestBlockChanged.get(blockHash);
+        if (pendingBest !== undefined) {
+            this.pendingBestBlockChanged.delete(blockHash);
+            for (const message of pendingBest) {
+                this.broadcast(message);
+            }
+        }
+        const pendingFinalized = this.pendingFinalized.get(blockHash);
+        if (pendingFinalized !== undefined) {
+            this.pendingFinalized.delete(blockHash);
+            for (const message of pendingFinalized) {
+                this.broadcast(message);
+            }
+        }
+        const pendingChildren = this.pendingNewBlocks.get(blockHash);
+        if (pendingChildren !== undefined) {
+            this.pendingNewBlocks.delete(blockHash);
+            for (const message of pendingChildren) {
+                this.forwardNewBlock(message);
+            }
+        }
+    }
+    async hydrateAncestorChain(blockHash, depth = 0) {
+        if (this.rootedBlockHashes.has(blockHash)) {
+            return;
+        }
+        if (depth > 256) {
+            throw new Error(`shared follow hydration exceeded depth for ${blockHash}`);
+        }
+        const existing = this.hydrationPromises.get(blockHash);
+        if (existing !== undefined) {
+            await existing;
+            return;
+        }
+        if (this.upstreamSubscriptionId === null) {
+            throw new Error("shared chainHead follow is not ready");
+        }
+        const hydration = (async () => {
+            let response = await this.service.sendRpc(this.chainName, "chain_getHeader", JSON.stringify([blockHash]));
+            let parentBlockHash = parseHeaderParentHashFromResponse(response);
+            if (parentBlockHash === null) {
+                response = await this.service.sendRpc(this.chainName, "chainHead_v1_header", JSON.stringify([this.upstreamSubscriptionId, blockHash]));
+                parentBlockHash = parseHeaderParentHashFromResponse(response);
+            }
+            if (parentBlockHash === null) {
+                throw new Error(`Unable to decode header parent for ${blockHash}`);
+            }
+            if (!this.rootedBlockHashes.has(parentBlockHash)) {
+                await this.hydrateAncestorChain(parentBlockHash, depth + 1);
+            }
+            if (!this.rootedBlockHashes.has(parentBlockHash)) {
+                return;
+            }
+            const upstreamSubscriptionId = this.upstreamSubscriptionId;
+            if (upstreamSubscriptionId === null) {
+                throw new Error("shared chainHead follow is not ready");
+            }
+            const syntheticMessage = buildSyntheticNewBlockEvent(upstreamSubscriptionId, blockHash, parentBlockHash);
+            recordRemoteProviderTrace({
+                direction: "recv",
+                method: "sharedFollow.syntheticNewBlock",
+                message: syntheticMessage,
+                detail: `parent:${parentBlockHash}`,
+            });
+            this.broadcast(syntheticMessage);
+            this.markRooted(blockHash);
+        })().finally(() => {
+            this.hydrationPromises.delete(blockHash);
+        });
+        this.hydrationPromises.set(blockHash, hydration);
+        await hydration;
+    }
+    forwardNewBlock(message) {
+        const block = parseNewBlockEvent(message);
+        if (block === null) {
+            this.broadcast(message);
+            return;
+        }
+        if (!this.rootedBlockHashes.has(block.parentBlockHash)) {
+            recordRemoteProviderTrace({
+                direction: "recv",
+                method: "sharedFollow.bufferNewBlock",
+                message,
+                detail: `missing-parent:${block.parentBlockHash}`,
+            });
+            const pending = this.pendingNewBlocks.get(block.parentBlockHash) ?? [];
+            pending.push(message);
+            this.pendingNewBlocks.set(block.parentBlockHash, pending);
+            void this.hydrateAncestorChain(block.parentBlockHash).catch((error) => {
+                recordRemoteProviderTrace({
+                    direction: "abort",
+                    method: "sharedFollow.hydrateAncestorChain",
+                    reason: toErrorMessage(error),
+                    detail: `block:${block.parentBlockHash}`,
+                });
+            });
+            return;
+        }
+        recordRemoteProviderTrace({
+            direction: "recv",
+            method: "sharedFollow.forwardNewBlock",
+            message,
+            detail: `parent:${block.parentBlockHash}`,
+        });
+        this.broadcast(message);
+        this.markRooted(block.blockHash);
+    }
+    forwardBestBlockChanged(message) {
+        const blockHash = parseBestBlockChangedHash(message);
+        if (blockHash === null) {
+            this.broadcast(message);
+            return;
+        }
+        if (!this.rootedBlockHashes.has(blockHash)) {
+            recordRemoteProviderTrace({
+                direction: "recv",
+                method: "sharedFollow.bufferBestBlockChanged",
+                message,
+                detail: `missing-block:${blockHash}`,
+            });
+            const pending = this.pendingBestBlockChanged.get(blockHash) ?? [];
+            pending.push(message);
+            this.pendingBestBlockChanged.set(blockHash, pending);
+            return;
+        }
+        this.broadcast(message);
+    }
+    forwardFinalized(message) {
+        const blockHashes = parseFinalizedEventHashes(message);
+        if (blockHashes === null || blockHashes.length === 0) {
+            this.broadcast(message);
+            return;
+        }
+        const unknown = blockHashes.filter((blockHash) => !this.rootedBlockHashes.has(blockHash));
+        if (unknown.length > 0) {
+            recordRemoteProviderTrace({
+                direction: "recv",
+                method: "sharedFollow.bufferFinalized",
+                message,
+                detail: `missing-blocks:${unknown.join(",")}`,
+            });
+            for (const blockHash of unknown) {
+                const pending = this.pendingFinalized.get(blockHash) ?? [];
+                pending.push(message);
+                this.pendingFinalized.set(blockHash, pending);
+            }
+            return;
+        }
+        this.broadcast(message);
+    }
+    async sendFollowBoundRpc(clientSubscriptionId, method, params) {
+        await this.ensureStarted();
+        if (this.upstreamSubscriptionId === null) {
+            throw new Error("shared chainHead follow is not ready");
+        }
+        const rewrittenParams = [...params];
+        rewrittenParams[0] = this.upstreamSubscriptionId;
+        const response = normalizeJsonRpcMessage(await this.service.sendRpc(this.chainName, method, JSON.stringify(rewrittenParams)));
+        const operationId = parseOperationIdFromResponse(response);
+        if (operationId !== null) {
+            this.operationOwners.set(operationId, clientSubscriptionId);
+            this.flushPendingOperationMessages(operationId, clientSubscriptionId);
+        }
+        return response;
+    }
+    async ensureStarted() {
+        if (this.startPromise !== null) {
+            await this.startPromise;
+            return;
+        }
+        this.startPromise = new Promise((resolve, reject) => {
+            let ready = false;
+            const markReady = () => {
+                if (ready) {
+                    return;
+                }
+                ready = true;
+                resolve();
+            };
+            void Promise.resolve(this.service.startSubscription(this.chainName, FOLLOW_START_METHOD, JSON.stringify([true]), (message) => {
+                const normalizedMessage = normalizeJsonRpcMessage(message);
+                const subscriptionId = parseSubscriptionResultId(normalizedMessage);
+                if (subscriptionId !== null) {
+                    this.upstreamSubscriptionId = subscriptionId;
+                    markReady();
+                    return;
+                }
+                const followEvent = parseFollowEventMessage(normalizedMessage);
+                if (followEvent === null) {
+                    return;
+                }
+                if (followEvent.event === "initialized") {
+                    this.lastInitializedMessage = normalizedMessage;
+                    this.replayMessages = [];
+                    this.rootedBlockHashes.clear();
+                    this.pendingNewBlocks.clear();
+                    this.pendingBestBlockChanged.clear();
+                    this.pendingFinalized.clear();
+                    const finalizedBlockHashes = parseInitializedFinalizedHashes(normalizedMessage) ?? [];
+                    for (const blockHash of finalizedBlockHashes) {
+                        this.rootedBlockHashes.add(blockHash);
+                    }
+                    recordRemoteProviderTrace({
+                        direction: "recv",
+                        method: "sharedFollow.initialized",
+                        message: normalizedMessage,
+                        detail: `rooted:${finalizedBlockHashes.join(",")}`,
+                    });
+                }
+                if (followEvent.operationId !== null) {
+                    const owner = this.operationOwners.get(followEvent.operationId);
+                    if (owner === undefined) {
+                        this.bufferOperationMessage(followEvent.operationId, normalizedMessage);
+                        return;
+                    }
+                    const client = this.clients.get(owner);
+                    if (client !== undefined) {
+                        this.deliverToClient(owner, client, normalizedMessage);
+                    }
+                    if (followEvent.event === "operationStorageDone" ||
+                        followEvent.event === "operationCallDone" ||
+                        followEvent.event === "operationBodyDone" ||
+                        followEvent.event === "operationInaccessible" ||
+                        followEvent.event === "operationError") {
+                        this.operationOwners.delete(followEvent.operationId);
+                    }
+                    return;
+                }
+                switch (followEvent.event) {
+                    case "initialized":
+                        this.broadcast(normalizedMessage);
+                        return;
+                    case "newBlock":
+                        this.forwardNewBlock(normalizedMessage);
+                        return;
+                    case "bestBlockChanged":
+                        this.forwardBestBlockChanged(normalizedMessage);
+                        return;
+                    case "finalized":
+                        this.forwardFinalized(normalizedMessage);
+                        return;
+                    default:
+                        this.broadcast(normalizedMessage);
+                        return;
+                }
+            }, (reason) => {
+                this.startPromise = null;
+                this.upstreamSubscriptionId = null;
+                if (!ready) {
+                    reject(new Error(reason));
+                }
+                for (const client of this.clients.values()) {
+                    client.onMessage(JSON.stringify({
+                        jsonrpc: "2.0",
+                        error: { code: -32000, message: reason },
+                    }));
+                }
+            })).catch((error) => {
+                this.startPromise = null;
+                this.upstreamSubscriptionId = null;
+                reject(error instanceof Error ? error : new Error(String(error)));
+            });
+        });
+        await this.startPromise;
+    }
+}
+function getSharedFollowBridge(service, chainName) {
+    let byChain = sharedFollowBridges.get(service);
+    if (byChain === undefined) {
+        byChain = new Map();
+        sharedFollowBridges.set(service, byChain);
+    }
+    let bridge = byChain.get(chainName);
+    if (bridge === undefined) {
+        bridge = new SharedFollowBridge(service, chainName);
+        byChain.set(chainName, bridge);
+    }
+    return bridge;
+}
+export function createRemoteRuntimeProvider(service, chainName) {
+    return (onMessage) => {
+        const debug = typeof window !== "undefined" && window.location.hostname.endsWith(".localhost");
+        let disconnected = false;
+        const activeSubscriptions = new Map();
+        const followSubscriptions = new Map();
+        const sharedFollowBridge = getSharedFollowBridge(service, chainName);
+        const sanitizeFollowEventForConnection = (rawMessage) => {
+            const parsed = safeParseJson(rawMessage);
+            if (!isJsonRecord(parsed) ||
+                parsed.method !== "chainHead_v1_followEvent" ||
+                !isJsonRecord(parsed.params) ||
+                typeof parsed.params.subscription !== "string" ||
+                !isJsonRecord(parsed.params.result)) {
+                return rawMessage;
+            }
+            const followState = followSubscriptions.get(parsed.params.subscription);
+            if (followState === undefined) {
+                return rawMessage;
+            }
+            const result = parsed.params.result;
+            const event = result.event;
+            if (event === "initialized") {
+                const hashes = Array.isArray(result.finalizedBlockHashes)
+                    ? result.finalizedBlockHashes.filter((value) => typeof value === "string" && value !== "")
+                    : [];
+                followState.knownBlockHashes.clear();
+                for (const hash of hashes) {
+                    followState.knownBlockHashes.add(hash);
+                }
+                return rawMessage;
+            }
+            if (event === "newBlock") {
+                if (typeof result.parentBlockHash !== "string" ||
+                    !followState.knownBlockHashes.has(result.parentBlockHash)) {
+                    return null;
+                }
+                if (typeof result.blockHash === "string") {
+                    followState.knownBlockHashes.add(result.blockHash);
+                }
+                return rawMessage;
+            }
+            if (event === "bestBlockChanged") {
+                if (typeof result.bestBlockHash === "string" &&
+                    !followState.knownBlockHashes.has(result.bestBlockHash)) {
+                    return null;
+                }
+                return rawMessage;
+            }
+            if (event === "finalized") {
+                const finalizedBlockHashes = Array.isArray(result.finalizedBlockHashes)
+                    ? result.finalizedBlockHashes.filter((value) => typeof value === "string" && followState.knownBlockHashes.has(value))
+                    : [];
+                if (finalizedBlockHashes.length === 0) {
+                    return null;
+                }
+                if (Array.isArray(result.prunedBlockHashes)) {
+                    for (const hash of result.prunedBlockHashes) {
+                        if (typeof hash === "string") {
+                            followState.knownBlockHashes.delete(hash);
+                        }
+                    }
+                }
+                return JSON.stringify({
+                    ...parsed,
+                    params: {
+                        ...parsed.params,
+                        result: {
+                            ...result,
+                            finalizedBlockHashes,
+                        },
+                    },
+                });
+            }
+            return rawMessage;
+        };
+        return {
+            send(message) {
+                if (disconnected) {
+                    return;
+                }
+                const parsed = safeParseJson(message);
+                if (!isJsonRecord(parsed) || typeof parsed.method !== "string") {
+                    return;
+                }
+                const method = parsed.method;
+                const requestId = parseJsonRpcId(parsed.id);
+                const params = parsed.params ?? [];
+                const paramsJson = JSON.stringify(params);
+                if (method === FOLLOW_STOP_METHOD) {
+                    if (Array.isArray(params) && typeof params[0] === "string") {
+                        const subscriptionId = params[0];
+                        const stop = activeSubscriptions.get(subscriptionId);
+                        if (stop !== undefined) {
+                            activeSubscriptions.delete(subscriptionId);
+                            followSubscriptions.delete(subscriptionId);
+                            void Promise.resolve(stop()).then(() => {
+                                if (!disconnected && requestId !== null) {
+                                    onMessage(buildJsonRpcSuccess(requestId, true));
+                                }
+                            });
+                            return;
+                        }
+                    }
+                }
+                if (method === FOLLOW_START_METHOD) {
+                    void sharedFollowBridge
+                        .attachClient((jsonRpcMessage) => {
+                        if (!disconnected) {
+                            const sanitizedMessage = sanitizeFollowEventForConnection(jsonRpcMessage);
+                            if (sanitizedMessage !== null) {
+                                onMessage(sanitizedMessage);
+                            }
+                        }
+                    })
+                        .then((subscriptionId) => {
+                        if (disconnected) {
+                            sharedFollowBridge.detachClient(subscriptionId);
+                            return;
+                        }
+                        activeSubscriptions.set(subscriptionId, () => {
+                            sharedFollowBridge.detachClient(subscriptionId);
+                        });
+                        followSubscriptions.set(subscriptionId, {
+                            knownBlockHashes: new Set(),
+                        });
+                        if (requestId !== null) {
+                            onMessage(buildJsonRpcSuccess(requestId, subscriptionId));
+                        }
+                        sharedFollowBridge.replayClient(subscriptionId);
+                    })
+                        .catch((error) => {
+                        if (!disconnected && requestId !== null) {
+                            onMessage(buildJsonRpcError(requestId, toErrorMessage(error)));
+                        }
+                    });
+                    return;
+                }
+                if (FOLLOW_BOUND_RPC_METHODS.has(method) &&
+                    Array.isArray(params) &&
+                    typeof params[0] === "string") {
+                    const subscriptionId = params[0];
+                    if (!activeSubscriptions.has(subscriptionId)) {
+                        if (requestId !== null) {
+                            onMessage(buildJsonRpcError(requestId, `unknown chainHead subscription: ${subscriptionId}`));
+                        }
+                        return;
+                    }
+                    void sharedFollowBridge
+                        .sendFollowBoundRpc(subscriptionId, method, params)
+                        .then((jsonRpc) => {
+                        const response = requestId === null ? jsonRpc : remapJsonRpcResponseId(jsonRpc, requestId);
+                        if (!disconnected) {
+                            onMessage(response);
+                        }
+                    })
+                        .catch((error) => {
+                        if (!disconnected && requestId !== null) {
+                            onMessage(buildJsonRpcError(requestId, toErrorMessage(error)));
+                        }
+                    });
+                    return;
+                }
+                if (SUBSCRIPTION_STOP_METHODS.has(parsed.method) &&
+                    Array.isArray(params) &&
+                    typeof params[0] === "string") {
+                    recordRemoteProviderTrace({
+                        direction: "send",
+                        method,
+                        message,
+                    });
+                    if (debug) {
+                        console.warn(`[host-sdk remote-provider] stop ${method} sub=${params[0]}`);
+                    }
+                    const subscriptionId = params[0];
+                    const stop = activeSubscriptions.get(subscriptionId);
+                    if (stop === undefined) {
+                        return;
+                    }
+                    activeSubscriptions.delete(subscriptionId);
+                    void Promise.resolve(stop())
+                        .then(() => {
+                        if (!disconnected && requestId !== null) {
+                            onMessage(buildJsonRpcSuccess(requestId, true));
+                        }
+                    })
+                        .catch((error) => {
+                        if (!disconnected && requestId !== null) {
+                            onMessage(buildJsonRpcError(requestId, toErrorMessage(error)));
+                        }
+                    });
+                    return;
+                }
+                if (method in AUDITED_SUBSCRIPTION_STOP_METHODS) {
+                    recordRemoteProviderTrace({
+                        direction: "send",
+                        method,
+                        message,
+                    });
+                    if (debug) {
+                        console.warn(`[host-sdk remote-provider] start sub ${method} params=${paramsJson}`);
+                    }
+                    let knownSubscriptionId = null;
+                    let stopPromise = null;
+                    let stopWrapper = null;
+                    stopPromise = Promise.resolve(service.startSubscription(chainName, method, paramsJson, (jsonRpcMessage) => {
+                        const normalizedMessage = normalizeJsonRpcMessage(jsonRpcMessage);
+                        recordRemoteProviderTrace({
+                            direction: "recv",
+                            method,
+                            message: normalizedMessage,
+                        });
+                        if (debug) {
+                            console.warn(`[host-sdk remote-provider] sub message ${method}: ${normalizedMessage}`);
+                        }
+                        if (disconnected) {
+                            return;
+                        }
+                        if (knownSubscriptionId === null) {
+                            const subscriptionId = parseSubscriptionResultId(normalizedMessage);
+                            if (subscriptionId !== null) {
+                                knownSubscriptionId = subscriptionId;
+                                stopWrapper = () => {
+                                    const currentStopPromise = stopPromise;
+                                    if (currentStopPromise === null) {
+                                        return;
+                                    }
+                                    return Promise.resolve(currentStopPromise).then((stop) => stop());
+                                };
+                                activeSubscriptions.set(subscriptionId, stopWrapper);
+                                if (requestId !== null) {
+                                    const response = buildJsonRpcSuccess(requestId, subscriptionId);
+                                    if (debug) {
+                                        console.warn(`[host-sdk remote-provider] sub response ${method}: ${response}`);
+                                    }
+                                    onMessage(response);
+                                }
+                                return;
+                            }
+                        }
+                        if (debug) {
+                            console.warn(`[host-sdk remote-provider] forward sub ${method}: ${normalizedMessage}`);
+                        }
+                        onMessage(normalizedMessage);
+                    }, (reason) => {
+                        recordRemoteProviderTrace({
+                            direction: "abort",
+                            method,
+                            reason,
+                        });
+                        if (debug) {
+                            console.warn(`[host-sdk remote-provider] sub abort ${method}: ${reason}`);
+                        }
+                        if (knownSubscriptionId !== null) {
+                            activeSubscriptions.delete(knownSubscriptionId);
+                        }
+                        stopWrapper = null;
+                        if (!disconnected && requestId !== null) {
+                            onMessage(buildJsonRpcError(requestId, reason));
+                        }
+                    }));
+                    void stopPromise.catch((error) => {
+                        if (knownSubscriptionId !== null) {
+                            activeSubscriptions.delete(knownSubscriptionId);
+                        }
+                        stopWrapper = null;
+                        if (!disconnected && requestId !== null) {
+                            onMessage(buildJsonRpcError(requestId, toErrorMessage(error)));
+                        }
+                    });
+                    return;
+                }
+                recordRemoteProviderTrace({
+                    direction: "send",
+                    method,
+                    message,
+                });
+                if (debug) {
+                    console.warn(`[host-sdk remote-provider] rpc ${method} params=${paramsJson}`);
+                }
+                void service
+                    .sendRpc(chainName, method, paramsJson)
+                    .then((jsonRpc) => {
+                    const normalizedMessage = normalizeJsonRpcMessage(jsonRpc);
+                    const response = requestId === null
+                        ? normalizedMessage
+                        : remapJsonRpcResponseId(normalizedMessage, requestId);
+                    recordRemoteProviderTrace({
+                        direction: "recv",
+                        method,
+                        message: response,
+                    });
+                    if (debug) {
+                        console.warn(`[host-sdk remote-provider] rpc response ${method}: ${response}`);
+                    }
+                    if (!disconnected) {
+                        onMessage(response);
+                    }
+                })
+                    .catch((error) => {
+                    if (!disconnected && requestId !== null) {
+                        onMessage(buildJsonRpcError(requestId, toErrorMessage(error)));
+                    }
+                });
+            },
+            disconnect() {
+                if (disconnected) {
+                    return;
+                }
+                disconnected = true;
+                for (const stop of activeSubscriptions.values()) {
+                    void Promise.resolve(stop());
+                }
+                activeSubscriptions.clear();
+            },
+        };
+    };
+}
+//# sourceMappingURL=remote-runtime-provider.js.map