@polkadot-api/ws-middleware 1.0.0-canary.3789023

package/dist/index.js

@@ -0,0 +1,1706 @@
+'use strict';
+
+var utils = require('@polkadot-api/utils');
+var rxjs = require('rxjs');
+var substrateBindings = require('@polkadot-api/substrate-bindings');
+var rawClient = require('@polkadot-api/raw-client');
+
+const shareLatest = rxjs.shareReplay({
+  refCount: true,
+  bufferSize: 1
+});
+
+const getBlocks = ({
+  allHeads$,
+  finalized$: finalizedWire$,
+  getHeader$,
+  hasher$,
+  getRecursiveHeader
+}) => {
+  const connectedBlocks = {
+    blocks: /* @__PURE__ */ new Map(),
+    prevFin: "",
+    finalized: "",
+    best: ""
+  };
+  const getTree = (root, result = []) => {
+    result.push(root);
+    connectedBlocks.blocks.get(root).children.forEach((c) => {
+      getTree(c, result);
+    });
+    return result;
+  };
+  const addBlock = (block) => {
+    const { blocks } = connectedBlocks;
+    const { hash, parent } = block;
+    const me = {
+      ...block,
+      children: /* @__PURE__ */ new Set(),
+      usages: /* @__PURE__ */ new Set()
+    };
+    blocks.set(hash, me);
+    blocks.get(parent)?.children.add(hash);
+    return me;
+  };
+  const setBestFromFinalized = () => {
+    connectedBlocks.best = connectedBlocks.finalized;
+    let bestHeight = 0;
+    const { finalized, blocks } = connectedBlocks;
+    getTree(finalized).map((x) => blocks.get(x)).forEach((x) => {
+      if (x.number > bestHeight) {
+        bestHeight = x.number;
+        connectedBlocks.best = x.hash;
+      }
+    });
+  };
+  const pendingBlocks = /* @__PURE__ */ new Map();
+  const trimPending = (root) => {
+    const desc = [...pendingBlocks.get(root).children];
+    pendingBlocks.delete(root);
+    desc.forEach(trimPending);
+  };
+  const getPendingTree = (root, result = []) => {
+    const me = pendingBlocks.get(root);
+    if (!me.header) return result;
+    result.push(me.header);
+    me.children.forEach((c) => {
+      getPendingTree(c, result);
+    });
+    return result;
+  };
+  const _newBlocks$ = new rxjs.Subject();
+  const onError = (e) => _newBlocks$.error(e);
+  const _finalized$ = finalizedWire$.pipe(
+    rxjs.concatMap((header, idx) => {
+      const { hash } = header;
+      if (!idx) {
+        addBlock(header);
+        connectedBlocks.finalized = connectedBlocks.best = header.hash;
+      }
+      return connectedBlocks.blocks.has(hash) ? rxjs.of(hash) : _newBlocks$.pipe(
+        rxjs.filter((x) => x === hash),
+        // some of the following blocks could be prunned b/c of this finalized event.
+        // So, we have to make sure that this "batch" of _newBlocks has been flushed.
+        rxjs.debounceTime(0),
+        rxjs.take(1)
+      );
+    }),
+    rxjs.share()
+  );
+  allHeads$.subscribe((header) => {
+    const { parent, hash, number } = header;
+    if (connectedBlocks.blocks.has(hash) || !number) return;
+    if (connectedBlocks.blocks.has(parent)) {
+      addBlock(header);
+      _newBlocks$.next(hash);
+    } else {
+      pendingBlocks.set(hash, {
+        hash: header.hash,
+        header,
+        children: /* @__PURE__ */ new Set()
+      });
+      if (!pendingBlocks.has(parent)) {
+        pendingBlocks.set(parent, {
+          hash: parent,
+          header: null,
+          children: /* @__PURE__ */ new Set()
+        });
+        getRecursiveHeader(parent).pipe(
+          rxjs.takeWhile((result) => {
+            let me = pendingBlocks.get(result.hash);
+            if (!me) return false;
+            me.header = result;
+            const finalized = connectedBlocks.blocks.get(
+              connectedBlocks.finalized
+            );
+            if (finalized && result.number <= finalized.number) {
+              while (pendingBlocks.has(me.header?.parent ?? ""))
+                me = pendingBlocks.get(me.header.parent);
+              trimPending(me.hash);
+              return false;
+            }
+            if (connectedBlocks.blocks.has(result.parent)) {
+              let target = connectedBlocks.blocks.get(result.parent);
+              const diff = target.number - finalized.number;
+              for (let i = 0; i < diff; i++) {
+                const nextTarget = connectedBlocks.blocks.get(target.parent);
+                if (!nextTarget) break;
+                target = nextTarget;
+              }
+              if (target === finalized) {
+                const pendingOnes = getPendingTree(result.hash);
+                pendingOnes.forEach((h) => {
+                  pendingBlocks.delete(h.hash);
+                  addBlock(h);
+                  _newBlocks$.next(h.hash);
+                });
+              } else trimPending(result.hash);
+              return false;
+            }
+            const pendingParent = pendingBlocks.get(result.parent);
+            if (pendingParent) {
+              pendingParent.children.add(result.hash);
+              return false;
+            }
+            pendingBlocks.set(result.parent, {
+              hash: result.parent,
+              header: null,
+              children: /* @__PURE__ */ new Set([result.hash])
+            });
+            return true;
+          })
+        ).subscribe({ error: onError });
+      }
+      pendingBlocks.get(parent).children.add(hash);
+    }
+  }, onError);
+  const getFinalizedEvent = () => {
+    const prunedBlockHashes = [];
+    const finalizedBlockHashes = [];
+    const { blocks, finalized, prevFin } = connectedBlocks;
+    let current = blocks.get(finalized);
+    let prev = blocks.get(current.parent);
+    while (prev) {
+      finalizedBlockHashes.push(current.hash);
+      prev.children.forEach((c) => {
+        if (c !== current.hash) getTree(c, prunedBlockHashes);
+      });
+      current = prev;
+      if (current.hash === prevFin) break;
+      prev = blocks.get(current.parent);
+    }
+    finalizedBlockHashes.reverse();
+    return { event: "finalized", prunedBlockHashes, finalizedBlockHashes };
+  };
+  let activeSubscriptions = /* @__PURE__ */ new Set();
+  const getNewBlockEvent = (blockHash) => {
+    const block = connectedBlocks.blocks.get(blockHash);
+    activeSubscriptions.forEach((subId) => {
+      block.usages.add(subId);
+    });
+    return {
+      event: "newBlock",
+      blockHash,
+      parentBlockHash: block.parent,
+      newRuntime: block.hasUpgrade ? {} : null
+    };
+  };
+  const tryRemove = (blockHash, up) => {
+    const { blocks } = connectedBlocks;
+    const block = blocks.get(blockHash);
+    if (!block || block.usages.size > 0) return;
+    const { parent, children } = block;
+    if (up !== true) children.forEach((c) => tryRemove(c, false));
+    if (up !== false) tryRemove(parent, true);
+    if (!blocks.has(parent) || !block.children.size) {
+      blocks.get(parent)?.children.delete(blockHash);
+      blocks.delete(blockHash);
+    }
+  };
+  const updates$ = rxjs.merge(
+    _newBlocks$.pipe(
+      rxjs.map((hash) => ({
+        type: "new",
+        value: connectedBlocks.blocks.get(hash)
+      }))
+    ),
+    _finalized$.pipe(rxjs.map((hash) => ({ type: "fin", value: hash })))
+  ).pipe(
+    rxjs.mergeMap((x) => {
+      if (x.type === "new") {
+        const block = x.value;
+        const { hash } = block;
+        addBlock(block);
+        const result2 = [getNewBlockEvent(hash)];
+        if (block.number > connectedBlocks.blocks.get(connectedBlocks.best).number) {
+          connectedBlocks.best = hash;
+          result2.push({ event: "bestBlockChanged", bestBlockHash: hash });
+        }
+        return result2;
+      }
+      connectedBlocks.prevFin = connectedBlocks.finalized;
+      connectedBlocks.finalized = x.value;
+      let prevBest = connectedBlocks.best;
+      setBestFromFinalized();
+      const result = [getFinalizedEvent()];
+      if (prevBest !== connectedBlocks.best)
+        result.unshift({
+          event: "bestBlockChanged",
+          bestBlockHash: connectedBlocks.best
+        });
+      return result;
+    }),
+    rxjs.share()
+  );
+  const ready$ = rxjs.defer(
+    () => connectedBlocks.blocks.size ? [null] : _finalized$.pipe(
+      rxjs.take(1),
+      rxjs.map(() => null)
+    )
+  ).pipe(shareLatest);
+  const finalized$ = _finalized$.pipe(
+    rxjs.map((hash) => connectedBlocks.blocks.get(hash)),
+    shareLatest
+  );
+  rxjs.merge(updates$, finalized$).subscribe({
+    error: onError
+  });
+  const upstream = (subId) => {
+    const getInitialized = () => {
+      const { blocks, finalized } = connectedBlocks;
+      const finalizedBlockHashes = [];
+      let current = blocks.get(finalized);
+      while (current && finalizedBlockHashes.length < 10) {
+        finalizedBlockHashes.push(current.hash);
+        current.usages.add(subId);
+        current = blocks.get(current.parent);
+      }
+      finalizedBlockHashes.reverse();
+      return {
+        event: "initialized",
+        finalizedBlockHashes
+      };
+    };
+    const unpin = (blockHash) => {
+      const block = connectedBlocks.blocks.get(blockHash);
+      if (block) {
+        block.usages.delete(subId);
+        tryRemove(blockHash);
+      }
+    };
+    const initialEvents$ = ready$.pipe(
+      rxjs.mergeMap(() => {
+        const { best, finalized } = connectedBlocks;
+        const others = getTree(
+          finalized
+        ).slice(1).map(getNewBlockEvent);
+        others.push({
+          event: "bestBlockChanged",
+          bestBlockHash: best
+        });
+        return [getInitialized(), ...others];
+      })
+    );
+    return {
+      blocks$: rxjs.concat(initialEvents$, updates$).pipe(
+        rxjs.tap({
+          subscribe: () => {
+            activeSubscriptions.add(subId);
+          },
+          finalize: () => {
+            activeSubscriptions.delete(subId);
+          }
+        }),
+        rxjs.share()
+      ),
+      getHeader: (blockHash) => connectedBlocks.blocks.get(blockHash)?.header ?? null,
+      isPinned: (blockHash) => !!connectedBlocks.blocks.get(blockHash)?.usages.has(subId),
+      unpin
+    };
+  };
+  const clean = () => {
+    pendingBlocks.clear();
+    connectedBlocks.blocks.clear();
+  };
+  return {
+    clean,
+    upstream,
+    finalized$,
+    getHeader$: (hash) => {
+      const block = connectedBlocks.blocks.get(hash);
+      return block ? rxjs.of(block) : getHeader$(hash);
+    },
+    hasher$
+  };
+};
+
+const getFromShittyHeader = (hasher) => ({
+  parentHash,
+  number: rawNumber,
+  stateRoot,
+  extrinsicsRoot,
+  digest
+}) => {
+  const number = Number(rawNumber);
+  const rawDigests = digest.logs.map(utils.fromHex);
+  const rawHeader = utils.mergeUint8([
+    utils.fromHex(parentHash),
+    substrateBindings.compact.enc(number),
+    utils.fromHex(stateRoot),
+    utils.fromHex(extrinsicsRoot),
+    substrateBindings.compact.enc(digest.logs.length),
+    ...rawDigests
+  ]);
+  return {
+    parent: parentHash,
+    hash: utils.toHex(hasher(rawHeader)),
+    number,
+    hasUpgrade: rawDigests.some(([x]) => x === 8),
+    header: utils.toHex(rawHeader)
+  };
+};
+
+const hashers = [substrateBindings.Blake2256, substrateBindings.Keccak256];
+const fns = hashers.map(getFromShittyHeader);
+const noHasher = (_) => {
+  throw new Error("Hasher not supported");
+};
+const getHasherFromBlock = (shitHeader) => (hash) => hashers[fns.findIndex((fn) => fn(shitHeader).hash === hash)] || noHasher;
+
+const withLatestFromBp = (latest$) => (base$) => new rxjs.Observable((observer) => {
+  let latest;
+  let prev = [];
+  const subscription = base$.subscribe({
+    next(v) {
+      if (prev) prev.push(v);
+      else observer.next([latest, v]);
+    },
+    error(e) {
+      observer.error(e);
+    },
+    complete() {
+      observer.complete();
+    }
+  });
+  subscription.add(
+    latest$.subscribe({
+      next(v) {
+        latest = v;
+        if (prev) {
+          const copy = [...prev];
+          prev = null;
+          copy.forEach((p) => observer.next([latest, p]));
+        }
+      },
+      error(e) {
+        observer.error(e);
+      },
+      complete() {
+        if (prev) observer.error(new Error("Empty complete"));
+      }
+    })
+  );
+  return subscription;
+});
+
+const INITIAL_ERROR = {};
+const getUpstreamEvents = (request, request$) => {
+  const firstFinHeader$ = new rxjs.Subject();
+  const hasher$ = firstFinHeader$.pipe(
+    rxjs.mergeMap(
+      (h) => request$("chain_getBlockHash", [
+        h.number
+      ]).pipe(rxjs.map(getHasherFromBlock(h)))
+    ),
+    shareLatest
+  );
+  const fromShittyHeader$ = hasher$.pipe(rxjs.map(getFromShittyHeader), shareLatest);
+  const toNiceHeader = rxjs.pipe(
+    withLatestFromBp(fromShittyHeader$),
+    rxjs.map(([fromShittyHeader, shitHeader]) => fromShittyHeader(shitHeader))
+  );
+  const getHeaders$ = (startMethod, stopMethod, isFin = false) => new rxjs.Observable((observer) => {
+    const onError = (e) => {
+      observer.error(e);
+    };
+    let stop = null;
+    let isFirstFin = isFin;
+    request(startMethod, [], {
+      onSuccess: (subId, followSub) => {
+        const done = followSub(subId, {
+          next: (v) => {
+            if (isFirstFin) {
+              isFirstFin = false;
+              firstFinHeader$.next(v);
+              firstFinHeader$.complete();
+            }
+            observer.next(v);
+          },
+          error: onError
+        });
+        const unsubscribe = () => {
+          done();
+          try {
+            request(stopMethod, [subId], {
+              onError: utils.noop,
+              onSuccess: utils.noop
+            });
+          } catch {
+          }
+        };
+        if (stop !== null) unsubscribe();
+        else stop = unsubscribe;
+      },
+      onError() {
+        onError(INITIAL_ERROR);
+      }
+    });
+    return () => {
+      stop?.();
+      stop = utils.noop;
+    };
+  }).pipe(toNiceHeader);
+  const allHeads$ = getHeaders$(
+    "chain_subscribeAllHeads",
+    "chain_unsubscribeAllHeads"
+  );
+  const finalized$ = getHeaders$(
+    "chain_subscribeFinalizedHeads",
+    "chain_unsubscribeFinalizedHeads",
+    true
+  );
+  const getHeader$ = (hash) => request$("chain_getHeader", [hash]).pipe(
+    toNiceHeader
+  );
+  const getRecursiveHeader = (hash) => getHeader$(hash).pipe(
+    rxjs.mergeMap(
+      (header) => rxjs.concat(rxjs.of(header), getRecursiveHeader(header.parent))
+    )
+  );
+  return {
+    allHeads$,
+    finalized$,
+    hasher$,
+    getRecursiveHeader,
+    getHeader$
+  };
+};
+
+const getBlocks$ = (request, request$) => getBlocks(getUpstreamEvents(request, request$));
+
+const createClosestDescendantMerkleValue = (obsRequest) => (at, key) => obsRequest("state_getReadProof", [[key], at]).pipe(
+  rxjs.mergeMap((x) => {
+    const result = substrateBindings.validateProofs(x.proof);
+    if (!result) throw new Error("Invalid Proof");
+    const { rootHash, proofs } = result;
+    let winnerHash = rootHash;
+    let current = proofs[winnerHash];
+    let nKeyChars = 2;
+    do {
+      const nextOne = proofs[winnerHash];
+      if (!nextOne || nextOne.type === "Raw") break;
+      current = nextOne;
+      winnerHash = void 0;
+      if (!current.partialKey.startsWith(
+        key.slice(nKeyChars, nKeyChars + current.partialKey.length)
+      ))
+        return [];
+      nKeyChars += current.partialKey.length;
+      if ((current.type === "LeafWithHash" || current.type === "BranchWithHash") && proofs[current.value]) {
+        winnerHash = current.value;
+        continue;
+      }
+      if ("children" in current) {
+        const winner = Object.entries(
+          current.children
+        ).find(([, hash]) => proofs[hash]);
+        if (winner) {
+          if (winner[0] !== key[nKeyChars++]) return [];
+          winnerHash = winner[1];
+        }
+      }
+    } while (winnerHash);
+    return [current.hash];
+  })
+);
+
+const createUpstream = (request) => {
+  const simpleRequest = (method, params, onSuccess, onError) => request(method, params, { onSuccess, onError });
+  const obsRequest = (method, params) => new rxjs.Observable(
+    (observer) => simpleRequest(
+      method,
+      params,
+      (v) => {
+        observer.next(v);
+        observer.complete();
+      },
+      (e) => {
+        observer.error(e);
+      }
+    )
+  );
+  const {
+    upstream: getBlocks,
+    finalized$,
+    getHeader$,
+    hasher$,
+    clean
+  } = getBlocks$(request, obsRequest);
+  const runtimeCall = (atBlock, method, data) => obsRequest("state_call", [
+    method,
+    data,
+    atBlock
+  ]);
+  const stgDescendantValues = (at, rootKey) => {
+    const PAGE_SIZE = 1e3;
+    const getKeys = (startAtKey) => {
+      return obsRequest(
+        "state_getKeysPaged",
+        [rootKey, PAGE_SIZE, startAtKey || void 0, at]
+      ).pipe(
+        rxjs.mergeMap((receivedKeys) => {
+          const keys = receivedKeys[0] === startAtKey ? receivedKeys.slice(1) : receivedKeys;
+          const continuation = receivedKeys.length < PAGE_SIZE ? rxjs.EMPTY : getKeys(receivedKeys.at(-1));
+          return rxjs.merge(rxjs.of(keys), continuation);
+        })
+      );
+    };
+    const getValues = (keys, nSplits = 0) => keys.length ? obsRequest("state_queryStorageAt", [keys, at]).pipe(
+      rxjs.map(([{ changes }]) => changes),
+      rxjs.catchError((e) => {
+        if (nSplits > 3) throw e;
+        const midIdx = Math.floor(keys.length / 2);
+        return rxjs.merge(
+          getValues(keys.slice(0, midIdx), ++nSplits),
+          getValues(keys.slice(midIdx), nSplits)
+        );
+      })
+    ) : rxjs.EMPTY;
+    return getKeys().pipe(rxjs.mergeMap((keys) => getValues(keys)));
+  };
+  const stgDescendantHashes = (at, rootKey) => stgDescendantValues(at, rootKey).pipe(
+    withLatestFromBp(hasher$),
+    rxjs.map(
+      ([hasher, results]) => results.map(
+        ([key, value]) => [key, utils.toHex(hasher(utils.fromHex(value)))]
+      )
+    )
+  );
+  const stgClosestDescendant = createClosestDescendantMerkleValue(obsRequest);
+  const [stgValue, stgHash] = ["state_getStorage", "state_getStorageHash"].map(
+    (method) => (atBlock, key) => obsRequest(method, [
+      key,
+      atBlock
+    ])
+  );
+  const methods = obsRequest("rpc_methods", []);
+  const chainName = obsRequest("system_name", []);
+  const properties = obsRequest("system_properties", []);
+  const getBody = (at) => obsRequest(
+    "chain_getBlock",
+    [at]
+  );
+  const getBlockHash$ = (height) => obsRequest("chain_getBlockHash", [height]);
+  const genesisHash = getBlockHash$(0);
+  return {
+    getBlocks,
+    finalized$,
+    getBlockHash$,
+    getHeader$,
+    stgValue,
+    stgHash,
+    stgDescendantValues,
+    stgDescendantHashes,
+    stgClosestDescendant,
+    runtimeCall,
+    getBody,
+    chainName,
+    properties,
+    genesisHash,
+    clean,
+    methods,
+    request: simpleRequest,
+    obsRequest
+  };
+};
+
+const createChainSpec = (upstream, reply, err) => {
+  return (rId, method) => {
+    const [, , name] = method.split("_");
+    const observable = upstream[name];
+    if (!observable) throw null;
+    observable.subscribe(
+      (result) => {
+        reply(rId, result);
+      },
+      () => {
+        err(rId, -32602, "Invalid");
+      }
+    );
+  };
+};
+
+let latestId = 1;
+const createOpaqueToken = () => {
+  return `${latestId++}${Date.now()}`;
+};
+
+const validStorageTypes = /* @__PURE__ */ new Set([
+  "value",
+  "hash",
+  "closestDescendantMerkleValue",
+  "descendantsValues",
+  "descendantsHashes"
+]);
+const areItemsValid = (items) => Array.isArray(items) && items.every(
+  (x) => typeof x === "object" && typeof x.key === "string" && validStorageTypes.has(x.type)
+);
+const getStg$ = (upstream, at, items) => rxjs.merge(
+  ...items.map(({ key, type }) => {
+    switch (type) {
+      case "value":
+        return upstream.stgValue(at, key).pipe(
+          rxjs.filter(Boolean),
+          rxjs.map((value) => [
+            {
+              key,
+              value
+            }
+          ])
+        );
+      case "hash":
+        return upstream.stgHash(at, key).pipe(
+          rxjs.filter(Boolean),
+          rxjs.map((hash) => [
+            {
+              key,
+              hash
+            }
+          ])
+        );
+      case "descendantsValues":
+        return upstream.stgDescendantValues(at, key).pipe(
+          rxjs.map((values) => values.map(([key2, value]) => ({ key: key2, value })))
+        );
+      case "descendantsHashes":
+        return upstream.stgDescendantHashes(at, key).pipe(rxjs.map((values) => values.map(([key2, hash]) => ({ key: key2, hash }))));
+      case "closestDescendantMerkleValue":
+        return upstream.stgClosestDescendant(at, key).pipe(
+          rxjs.filter(Boolean),
+          rxjs.map((closestDescendantMerkleValue) => [
+            {
+              key,
+              closestDescendantMerkleValue
+            }
+          ])
+        );
+    }
+  })
+);
+
+const getMsgFromErr = (e) => {
+  if (e instanceof Error) return e.message;
+  if (typeof e === "string") return e;
+  return "Unhandled exception";
+};
+
+const chainHead = {
+  body: "",
+  call: "",
+  continue: "",
+  follow: "",
+  header: "",
+  stopOperation: "",
+  storage: "",
+  unfollow: "",
+  unpin: ""
+};
+const archive = {
+  body: "",
+  call: "",
+  finalizedHeight: "",
+  genesisHash: "",
+  hashByHeight: "",
+  header: "",
+  stopStorage: "",
+  storage: ""
+};
+const transaction = {
+  broadcast: "",
+  stop: ""
+};
+const chainSpec = {
+  chainName: "",
+  genesisHash: "",
+  properties: ""
+};
+Object.entries({ chainHead, chainSpec, transaction, archive }).forEach(
+  ([fnGroupName, methods]) => {
+    Object.keys(methods).forEach((methodName) => {
+      methods[methodName] = `${fnGroupName}_v1_${methodName}`;
+    });
+  }
+);
+
+const { follow: follow$4, header: header$1, storage: storage$2, body: body$2, call: call$2, unfollow: unfollow$4, stopOperation: stopOperation$1, unpin: unpin$2 } = chainHead;
+const createChainHead = (upstream, reply, err, notification) => {
+  const subscriptions = /* @__PURE__ */ new Map();
+  const _follow = (rId) => {
+    if (subscriptions.size === 2) {
+      return err(rId, -32800, "Limit reached");
+    }
+    const token = createOpaqueToken();
+    const fNotification = (result2) => notification("chainHead_v1_followEvent", token, result2);
+    const up = upstream.getBlocks(token);
+    const operations = /* @__PURE__ */ new Map();
+    subscriptions.set(token, {
+      id: token,
+      up,
+      operations,
+      cleanUp: () => {
+        cleanUp();
+      }
+    });
+    reply(rId, token);
+    let subscription = null;
+    let cleanUp = () => {
+      cleanUp = utils.noop;
+      subscription?.unsubscribe();
+      subscription = null;
+      operations.forEach((cb) => {
+        cb();
+      });
+      operations.clear();
+      subscriptions.delete(token);
+    };
+    subscription = up.blocks$.subscribe({
+      next(v) {
+        fNotification(v);
+      },
+      error() {
+        cleanUp();
+        fNotification({ event: "stop" });
+      }
+    });
+    if (subscription.closed) subscription = null;
+  };
+  const _unfollow = (rId, followId) => {
+    subscriptions.get(followId)?.cleanUp();
+    reply(rId, "null");
+  };
+  const _stopOperation = (rId, followId, operationId) => {
+    const cb = subscriptions.get(followId)?.operations.get(operationId);
+    if (cb) cb();
+    reply(rId, "null");
+  };
+  const _header = ({ up: { getHeader } }, reply2, at) => reply2(getHeader(at));
+  const _unpin = ({ up: { unpin: innerUnpin } }, reply2, hashOrHashes) => {
+    const hashes = typeof hashOrHashes === "string" ? [hashOrHashes] : hashOrHashes;
+    hashes.forEach(innerUnpin);
+    reply2(null);
+  };
+  const _call = ({ operations, id: followId }, reply2, at, method, args) => {
+    const operationId = createOpaqueToken();
+    reply2({ result: "started", operationId });
+    const cNotification = (output, isErr = false) => notification(
+      call$2,
+      followId,
+      isErr ? {
+        operationId,
+        event: "operationError",
+        error: output
+      } : {
+        operationId,
+        event: "operationCallDone",
+        output
+      }
+    );
+    const subscription = upstream.runtimeCall(at, method, args).subscribe(
+      (output) => {
+        operations.delete(operationId);
+        cNotification(output);
+      },
+      (e) => {
+        operations.delete(operationId);
+        cNotification(getMsgFromErr(e), true);
+      }
+    );
+    if (!subscription.closed)
+      operations.set(operationId, () => {
+        subscription.unsubscribe();
+        operations.delete(operationId);
+      });
+  };
+  const _body = ({ operations, id: followId }, reply2, at) => {
+    const operationId = createOpaqueToken();
+    reply2({ result: "started", operationId });
+    const subscription = upstream.getBody(at).subscribe(
+      ({ block: { extrinsics: value } }) => {
+        operations.delete(operationId);
+        notification(body$2, followId, {
+          event: "operationBodyDone",
+          operationId,
+          value
+        });
+      },
+      (e) => {
+        operations.delete(operationId);
+        notification(body$2, followId, {
+          event: "operationError",
+          operationId,
+          error: getMsgFromErr(e)
+        });
+      }
+    );
+    if (!subscription.closed)
+      operations.set(operationId, () => {
+        subscription.unsubscribe();
+        operations.delete(operationId);
+      });
+  };
+  const _stg = ({ operations, id: followId }, reply2, at, items) => {
+    const operationId = createOpaqueToken();
+    reply2({ result: "started", operationId });
+    const innerNotifiaction = (msg) => {
+      notification(storage$2, followId, msg);
+    };
+    const subscription = getStg$(upstream, at, items).pipe(
+      rxjs.finalize(() => {
+        operations.delete(operationId);
+      })
+    ).subscribe(
+      (items2) => {
+        innerNotifiaction({
+          event: "operationStorageItems",
+          operationId,
+          items: items2
+        });
+      },
+      (e) => {
+        innerNotifiaction({
+          event: "operationError",
+          operationId,
+          error: getMsgFromErr(e)
+        });
+      },
+      () => {
+        innerNotifiaction({
+          event: "operationStorageDone",
+          operationId
+        });
+      }
+    );
+    if (!subscription.closed)
+      operations.set(operationId, () => {
+        subscription.unsubscribe();
+      });
+  };
+  const result = (rId, method, params) => {
+    if (method === follow$4) return _follow(rId);
+    const [followId, ...rest] = params;
+    const ctx = subscriptions.get(followId);
+    if (!ctx) return err(rId, -32602, "Ivalid followSubscription");
+    const innerReply = (value) => {
+      reply(rId, value);
+    };
+    switch (method) {
+      case unfollow$4:
+        return _unfollow(rId, followId);
+      case stopOperation$1:
+        return _stopOperation(rId, followId, rest[0]);
+      case unpin$2: {
+        const [hashOrHashes] = rest;
+        if ((Array.isArray(hashOrHashes) ? hashOrHashes : [hashOrHashes]).some(
+          (hash) => typeof hash !== "string"
+        ))
+          return err(rId, -32602, "Invalid args");
+        return _unpin(ctx, innerReply, hashOrHashes);
+      }
+      default: {
+        const [at, ...other] = rest;
+        if (!ctx.up.isPinned(at)) return err(rId, -32801, "Block not pinned");
+        switch (method) {
+          case header$1:
+            return _header(ctx, innerReply, at);
+          case body$2:
+            return _body(ctx, innerReply, at);
+          case call$2: {
+            const [method2, data] = other;
+            if (typeof method2 !== "string" || typeof data !== "string")
+              return err(rId, -32602, "Invalid args");
+            return _call(ctx, innerReply, at, method2, data);
+          }
+          case storage$2: {
+            const [items] = other;
+            return areItemsValid(items) ? _stg(ctx, innerReply, at, items) : err(rId, -32602, "Invalid args");
+          }
+        }
+      }
+    }
+    throw null;
+  };
+  result.stop = () => {
+    subscriptions.forEach((x) => {
+      x.cleanUp();
+    });
+  };
+  return result;
+};
+
+const { stop, broadcast } = transaction;
+const createTransactionFns = (upstream, reply) => {
+  const ongoing = /* @__PURE__ */ new Map();
+  const result = (rId, method, args) => {
+    if (method === stop) {
+      const [token] = args;
+      ongoing.get(token)?.unsubscribe();
+      ongoing.delete(token);
+      reply(rId, null);
+    } else if (method === broadcast) {
+      const token = createOpaqueToken();
+      ongoing.set(
+        token,
+        upstream.obsRequest("author_submitExtrinsic", args).pipe(
+          // We want to make sure that we keep on retrying if there
+          // are errors with the `author_submitExtrinsic` request
+          rxjs.catchError((_, source) => rxjs.concat(rxjs.timer(5e3), source)),
+          // This logic ensures that the subscription dies if an
+          // upstream error (like the client being destroyed) takes place
+          rxjs.takeUntil(
+            upstream.finalized$.pipe(
+              rxjs.ignoreElements(),
+              rxjs.catchError(() => {
+                ongoing.delete(token);
+                return [null];
+              })
+            )
+          )
+        ).subscribe()
+      );
+      reply(rId, token);
+    } else {
+      throw null;
+    }
+  };
+  result.stop = () => {
+    ongoing.forEach((s) => s.unsubscribe());
+    ongoing.clear();
+  };
+  return result;
+};
+
+const {
+  body: body$1,
+  call: call$1,
+  finalizedHeight,
+  genesisHash,
+  hashByHeight,
+  header,
+  stopStorage,
+  storage: storage$1
+} = archive;
+const createArchive = (upstream, reply, err, notification) => {
+  const stgSubscriptions = /* @__PURE__ */ new Map();
+  const stg = (reply2, at, items) => {
+    const subId = createOpaqueToken();
+    reply2(subId);
+    const innerNotifiaction = (result2) => {
+      notification("archive_v1_storageEvent", subId, result2);
+    };
+    const subscription = getStg$(upstream, at, items).pipe(
+      rxjs.finalize(() => {
+        stgSubscriptions.delete(subId);
+      })
+    ).subscribe(
+      (items2) => {
+        items2.forEach(
+          (item) => innerNotifiaction({ event: "storage", ...item })
+        );
+      },
+      (e) => {
+        innerNotifiaction({ event: "storageError", error: getMsgFromErr(e) });
+      },
+      () => {
+        innerNotifiaction({ event: "storageDone" });
+      }
+    );
+    if (!subscription.closed) stgSubscriptions.set(subId, subscription);
+  };
+  const result = (rId, name, params) => {
+    const innerReply = (value) => {
+      reply(rId, value);
+    };
+    const obsReply = (input) => {
+      input.subscribe({
+        next: innerReply,
+        error: (e) => {
+          err(rId, e.code ?? -1, getMsgFromErr(e));
+        }
+      });
+    };
+    const [firstArg, secondArg, thirdArg] = params;
+    switch (name) {
+      case body$1:
+        return obsReply(upstream.getBody(firstArg));
+      case call$1:
+        return obsReply(
+          upstream.runtimeCall(firstArg, secondArg, thirdArg).pipe(rxjs.map((value) => ({ success: true, value })))
+        );
+      case finalizedHeight:
+        return obsReply(
+          upstream.finalized$.pipe(
+            rxjs.map((x) => x.number),
+            rxjs.take(1)
+          )
+        );
+      case genesisHash:
+        return obsReply(upstream.genesisHash);
+      case hashByHeight:
+        return obsReply(upstream.getBlockHash$(firstArg));
+      case header:
+        return obsReply(
+          upstream.getHeader$(firstArg).pipe(rxjs.map((h) => h.header))
+        );
+      case stopStorage: {
+        const sub = stgSubscriptions.get(firstArg);
+        return sub ? sub.unsubscribe() : err(rId, -32602, "Invalid args");
+      }
+      case storage$1:
+        return areItemsValid(secondArg) ? stg(innerReply, firstArg, secondArg) : err(rId, -32602, "Invalid args");
+    }
+    throw null;
+  };
+  result.stop = () => {
+    [...stgSubscriptions].forEach(([, s]) => s.unsubscribe());
+    stgSubscriptions.clear();
+  };
+  return result;
+};
+
+const supportedMethods = new Set(
+  [chainHead, chainSpec, archive, transaction].map((methods) => Object.values(methods)).flat()
+);
+const withLegacy = (base) => (onMessage, onHalt) => {
+  let clean = utils.noop;
+  let onMsg = utils.noop;
+  const innerConnection = base(
+    (msg) => {
+      onMsg(msg);
+    },
+    (e) => {
+      clean();
+      onHalt(e);
+    }
+  );
+  const { disconnect, request } = rawClient.createClient((_onMsg) => {
+    onMsg = _onMsg;
+    return innerConnection;
+  });
+  const upstream = createUpstream(request);
+  const jsonRpc = (input) => onMessage({
+    jsonrpc: "2.0",
+    ...input
+  });
+  const reply = (id, result) => {
+    jsonRpc({ id, result });
+  };
+  const err = (id, code, message) => {
+    jsonRpc({ id, error: { code, message } });
+  };
+  const notification = (method, subscription, result) => {
+    jsonRpc({ method, params: { subscription, result } });
+  };
+  const groups = {
+    chainSpec: createChainSpec(upstream, reply, err),
+    chainHead: createChainHead(upstream, reply, err, notification),
+    archive: createArchive(upstream, reply, err, notification),
+    transaction: createTransactionFns(upstream, reply)
+  };
+  clean = () => {
+    groups.chainHead.stop();
+    groups.archive.stop();
+    groups.transaction.stop();
+    upstream.clean();
+  };
+  return {
+    send: (parsedMsg) => {
+      if (!parsedMsg) return;
+      const { id, method, params } = parsedMsg;
+      if (id !== null && typeof id !== "string" && typeof id !== "number" || typeof method !== "string") {
+        console.warn(`Invalid message:
+${JSON.stringify(parsedMsg)}`);
+        return;
+      }
+      if (method === "rpc_methods") {
+        return upstream.methods.subscribe(
+          ({ methods }) => {
+            reply(id, {
+              methods: [
+                ...supportedMethods,
+                ...methods.filter((method2) => !supportedMethods.has(method2))
+              ]
+            });
+          },
+          (e) => {
+            console.error(e);
+            err(id, -32602, "Invalid");
+          }
+        );
+      }
+      const [groupName] = method.split("_");
+      if (groupName in groups) {
+        try {
+          return groups[groupName](id, method, params);
+        } catch (e) {
+          if (e !== null) throw e;
+        }
+      }
+      upstream.request(
+        method,
+        params,
+        (value) => {
+          reply(id, value);
+        },
+        (e) => {
+          err(id, e?.code || -1, e?.message || "");
+        }
+      );
+    },
+    disconnect: () => {
+      clean();
+      disconnect();
+    }
+  };
+};
+
+const apply = (...middlewares) => (base) => middlewares.reduce((a, b) => b(a), base);
+const jsonObj = (input) => ({
+  jsonrpc: "2.0",
+  ...input
+});
+
+const getAsyncMiddleware = (input) => (base) => (onMessageOut, onHaltOut) => {
+  let interceptedMessage = utils.noop;
+  let pending = [];
+  let send = (msg) => {
+    pending.push(msg);
+  };
+  let stopRequest = utils.noop;
+  let isOn = true;
+  let done = () => {
+    isOn = false;
+    pending = [];
+    stopRequest();
+    done = interceptedMessage = interceptedHalt = stopRequest = utils.noop;
+  };
+  let interceptedHalt = (e) => {
+    done();
+    onHaltOut(e);
+  };
+  const innerCon = base(
+    (msg) => interceptedMessage(msg),
+    (e) => interceptedHalt(e)
+  );
+  let { disconnect } = innerCon;
+  const { request } = rawClient.createClient((innerClientOnMsg) => {
+    interceptedMessage = innerClientOnMsg;
+    return { ...innerCon, disconnect: utils.noop };
+  });
+  if (isOn)
+    stopRequest = input((cb) => {
+      stopRequest = utils.noop;
+      if (!cb) interceptedHalt();
+      else {
+        ({ send, disconnect } = cb((onMiddleMsg, onMiddleHalt) => {
+          interceptedHalt = (e) => {
+            done();
+            onMiddleHalt(e);
+          };
+          interceptedMessage = onMiddleMsg;
+          return innerCon;
+        })(onMessageOut, onHaltOut));
+        pending.forEach(send);
+        pending = [];
+      }
+    }, request);
+  return {
+    send: (msg) => {
+      send(msg);
+    },
+    disconnect: () => {
+      done();
+      disconnect();
+    }
+  };
+};
+
+const RPC_METHODS = "rpc_methods";
+const withMethods = (methods) => (base) => (onMsg, onHalt) => {
+  const result = { methods };
+  const { send, disconnect } = base(onMsg, onHalt);
+  return {
+    disconnect,
+    send(msg) {
+      if (msg.id && msg.method === RPC_METHODS) {
+        onMsg(jsonObj({ id: msg.id, result }));
+      } else send(msg);
+    }
+  };
+};
+const methodsRouter = (getMiddleware) => getAsyncMiddleware((onReady, request) => {
+  let nTries = 0;
+  let stopRequest = utils.noop;
+  const getMethods = () => {
+    nTries++;
+    stopRequest = request(RPC_METHODS, [], {
+      onSuccess: ({ methods }) => {
+        onReady(apply(withMethods(methods), getMiddleware(methods)));
+      },
+      onError: () => {
+        if (nTries > 3) onReady(null);
+        else {
+          const token = setTimeout(getMethods, 500);
+          stopRequest = () => clearTimeout(token);
+        }
+      }
+    });
+  };
+  getMethods();
+  return () => stopRequest();
+});
+
+const { follow: follow$3, unfollow: unfollow$3 } = chainHead;
+const resetStops = () => ({ latest: Date.now(), count: 0 });
+const followEnhancer = (base) => (onMsg, onHalt) => {
+  const prematureStops = /* @__PURE__ */ new Map();
+  const preOpId = /* @__PURE__ */ new Map();
+  const onGoing = /* @__PURE__ */ new Set();
+  let nStops = resetStops();
+  const cleanup = () => {
+    [prematureStops, preOpId, onGoing].forEach((x) => {
+      x.clear();
+    });
+  };
+  const forceDisconnect = () => {
+    disconnect();
+    cleanup();
+    onHalt();
+  };
+  const { send, disconnect } = base(
+    (parsed) => {
+      if ("id" in parsed) {
+        const { id, result } = parsed;
+        const msg = preOpId.get(id);
+        if (msg) {
+          preOpId.delete(id);
+          const prematureStop = prematureStops.get(result);
+          if (prematureStop) {
+            prematureStops.delete(result);
+            onMsg(parsed);
+            onMsg(prematureStop);
+            return;
+          }
+          onGoing.add(result);
+          const currentSize = onGoing.size + preOpId.size;
+          if (currentSize > 2)
+            console.warn(
+              `Too many chainHead follow subscriptions (${currentSize})`
+            );
+          else if (parsed.error) {
+            console.warn(`chainHead follow failed on the ${currentSize} sub`);
+            forceDisconnect();
+            return;
+          }
+        }
+      } else {
+        const { subscription, result } = parsed.params;
+        if (result?.event === "stop") {
+          const diff = Date.now() - nStops.latest;
+          nStops.latest += diff;
+          nStops.count = diff < 1e3 ? nStops.count + 1 : 1;
+          if (onGoing.has(subscription)) onGoing.delete(subscription);
+          else prematureStops.set(subscription, parsed);
+        }
+      }
+      onMsg(parsed);
+      if (nStops.count > 2) {
+        nStops = resetStops();
+        forceDisconnect();
+      }
+    },
+    (e) => {
+      cleanup();
+      onHalt(e);
+    }
+  );
+  return {
+    send(parsed) {
+      const { method } = parsed;
+      if (method === follow$3) preOpId.set(parsed.id, parsed);
+      else if (method === unfollow$3) onGoing.delete(parsed.params[0]);
+      send(parsed);
+    },
+    disconnect
+  };
+};
+
+const { follow: follow$2, unpin: unpin$1, unfollow: unfollow$2 } = chainHead;
+const fixPrematureBlocks = (base) => (onMsg, onHalt) => {
+  const pendingChainHeadSubs = /* @__PURE__ */ new Set();
+  const pinnedBlocksInSub = /* @__PURE__ */ new Map();
+  const prematureBlocks = /* @__PURE__ */ new Map();
+  const withClear = (fn) => (...args) => {
+    [pendingChainHeadSubs, pinnedBlocksInSub, prematureBlocks].forEach(
+      (x) => {
+        x.clear();
+      }
+    );
+    fn(...args);
+  };
+  const { send: originalSend, disconnect } = base((message) => {
+    if ("id" in message) {
+      onMsg(message);
+      const { id, result } = message;
+      if (pendingChainHeadSubs.has(id)) {
+        pendingChainHeadSubs.delete(id);
+        pinnedBlocksInSub.set(result, /* @__PURE__ */ new Set());
+        prematureBlocks.set(result, /* @__PURE__ */ new Map());
+        return;
+      }
+    } else {
+      const { subscription } = message.params;
+      const pinnedBlocks = pinnedBlocksInSub.get(subscription);
+      const prematureSub = prematureBlocks.get(subscription);
+      if (pinnedBlocks) {
+        const result = message.params.result;
+        const { event } = result;
+        if (event === "initialized") {
+          result.finalizedBlockHashes.forEach((hash) => {
+            pinnedBlocks.add(hash);
+          });
+        }
+        if (event === "newBlock") {
+          const { parentBlockHash } = result;
+          if (!pinnedBlocks.has(parentBlockHash)) {
+            const list = prematureSub.get(parentBlockHash) ?? [];
+            list.push(message);
+            prematureSub.set(parentBlockHash, list);
+            return;
+          }
+          const hash = result.blockHash;
+          pinnedBlocks.add(result.blockHash);
+          onMsg(message);
+          const prematureMessages = prematureSub.get(hash);
+          if (prematureMessages) {
+            prematureSub.delete(hash);
+            prematureMessages.forEach((msg) => {
+              pinnedBlocks.add(msg.params.result.blockHash);
+              onMsg(msg);
+            });
+          }
+          return;
+        }
+        if (event === "stop") {
+          pinnedBlocks.delete(subscription);
+          prematureBlocks.delete(subscription);
+        }
+      }
+      onMsg(message);
+    }
+  }, withClear(onHalt));
+  const send = (msg) => {
+    const subId = msg.params[0];
+    switch (msg.method) {
+      case follow$2:
+        pendingChainHeadSubs.add(msg.id);
+        break;
+      case unpin$1:
+        const [subscription, blocks] = msg.params;
+        blocks.forEach((block) => {
+          pinnedBlocksInSub.get(subscription)?.delete(block);
+          prematureBlocks.get(subscription)?.delete(block);
+        });
+        break;
+      case unfollow$2:
+        pinnedBlocksInSub.delete(subId);
+        prematureBlocks.delete(subId);
+        break;
+    }
+    originalSend(msg);
+  };
+  return {
+    send,
+    disconnect: withClear(disconnect)
+  };
+};
+
+const { follow: follow$1, unpin, unfollow: unfollow$1 } = chainHead;
+const fixUnorderedBlocks = (base) => (onMsg, onHalt) => {
+  const pendingChainHeadSubs = /* @__PURE__ */ new Set();
+  const pinnedBlocksInSub = /* @__PURE__ */ new Map();
+  const uknownBlocksNotifications = /* @__PURE__ */ new Map();
+  const withClear = (fn) => (...args) => {
+    [
+      pendingChainHeadSubs,
+      pinnedBlocksInSub,
+      uknownBlocksNotifications
+    ].forEach((x) => {
+      x.clear();
+    });
+    fn(...args);
+  };
+  const { send: originalSend, disconnect } = base((message) => {
+    if ("id" in message) {
+      onMsg(message);
+      const { id, result } = message;
+      if (pendingChainHeadSubs.has(id)) {
+        pendingChainHeadSubs.delete(id);
+        pinnedBlocksInSub.set(result, /* @__PURE__ */ new Set());
+        uknownBlocksNotifications.set(result, /* @__PURE__ */ new Map());
+        return;
+      }
+    } else {
+      const { subscription } = message.params;
+      const pinnedBlocks = pinnedBlocksInSub.get(subscription);
+      const premature = uknownBlocksNotifications.get(subscription);
+      if (pinnedBlocks) {
+        const result = message.params.result;
+        const { event } = result;
+        if (event === "initialized") {
+          result.finalizedBlockHashes.forEach((hash) => {
+            pinnedBlocks.add(hash);
+          });
+        }
+        if (event === "finalized") {
+          result.prunedBlockHashes = result.prunedBlockHashes.filter(
+            (x) => pinnedBlocks.has(x)
+          );
+        }
+        if (event === "newBlock") {
+          pinnedBlocks.add(result.blockHash);
+          const hash = result.blockHash;
+          const missing = premature.get(hash);
+          if (missing) {
+            premature.delete(hash);
+            onMsg(message);
+            Promise.resolve().then(() => {
+              onMsg(missing);
+            });
+            return;
+          }
+        }
+        if (event === "bestBlockChanged") {
+          const hash = result.bestBlockHash;
+          if (!pinnedBlocks.has(hash)) {
+            uknownBlocksNotifications.get(subscription).set(hash, message);
+            return;
+          }
+        }
+        if (event === "stop") {
+          pinnedBlocks.delete(subscription);
+          uknownBlocksNotifications.delete(subscription);
+        }
+      }
+      onMsg(message);
+    }
+  }, withClear(onHalt));
+  const send = (msg) => {
+    const subId = msg.params[0];
+    switch (msg.method) {
+      case follow$1:
+        pendingChainHeadSubs.add(msg.id);
+        break;
+      case unpin:
+        const [subscription, blocks] = msg.params;
+        blocks.forEach((block) => {
+          pinnedBlocksInSub.get(subscription)?.delete(block);
+          uknownBlocksNotifications.get(subscription)?.delete(block);
+        });
+        break;
+      case unfollow$1:
+        pinnedBlocksInSub.delete(subId);
+        uknownBlocksNotifications.delete(subId);
+        break;
+    }
+    originalSend(msg);
+  };
+  return {
+    send,
+    disconnect: withClear(disconnect)
+  };
+};
+
+const { follow, body, call, storage, unfollow, stopOperation } = chainHead;
+const terminalOperationEvents = new Set(
+  ["BodyDone", "CallDone", "StorageDone", "Inaccessible", "Error"].map(
+    (x) => "operation" + x
+  )
+);
+const isTerminalNotification = (msg) => terminalOperationEvents.has(msg.params?.result?.event);
+const fixUnorderedEvents = (base) => (onMsg, onHalt) => {
+  const pendingChainHeadSubs = /* @__PURE__ */ new Set();
+  const pendingOperationIds = /* @__PURE__ */ new Map();
+  const activeOperationIds = /* @__PURE__ */ new Map();
+  const uknownOperationNotifications = /* @__PURE__ */ new Map();
+  const withClear = (fn) => (...args) => {
+    [
+      pendingChainHeadSubs,
+      pendingOperationIds,
+      activeOperationIds,
+      uknownOperationNotifications
+    ].forEach((x) => {
+      x.clear();
+    });
+    fn(...args);
+  };
+  const { send: originalSend, disconnect } = base((message) => {
+    if ("id" in message) {
+      onMsg(message);
+      const { id, result } = message;
+      if (pendingChainHeadSubs.has(id)) {
+        pendingChainHeadSubs.delete(id);
+        activeOperationIds.set(result, /* @__PURE__ */ new Set());
+        uknownOperationNotifications.set(result, /* @__PURE__ */ new Map());
+        return;
+      }
+      const subId = pendingOperationIds.get(id);
+      if (subId !== void 0) {
+        pendingOperationIds.delete(id);
+        const opId = message.result?.operationId;
+        if (opId !== void 0 && activeOperationIds.has(subId)) {
+          const subOperations = activeOperationIds.get(subId);
+          subOperations.add(opId);
+          const pendingNotifications = uknownOperationNotifications.get(subId)?.get(opId);
+          if (pendingNotifications) {
+            pendingNotifications.forEach(onMsg);
+            uknownOperationNotifications.get(subId).delete(opId);
+            if (isTerminalNotification(pendingNotifications.at(-1)))
+              subOperations.delete(opId);
+          }
+        }
+      }
+    } else {
+      const { subscription, result } = message.params;
+      const operationIds = activeOperationIds.get(subscription);
+      if (operationIds) {
+        const { operationId } = message.params.result;
+        if (operationId !== void 0) {
+          if (!operationIds.has(operationId)) {
+            const subscriptionPending = uknownOperationNotifications.get(subscription);
+            const pendingMessages = subscriptionPending.get(operationId) ?? [];
+            pendingMessages.push(message);
+            subscriptionPending.set(operationId, pendingMessages);
+            return;
+          } else if (isTerminalNotification(message))
+            operationIds.delete(operationId);
+        } else if (result?.event === "stop") {
+          activeOperationIds.delete(subscription);
+          uknownOperationNotifications.delete(subscription);
+        }
+      }
+      onMsg(message);
+    }
+  }, withClear(onHalt));
+  const send = (msg) => {
+    const subId = msg.params[0];
+    switch (msg.method) {
+      case follow:
+        pendingChainHeadSubs.add(msg.id);
+        break;
+      case body:
+      case call:
+      case storage:
+        pendingOperationIds.set(msg.id, subId);
+        break;
+      case unfollow:
+        activeOperationIds.delete(subId);
+        uknownOperationNotifications.delete(subId);
+        break;
+      case stopOperation:
+        activeOperationIds.get(subId)?.delete(msg.params[1]);
+    }
+    originalSend(msg);
+  };
+  return {
+    send,
+    disconnect: withClear(disconnect)
+  };
+};
+
+const patchChainHeadEvents = (base) => (onMsg, onHalt) => base((message) => {
+  const result = message.params?.result;
+  if (!("id" in message) && result) {
+    const { prunedBlockHashes, finalizedBlockHash, event } = result;
+    if (event === "finalized" && Array.isArray(prunedBlockHashes))
+      result.prunedBlockHashes = [...new Set(result.prunedBlockHashes)];
+    else if (event === "initialized" && finalizedBlockHash) {
+      result.finalizedBlockHashes = [result.finalizedBlockHash];
+      delete result.finalizedBlockHash;
+    }
+  }
+  onMsg(message);
+}, onHalt);
+
+const unpinHash = (base) => (...args) => {
+  const { send: _send, disconnect } = base(...args);
+  const send = (msg) => {
+    const { method, params, id, ...rest } = msg;
+    if (method == chainHead.unpin && params && Array.isArray(params[1])) {
+      params[1].forEach((hash, idx) => {
+        _send({
+          ...rest,
+          id: idx === 0 ? id : `${id}-patched-${idx}`,
+          method,
+          params: [params[0], hash]
+        });
+      });
+    } else _send(msg);
+  };
+  return { send, disconnect };
+};
+
+const modern = apply(
+  fixUnorderedEvents,
+  unpinHash,
+  patchChainHeadEvents,
+  fixPrematureBlocks,
+  fixUnorderedBlocks,
+  followEnhancer
+);
+
+const withNumericIds = (base) => (onMsg, onHalt) => {
+  let nextId = 0;
+  const numberToOriginal = /* @__PURE__ */ new Map();
+  const clear = () => {
+    numberToOriginal.clear();
+  };
+  const { send: originalSend, disconnect } = base(
+    (message) => {
+      const { id } = message;
+      if (numberToOriginal.has(id)) {
+        message.id = numberToOriginal.get(id);
+        numberToOriginal.delete(id);
+      }
+      onMsg(message);
+    },
+    (e) => {
+      clear();
+      onHalt(e);
+    }
+  );
+  return {
+    send: (msg) => {
+      if (msg.id !== void 0) {
+        numberToOriginal.set(nextId, msg.id);
+        msg.id = nextId++;
+      }
+      originalSend(msg);
+    },
+    disconnect() {
+      clear();
+      disconnect();
+    }
+  };
+};
+
+const modernGroups = ["chainHead", "transaction", "chainSpec", "archive"].map(
+  (name) => `${name}_v1`
+);
+const isModern = (methods) => modernGroups.every((group) => methods.some((m) => m.startsWith(group)));
+const middleware = apply(
+  withNumericIds,
+  methodsRouter((methods) => isModern(methods) ? modern : withLegacy)
+);
+
+exports.apply = apply;
+exports.fixPrematureBlocks = fixPrematureBlocks;
+exports.fixUnorderedBlocks = fixUnorderedBlocks;
+exports.fixUnorderedEvents = fixUnorderedEvents;
+exports.followEnhancer = followEnhancer;
+exports.methodsRouter = methodsRouter;
+exports.middleware = middleware;
+exports.modern = modern;
+exports.patchChainHeadEvents = patchChainHeadEvents;
+exports.unpinHash = unpinHash;
+exports.withLegacy = withLegacy;
+//# sourceMappingURL=index.js.map