refactor(reqresp)!: support byte based handlers

packages/beacon-node/src/network/metadata.ts

@@ -1,9 +1,8 @@
-import {BitArray, toHexString} from "@chainsafe/ssz";
+import {BitArray} from "@chainsafe/ssz";
 import {ForkName} from "@lodestar/params";
 import {altair, Epoch, phase0, ssz} from "@lodestar/types";
 import {BeaconConfig} from "@lodestar/config";
-import {Logger} from "@lodestar/utils";
-import {IBeaconChain} from "../chain/index.js";
+import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {FAR_FUTURE_EPOCH} from "../constants/index.js";
 import {getCurrentAndNextFork} from "./forks.js";
 
@@ -22,41 +21,29 @@ export type MetadataOpts = {
   metadata?: altair.Metadata;
 };
 
-export type MetadataModules = {
-  config: BeaconConfig;
-  chain: IBeaconChain;
-  logger: Logger;
-};
-
 /**
  * Implementation of Ethereum Consensus p2p MetaData.
  * For the spec that this code is based on, see:
  * https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/phase0/p2p-interface.md#metadata
  */
 export class MetadataController {
   private setEnrValue?: (key: string, value: Uint8Array) => Promise<void>;
-  private config: BeaconConfig;
-  private chain: IBeaconChain;
   private _metadata: altair.Metadata;
-  private logger: Logger;
 
-  constructor(opts: MetadataOpts, modules: MetadataModules) {
-    this.config = modules.config;
-    this.chain = modules.chain;
-    this.logger = modules.logger;
-    this._metadata = opts.metadata || ssz.altair.Metadata.defaultValue();
+  constructor(private readonly config: BeaconConfig, opts?: MetadataOpts) {
+    this._metadata = opts?.metadata || ssz.altair.Metadata.defaultValue();
   }
 
-  start(setEnrValue: ((key: string, value: Uint8Array) => Promise<void>) | undefined, currentFork: ForkName): void {
+  start(setEnrValue: ((key: string, value: Uint8Array) => Promise<void>) | undefined, currentEpoch: Epoch): void {
     this.setEnrValue = setEnrValue;
     if (this.setEnrValue) {
       // updateEth2Field() MUST be called with clock epoch
-      this.updateEth2Field(this.chain.clock.currentEpoch);
+      this.updateEth2Field(currentEpoch);
 
       void this.setEnrValue(ENRKey.attnets, ssz.phase0.AttestationSubnets.serialize(this._metadata.attnets));
       // Any fork after altair included
 
-      if (currentFork !== ForkName.phase0) {
+      if (this.config.getForkName(computeStartSlotAtEpoch(currentEpoch)) !== ForkName.phase0) {
         // Only persist syncnets if altair fork is already activated. If currentFork is altair but head is phase0
         // adding syncnets to the ENR is not a problem, we will just have a useless field for a few hours.
         void this.setEnrValue(ENRKey.syncnets, ssz.phase0.AttestationSubnets.serialize(this._metadata.syncnets));
@@ -107,11 +94,13 @@ export class MetadataController {
    * 2. Network MUST call this method on fork transition.
    *    Current Clock implementation ensures no race conditions, epoch is correct if re-fetched
    */
-  updateEth2Field(epoch: Epoch): void {
+  updateEth2Field(epoch: Epoch): Uint8Array | null {
     if (this.setEnrValue) {
       const enrForkId = ssz.phase0.ENRForkID.serialize(getENRForkID(this.config, epoch));
-      this.logger.verbose(`Updated ENR.eth2: ${toHexString(enrForkId)}`);
       void this.setEnrValue(ENRKey.eth2, enrForkId);
+      return enrForkId;
+    } else {
+      return null;
     }
   }
 }

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

@@ -2,7 +2,7 @@ import {Connection} from "@libp2p/interface-connection";
 import {PeerId} from "@libp2p/interface-peer-id";
 import {Multiaddr} from "@multiformats/multiaddr";
 import {BeaconConfig} from "@lodestar/config";
-import {Logger, sleep} from "@lodestar/utils";
+import {Logger, sleep, toHex} from "@lodestar/utils";
 import {ATTESTATION_SUBNET_COUNT, ForkName, ForkSeq, SYNC_COMMITTEE_SUBNET_COUNT} from "@lodestar/params";
 import {SignableENR} from "@chainsafe/discv5";
 import {computeEpochAtSlot, computeTimeAtSlot} from "@lodestar/state-transition";
@@ -156,7 +156,7 @@ export class Network implements INetwork {
     const clock = chain.clock;
     const peersData = new PeersData();
     const networkEventBus = new NetworkEventBus();
-    const metadata = new MetadataController({}, {config, chain, logger});
+    const metadata = new MetadataController(config);
     const peerRpcScores = new PeerRpcScoreStore(metrics);
 
     const libp2p = await createNodeJsLibp2p(peerId, opts, {
@@ -247,7 +247,7 @@ export class Network implements INetwork {
     const discv5 = peerManager["discovery"]?.discv5;
     const setEnrValue = discv5?.setEnrValue.bind(discv5);
     // Initialize ENR with clock's fork
-    metadata.start(setEnrValue, config.getForkName(clock.currentSlot));
+    metadata.start(setEnrValue, clock.currentEpoch);
     await gossip.start();
     attnetsService.start();
     syncnetsService.start();
@@ -496,7 +496,8 @@ export class Network implements INetwork {
           // On fork transition
           if (epoch === forkEpoch) {
             // updateEth2Field() MUST be called with clock epoch, onEpoch event is emitted in response to clock events
-            this.metadata.updateEth2Field(epoch);
+            const enrForkId = this.metadata.updateEth2Field(epoch);
+            if (enrForkId) this.logger.verbose(`Updated ENR.eth2: ${toHex(enrForkId)}`);
             this.reqResp.registerProtocolsAtFork(nextFork);
           }