getByBlockNumber replaced by getByBlockHeader on tests (#5259)

* Replace getByBlockNumber by getByBlockHeader

Signed-off-by: Gabriel Fukushima <gabrielfukushima@gmail.com>

* Replace getByBlockNumber by getByBlockHeader

Signed-off-by: Gabriel Fukushima <gabrielfukushima@gmail.com>

* Replace BlockDataGenerator by BlockHeaderTestFixture

Signed-off-by: Gabriel Fukushima <gabrielfukushima@gmail.com>

* Replace BlockDataGenerator by BlockHeaderTestFixture

Signed-off-by: Gabriel Fukushima <gabrielfukushima@gmail.com>

* Add final to method param

Signed-off-by: Gabriel Fukushima <gabrielfukushima@gmail.com>

* Replace BlockDataGEnerator by BlockHeaderTestFixture

Signed-off-by: Gabriel Fukushima <gabrielfukushima@gmail.com>

* Replace BlockDataGenerator by BlockHeaderTestFixture

Signed-off-by: Gabriel Fukushima <gabrielfukushima@gmail.com>

* Remove BlockDataGenerator

Signed-off-by: Gabriel Fukushima <gabrielfukushima@gmail.com>

---------

Signed-off-by: Gabriel Fukushima <gabrielfukushima@gmail.com>

besu/src/test/java/org/hyperledger/besu/PrivacyReorgTest.java

@@ -404,7 +404,7 @@ public class PrivacyReorgTest {
       final Block block) {
     besuController
         .getProtocolSchedule()
-        .getByBlockNumber(blockchain.getChainHeadBlockNumber())
+        .getByBlockHeader(blockchain.getChainHeadHeader())
         .getBlockImporter()
         .importBlock(protocolContext, block, HeaderValidationMode.NONE);
   }

besu/src/test/java/org/hyperledger/besu/PrivacyTest.java

@@ -29,6 +29,8 @@ import org.hyperledger.besu.crypto.NodeKeyUtils;
 import org.hyperledger.besu.datatypes.Address;
 import org.hyperledger.besu.enclave.EnclaveFactory;
 import org.hyperledger.besu.ethereum.GasLimitCalculator;
+import org.hyperledger.besu.ethereum.core.BlockHeader;
+import org.hyperledger.besu.ethereum.core.BlockHeaderTestFixture;
 import org.hyperledger.besu.ethereum.core.InMemoryKeyValueStorageProvider;
 import org.hyperledger.besu.ethereum.core.MiningParameters;
 import org.hyperledger.besu.ethereum.core.PrivacyParameters;
@@ -145,8 +147,12 @@ public class PrivacyTest {
       final BesuController besuController, final Address defaultPrivacy) {
     return besuController
         .getProtocolSchedule()
-        .getByBlockNumber(1)
+        .getByBlockHeader(blockHeader(0))
         .getPrecompileContractRegistry()
         .get(defaultPrivacy);
   }
+
+  private BlockHeader blockHeader(final long number) {
+    return new BlockHeaderTestFixture().number(number).buildHeader();
+  }
 }

consensus/clique/src/test/java/org/hyperledger/besu/consensus/clique/CliqueProtocolScheduleTest.java

@@ -57,10 +57,10 @@ public class CliqueProtocolScheduleTest {
     final ProtocolSchedule protocolSchedule =
         CliqueProtocolSchedule.create(config, NODE_KEY, false, EvmConfiguration.DEFAULT);
 
-    final ProtocolSpec homesteadSpec = protocolSchedule.getByBlockNumber(1);
+    final ProtocolSpec homesteadSpec = protocolSchedule.getByBlockHeader(blockHeader(1));
-    final ProtocolSpec tangerineWhistleSpec = protocolSchedule.getByBlockNumber(2);
+    final ProtocolSpec tangerineWhistleSpec = protocolSchedule.getByBlockHeader(blockHeader(2));
-    final ProtocolSpec spuriousDragonSpec = protocolSchedule.getByBlockNumber(3);
+    final ProtocolSpec spuriousDragonSpec = protocolSchedule.getByBlockHeader(blockHeader(3));
-    final ProtocolSpec byzantiumSpec = protocolSchedule.getByBlockNumber(1035301);
+    final ProtocolSpec byzantiumSpec = protocolSchedule.getByBlockHeader(blockHeader(1035301));
 
     assertThat(homesteadSpec.equals(tangerineWhistleSpec)).isFalse();
     assertThat(tangerineWhistleSpec.equals(spuriousDragonSpec)).isFalse();
@@ -75,7 +75,7 @@ public class CliqueProtocolScheduleTest {
                 NODE_KEY,
                 false,
                 EvmConfiguration.DEFAULT)
-            .getByBlockNumber(0);
+            .getByBlockHeader(blockHeader(0));
 
     assertThat(homestead.getName()).isEqualTo("Frontier");
     assertThat(homestead.getBlockReward()).isEqualTo(Wei.ZERO);
@@ -180,4 +180,8 @@ public class CliqueProtocolScheduleTest {
         .getBlockHeaderValidator()
         .validateHeader(blockHeader, parentBlockHeader, null, HeaderValidationMode.LIGHT);
   }
+
+  private BlockHeader blockHeader(final long number) {
+    return new BlockHeaderTestFixture().number(number).buildHeader();
+  }
 }

consensus/common/src/main/java/org/hyperledger/besu/consensus/common/CombinedProtocolScheduleFactory.java

@@ -36,10 +36,11 @@ public class CombinedProtocolScheduleFactory {
    * @param chainId the chain id
    * @return the protocol schedule
    */
-  public ProtocolSchedule create(
+  public BftProtocolSchedule create(
       final NavigableSet<ForkSpec<ProtocolSchedule>> forkSpecs,
       final Optional<BigInteger> chainId) {
-    final MutableProtocolSchedule combinedProtocolSchedule = new MutableProtocolSchedule(chainId);
+    final BftProtocolSchedule combinedProtocolSchedule =
+        new BftProtocolSchedule(new MutableProtocolSchedule(chainId));
     for (ForkSpec<ProtocolSchedule> spec : forkSpecs) {
       checkState(
           spec.getValue() instanceof MutableProtocolSchedule,

consensus/common/src/test/java/org/hyperledger/besu/consensus/common/CombinedProtocolScheduleFactoryTest.java

@@ -20,7 +20,6 @@ import org.hyperledger.besu.config.GenesisConfigOptions;
 import org.hyperledger.besu.config.StubGenesisConfigOptions;
 import org.hyperledger.besu.ethereum.core.BlockNumberStreamingProtocolSchedule;
 import org.hyperledger.besu.ethereum.core.PrivacyParameters;
-import org.hyperledger.besu.ethereum.mainnet.MutableProtocolSchedule;
 import org.hyperledger.besu.ethereum.mainnet.ProtocolSchedule;
 import org.hyperledger.besu.ethereum.mainnet.ProtocolScheduleBuilder;
 import org.hyperledger.besu.ethereum.mainnet.ProtocolSpecAdapters;
@@ -58,9 +57,7 @@ public class CombinedProtocolScheduleFactoryTest {
 
     final BlockNumberStreamingProtocolSchedule combinedProtocolSchedule =
         new BlockNumberStreamingProtocolSchedule(
-            (MutableProtocolSchedule)
+            combinedProtocolScheduleFactory.create(consensusSchedule, Optional.of(BigInteger.TEN)));
-                combinedProtocolScheduleFactory.create(
-                    consensusSchedule, Optional.of(BigInteger.TEN)));
 
     assertThat(combinedProtocolSchedule.getByBlockNumber(0L).getName()).isEqualTo("Frontier");
     assertThat(combinedProtocolSchedule.getByBlockNumber(0L))
@@ -101,9 +98,7 @@ public class CombinedProtocolScheduleFactoryTest {
 
     final BlockNumberStreamingProtocolSchedule combinedProtocolSchedule =
         new BlockNumberStreamingProtocolSchedule(
-            (MutableProtocolSchedule)
+            combinedProtocolScheduleFactory.create(consensusSchedule, Optional.of(BigInteger.TEN)));
-                combinedProtocolScheduleFactory.create(
-                    consensusSchedule, Optional.of(BigInteger.TEN)));
 
     // consensus schedule 1
     assertThat(combinedProtocolSchedule.getByBlockNumber(0L).getName()).isEqualTo("Frontier");

consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/BaseBftProtocolScheduleBuilderTest.java

@@ -28,6 +28,7 @@ import org.hyperledger.besu.consensus.common.ForksSchedule;
 import org.hyperledger.besu.datatypes.Address;
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.ethereum.core.BlockHeader;
+import org.hyperledger.besu.ethereum.core.BlockHeaderTestFixture;
 import org.hyperledger.besu.ethereum.core.BlockNumberStreamingProtocolSchedule;
 import org.hyperledger.besu.ethereum.core.PrivacyParameters;
 import org.hyperledger.besu.ethereum.mainnet.BlockHeaderValidator;
@@ -60,7 +61,7 @@ public class BaseBftProtocolScheduleBuilderTest {
 
     final ProtocolSchedule schedule =
         createProtocolSchedule(List.of(new ForkSpec<>(0, configOptions)));
-    final ProtocolSpec spec = schedule.getByBlockNumber(1);
+    final ProtocolSpec spec = schedule.getByBlockHeader(blockHeader(1));
 
     assertThat(spec.getBlockReward()).isEqualTo(Wei.of(arbitraryBlockReward));
     assertThat(spec.getMiningBeneficiaryCalculator().calculateBeneficiary(mock(BlockHeader.class)))
@@ -76,7 +77,7 @@ public class BaseBftProtocolScheduleBuilderTest {
 
     final ProtocolSchedule schedule =
         createProtocolSchedule(List.of(new ForkSpec<>(0, configOptions)));
-    final ProtocolSpec spec = schedule.getByBlockNumber(1);
+    final ProtocolSpec spec = schedule.getByBlockHeader(blockHeader(1));
 
     final Address headerCoinbase = Address.fromHexString("0x123");
     final BlockHeader header = mock(BlockHeader.class);
@@ -131,7 +132,7 @@ public class BaseBftProtocolScheduleBuilderTest {
 
     // Check initial config
     for (int i = 0; i < 2; i++) {
-      final ProtocolSpec spec = schedule.getByBlockNumber(i);
+      final ProtocolSpec spec = schedule.getByBlockHeader(blockHeader(i));
       final Address expectedBeneficiary = initialBeneficiaryIsEmpty ? headerCoinbase : beneficiary1;
       assertThat(spec.getBlockReward()).isEqualTo(Wei.of(BigInteger.valueOf(3)));
       assertThat(spec.getMiningBeneficiaryCalculator().calculateBeneficiary(header))
@@ -140,7 +141,7 @@ public class BaseBftProtocolScheduleBuilderTest {
 
     // Check fork1
     for (int i = 2; i < 5; i++) {
-      final ProtocolSpec spec = schedule.getByBlockNumber(i);
+      final ProtocolSpec spec = schedule.getByBlockHeader(blockHeader(i));
       final Address expectedBeneficiary = initialBeneficiaryIsEmpty ? beneficiary2 : headerCoinbase;
       assertThat(spec.getBlockReward()).isEqualTo(Wei.of(BigInteger.valueOf(2)));
       assertThat(spec.getMiningBeneficiaryCalculator().calculateBeneficiary(header))
@@ -149,7 +150,7 @@ public class BaseBftProtocolScheduleBuilderTest {
 
     // Check fork2
     for (int i = 5; i < 8; i++) {
-      final ProtocolSpec spec = schedule.getByBlockNumber(i);
+      final ProtocolSpec spec = schedule.getByBlockHeader(blockHeader(i));
       final Address expectedBeneficiary = initialBeneficiaryIsEmpty ? headerCoinbase : beneficiary3;
       assertThat(spec.getBlockReward()).isEqualTo(Wei.of(BigInteger.valueOf(1)));
       assertThat(spec.getMiningBeneficiaryCalculator().calculateBeneficiary(header))
@@ -219,9 +220,9 @@ public class BaseBftProtocolScheduleBuilderTest {
                         new ForkSpec<>(transitionBlock, blockRewardTransition))));
 
     assertThat(schedule.streamMilestoneBlocks().count()).isEqualTo(2);
-    assertThat(schedule.getByBlockNumber(0).getBlockReward())
+    assertThat(schedule.getByBlockHeader(blockHeader(0)).getBlockReward())
         .isEqualTo(Wei.of(arbitraryBlockReward));
-    assertThat(schedule.getByBlockNumber(transitionBlock).getBlockReward())
+    assertThat(schedule.getByBlockHeader(blockHeader(transitionBlock)).getBlockReward())
         .isEqualTo(Wei.of(forkBlockReward));
   }
 
@@ -256,4 +257,8 @@ public class BaseBftProtocolScheduleBuilderTest {
 
     return bftConfig;
   }
+
+  private BlockHeader blockHeader(final long number) {
+    return new BlockHeaderTestFixture().number(number).buildHeader();
+  }
 }

consensus/ibft/src/test/java/org/hyperledger/besu/consensus/ibft/IbftProtocolScheduleTest.java

@@ -41,7 +41,6 @@ import org.hyperledger.besu.ethereum.core.BlockNumberStreamingProtocolSchedule;
 import org.hyperledger.besu.ethereum.core.PrivacyParameters;
 import org.hyperledger.besu.ethereum.core.Util;
 import org.hyperledger.besu.ethereum.mainnet.HeaderValidationMode;
-import org.hyperledger.besu.ethereum.mainnet.MutableProtocolSchedule;
 import org.hyperledger.besu.ethereum.mainnet.ProtocolSchedule;
 import org.hyperledger.besu.evm.internal.EvmConfiguration;
 
@@ -94,14 +93,13 @@ public class IbftProtocolScheduleTest {
   private BlockNumberStreamingProtocolSchedule createProtocolSchedule(
       final GenesisConfigOptions genesisConfig, final List<ForkSpec<BftConfigOptions>> forks) {
     return new BlockNumberStreamingProtocolSchedule(
-        (MutableProtocolSchedule)
+        IbftProtocolScheduleBuilder.create(
-            IbftProtocolScheduleBuilder.create(
+            genesisConfig,
-                genesisConfig,
+            new ForksSchedule<>(forks),
-                new ForksSchedule<>(forks),
+            PrivacyParameters.DEFAULT,
-                PrivacyParameters.DEFAULT,
+            false,
-                false,
+            bftExtraDataCodec,
-                bftExtraDataCodec,
+            EvmConfiguration.DEFAULT));
-                EvmConfiguration.DEFAULT));
   }
 
   private boolean validateHeader(

consensus/merge/src/test/java/org/hyperledger/besu/consensus/merge/MergeProtocolScheduleTest.java

@@ -19,6 +19,8 @@ import static org.assertj.core.api.Assertions.assertThat;
 import org.hyperledger.besu.config.GenesisConfigFile;
 import org.hyperledger.besu.config.GenesisConfigOptions;
 import org.hyperledger.besu.datatypes.Wei;
+import org.hyperledger.besu.ethereum.core.BlockHeader;
+import org.hyperledger.besu.ethereum.core.BlockHeaderTestFixture;
 import org.hyperledger.besu.ethereum.mainnet.ProtocolSchedule;
 import org.hyperledger.besu.ethereum.mainnet.ProtocolSpec;
 import org.hyperledger.besu.evm.operation.PrevRanDaoOperation;
@@ -39,8 +41,8 @@ public class MergeProtocolScheduleTest {
     final GenesisConfigOptions config = GenesisConfigFile.fromConfig(jsonInput).getConfigOptions();
     final ProtocolSchedule protocolSchedule = MergeProtocolSchedule.create(config, false);
 
-    final ProtocolSpec homesteadSpec = protocolSchedule.getByBlockNumber(1);
+    final ProtocolSpec homesteadSpec = protocolSchedule.getByBlockHeader(blockHeader(1));
-    final ProtocolSpec londonSpec = protocolSchedule.getByBlockNumber(1559);
+    final ProtocolSpec londonSpec = protocolSchedule.getByBlockHeader(blockHeader(1559));
 
     assertThat(homesteadSpec).isNotEqualTo(londonSpec);
     assertThat(homesteadSpec.getFeeMarket().implementsBaseFee()).isFalse();
@@ -51,7 +53,7 @@ public class MergeProtocolScheduleTest {
   public void parametersAlignWithMainnetWithAdjustments() {
     final ProtocolSpec london =
         MergeProtocolSchedule.create(GenesisConfigFile.DEFAULT.getConfigOptions(), false)
-            .getByBlockNumber(0);
+            .getByBlockHeader(blockHeader(0));
 
     assertThat(london.getName()).isEqualTo("Frontier");
     assertThat(london.getBlockReward()).isEqualTo(Wei.ZERO);
@@ -60,4 +62,8 @@ public class MergeProtocolScheduleTest {
     var op = london.getEvm().getOperationsUnsafe()[0x44];
     assertThat(op).isInstanceOf(PrevRanDaoOperation.class);
   }
+
+  private BlockHeader blockHeader(final long number) {
+    return new BlockHeaderTestFixture().number(number).buildHeader();
+  }
 }

consensus/merge/src/test/java/org/hyperledger/besu/consensus/merge/TransitionProtocolScheduleTest.java

@@ -47,10 +47,8 @@ public class TransitionProtocolScheduleTest {
   @Mock MergeContext mergeContext;
   @Mock ProtocolSchedule preMergeProtocolSchedule;
   @Mock ProtocolSchedule postMergeProtocolSchedule;
-
   @Mock TimestampSchedule timestampSchedule;
   @Mock BlockHeader blockHeader;
-
   private static final Difficulty TTD = Difficulty.of(100L);
   private static final long BLOCK_NUMBER = 29L;
   private static final long TIMESTAMP = 1L;

consensus/qbft/src/test/java/org/hyperledger/besu/consensus/qbft/QbftProtocolScheduleTest.java

@@ -36,7 +36,6 @@ import org.hyperledger.besu.ethereum.core.BlockNumberStreamingProtocolSchedule;
 import org.hyperledger.besu.ethereum.core.PrivacyParameters;
 import org.hyperledger.besu.ethereum.core.Util;
 import org.hyperledger.besu.ethereum.mainnet.HeaderValidationMode;
-import org.hyperledger.besu.ethereum.mainnet.MutableProtocolSchedule;
 import org.hyperledger.besu.ethereum.mainnet.ProtocolSchedule;
 import org.hyperledger.besu.evm.internal.EvmConfiguration;
 
@@ -127,14 +126,13 @@ public class QbftProtocolScheduleTest {
   private BlockNumberStreamingProtocolSchedule createProtocolSchedule(
       final GenesisConfigOptions genesisConfig, final List<ForkSpec<QbftConfigOptions>> forks) {
     return new BlockNumberStreamingProtocolSchedule(
-        (MutableProtocolSchedule)
+        QbftProtocolScheduleBuilder.create(
-            QbftProtocolScheduleBuilder.create(
+            genesisConfig,
-                genesisConfig,
+            new ForksSchedule<>(forks),
-                new ForksSchedule<>(forks),
+            PrivacyParameters.DEFAULT,
-                PrivacyParameters.DEFAULT,
+            false,
-                false,
+            bftExtraDataCodec,
-                bftExtraDataCodec,
+            EvmConfiguration.DEFAULT));
-                EvmConfiguration.DEFAULT));
   }
 
   private boolean validateHeader(

ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/EthFeeHistoryTest.java

@@ -106,9 +106,6 @@ public class EthFeeHistoryTest {
 
   @Test
   public void cantGetBlockHigherThanChainHead() {
-    final ProtocolSpec londonSpec = mock(ProtocolSpec.class);
-    when(londonSpec.getFeeMarket()).thenReturn(FeeMarket.london(5));
-    when(protocolSchedule.getForNextBlockHeader(any(), anyLong())).thenReturn(londonSpec);
     assertThat(
             ((JsonRpcErrorResponse) feeHistoryRequest("0x2", "11", new double[] {100.0}))
                 .getError())
@@ -117,9 +114,6 @@ public class EthFeeHistoryTest {
 
   @Test
   public void blockCountBounds() {
-    final ProtocolSpec londonSpec = mock(ProtocolSpec.class);
-    when(londonSpec.getFeeMarket()).thenReturn(FeeMarket.london(5));
-    when(protocolSchedule.getByBlockNumber(anyLong())).thenReturn(londonSpec);
     assertThat(
             ((JsonRpcErrorResponse) feeHistoryRequest("0x0", "latest", new double[] {100.0}))
                 .getError())
@@ -134,7 +128,10 @@ public class EthFeeHistoryTest {
   public void doesntGoPastChainHeadWithHighBlockCount() {
     final ProtocolSpec londonSpec = mock(ProtocolSpec.class);
     when(londonSpec.getFeeMarket()).thenReturn(FeeMarket.london(5));
-    when(protocolSchedule.getForNextBlockHeader(any(), anyLong())).thenReturn(londonSpec);
+    when(protocolSchedule.getForNextBlockHeader(
+            eq(blockchain.getChainHeadHeader()),
+            eq(blockchain.getChainHeadHeader().getTimestamp())))
+        .thenReturn(londonSpec);
     final FeeHistory.FeeHistoryResult result =
         (ImmutableFeeHistoryResult)
             ((JsonRpcSuccessResponse) feeHistoryRequest("0x14", "latest")).getResult();
@@ -148,7 +145,10 @@ public class EthFeeHistoryTest {
   public void correctlyHandlesForkBlock() {
     final ProtocolSpec londonSpec = mock(ProtocolSpec.class);
     when(londonSpec.getFeeMarket()).thenReturn(FeeMarket.london(11));
-    when(protocolSchedule.getForNextBlockHeader(any(), anyLong())).thenReturn(londonSpec);
+    when(protocolSchedule.getForNextBlockHeader(
+            eq(blockchain.getChainHeadHeader()),
+            eq(blockchain.getChainHeadHeader().getTimestamp())))
+        .thenReturn(londonSpec);
     final FeeHistory.FeeHistoryResult result =
         (FeeHistory.FeeHistoryResult)
             ((JsonRpcSuccessResponse) feeHistoryRequest("0x1", "latest")).getResult();
@@ -160,13 +160,16 @@ public class EthFeeHistoryTest {
   public void allZeroPercentilesForZeroBlock() {
     final ProtocolSpec londonSpec = mock(ProtocolSpec.class);
     when(londonSpec.getFeeMarket()).thenReturn(FeeMarket.london(5));
-    when(protocolSchedule.getForNextBlockHeader(any(), anyLong())).thenReturn(londonSpec);
     final BlockDataGenerator.BlockOptions blockOptions = BlockDataGenerator.BlockOptions.create();
     blockOptions.hasTransactions(false);
     blockOptions.setParentHash(blockchain.getChainHeadHash());
     blockOptions.setBlockNumber(11);
     final Block emptyBlock = gen.block(blockOptions);
     blockchain.appendBlock(emptyBlock, gen.receipts(emptyBlock));
+    when(protocolSchedule.getForNextBlockHeader(
+            eq(blockchain.getChainHeadHeader()),
+            eq(blockchain.getChainHeadHeader().getTimestamp())))
+        .thenReturn(londonSpec);
     final FeeHistory.FeeHistoryResult result =
         (FeeHistory.FeeHistoryResult)
             ((JsonRpcSuccessResponse) feeHistoryRequest("0x1", "latest", new double[] {100.0}))

ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/EthGetTransactionReceiptTest.java

@@ -33,6 +33,7 @@ import org.hyperledger.besu.ethereum.api.query.BlockchainQueries;
 import org.hyperledger.besu.ethereum.api.query.TransactionReceiptWithMetadata;
 import org.hyperledger.besu.ethereum.core.BlockDataGenerator;
 import org.hyperledger.besu.ethereum.core.BlockHeader;
+import org.hyperledger.besu.ethereum.core.BlockHeaderTestFixture;
 import org.hyperledger.besu.ethereum.core.Transaction;
 import org.hyperledger.besu.ethereum.core.TransactionReceipt;
 import org.hyperledger.besu.ethereum.mainnet.PoWHasher;
@@ -50,7 +51,6 @@ import org.apache.tuweni.units.bigints.UInt256s;
 import org.junit.Test;
 
 public class EthGetTransactionReceiptTest {
-
   private final TransactionReceipt statusReceipt =
       new TransactionReceipt(1, 12, Collections.emptyList(), Optional.empty());
   private final Hash stateRoot =
@@ -163,7 +163,7 @@ public class EthGetTransactionReceiptTest {
     when(blockchain.headBlockNumber()).thenReturn(1L);
     when(blockchain.transactionReceiptByTransactionHash(receiptHash))
         .thenReturn(Optional.of(statusReceiptWithMetadata));
-    when(protocolSchedule.getByBlockNumber(1)).thenReturn(statusTransactionTypeSpec);
+    when(protocolSchedule.getByBlockHeader(blockHeader(1))).thenReturn(statusTransactionTypeSpec);
 
     final JsonRpcSuccessResponse response =
         (JsonRpcSuccessResponse) ethGetTransactionReceipt.response(request);
@@ -179,7 +179,7 @@ public class EthGetTransactionReceiptTest {
     when(blockchain.headBlockNumber()).thenReturn(1L);
     when(blockchain.transactionReceiptByTransactionHash(receiptHash))
         .thenReturn(Optional.of(rootReceiptWithMetaData));
-    when(protocolSchedule.getByBlockNumber(1)).thenReturn(rootTransactionTypeSpec);
+    when(protocolSchedule.getByBlockHeader(blockHeader(1))).thenReturn(rootTransactionTypeSpec);
 
     final JsonRpcSuccessResponse response =
         (JsonRpcSuccessResponse) ethGetTransactionReceipt.response(request);
@@ -200,7 +200,7 @@ public class EthGetTransactionReceiptTest {
             statusReceipt, transaction1559, hash, 1, 2, Optional.of(baseFee), blockHash, 4);
     when(blockchain.transactionReceiptByTransactionHash(receiptHash))
         .thenReturn(Optional.of(transactionReceiptWithMetadata));
-    when(protocolSchedule.getByBlockNumber(1)).thenReturn(rootTransactionTypeSpec);
+    when(protocolSchedule.getByBlockHeader(blockHeader(1))).thenReturn(rootTransactionTypeSpec);
 
     final JsonRpcSuccessResponse response =
         (JsonRpcSuccessResponse) ethGetTransactionReceipt.response(request);
@@ -215,4 +215,8 @@ public class EthGetTransactionReceiptTest {
                 baseFee.add(transaction1559.getMaxPriorityFeePerGas().get()),
                 transaction1559.getMaxFeePerGas().get()));
   }
+
+  private BlockHeader blockHeader(final long number) {
+    return new BlockHeaderTestFixture().number(number).buildHeader();
+  }
 }

ethereum/blockcreation/src/test/java/org/hyperledger/besu/ethereum/blockcreation/AbstractBlockTransactionSelectorTest.java

@@ -32,6 +32,7 @@ import org.hyperledger.besu.ethereum.chain.Blockchain;
 import org.hyperledger.besu.ethereum.core.AddressHelpers;
 import org.hyperledger.besu.ethereum.core.BlockHeader;
 import org.hyperledger.besu.ethereum.core.BlockHeaderBuilder;
+import org.hyperledger.besu.ethereum.core.BlockHeaderTestFixture;
 import org.hyperledger.besu.ethereum.core.Difficulty;
 import org.hyperledger.besu.ethereum.core.InMemoryKeyValueStorageProvider;
 import org.hyperledger.besu.ethereum.core.MutableWorldState;
@@ -77,7 +78,6 @@ import org.mockito.junit.MockitoJUnitRunner;
 
 @RunWith(MockitoJUnitRunner.class)
 public abstract class AbstractBlockTransactionSelectorTest {
-
   protected static final KeyPair keyPair =
       SignatureAlgorithmFactory.getInstance().generateKeyPair();
   protected final MetricsSystem metricsSystem = new NoOpMetricsSystem();
@@ -124,7 +124,7 @@ public abstract class AbstractBlockTransactionSelectorTest {
         FixedDifficultyProtocolSchedule.create(
             GenesisConfigFile.development().getConfigOptions(), EvmConfiguration.DEFAULT);
     final MainnetTransactionProcessor mainnetTransactionProcessor =
-        protocolSchedule.getByBlockNumber(0).getTransactionProcessor();
+        protocolSchedule.getByBlockHeader(blockHeader(0)).getTransactionProcessor();
 
     // The block should fit 5 transactions only
     final ProcessableBlockHeader blockHeader = createBlock(5000);
@@ -522,4 +522,8 @@ public abstract class AbstractBlockTransactionSelectorTest {
             any(), any(), any(), eq(tx), any(), any(), anyBoolean(), any(), any()))
         .thenReturn(TransactionProcessingResult.invalid(ValidationResult.invalid(invalidReason)));
   }
+
+  private BlockHeader blockHeader(final long number) {
+    return new BlockHeaderTestFixture().number(number).buildHeader();
+  }
 }

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/bonsai/AbstractIsolationTests.java

@@ -35,6 +35,7 @@ import org.hyperledger.besu.ethereum.chain.MutableBlockchain;
 import org.hyperledger.besu.ethereum.core.Block;
 import org.hyperledger.besu.ethereum.core.BlockHeader;
 import org.hyperledger.besu.ethereum.core.BlockHeaderBuilder;
+import org.hyperledger.besu.ethereum.core.BlockHeaderTestFixture;
 import org.hyperledger.besu.ethereum.core.Difficulty;
 import org.hyperledger.besu.ethereum.core.MutableWorldState;
 import org.hyperledger.besu.ethereum.core.SealableBlockHeader;
@@ -241,10 +242,14 @@ public abstract class AbstractIsolationTests {
   protected BlockProcessingResult executeBlock(final MutableWorldState ws, final Block block) {
     var res =
         protocolSchedule
-            .getByBlockNumber(0)
+            .getByBlockHeader(blockHeader(0))
             .getBlockProcessor()
             .processBlock(blockchain, ws, block);
     blockchain.appendBlock(block, res.getReceipts());
     return res;
   }
+
+  private BlockHeader blockHeader(final long number) {
+    return new BlockHeaderTestFixture().number(number).buildHeader();
+  }
 }

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/difficulty/fixed/FixedProtocolScheduleTest.java

@@ -39,21 +39,21 @@ public class FixedProtocolScheduleTest {
 
     assertThat(
             schedule
-                .getByBlockNumber(0)
+                .getByBlockHeader(blockHeader(0))
                 .getDifficultyCalculator()
                 .nextDifficulty(1, parentHeader, null))
         .isEqualTo(FixedDifficultyCalculators.DEFAULT_DIFFICULTY);
 
     assertThat(
             schedule
-                .getByBlockNumber(500)
+                .getByBlockHeader(blockHeader(500))
                 .getDifficultyCalculator()
                 .nextDifficulty(1, parentHeader, null))
         .isEqualTo(FixedDifficultyCalculators.DEFAULT_DIFFICULTY);
 
     assertThat(
             schedule
-                .getByBlockNumber(500_000)
+                .getByBlockHeader(blockHeader(500_000))
                 .getDifficultyCalculator()
                 .nextDifficulty(1, parentHeader, null))
         .isEqualTo(FixedDifficultyCalculators.DEFAULT_DIFFICULTY);
@@ -72,23 +72,27 @@ public class FixedProtocolScheduleTest {
 
     assertThat(
             schedule
-                .getByBlockNumber(0)
+                .getByBlockHeader(blockHeader(0))
                 .getDifficultyCalculator()
                 .nextDifficulty(1, parentHeader, null))
         .isEqualTo(10000);
 
     assertThat(
             schedule
-                .getByBlockNumber(500)
+                .getByBlockHeader(blockHeader(500))
                 .getDifficultyCalculator()
                 .nextDifficulty(1, parentHeader, null))
         .isEqualTo(10000);
 
     assertThat(
             schedule
-                .getByBlockNumber(500_000)
+                .getByBlockHeader(blockHeader(500_000))
                 .getDifficultyCalculator()
                 .nextDifficulty(1, parentHeader, null))
         .isEqualTo(10000);
   }
+
+  private BlockHeader blockHeader(final long number) {
+    return new BlockHeaderTestFixture().number(number).buildHeader();
+  }
 }

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/mainnet/MainnetProtocolScheduleTest.java

@@ -15,6 +15,8 @@
 package org.hyperledger.besu.ethereum.mainnet;
 
 import org.hyperledger.besu.config.GenesisConfigFile;
+import org.hyperledger.besu.ethereum.core.BlockHeader;
+import org.hyperledger.besu.ethereum.core.BlockHeaderTestFixture;
 import org.hyperledger.besu.ethereum.core.ProtocolScheduleFixture;
 import org.hyperledger.besu.evm.internal.EvmConfiguration;
 
@@ -29,27 +31,39 @@ public class MainnetProtocolScheduleTest {
   @Test
   public void shouldReturnDefaultProtocolSpecsWhenCustomNumbersAreNotUsed() {
     final ProtocolSchedule sched = ProtocolScheduleFixture.MAINNET;
-    Assertions.assertThat(sched.getByBlockNumber(1L).getName()).isEqualTo("Frontier");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(1L)).getName()).isEqualTo("Frontier");
-    Assertions.assertThat(sched.getByBlockNumber(1_150_000L).getName()).isEqualTo("Homestead");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(1_150_000L)).getName())
-    Assertions.assertThat(sched.getByBlockNumber(1_920_000L).getName())
+        .isEqualTo("Homestead");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(1_920_000L)).getName())
         .isEqualTo("DaoRecoveryInit");
-    Assertions.assertThat(sched.getByBlockNumber(1_920_001L).getName())
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(1_920_001L)).getName())
         .isEqualTo("DaoRecoveryTransition");
-    Assertions.assertThat(sched.getByBlockNumber(1_920_010L).getName()).isEqualTo("Homestead");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(1_920_010L)).getName())
-    Assertions.assertThat(sched.getByBlockNumber(2_463_000L).getName())
+        .isEqualTo("Homestead");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(2_463_000L)).getName())
         .isEqualTo("TangerineWhistle");
-    Assertions.assertThat(sched.getByBlockNumber(2_675_000L).getName()).isEqualTo("SpuriousDragon");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(2_675_000L)).getName())
-    Assertions.assertThat(sched.getByBlockNumber(4_730_000L).getName()).isEqualTo("Byzantium");
+        .isEqualTo("SpuriousDragon");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(4_730_000L)).getName())
+        .isEqualTo("Byzantium");
     // Constantinople was originally scheduled for 7_080_000, but postponed
-    Assertions.assertThat(sched.getByBlockNumber(7_080_000L).getName()).isEqualTo("Byzantium");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(7_080_000L)).getName())
-    Assertions.assertThat(sched.getByBlockNumber(7_280_000L).getName()).isEqualTo("Petersburg");
+        .isEqualTo("Byzantium");
-    Assertions.assertThat(sched.getByBlockNumber(9_069_000L).getName()).isEqualTo("Istanbul");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(7_280_000L)).getName())
-    Assertions.assertThat(sched.getByBlockNumber(9_200_000L).getName()).isEqualTo("MuirGlacier");
+        .isEqualTo("Petersburg");
-    Assertions.assertThat(sched.getByBlockNumber(12_244_000L).getName()).isEqualTo("Berlin");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(9_069_000L)).getName())
-    Assertions.assertThat(sched.getByBlockNumber(12_965_000L).getName()).isEqualTo("London");
+        .isEqualTo("Istanbul");
-    Assertions.assertThat(sched.getByBlockNumber(13_773_000L).getName()).isEqualTo("ArrowGlacier");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(9_200_000L)).getName())
-    Assertions.assertThat(sched.getByBlockNumber(15_050_000L).getName()).isEqualTo("GrayGlacier");
+        .isEqualTo("MuirGlacier");
-    Assertions.assertThat(sched.getByBlockNumber(Long.MAX_VALUE).getName())
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(12_244_000L)).getName())
+        .isEqualTo("Berlin");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(12_965_000L)).getName())
+        .isEqualTo("London");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(13_773_000L)).getName())
+        .isEqualTo("ArrowGlacier");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(15_050_000L)).getName())
+        .isEqualTo("GrayGlacier");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(Long.MAX_VALUE)).getName())
         .isEqualTo("GrayGlacier");
   }
 
@@ -58,8 +72,9 @@ public class MainnetProtocolScheduleTest {
     final ProtocolSchedule sched =
         MainnetProtocolSchedule.fromConfig(
             GenesisConfigFile.fromConfig("{}").getConfigOptions(), EvmConfiguration.DEFAULT);
-    Assertions.assertThat(sched.getByBlockNumber(1L).getName()).isEqualTo("Frontier");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(1L)).getName()).isEqualTo("Frontier");
-    Assertions.assertThat(sched.getByBlockNumber(Long.MAX_VALUE).getName()).isEqualTo("Frontier");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(Long.MAX_VALUE)).getName())
+        .isEqualTo("Frontier");
   }
 
   @Test
@@ -69,16 +84,22 @@ public class MainnetProtocolScheduleTest {
     final ProtocolSchedule sched =
         MainnetProtocolSchedule.fromConfig(
             GenesisConfigFile.fromConfig(json).getConfigOptions(), EvmConfiguration.DEFAULT);
-    Assertions.assertThat(sched.getByBlockNumber(1).getName()).isEqualTo("Frontier");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(1)).getName()).isEqualTo("Frontier");
-    Assertions.assertThat(sched.getByBlockNumber(2).getName()).isEqualTo("Homestead");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(2)).getName()).isEqualTo("Homestead");
-    Assertions.assertThat(sched.getByBlockNumber(3).getName()).isEqualTo("DaoRecoveryInit");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(3)).getName())
-    Assertions.assertThat(sched.getByBlockNumber(4).getName()).isEqualTo("DaoRecoveryTransition");
+        .isEqualTo("DaoRecoveryInit");
-    Assertions.assertThat(sched.getByBlockNumber(13).getName()).isEqualTo("Homestead");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(4)).getName())
-    Assertions.assertThat(sched.getByBlockNumber(14).getName()).isEqualTo("TangerineWhistle");
+        .isEqualTo("DaoRecoveryTransition");
-    Assertions.assertThat(sched.getByBlockNumber(15).getName()).isEqualTo("SpuriousDragon");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(13)).getName()).isEqualTo("Homestead");
-    Assertions.assertThat(sched.getByBlockNumber(16).getName()).isEqualTo("Byzantium");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(14)).getName())
-    Assertions.assertThat(sched.getByBlockNumber(18).getName()).isEqualTo("Constantinople");
+        .isEqualTo("TangerineWhistle");
-    Assertions.assertThat(sched.getByBlockNumber(19).getName()).isEqualTo("Petersburg");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(15)).getName())
+        .isEqualTo("SpuriousDragon");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(16)).getName()).isEqualTo("Byzantium");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(18)).getName())
+        .isEqualTo("Constantinople");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(19)).getName())
+        .isEqualTo("Petersburg");
   }
 
   @Test
@@ -104,11 +125,16 @@ public class MainnetProtocolScheduleTest {
                         this.getClass().getResource("/goerli.json"), StandardCharsets.UTF_8))
                 .getConfigOptions(),
             EvmConfiguration.DEFAULT);
-    Assertions.assertThat(sched.getByBlockNumber(0L).getName()).isEqualTo("Petersburg");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(0L)).getName())
-    Assertions.assertThat(sched.getByBlockNumber(1_561_651L).getName()).isEqualTo("Istanbul");
+        .isEqualTo("Petersburg");
-    Assertions.assertThat(sched.getByBlockNumber(4_460_644L).getName()).isEqualTo("Berlin");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(1_561_651L)).getName())
-    Assertions.assertThat(sched.getByBlockNumber(5_062_605L).getName()).isEqualTo("London");
+        .isEqualTo("Istanbul");
-    Assertions.assertThat(sched.getByBlockNumber(Long.MAX_VALUE).getName()).isEqualTo("London");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(4_460_644L)).getName())
+        .isEqualTo("Berlin");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(5_062_605L)).getName())
+        .isEqualTo("London");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(Long.MAX_VALUE)).getName())
+        .isEqualTo("London");
   }
 
   @Test
@@ -120,16 +146,29 @@ public class MainnetProtocolScheduleTest {
                         this.getClass().getResource("/rinkeby.json"), StandardCharsets.UTF_8))
                 .getConfigOptions(),
             EvmConfiguration.DEFAULT);
-    Assertions.assertThat(sched.getByBlockNumber(0L).getName()).isEqualTo("Frontier");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(0L)).getName()).isEqualTo("Frontier");
-    Assertions.assertThat(sched.getByBlockNumber(1L).getName()).isEqualTo("Homestead");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(1L)).getName()).isEqualTo("Homestead");
-    Assertions.assertThat(sched.getByBlockNumber(2L).getName()).isEqualTo("TangerineWhistle");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(2L)).getName())
-    Assertions.assertThat(sched.getByBlockNumber(3L).getName()).isEqualTo("SpuriousDragon");
+        .isEqualTo("TangerineWhistle");
-    Assertions.assertThat(sched.getByBlockNumber(1_035_301L).getName()).isEqualTo("Byzantium");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(3L)).getName())
-    Assertions.assertThat(sched.getByBlockNumber(3_660_663L).getName()).isEqualTo("Constantinople");
+        .isEqualTo("SpuriousDragon");
-    Assertions.assertThat(sched.getByBlockNumber(4_321_234L).getName()).isEqualTo("Petersburg");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(1_035_301L)).getName())
-    Assertions.assertThat(sched.getByBlockNumber(5_435_345L).getName()).isEqualTo("Istanbul");
+        .isEqualTo("Byzantium");
-    Assertions.assertThat(sched.getByBlockNumber(8_290_928L).getName()).isEqualTo("Berlin");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(3_660_663L)).getName())
-    Assertions.assertThat(sched.getByBlockNumber(8_897_988L).getName()).isEqualTo("London");
+        .isEqualTo("Constantinople");
-    Assertions.assertThat(sched.getByBlockNumber(Long.MAX_VALUE).getName()).isEqualTo("London");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(4_321_234L)).getName())
+        .isEqualTo("Petersburg");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(5_435_345L)).getName())
+        .isEqualTo("Istanbul");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(8_290_928L)).getName())
+        .isEqualTo("Berlin");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(8_897_988L)).getName())
+        .isEqualTo("London");
+    Assertions.assertThat(sched.getByBlockHeader(blockHeader(Long.MAX_VALUE)).getName())
+        .isEqualTo("London");
+  }
+
+  private BlockHeader blockHeader(final long number) {
+    return new BlockHeaderTestFixture().number(number).buildHeader();
   }
 }

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/mainnet/MutableProtocolScheduleTest.java

@@ -100,7 +100,7 @@ public class MutableProtocolScheduleTest {
     final MutableProtocolSchedule protocolSchedule = new MutableProtocolSchedule(CHAIN_ID);
     protocolSchedule.putMilestone(0, spec1);
     protocolSchedule.putMilestone(0, spec2);
-    assertThat(protocolSchedule.getByBlockNumber(0)).isSameAs(spec2);
+    assertThat(protocolSchedule.getByBlockHeader(header(0))).isSameAs(spec2);
   }
 
   @Test

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/mainnet/ProtocolScheduleBuilderTest.java

@@ -22,6 +22,8 @@ import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import org.hyperledger.besu.config.GenesisConfigOptions;
+import org.hyperledger.besu.ethereum.core.BlockHeader;
+import org.hyperledger.besu.ethereum.core.BlockHeaderTestFixture;
 import org.hyperledger.besu.ethereum.core.BlockNumberStreamingProtocolSchedule;
 import org.hyperledger.besu.ethereum.core.PrivacyParameters;
 import org.hyperledger.besu.evm.internal.EvmConfiguration;
@@ -40,7 +42,6 @@ import org.mockito.stubbing.Answer;
 
 @RunWith(MockitoJUnitRunner.class)
 public class ProtocolScheduleBuilderTest {
-
   @Mock GenesisConfigOptions configOptions;
   @Mock private Function<ProtocolSpecBuilder, ProtocolSpecBuilder> modifier;
   private static final BigInteger CHAIN_ID = BigInteger.ONE;
@@ -68,15 +69,17 @@ public class ProtocolScheduleBuilderTest {
     final ProtocolSchedule protocolSchedule = builder.createProtocolSchedule();
 
     assertThat(protocolSchedule.getChainId()).contains(CHAIN_ID);
-    assertThat(protocolSchedule.getByBlockNumber(0).getName()).isEqualTo("Frontier");
+    assertThat(protocolSchedule.getByBlockHeader(blockHeader(0)).getName()).isEqualTo("Frontier");
-    assertThat(protocolSchedule.getByBlockNumber(1).getName()).isEqualTo("Homestead");
+    assertThat(protocolSchedule.getByBlockHeader(blockHeader(1)).getName()).isEqualTo("Homestead");
-    assertThat(protocolSchedule.getByBlockNumber(2).getName()).isEqualTo("DaoRecoveryInit");
+    assertThat(protocolSchedule.getByBlockHeader(blockHeader(2)).getName())
-    assertThat(protocolSchedule.getByBlockNumber(3).getName()).isEqualTo("DaoRecoveryTransition");
+        .isEqualTo("DaoRecoveryInit");
-    assertThat(protocolSchedule.getByBlockNumber(12).getName()).isEqualTo("Homestead");
+    assertThat(protocolSchedule.getByBlockHeader(blockHeader(3)).getName())
-    assertThat(protocolSchedule.getByBlockNumber(13).getName()).isEqualTo("Byzantium");
+        .isEqualTo("DaoRecoveryTransition");
-    assertThat(protocolSchedule.getByBlockNumber(14).getName()).isEqualTo("Byzantium");
+    assertThat(protocolSchedule.getByBlockHeader(blockHeader(12)).getName()).isEqualTo("Homestead");
-    assertThat(protocolSchedule.getByBlockNumber(15).getName()).isEqualTo("ParisFork");
+    assertThat(protocolSchedule.getByBlockHeader(blockHeader(13)).getName()).isEqualTo("Byzantium");
-    assertThat(protocolSchedule.getByBlockNumber(50).getName()).isEqualTo("ParisFork");
+    assertThat(protocolSchedule.getByBlockHeader(blockHeader(14)).getName()).isEqualTo("Byzantium");
+    assertThat(protocolSchedule.getByBlockHeader(blockHeader(15)).getName()).isEqualTo("ParisFork");
+    assertThat(protocolSchedule.getByBlockHeader(blockHeader(50)).getName()).isEqualTo("ParisFork");
   }
 
   @Test
@@ -86,8 +89,8 @@ public class ProtocolScheduleBuilderTest {
     final ProtocolSchedule protocolSchedule = builder.createProtocolSchedule();
 
     assertThat(protocolSchedule.getChainId()).contains(CHAIN_ID);
-    assertThat(protocolSchedule.getByBlockNumber(0).getName()).isEqualTo("Byzantium");
+    assertThat(protocolSchedule.getByBlockHeader(blockHeader(0)).getName()).isEqualTo("Byzantium");
-    assertThat(protocolSchedule.getByBlockNumber(1).getName()).isEqualTo("Byzantium");
+    assertThat(protocolSchedule.getByBlockHeader(blockHeader(1)).getName()).isEqualTo("Byzantium");
   }
 
   @Test
@@ -114,9 +117,9 @@ public class ProtocolScheduleBuilderTest {
     // added at the point at which the modifier is applied.
     assertThat(schedule.streamMilestoneBlocks().collect(Collectors.toList()))
         .containsExactly(0L, 2L, 5L);
-    assertThat(schedule.getByBlockNumber(0).getName()).isEqualTo("Frontier");
+    assertThat(schedule.getByBlockHeader(blockHeader(0)).getName()).isEqualTo("Frontier");
-    assertThat(schedule.getByBlockNumber(2).getName()).isEqualTo("Frontier");
+    assertThat(schedule.getByBlockHeader(blockHeader(2)).getName()).isEqualTo("Frontier");
-    assertThat(schedule.getByBlockNumber(5).getName()).isEqualTo("Homestead");
+    assertThat(schedule.getByBlockHeader(blockHeader(5)).getName()).isEqualTo("Homestead");
 
     verify(modifier, times(2)).apply(any());
   }
@@ -132,8 +135,8 @@ public class ProtocolScheduleBuilderTest {
     // added at the point at which the modifier is applied.
     assertThat(schedule.streamMilestoneBlocks().collect(Collectors.toList()))
         .containsExactly(0L, 2L);
-    assertThat(schedule.getByBlockNumber(0).getName()).isEqualTo("Frontier");
+    assertThat(schedule.getByBlockHeader(blockHeader(0)).getName()).isEqualTo("Frontier");
-    assertThat(schedule.getByBlockNumber(2).getName()).isEqualTo("Frontier");
+    assertThat(schedule.getByBlockHeader(blockHeader(2)).getName()).isEqualTo("Frontier");
 
     verify(modifier, times(1)).apply(any());
   }
@@ -150,9 +153,8 @@ public class ProtocolScheduleBuilderTest {
     // added at the point at which the modifier is applied.
     assertThat(schedule.streamMilestoneBlocks().collect(Collectors.toList()))
         .containsExactly(0L, 5L);
-    assertThat(schedule.getByBlockNumber(0).getName()).isEqualTo("Frontier");
+    assertThat(schedule.getByBlockHeader(blockHeader(0)).getName()).isEqualTo("Frontier");
-    assertThat(schedule.getByBlockNumber(5).getName()).isEqualTo("Homestead");
+    assertThat(schedule.getByBlockHeader(blockHeader(5)).getName()).isEqualTo("Homestead");
-
     verify(modifier, times(1)).apply(any());
   }
 
@@ -170,4 +172,8 @@ public class ProtocolScheduleBuilderTest {
     return new BlockNumberStreamingProtocolSchedule(
         (MutableProtocolSchedule) builder.createProtocolSchedule());
   }
+
+  private BlockHeader blockHeader(final long number) {
+    return new BlockHeaderTestFixture().number(number).buildHeader();
+  }
 }

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/privacy/storage/migration/PrivateStorageMigrationTest.java

@@ -22,7 +22,6 @@ import static org.hyperledger.besu.ethereum.privacy.PrivateStateRootResolver.EMP
 import static org.hyperledger.besu.ethereum.privacy.storage.PrivateStateKeyValueStorage.SCHEMA_VERSION_1_0_0;
 import static org.hyperledger.besu.ethereum.privacy.storage.PrivateStateKeyValueStorage.SCHEMA_VERSION_1_4_0;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.lenient;
 import static org.mockito.Mockito.verify;
@@ -103,7 +102,7 @@ public class PrivateStorageMigrationTest {
     privateStateStorage = new PrivateStateKeyValueStorage(kvStorage);
     privateStateRootResolver = new PrivateStateRootResolver(privateStateStorage);
 
-    lenient().when(protocolSchedule.getByBlockNumber(anyLong())).thenReturn(protocolSpec);
+    lenient().when(protocolSchedule.getByBlockHeader(any())).thenReturn(protocolSpec);
     lenient().when(protocolSpec.getTransactionProcessor()).thenReturn(transactionProcessor);
     lenient()
         .when(protocolSpec.getTransactionReceiptFactory())

ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/AbstractBlockPropagationManagerTest.java

@@ -16,7 +16,6 @@ package org.hyperledger.besu.ethereum.eth.sync;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
@@ -36,6 +35,8 @@ import org.hyperledger.besu.ethereum.chain.MutableBlockchain;
 import org.hyperledger.besu.ethereum.core.Block;
 import org.hyperledger.besu.ethereum.core.BlockDataGenerator;
 import org.hyperledger.besu.ethereum.core.BlockDataGenerator.BlockOptions;
+import org.hyperledger.besu.ethereum.core.BlockHeader;
+import org.hyperledger.besu.ethereum.core.BlockHeaderTestFixture;
 import org.hyperledger.besu.ethereum.core.BlockImporter;
 import org.hyperledger.besu.ethereum.core.BlockchainSetupUtil;
 import org.hyperledger.besu.ethereum.core.Difficulty;
@@ -325,10 +326,11 @@ public abstract class AbstractBlockPropagationManagerTest {
 
   @Test
   public void handlesDuplicateAnnouncements() {
+
     final ProtocolSchedule stubProtocolSchedule = spy(protocolSchedule);
-    final ProtocolSpec stubProtocolSpec = spy(protocolSchedule.getByBlockNumber(2));
+    final ProtocolSpec stubProtocolSpec = spy(protocolSchedule.getByBlockHeader(blockHeader(2)));
     final BlockImporter stubBlockImporter = spy(stubProtocolSpec.getBlockImporter());
-    doReturn(stubProtocolSpec).when(stubProtocolSchedule).getByBlockNumber(anyLong());
+    doReturn(stubProtocolSpec).when(stubProtocolSchedule).getByBlockHeader(any());
     doReturn(stubBlockImporter).when(stubProtocolSpec).getBlockImporter();
     final BlockPropagationManager blockPropagationManager =
         new BlockPropagationManager(
@@ -378,9 +380,9 @@ public abstract class AbstractBlockPropagationManagerTest {
   @Test
   public void handlesPendingDuplicateAnnouncements() {
     final ProtocolSchedule stubProtocolSchedule = spy(protocolSchedule);
-    final ProtocolSpec stubProtocolSpec = spy(protocolSchedule.getByBlockNumber(2));
+    final ProtocolSpec stubProtocolSpec = spy(protocolSchedule.getByBlockHeader(blockHeader(2)));
     final BlockImporter stubBlockImporter = spy(stubProtocolSpec.getBlockImporter());
-    doReturn(stubProtocolSpec).when(stubProtocolSchedule).getByBlockNumber(anyLong());
+    doReturn(stubProtocolSpec).when(stubProtocolSchedule).getByBlockHeader(any());
     doReturn(stubBlockImporter).when(stubProtocolSpec).getBlockImporter();
     final BlockPropagationManager blockPropagationManager =
         new BlockPropagationManager(
@@ -772,7 +774,7 @@ public abstract class AbstractBlockPropagationManagerTest {
     blockchainUtil.importFirstBlocks(2);
     final Block firstBlock = blockchainUtil.getBlock(1);
     final BadBlockManager badBlocksManager =
-        protocolSchedule.getByBlockNumber(1).getBadBlocksManager();
+        protocolSchedule.getByBlockHeader(blockHeader(1)).getBadBlocksManager();
     final Block badBlock =
         new BlockDataGenerator()
             .block(
@@ -983,4 +985,8 @@ public abstract class AbstractBlockPropagationManagerTest {
   }
 
   public abstract Blockchain getFullBlockchain();
+
+  private BlockHeader blockHeader(final long number) {
+    return new BlockHeaderTestFixture().number(number).buildHeader();
+  }
 }

ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/backwardsync/BackwardSyncContextTest.java

@@ -21,7 +21,6 @@ import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
 import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
 import static org.hyperledger.besu.ethereum.core.InMemoryKeyValueStorageProvider.createInMemoryBlockchain;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
@@ -83,12 +82,15 @@ public class BackwardSyncContextTest {
   private MutableBlockchain remoteBlockchain;
   private RespondingEthPeer peer;
   private MutableBlockchain localBlockchain;
+  private static final BlockDataGenerator blockDataGenerator = new BlockDataGenerator();
 
   @Spy
   private ProtocolSchedule protocolSchedule =
       MainnetProtocolSchedule.fromConfig(new StubGenesisConfigOptions());
 
-  @Spy private ProtocolSpec mockProtocolSpec = protocolSchedule.getByBlockNumber(0L);
+  @Spy
+  private ProtocolSpec protocolSpec =
+      protocolSchedule.getByBlockHeader(blockDataGenerator.header(0L));
 
   @Mock(answer = Answers.RETURNS_DEEP_STUBS)
   private ProtocolContext protocolContext;
@@ -101,12 +103,11 @@ public class BackwardSyncContextTest {
   private BackwardChain backwardChain;
   private Block uncle;
   private Block genesisBlock;
-  private static final BlockDataGenerator blockDataGenerator = new BlockDataGenerator();
 
   @Before
   public void setup() {
-    when(mockProtocolSpec.getBlockValidator()).thenReturn(blockValidator);
+    when(protocolSpec.getBlockValidator()).thenReturn(blockValidator);
-    when(protocolSchedule.getByBlockNumber(anyLong())).thenReturn(mockProtocolSpec);
+    doReturn(protocolSpec).when(protocolSchedule).getByBlockHeader(any());
     genesisBlock = blockDataGenerator.genesisBlock();
     remoteBlockchain = createInMemoryBlockchain(genesisBlock);
     localBlockchain = createInMemoryBlockchain(genesisBlock);

ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/transactions/AbstractTransactionPoolTest.java

@@ -26,7 +26,6 @@ import static org.hyperledger.besu.ethereum.transaction.TransactionInvalidReason
 import static org.hyperledger.besu.ethereum.transaction.TransactionInvalidReason.TRANSACTION_REPLACEMENT_UNDERPRICED;
 import static org.hyperledger.besu.ethereum.transaction.TransactionInvalidReason.TX_FEECAP_EXCEEDED;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.ArgumentMatchers.nullable;
 import static org.mockito.Mockito.atLeastOnce;
@@ -136,7 +135,7 @@ public abstract class AbstractTransactionPoolTest {
     when(protocolSpec.getTransactionValidator()).thenReturn(transactionValidator);
     when(protocolSpec.getFeeMarket()).thenReturn(getFeeMarket());
     protocolSchedule = spy(executionContext.getProtocolSchedule());
-    doReturn(protocolSpec).when(protocolSchedule).getByBlockNumber(anyLong());
+    doReturn(protocolSpec).when(protocolSchedule).getByBlockHeader(any());
     blockGasLimit = blockchain.getChainHeadBlock().getHeader().getGasLimit();
     ethProtocolManager = EthProtocolManagerTestUtil.create();
     ethContext = spy(ethProtocolManager.ethContext());

ethereum/referencetests/src/reference-test/java/org/hyperledger/besu/ethereum/mainnet/DifficultyCalculatorTests.java

@@ -171,7 +171,7 @@ public class DifficultyCalculatorTests {
       final long currentTime = extractLong(value, "currentTimestamp");
       final UInt256 currentDifficulty =
           UInt256.fromHexString(value.get("currentDifficulty").asText());
-      final var spec = protocolSchedule.getByBlockNumber(currentBlockNumber);
+      final var spec = protocolSchedule.getByBlockHeader(testHeader);
       final var calculator = spec.getDifficultyCalculator();
       assertThat(UInt256.valueOf(calculator.nextDifficulty(currentTime, testHeader, null)))
           .describedAs("File %s Test %s", testFile, entry.getKey())