@polkadot-api/ws-middleware 0.2.3 → 0.2.4-canary.5629cfc

package/dist/index.js

@@ -1,9 +1,47 @@
 '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');
+var utils = require('@polkadot-api/utils');
+var substrateBindings = require('@polkadot-api/substrate-bindings');
+
+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 shareLatest = rxjs.shareReplay({
   refCount: true,
@@ -350,18 +388,23 @@ const getHasherFromBlock = (shitHeader) => (hash) => hashers[fns.findIndex((fn)
 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();
-    }
-  });
+  let finished = false;
+  const subscription = new rxjs.Subscription();
+  subscription.add(
+    base$.subscribe({
+      next(v) {
+        if (prev) prev.push(v);
+        else observer.next([latest, v]);
+      },
+      error(e) {
+        observer.error(e);
+      },
+      complete() {
+        if (prev) finished = true;
+        else observer.complete();
+      }
+    })
+  );
   subscription.add(
     latest$.subscribe({
       next(v) {
@@ -371,6 +414,7 @@ const withLatestFromBp = (latest$) => (base$) => new rxjs.Observable((observer)
           prev = null;
           copy.forEach((p) => observer.next([latest, p]));
         }
+        if (finished) observer.complete();
       },
       error(e) {
         observer.error(e);
@@ -519,13 +563,15 @@ const createUpstream = (request) => {
       }
     )
   );
-  const {
-    upstream: getBlocks,
-    finalized$,
-    getHeader$,
-    hasher$,
-    clean
-  } = getBlocks$(request, obsRequest);
+  let blockSubscription = null;
+  const subscribeBlocks = () => {
+    blockSubscription ?? (blockSubscription = getBlocks$(request, obsRequest));
+    return {
+      ...blockSubscription,
+      getBlocks: blockSubscription.upstream
+    };
+  };
+  const clean = () => blockSubscription?.clean();
   const runtimeCall = (atBlock, method, data) => obsRequest("state_call", [
     method,
     data,
@@ -559,7 +605,7 @@ const createUpstream = (request) => {
     return getKeys().pipe(rxjs.mergeMap((keys) => getValues(keys)));
   };
   const stgDescendantHashes = (at, rootKey) => stgDescendantValues(at, rootKey).pipe(
-    withLatestFromBp(hasher$),
+    withLatestFromBp(subscribeBlocks().hasher$),
     rxjs.map(
       ([hasher, results]) => results.map(
         ([key, value]) => [key, utils.toHex(hasher(utils.fromHex(value)))]
@@ -583,10 +629,8 @@ const createUpstream = (request) => {
   const getBlockHash$ = (height) => obsRequest("chain_getBlockHash", [height]);
   const genesisHash = getBlockHash$(0);
   return {
-    getBlocks,
-    finalized$,
+    subscribeBlocks,
     getBlockHash$,
-    getHeader$,
     stgValue,
     stgHash,
     stgDescendantValues,
@@ -597,26 +641,10 @@ const createUpstream = (request) => {
     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");
-      }
-    );
+    obsRequest,
+    clean
   };
 };
 
@@ -684,45 +712,155 @@ const getMsgFromErr = (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 {
+  body: body$2,
+  call: call$2,
+  finalizedHeight,
+  genesisHash,
+  hashByHeight,
+  header: header$1,
+  stopStorage,
+  storage: storage$2
+} = 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$2:
+        return obsReply(
+          upstream.getBody(firstArg).pipe(rxjs.map(({ block }) => block.extrinsics))
+        );
+      case call$2:
+        return obsReply(
+          upstream.runtimeCall(firstArg, secondArg, thirdArg).pipe(rxjs.map((value) => ({ success: true, value })))
+        );
+      case finalizedHeight:
+        return obsReply(
+          upstream.subscribeBlocks().finalized$.pipe(
+            rxjs.map((x) => x.number),
+            rxjs.take(1)
+          )
+        );
+      case genesisHash:
+        return obsReply(upstream.genesisHash);
+      case hashByHeight:
+        return obsReply(upstream.getBlockHash$(firstArg).pipe(rxjs.map((x) => [x])));
+      case header$1:
+        return obsReply(
+          upstream.subscribeBlocks().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$2:
+        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 transaction = {
-  broadcast: "",
-  stop: ""
+
+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");
+      }
+    );
+  };
 };
-const chainSpec = {
-  chainName: "",
-  genesisHash: "",
-  properties: ""
+
+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.subscribeBlocks().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;
 };
-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 { follow: follow$4, header, storage: storage$1, body: body$1, call: call$1, unfollow: unfollow$4, stopOperation: stopOperation$1, unpin: unpin$2 } = chainHead;
 const createChainHead = (upstream, reply, err, notification) => {
   const subscriptions = /* @__PURE__ */ new Map();
   const _follow = (rId) => {
@@ -731,7 +869,7 @@ const createChainHead = (upstream, reply, err, notification) => {
     }
     const token = createOpaqueToken();
     const fNotification = (result2) => notification("chainHead_v1_followEvent", token, result2);
-    const up = upstream.getBlocks(token);
+    const up = upstream.subscribeBlocks().getBlocks(token);
     const operations = /* @__PURE__ */ new Map();
     subscriptions.set(token, {
       id: token,
@@ -783,7 +921,7 @@ const createChainHead = (upstream, reply, err, notification) => {
     const operationId = createOpaqueToken();
     reply2({ result: "started", operationId });
     const cNotification = (output, isErr = false) => notification(
-      call$2,
+      call$1,
       followId,
       isErr ? {
         operationId,
@@ -817,7 +955,7 @@ const createChainHead = (upstream, reply, err, notification) => {
     const subscription = upstream.getBody(at).subscribe(
       ({ block: { extrinsics: value } }) => {
         operations.delete(operationId);
-        notification(body$2, followId, {
+        notification(body$1, followId, {
           event: "operationBodyDone",
           operationId,
           value
@@ -825,7 +963,7 @@ const createChainHead = (upstream, reply, err, notification) => {
       },
       (e) => {
         operations.delete(operationId);
-        notification(body$2, followId, {
+        notification(body$1, followId, {
           event: "operationError",
           operationId,
           error: getMsgFromErr(e)
@@ -842,7 +980,7 @@ const createChainHead = (upstream, reply, err, notification) => {
     const operationId = createOpaqueToken();
     reply2({ result: "started", operationId });
     const innerNotifiaction = (msg) => {
-      notification(storage$2, followId, msg);
+      notification(storage$1, followId, msg);
     };
     const subscription = getStg$(upstream, at, items).pipe(
       rxjs.finalize(() => {
@@ -900,17 +1038,17 @@ const createChainHead = (upstream, reply, err, notification) => {
         const [at, ...other] = rest;
         if (!ctx.up.isPinned(at)) return err(rId, -32801, "Block not pinned");
         switch (method) {
-          case header$1:
+          case header:
             return _header(ctx, innerReply, at);
-          case body$2:
+          case body$1:
             return _body(ctx, innerReply, at);
-          case call$2: {
+          case call$1: {
             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: {
+          case storage$1: {
             const [items] = other;
             return areItemsValid(items) ? _stg(ctx, innerReply, at, items) : err(rId, -32602, "Invalid args");
           }
@@ -927,138 +1065,6 @@ const createChainHead = (upstream, reply, err, notification) => {
   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).pipe(rxjs.map(({ block }) => block.extrinsics))
-        );
-      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).pipe(rxjs.map((x) => [x])));
-      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()
 );
@@ -1092,16 +1098,22 @@ const withLegacy = (base) => (onMessage, onHalt) => {
   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)
+  const groupsCtor = {
+    chainSpec: () => createChainSpec(upstream, reply, err),
+    chainHead: () => createChainHead(upstream, reply, err, notification),
+    archive: () => createArchive(upstream, reply, err, notification),
+    transaction: () => createTransactionFns(upstream, reply)
+  };
+  const groups = {};
+  const getGroup = (name) => {
+    if (name in groups) return groups[name];
+    if (name in groupsCtor) return groups[name] = groupsCtor[name]();
+    return null;
   };
   clean = () => {
-    groups.chainHead.stop();
-    groups.archive.stop();
-    groups.transaction.stop();
+    groups.chainHead?.stop();
+    groups.archive?.stop();
+    groups.transaction?.stop();
     upstream.clean();
   };
   return {
@@ -1130,9 +1142,10 @@ ${JSON.stringify(parsedMsg)}`);
         );
       }
       const [groupName] = method.split("_");
-      if (groupName in groups) {
+      const group = getGroup(groupName);
+      if (group) {
         try {
-          return groups[groupName](id, method, params);
+          return group(id, method, params);
         } catch (e) {
           if (e !== null) throw e;
         }
@@ -1155,113 +1168,6 @@ ${JSON.stringify(parsedMsg)}`);
   };
 };
 
-const apply = (...middlewares) => (base) => middlewares.reduce((a, b) => b(a), base);
-const jsonObj = (input) => ({
-  jsonrpc: "2.0",
-  ...input
-});
-const operationNotification = (subscription, event, operationId, innerResult = {}) => jsonObj({
-  method: "chainHead_v1_followEvent",
-  params: {
-    subscription,
-    result: {
-      event,
-      operationId,
-      ...innerResult
-    }
-  }
-});
-
-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) => {
@@ -1652,6 +1558,23 @@ const unpinHash = (base) => (...args) => {
   return { send, disconnect };
 };
 
+const apply = (...middlewares) => (base) => middlewares.reduce((a, b) => b(a), base);
+const jsonObj = (input) => ({
+  jsonrpc: "2.0",
+  ...input
+});
+const operationNotification = (subscription, event, operationId, innerResult = {}) => jsonObj({
+  method: "chainHead_v1_followEvent",
+  params: {
+    subscription,
+    result: {
+      event,
+      operationId,
+      ...innerResult
+    }
+  }
+});
+
 const cancelEvents = /* @__PURE__ */ new Set(["newBlock", "bestBlockChanged", "stop"]);
 const fixMissingInitialBest = (base) => (onMsg, onHalt) => {
   const pendingChainHeadSubs = /* @__PURE__ */ new Set();
@@ -1723,6 +1646,185 @@ const modern = apply(
   followEnhancer
 );
 
+const modernGroups = ["chainHead", "transaction", "chainSpec", "archive"].map(
+  (name) => `${name}_v1`
+);
+const hybridMiddleware = (methods) => {
+  const individualChecks = Object.fromEntries(
+    modernGroups.map((group) => [
+      group,
+      !!methods.find((v) => v.startsWith(group))
+    ])
+  );
+  return (base) => {
+    const multiplexed = multiplex(base);
+    const modernProvider = modern(multiplexed);
+    const legacyProvider = withLegacy(multiplexed);
+    return (onMsg, onHalt) => {
+      const modernConnection = modernProvider((message) => {
+        if ("error" in message && message.error.code === -32800) {
+          console.warn("Max follow connections received: chainHead_v1 disabled");
+          individualChecks.chainHead_v1 = false;
+        }
+        onMsg(message);
+      }, onHalt);
+      const legacyConnection = legacyProvider(onMsg, onHalt);
+      return {
+        send(message) {
+          for (const group of modernGroups) {
+            if (message.method.startsWith(group)) {
+              if (individualChecks[group]) {
+                modernConnection.send(message);
+              } else {
+                legacyConnection.send(message);
+              }
+              return;
+            }
+          }
+          modernConnection.send(message);
+        },
+        disconnect() {
+          modernConnection.disconnect();
+          legacyConnection.disconnect();
+        }
+      };
+    };
+  };
+};
+const multiplex = (base) => {
+  const halt$ = new rxjs.Subject();
+  const msg$ = new rxjs.Subject();
+  let refCount = 0;
+  let baseConnection = null;
+  return (onMsg, onHalt) => {
+    refCount++;
+    baseConnection ?? (baseConnection = base(
+      (msg) => msg$.next(msg),
+      (e) => halt$.next(e)
+    ));
+    const notificationSub = msg$.pipe(rxjs.filter((v) => v.id == null)).subscribe(onMsg);
+    const haltSub = halt$.subscribe(onHalt);
+    const responseSubs = /* @__PURE__ */ new Set();
+    return {
+      send(message) {
+        if (message.id == null) {
+          return baseConnection?.send(message);
+        }
+        const id = message.id;
+        const responseSub = msg$.pipe(
+          rxjs.filter((r) => r.id === id),
+          rxjs.take(1)
+        ).subscribe((msg) => {
+          onMsg(msg);
+          if (!responseSub) throw new Error("unreachable");
+          responseSubs.delete(responseSub);
+        });
+        responseSubs.add(responseSub);
+        baseConnection?.send(message);
+      },
+      disconnect() {
+        notificationSub.unsubscribe();
+        haltSub.unsubscribe();
+        responseSubs.forEach((s) => s.unsubscribe());
+        refCount--;
+        if (refCount === 0) {
+          baseConnection?.disconnect();
+        }
+      }
+    };
+  };
+};
+
+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 withNumericIds = (base) => (onMsg, onHalt) => {
   let nextId = 0;
   const numberToOriginal = /* @__PURE__ */ new Map();
@@ -1758,16 +1860,7 @@ const withNumericIds = (base) => (onMsg, onHalt) => {
   };
 };
 
-const modernGroups = [
-  "chainHead",
-  "transaction",
-  "chainSpec"
-].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)
-);
+const middleware = apply(withNumericIds, methodsRouter(hybridMiddleware));
 
 exports.apply = apply;
 exports.fixMissingInitialBest = fixMissingInitialBest;