Add ENRForkID to ENR eth2

packages/lodestar-beacon-state-transition/src/epoch/fork.ts

@@ -0,0 +1,19 @@
+import {IBeaconConfig} from "@chainsafe/lodestar-config";
+import {BeaconState} from "@chainsafe/lodestar-types";
+import {getCurrentEpoch} from "..";
+import {intToBytes} from "@chainsafe/lodestar-utils";
+
+export function processForkChanged(config: IBeaconConfig, state: BeaconState): void {
+  const currentEpoch = getCurrentEpoch(config, state);
+  const nextEpoch = currentEpoch + 1;
+  const currentForkVersion = state.fork.currentVersion;
+  const nextFork = config.params.ALL_FORKS && config.params.ALL_FORKS.find(
+    (fork) => config.types.Version.equals(currentForkVersion, intToBytes(fork.previousVersion, 4)));
+  if (nextFork && nextFork.epoch === nextEpoch) {
+    state.fork = {
+      previousVersion: state.fork.currentVersion,
+      currentVersion: intToBytes(nextFork.currentVersion, 4),
+      epoch: nextFork.epoch,
+    };
+  }
+}

packages/lodestar-beacon-state-transition/src/epoch/index.ts

@@ -10,6 +10,7 @@ import {processFinalUpdates} from "./finalUpdates";
 import {processJustificationAndFinalization} from "./justification";
 import {processRegistryUpdates} from "./registryUpdates";
 import {processSlashings} from "./slashings";
+import {processForkChanged} from "./fork";
 
 export * from "./balanceUpdates";
 export * from "./finalUpdates";
@@ -41,6 +42,9 @@ export function processEpoch(config: IBeaconConfig, state: BeaconState): BeaconS
   // Final Updates
   processFinalUpdates(config, state);
 
+  // check and process planned hard fork
+  processForkChanged(config, state);
+
   // TODO Later Phase
   // afterProcessFinalUpdates
 

packages/lodestar-beacon-state-transition/test/unit/stateTransition/epoch/fork.test.ts

@@ -0,0 +1,59 @@
+import {config} from "@chainsafe/lodestar-config/lib/presets/mainnet";
+import {BeaconState} from "@chainsafe/lodestar-types";
+import {generateState} from "../../../utils/state";
+import {processForkChanged} from "../../../../src/epoch/fork";
+import {expect} from "chai";
+import {bytesToInt} from "@chainsafe/lodestar-utils";
+
+describe("processForkChanged", () => {
+  let state: BeaconState;
+
+  beforeEach(() => {
+    state = generateState();
+    state.fork = {
+      currentVersion: Buffer.from([1, 0, 0, 0]),
+      epoch: 100,
+      previousVersion: Buffer.alloc(4),
+    };
+  });
+
+  afterEach(() => {
+    config.params.ALL_FORKS = undefined;
+  });
+
+  it("should not update fork if no matched next fork", () => {
+    config.params.ALL_FORKS = undefined;
+    const preFork = state.fork;
+    processForkChanged(config, state);
+    expect(config.types.Fork.equals(preFork, state.fork)).to.be.true;
+  });
+
+  it("should not update fork if found matched next fork but epoch not matched", () => {
+    config.params.ALL_FORKS = [
+      {
+        previousVersion: bytesToInt(Buffer.from([1, 0, 0, 0])),
+        currentVersion: bytesToInt(Buffer.from([2, 0, 0, 0])),
+        epoch: 200,
+      },
+    ];
+    const preFork = state.fork;
+    processForkChanged(config, state);
+    expect(config.types.Fork.equals(preFork, state.fork)).to.be.true;
+  });
+
+  it("should update fork if found matched next fork and matched epoch", () => {
+    config.params.ALL_FORKS = [
+      {
+        previousVersion: bytesToInt(Buffer.from([1, 0, 0, 0])),
+        currentVersion: bytesToInt(Buffer.from([2, 0, 0, 0])),
+        epoch: 200,
+      },
+    ];
+    const preFork = state.fork;
+    state.slot = 200 * config.params.SLOTS_PER_EPOCH - 1;
+    processForkChanged(config, state);
+    expect(config.types.Fork.equals(preFork, state.fork)).to.be.false;
+    expect(config.types.Version.equals(preFork.currentVersion, state.fork.previousVersion));
+    expect(state.fork.epoch).to.be.equal(200);
+  });
+});

packages/lodestar-cli/src/commands/beacon.ts

@@ -16,10 +16,13 @@ import {getTomlConfig} from "../lodestar/util/file";
 import {createNodeJsLibp2p, loadPeerIdFromJsonFile} from "@chainsafe/lodestar/lib/network/nodejs";
 import {ENR} from "@chainsafe/discv5";
 import {initBLS} from "@chainsafe/bls";
+import fs from "fs";
+import {load} from "js-yaml";
 
 interface IBeaconCommandOptions {
   [key: string]: string;
   peerId: string;
+  forkFile?: string;
   configFile?: string;
   preset?: string;
   loggingLevel?: string;
@@ -52,7 +55,7 @@ export class BeaconNodeCommand implements ICliCommand {
     generateCommanderOptions(command, BeaconNodeOptions);
   }
 
-  public async action(cmdOptions: IBeaconCommandOptions, logger: ILogger): Promise<void> {
+  public async action(cmdOptions: IBeaconCommandOptions, logger: ILogger): Promise<BeaconNode> {
     let nodeOptions: Partial<IBeaconNodeOptions> = {};
     //find better place for this once this cli is refactored
     await initBLS();
@@ -81,7 +84,12 @@ export class BeaconNodeCommand implements ICliCommand {
     const libp2p = await createNodeJsLibp2p(peerId, libp2pOpt);
     const config = cmdOptions.preset === "minimal" ? minimalConfig : mainnetConfig;
     // nodejs will create EthersEth1Notifier by default
+    if (cmdOptions.forkFile) {
+      // @ts-ignore
+      config.params.ALL_FORKS = load(fs.readFileSync(cmdOptions.forkFile));
+    }
     this.node = new BeaconNode(nodeOptions, {config, logger, libp2p});
     await this.node.start();
+    return this.node;
   }
 }

packages/lodestar-cli/test/e2e/commands/beacon.test.ts

@@ -1,12 +1,15 @@
 import {config} from "@chainsafe/lodestar-config/lib/presets/minimal";
 import rimraf from "rimraf";
 import fs from "fs";
+import {assert} from "chai";
 import {BeaconNodeCommand, DepositCommand} from "../../../src/commands";
 import {ILogger, WinstonLogger} from "@chainsafe/lodestar-utils/lib/logger";
 import {PrivateEth1Network} from "@chainsafe/lodestar/lib/eth1/dev";
 import {JsonRpcProvider} from "ethers/providers";
 import {createPeerId} from "@chainsafe/lodestar/lib/network";
 import {savePeerId} from "@chainsafe/lodestar/lib/network/nodejs";
+import {bytesToInt, intToBytes} from "@chainsafe/lodestar-utils";
+import {dump} from "js-yaml";
 
 describe("beacon cli", function() {
   this.timeout(0);
@@ -16,6 +19,7 @@ describe("beacon cli", function() {
   //same folder of default db
   const tmpDir = ".tmp";
   const peerIdPath = `${tmpDir}/peer-id.json`;
+  const forkFile = `${tmpDir}/forks.yml`;
 
   before(async () => {
     if (fs.existsSync(tmpDir)) {
@@ -24,6 +28,16 @@ describe("beacon cli", function() {
     fs.mkdirSync(`${tmpDir}/lodestar-db`, {recursive: true});
     const peerId = await createPeerId();
     await savePeerId(peerIdPath, peerId);
+    const ALL_FORKS = [
+      {
+        currentVersion: 2,
+        epoch: 100,
+        // GENESIS_FORK_VERSION is <Buffer 00 00 00 01> but previousVersion = 16777216 not 1 due to bytesToInt
+        previousVersion: bytesToInt(config.params.GENESIS_FORK_VERSION)
+      },
+    ];
+    const yml = dump(ALL_FORKS);
+    fs.writeFileSync(forkFile, yml);
   });
 
   after(() => {
@@ -66,11 +80,15 @@ describe("beacon cli", function() {
       eth1RpcUrl: eth1Network.rpcUrl(),
       networkId: "999",
       depositContractBlockNum: "0", // not really but it's ok
-      depositContract: contractAddress
+      depositContract: contractAddress,
+      forkFile: forkFile,
     };
     const cmd = new BeaconNodeCommand();
-    await cmd.action(cmdOptions, logger);
+    const node = await cmd.action(cmdOptions, logger);
     logger.verbose("cmd.action started node successfully");
+    const enrForkID = await node.chain.getENRForkID();
+    assert(config.types.Version.equals(enrForkID.nextForkVersion, intToBytes(2, 4)));
+    assert(enrForkID.nextForkEpoch === 100);
     await new Promise((resolve) => setTimeout(resolve, 10 * config.params.SECONDS_PER_SLOT * 1000));
     await cmd.node.stop();
     logger.verbose("cmd.stop stopped node successfully");

packages/lodestar-params/src/interface.ts

@@ -70,4 +70,17 @@ export interface IBeaconParams {
   MAX_ATTESTATIONS: number;
   MAX_DEPOSITS: number;
   MAX_VOLUNTARY_EXITS: number;
+
+  // Old and future forks
+  ALL_FORKS: IFork[];
+}
+
+interface IFork {
+  // 4 bytes
+  previousVersion: number;
+  // 4 bytes
+  currentVersion: number;
+  // Fork epoch number
+  epoch: number;
 }
+

packages/lodestar-types/src/ssz/generators/misc.ts

@@ -23,6 +23,14 @@ export const ForkData = (ssz: IBeaconSSZTypes): ContainerType => new ContainerTy
   },
 });
 
+export const ENRForkID = (ssz: IBeaconSSZTypes): ContainerType => new ContainerType({
+  fields: {
+    forkDigest: ssz.ForkDigest,
+    nextForkVersion: ssz.Version,
+    nextForkEpoch: ssz.Epoch,
+  },
+});
+
 export const Checkpoint = (ssz: IBeaconSSZTypes): ContainerType => new ContainerType({
   fields: {
     epoch: ssz.Epoch,

packages/lodestar-types/src/ssz/interface.ts

@@ -34,6 +34,7 @@ export interface IBeaconSSZTypes {
   // misc
   Fork: ContainerType<t.Fork>;
   ForkData: ContainerType<t.ForkData>;
+  ENRForkID: ContainerType<t.ENRForkID>;
   Checkpoint: ContainerType<t.Checkpoint>;
   Validator: ContainerType<t.Validator>;
   AttestationData: ContainerType<t.AttestationData>;
@@ -110,6 +111,7 @@ export const typeNames: (keyof IBeaconSSZTypes)[] = [
   // misc
   "Fork",
   "ForkData",
+  "ENRForkID",
   "Checkpoint",
   "Validator",
   "AttestationData",

packages/lodestar-types/src/types/misc.ts

@@ -18,6 +18,7 @@ import {
   CommitteeIndex,
   Bytes32,
   Domain,
+  ForkDigest,
 } from "./primitive";
 
 export interface Fork {
@@ -36,6 +37,15 @@ export interface ForkData {
   genesisValidatorsRoot: Root;
 }
 
+export interface ENRForkID {
+  // Current fork digest
+  forkDigest: ForkDigest;
+  // next planned fork versin
+  nextForkVersion: Version;
+  // next fork epoch
+  nextForkEpoch: Epoch;
+}
+
 export interface Checkpoint {
   epoch: Epoch;
   root: Root;

packages/lodestar-utils/test/unit/bytes.test.ts

@@ -2,10 +2,11 @@ import {assert, expect} from "chai";
 import {describe, it} from "mocha";
 import {intToBytes, bytesToInt} from "../../src";
 
-describe("intToBytes", () => {                                    
+describe("intToBytes", () => {
   const zeroedArray = (length: number): number[] => Array.from({length}, () => 0);
   const testCases: { input: [bigint | number, number]; output: Buffer }[] = [
-    {input: [255, 1], output: Buffer.from([255])},                                        
+    {input: [255, 1], output: Buffer.from([255])},
+    {input: [1, 4], output: Buffer.from([1, 0, 0, 0])},
     {input: [255n, 1], output: Buffer.from([255])},
     {input: [65535, 2], output: Buffer.from([255, 255])},
     {input: [65535n, 2], output: Buffer.from([255, 255])},
@@ -31,7 +32,7 @@ describe("intToBytes", () => {
   }
 });
 
-describe.only("bytesToInt", () => {
+describe("bytesToInt", () => {
   const testCases: { input: Buffer; output: number}[] = [
     {input: Buffer.from([3]), output: 3},
     {input: Buffer.from([20, 0]), output: 20},

packages/lodestar/src/chain/blocks/process.ts

@@ -1,15 +1,21 @@
 import {IBlockProcessJob} from "../chain";
 import {BeaconState, Root, SignedBeaconBlock} from "@chainsafe/lodestar-types";
-import {stateTransition} from "@chainsafe/lodestar-beacon-state-transition";
+import {stateTransition, computeEpochAtSlot} from "@chainsafe/lodestar-beacon-state-transition";
 import {toHexString} from "@chainsafe/ssz";
 import {IBeaconConfig} from "@chainsafe/lodestar-config";
 import {IBeaconDb} from "../../db/api";
 import {ILogger} from "@chainsafe/lodestar-utils/lib/logger";
 import {ILMDGHOST} from "../forkChoice";
 import {BlockPool} from "./pool";
+import {ChainEventEmitter} from "..";
 
 export function processBlock(
-  config: IBeaconConfig, db: IBeaconDb, logger: ILogger, forkChoice: ILMDGHOST, pool: BlockPool
+  config: IBeaconConfig,
+  db: IBeaconDb,
+  logger: ILogger,
+  forkChoice: ILMDGHOST,
+  pool: BlockPool,
+  eventBus: ChainEventEmitter,
 ): (source: AsyncIterable<IBlockProcessJob>) => AsyncGenerator<{block: SignedBeaconBlock; postState: BeaconState}> {
   return (source) => {
     return (async function*() {
@@ -32,6 +38,12 @@ export function processBlock(
         const newChainHeadRoot = await updateForkChoice(config, db, forkChoice, job.signedBlock, newState);
         if(newChainHeadRoot) {
           logger.important(`Fork choice changed head to 0x${toHexString(newChainHeadRoot)}`);
+          if(!config.types.Fork.equals(preState.fork, newState.fork)) {
+            const epoch = computeEpochAtSlot(config, newState.slot);
+            const currentVersion = newState.fork.currentVersion;
+            logger.important(`Fork version changed to ${currentVersion} at slot ${newState.slot} and epoch ${epoch}`);
+            eventBus.emit("forkDigestChanged");
+          }
           await updateDepositMerkleTree(config, db, newState);
         }
         pool.onProcessedBlock(job.signedBlock);

packages/lodestar/src/chain/blocks/processor.ts

@@ -64,7 +64,7 @@ export class BlockProcessor implements IService {
         return abortable(source, abortSignal, {returnOnAbort: true});
       },
       validateBlock(this.config, this.logger, this.db, this.forkChoice),
-      processBlock(this.config, this.db, this.logger, this.forkChoice, this.pendingBlocks),
+      processBlock(this.config, this.db, this.logger, this.forkChoice, this.pendingBlocks, this.eventBus),
       postProcess(
         this.config,
         this.db,