generate the value for parentBeaconBlockRootGenerator

packages/hardhat-core/src/internal/hardhat-network/provider/node-types.ts

@@ -131,6 +131,7 @@ export interface Snapshot {
   userProvidedNextBlockBaseFeePerGas: bigint | undefined;
   coinbase: string;
   mixHashGenerator: RandomBufferGenerator;
+  parentBeaconBlockRootGenerator: RandomBufferGenerator;
 }
 
 export type SendTransactionResult =

packages/hardhat-core/src/internal/hardhat-network/provider/node.ts

@@ -174,6 +174,10 @@ export class HardhatNode extends EventEmitter {
 
     const hardfork = getHardforkName(config.hardfork);
     const mixHashGenerator = RandomBufferGenerator.create("randomMixHashSeed");
+    const parentBeaconBlockRootGenerator = RandomBufferGenerator.create(
+      "randomParentBeaconBlockRootSeed"
+    );
+
     let forkClient: JsonRpcClient | undefined;
 
     const common = makeCommon(config);
@@ -255,6 +259,7 @@ export class HardhatNode extends EventEmitter {
         stateTrie,
         hardfork,
         mixHashGenerator.next(),
+        parentBeaconBlockRootGenerator.next(),
         genesisBlockBaseFeePerGas
       );
 
@@ -304,6 +309,7 @@ export class HardhatNode extends EventEmitter {
       hardfork,
       hardforkActivations,
       mixHashGenerator,
+      parentBeaconBlockRootGenerator,
       allowUnlimitedContractSize,
       allowBlocksWithSameTimestamp,
       tracingConfig,
@@ -392,6 +398,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     public readonly hardfork: HardforkName,
     private readonly _hardforkActivations: HardforkHistoryConfig,
     private _mixHashGenerator: RandomBufferGenerator,
+    private _parentBeaconBlockRootGenerator: RandomBufferGenerator,
     public readonly allowUnlimitedContractSize: boolean,
     private _allowBlocksWithSameTimestamp: boolean,
     tracingConfig?: TracingConfig,
@@ -1068,6 +1075,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         this.getUserProvidedNextBlockBaseFeePerGas(),
       coinbase: this.getCoinbaseAddress().toString(),
       mixHashGenerator: this._mixHashGenerator.clone(),
+      parentBeaconBlockRootGenerator:
+        this._parentBeaconBlockRootGenerator.clone(),
     };
 
     this._irregularStatesByBlockNumber = new Map(
@@ -1124,6 +1133,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     this._coinbase = snapshot.coinbase;
 
     this._mixHashGenerator = snapshot.mixHashGenerator;
+    this._parentBeaconBlockRootGenerator =
+      snapshot.parentBeaconBlockRootGenerator;
 
     // We delete this and the following snapshots, as they can only be used
     // once in Ganache
@@ -1852,6 +1863,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       headerData.mixHash = this._getNextMixHash();
     }
 
+    if (this.isPostCancunHardfork()) {
+      headerData.parentBeaconBlockRoot = this._getNextParentBeaconBlockRoot();
+    }
+
     headerData.baseFeePerGas = await this.getNextBlockBaseFeePerGas();
 
     const blockBuilder = await this._vm.buildBlock({
@@ -2724,6 +2739,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     return hardforkGte(this.hardfork, HardforkName.MERGE);
   }
 
+  public isPostCancunHardfork(): boolean {
+    return hardforkGte(this.hardfork, HardforkName.CANCUN);
+  }
+
   public setPrevRandao(prevRandao: Buffer): void {
     this._mixHashGenerator.setNext(prevRandao);
   }
@@ -2779,6 +2798,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     return this._mixHashGenerator.next();
   }
 
+  private _getNextParentBeaconBlockRoot(): Uint8Array {
+    return this._parentBeaconBlockRootGenerator.next();
+  }
+
   private async _getEstimateGasFeePriceFields(
     callParams: CallParams,
     blockNumberOrPending: bigint | "pending"

packages/hardhat-core/src/internal/hardhat-network/provider/utils/putGenesisBlock.ts

@@ -16,6 +16,7 @@ export async function putGenesisBlock(
   stateTrie: Trie,
   hardfork: HardforkName,
   initialMixHash: Uint8Array,
+  initialParentBeaconBlockRoot: Uint8Array,
   initialBaseFee?: bigint
 ) {
   const initialBlockTimestamp =
@@ -24,6 +25,7 @@ export async function putGenesisBlock(
       : getCurrentTimestamp();
 
   const isPostMerge = hardforkGte(hardfork, HardforkName.MERGE);
+  const isPostCancun = hardforkGte(hardfork, HardforkName.CANCUN);
 
   const header: HeaderData = {
     timestamp: `0x${initialBlockTimestamp.toString(16)}`,
@@ -38,6 +40,10 @@ export async function putGenesisBlock(
     header.mixHash = initialMixHash;
   }
 
+  if (isPostCancun) {
+    header.parentBeaconBlockRoot = initialParentBeaconBlockRoot;
+  }
+
   if (initialBaseFee !== undefined) {
     header.baseFeePerGas = initialBaseFee;
   }

packages/hardhat-core/test/internal/hardhat-network/provider/node.ts

@@ -40,6 +40,7 @@ import {
   DEFAULT_NETWORK_ID,
 } from "../helpers/providers";
 import { sleep } from "../helpers/sleep";
+import { bufferToRpcData } from "../../../../src/internal/core/jsonrpc/types/base-types";
 import { runFullBlock } from "./utils/runFullBlock";
 
 function toBuffer(x: Parameters<typeof toBytes>[0]) {
@@ -1375,5 +1376,63 @@ describe("HardhatNode", () => {
         assert.isUndefined(estimateGasResult.error);
       });
     });
+
+    describe("cancun hardfork", function () {
+      describe("parentBeaconBlockRoot property", function () {
+        beforeEach(async () => {
+          [, node] = await HardhatNode.create({
+            ...config,
+            hardfork: "cancun",
+          });
+        });
+
+        it("should have the parentBeaconBlockRoot property only after cancun", async () => {
+          [, node] = await HardhatNode.create({
+            ...config,
+            hardfork: "shanghai",
+          });
+
+          const block = await node.getBlockByNumber(0n);
+
+          assert.isUndefined(block!.header.parentBeaconBlockRoot);
+        });
+
+        it("should have a non empty parentBeaconBlockRoot in the genesis block and the value should be an expected one", async () => {
+          const block = await node.getBlockByNumber(0n);
+
+          assert.equal(
+            bufferToRpcData(block!.header.parentBeaconBlockRoot!),
+            "0xdd8876ba5af271ae9d93ececb192d6a7b4e6094ca5999756336279fd796b8619"
+          );
+        });
+
+        it("should have different parentBeaconBlockRoot values in different blocks", async () => {
+          const block1 = await node.getBlockByNumber(0n);
+          const parentBeaconBlockRoot1 = bufferToRpcData(
+            block1!.header.parentBeaconBlockRoot!
+          );
+
+          await node.mineBlock();
+
+          const block2 = await node.getBlockByNumber(1n);
+          const parentBeaconBlockRoot2 = bufferToRpcData(
+            block2!.header.parentBeaconBlockRoot!
+          );
+
+          assert.notEqual(parentBeaconBlockRoot1, parentBeaconBlockRoot2);
+        });
+
+        it("should have the parentBeaconBlockRoot value different from the mixhash value", async () => {
+          const block = await node.getBlockByNumber(0n);
+
+          const mixHash = bufferToRpcData(block!.header.mixHash);
+          const parentBeaconBlockRoot = bufferToRpcData(
+            block!.header.parentBeaconBlockRoot!
+          );
+
+          assert.notEqual(parentBeaconBlockRoot, mixHash);
+        });
+      });
+    });
   });
 });