feat: override libp2p handler when registering protocol for new fork (#7755)

**Motivation**

Right now, we do [not register a handler if it already is already
registered](https://github.com/ChainSafe/lodestar/blob/78a5e72989d10426b77bd408673fe191bbf33f8a/packages/reqresp/src/ReqResp.ts#L102-L105)
but even though we update some parts now such as rate limit at the hard
fork, we do not update all of them like `requestSizes`, we can either
pass the fork down in all the code paths where it is needed and use
getter functions or we override the handler once during the hard fork
transition. This PR proposes the later solution as it's much simpler and
seems cleaner as well.

**Description**

Override libp2p handler when registering protocol for new fork, this is
possible now due to libp2p/js-libp2p#2945 since
we updated to libp2p 2.0 in
#7359.

More context libp2p/js-libp2p#2928

Closes #7557

Author: nflaig

packages/beacon-node/src/network/reqresp/ReqRespBeaconNode.ts

@@ -137,9 +137,9 @@ export class ReqRespBeaconNode extends ReqResp {
       }
     }
 
-    // Subscribe required protocols, prevent libp2p for throwing if already registered
+    // Subscribe required protocols
     for (const [protocol, handler] of mustSubscribeProtocols) {
-      this.registerProtocol({...protocol, handler}, {ignoreIfDuplicate: true}).catch((e) => {
+      this.registerProtocol({...protocol, handler}).catch((e) => {
         this.logger.error("Error on ReqResp.registerProtocol", {protocolID: this.formatProtocolID(protocol)}, e);
       });
     }

packages/reqresp/src/ReqResp.ts

@@ -33,10 +33,6 @@ export interface ReqRespOpts extends SendRequestOpts, ReqRespRateLimiterOpts {
   getPeerLogMetadata?: (peerId: string) => string;
 }
 
-export interface ReqRespRegisterOpts {
-  ignoreIfDuplicate?: boolean;
-}
-
 /**
  * Implementation of Ethereum Consensus p2p Req/Resp domain.
  * For the spec that this code is based on, see:
@@ -87,27 +83,21 @@ export class ReqResp {
   /**
    * Register protocol as supported and to libp2p.
    * async because libp2p registrar persists the new protocol list in the peer-store.
-   * Throws if the same protocol is registered twice.
+   * Overrides handler and rate limits in case protocol is already registered.
    * Can be called at any time, no concept of started / stopped
    */
-  async registerProtocol(protocol: Protocol, opts?: ReqRespRegisterOpts): Promise<void> {
+  async registerProtocol(protocol: Protocol): Promise<void> {
     const protocolID = this.formatProtocolID(protocol);
     const {handler: _handler, inboundRateLimits, ...rest} = protocol;
 
+    this.registerDialOnlyProtocol(rest);
+    this.dialOnlyProtocols.set(protocolID, false);
+
     if (inboundRateLimits) {
-      // Rate limits can change across hard forks and must always be updated
       this.rateLimiter.setRateLimits(protocolID, inboundRateLimits);
     }
 
-    // libp2p will throw if handler for protocol is already registered, allow to overwrite behavior
-    if (opts?.ignoreIfDuplicate && this.registeredProtocols.has(protocolID)) {
-      return;
-    }
-
-    this.registerDialOnlyProtocol(rest);
-    this.dialOnlyProtocols.set(protocolID, false);
-
-    return this.libp2p.handle(protocolID, this.getRequestHandler(protocol, protocolID));
+    return this.libp2p.handle(protocolID, this.getRequestHandler(protocol, protocolID), {force: true});
   }
 
   /**

packages/reqresp/test/unit/ReqResp.test.ts

@@ -66,19 +66,22 @@ describe("ResResp", () => {
       expect(libp2p.handle).toHaveBeenCalledOnce();
     });
 
-    it("should not register handler twice for same protocol if ignoreIfDuplicate=true", async () => {
-      await reqresp.registerProtocol(numberToStringProtocol, {ignoreIfDuplicate: true});
+    it("should override existing handler if same protocol is registered multiple times", async () => {
+      await reqresp.registerProtocol(numberToStringProtocol);
       expect(libp2p.handle).toHaveBeenCalledOnce();
 
-      await reqresp.registerProtocol(numberToStringProtocol, {ignoreIfDuplicate: true});
-      expect(libp2p.handle).toHaveBeenCalledOnce();
+      await reqresp.registerProtocol(numberToStringProtocol);
+      expect(libp2p.handle).toHaveBeenCalledTimes(2);
+
+      await reqresp.registerProtocol(numberToStringProtocol);
+      expect(libp2p.handle).toHaveBeenCalledTimes(3);
     });
 
     it("should apply new rate limits if same protocol is registered with different limits", async () => {
       // Initial registration of protocol
       const {quota, quotaTimeMs} = numberToStringProtocol.inboundRateLimits?.byPeer as RateLimiterQuota;
       const initialMsPerToken = quotaTimeMs / quota;
-      await reqresp.registerProtocol(numberToStringProtocol, {ignoreIfDuplicate: true});
+      await reqresp.registerProtocol(numberToStringProtocol);
       const initialLimit = reqresp["rateLimiter"]["rateLimitersPerPeer"].get(
         "/eth2/beacon_chain/req/number_to_string/1/ssz_snappy"
       );
@@ -92,7 +95,7 @@ describe("ResResp", () => {
         inboundRateLimits: {byPeer: updatedQuota},
       };
       const updatedMsPerToken = updatedQuota.quotaTimeMs / updatedQuota.quota;
-      await reqresp.registerProtocol(updatedProtocol, {ignoreIfDuplicate: true});
+      await reqresp.registerProtocol(updatedProtocol);
       const updatedLimit = reqresp["rateLimiter"]["rateLimitersPerPeer"].get(
         "/eth2/beacon_chain/req/number_to_string/1/ssz_snappy"
       );