Warm Coinbase (EIP-3651) (hyperledger#4620)

shemnon · macfarla · commit 65ed6233c2d8 · 2023-01-10T16:02:21.000+10:00
Add a flag to MainnetTransactionProcessor to add the miningBeneficiary
to the list of pre-warmed addresses.
Have shandong fork set this flag to true by default.

Signed-off-by: Danno Ferrin &lt;danno.ferrin@swirldslabs.com&gt;
Signed-off-by: Sally MacFarlane &lt;macfarla.github@gmail.com&gt;
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/ClassicProtocolSpecs.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/ClassicProtocolSpecs.java
@@ -50,6 +50,10 @@
 public class ClassicProtocolSpecs {
   private static final Wei MAX_BLOCK_REWARD = Wei.fromEth(5);
 
+  private ClassicProtocolSpecs() {
+    // utility class
+  }
+
   public static ProtocolSpecBuilder classicRecoveryInitDefinition(
       final OptionalInt contractSizeLimit,
       final OptionalInt configStackSizeLimit,
@@ -80,7 +84,7 @@ public static ProtocolSpecBuilder tangerineWhistleDefinition(
 
   public static ProtocolSpecBuilder dieHardDefinition(
       final Optional<BigInteger> chainId,
-      final OptionalInt configContractSizeLimit,
+      final OptionalInt ignoredConfigContractSizeLimit,
       final OptionalInt configStackSizeLimit,
       final boolean quorumCompatibilityMode,
       final EvmConfiguration evmConfiguration) {
@@ -197,6 +201,7 @@ public static ProtocolSpecBuilder atlantisDefinition(
                     contractCreationProcessor,
                     messageCallProcessor,
                     true,
+                    false,
                     stackSizeLimit,
                     FeeMarket.legacy(),
                     CoinbaseFeePriceCalculator.frontier()))
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetProtocolSpecs.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetProtocolSpecs.java
@@ -134,6 +134,7 @@ public static ProtocolSpecBuilder frontierDefinition(
                     contractCreationProcessor,
                     messageCallProcessor,
                     false,
+                    false,
                     stackSizeLimit,
                     FeeMarket.legacy(),
                     CoinbaseFeePriceCalculator.frontier()))
@@ -324,6 +325,7 @@ public static ProtocolSpecBuilder spuriousDragonDefinition(
                     contractCreationProcessor,
                     messageCallProcessor,
                     true,
+                    false,
                     stackSizeLimit,
                     FeeMarket.legacy(),
                     CoinbaseFeePriceCalculator.frontier()))
@@ -540,6 +542,7 @@ static ProtocolSpecBuilder londonDefinition(
                     contractCreationProcessor,
                     messageCallProcessor,
                     true,
+                    false,
                     stackSizeLimit,
                     londonFeeMarket,
                     CoinbaseFeePriceCalculator.eip1559()))
@@ -638,6 +641,12 @@ static ProtocolSpecBuilder shandongDefinition(
       final GenesisConfigOptions genesisConfigOptions,
       final boolean quorumCompatibilityMode,
       final EvmConfiguration evmConfiguration) {
+    final int stackSizeLimit = configStackSizeLimit.orElse(MessageFrame.DEFAULT_MAX_STACK_SIZE);
+    final long londonForkBlockNumber = genesisConfigOptions.getLondonBlockNumber().orElse(0L);
+    final BaseFeeMarket londonFeeMarket =
+        genesisConfigOptions.isZeroBaseFee()
+            ? FeeMarket.zeroBaseFee(londonForkBlockNumber)
+            : FeeMarket.london(londonForkBlockNumber, genesisConfigOptions.getBaseFeePerGas());
 
     return parisDefinition(
             chainId,
@@ -651,6 +660,21 @@ static ProtocolSpecBuilder shandongDefinition(
             (gasCalculator, jdCacheConfig) ->
                 MainnetEVMs.shandong(
                     gasCalculator, chainId.orElse(BigInteger.ZERO), evmConfiguration))
+        .transactionProcessorBuilder(
+            (gasCalculator,
+                transactionValidator,
+                contractCreationProcessor,
+                messageCallProcessor) ->
+                new MainnetTransactionProcessor(
+                    gasCalculator,
+                    transactionValidator,
+                    contractCreationProcessor,
+                    messageCallProcessor,
+                    true,
+                    true,
+                    stackSizeLimit,
+                    londonFeeMarket,
+                    CoinbaseFeePriceCalculator.eip1559()))
         .name("Shandong");
   }
 
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessor.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessor.java
@@ -75,9 +75,32 @@ public class MainnetTransactionProcessor {
 
   protected final boolean clearEmptyAccounts;
 
+  protected final boolean warmCoinbase;
+
   protected final FeeMarket feeMarket;
   protected final CoinbaseFeePriceCalculator coinbaseFeePriceCalculator;
 
+  public MainnetTransactionProcessor(
+      final GasCalculator gasCalculator,
+      final MainnetTransactionValidator transactionValidator,
+      final AbstractMessageProcessor contractCreationProcessor,
+      final AbstractMessageProcessor messageCallProcessor,
+      final boolean clearEmptyAccounts,
+      final boolean warmCoinbase,
+      final int maxStackSize,
+      final FeeMarket feeMarket,
+      final CoinbaseFeePriceCalculator coinbaseFeePriceCalculator) {
+    this.gasCalculator = gasCalculator;
+    this.transactionValidator = transactionValidator;
+    this.contractCreationProcessor = contractCreationProcessor;
+    this.messageCallProcessor = messageCallProcessor;
+    this.clearEmptyAccounts = clearEmptyAccounts;
+    this.warmCoinbase = warmCoinbase;
+    this.maxStackSize = maxStackSize;
+    this.feeMarket = feeMarket;
+    this.coinbaseFeePriceCalculator = coinbaseFeePriceCalculator;
+  }
+
   /**
    * Applies a transaction to the current system state.
    *
@@ -228,27 +251,8 @@ public TransactionProcessingResult processTransaction(
         null);
   }
 
-  public MainnetTransactionProcessor(
-      final GasCalculator gasCalculator,
-      final MainnetTransactionValidator transactionValidator,
-      final AbstractMessageProcessor contractCreationProcessor,
-      final AbstractMessageProcessor messageCallProcessor,
-      final boolean clearEmptyAccounts,
-      final int maxStackSize,
-      final FeeMarket feeMarket,
-      final CoinbaseFeePriceCalculator coinbaseFeePriceCalculator) {
-    this.gasCalculator = gasCalculator;
-    this.transactionValidator = transactionValidator;
-    this.contractCreationProcessor = contractCreationProcessor;
-    this.messageCallProcessor = messageCallProcessor;
-    this.clearEmptyAccounts = clearEmptyAccounts;
-    this.maxStackSize = maxStackSize;
-    this.feeMarket = feeMarket;
-    this.coinbaseFeePriceCalculator = coinbaseFeePriceCalculator;
-  }
-
   public TransactionProcessingResult processTransaction(
-      final Blockchain blockchain,
+      final Blockchain ignoredBlockchain,
       final WorldUpdater worldState,
       final ProcessableBlockHeader blockHeader,
       final Transaction transaction,
@@ -314,6 +318,9 @@ public TransactionProcessingResult processTransaction(
         storageList.putAll(address, storageKeys);
         accessListStorageCount += storageKeys.size();
       }
+      if (warmCoinbase) {
+        addressList.add(miningBeneficiary);
+      }
 
       final long intrinsicGas =
           gasCalculator.transactionIntrinsicGasCost(
@@ -448,7 +455,7 @@ public TransactionProcessingResult processTransaction(
       initialFrame.getSelfDestructs().forEach(worldState::deleteAccount);
 
       if (clearEmptyAccounts) {
-        clearEmptyAccounts(worldState);
+        clearAccountsThatAreEmpty(worldState);
       }
 
       if (initialFrame.getState() == MessageFrame.State.COMPLETED_SUCCESS) {
@@ -474,7 +481,7 @@ public MainnetTransactionValidator getTransactionValidator() {
     return transactionValidator;
   }
 
-  protected static void clearEmptyAccounts(final WorldUpdater worldState) {
+  protected static void clearAccountsThatAreEmpty(final WorldUpdater worldState) {
     new ArrayList<>(worldState.getTouchedAccounts())
         .stream().filter(Account::isEmpty).forEach(a -> worldState.deleteAccount(a.getAddress()));
   }
diff --git a/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessorTest.java b/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessorTest.java
@@ -16,21 +16,31 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.when;
 
 import org.hyperledger.besu.datatypes.Address;
+import org.hyperledger.besu.datatypes.Hash;
+import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.ethereum.chain.Blockchain;
 import org.hyperledger.besu.ethereum.core.ProcessableBlockHeader;
 import org.hyperledger.besu.ethereum.core.Transaction;
 import org.hyperledger.besu.ethereum.core.feemarket.CoinbaseFeePriceCalculator;
 import org.hyperledger.besu.ethereum.mainnet.feemarket.FeeMarket;
 import org.hyperledger.besu.ethereum.transaction.TransactionInvalidReason;
 import org.hyperledger.besu.ethereum.vm.BlockHashLookup;
+import org.hyperledger.besu.evm.account.EvmAccount;
+import org.hyperledger.besu.evm.account.MutableAccount;
+import org.hyperledger.besu.evm.frame.MessageFrame;
 import org.hyperledger.besu.evm.gascalculator.GasCalculator;
+import org.hyperledger.besu.evm.gascalculator.LondonGasCalculator;
 import org.hyperledger.besu.evm.processor.AbstractMessageProcessor;
 import org.hyperledger.besu.evm.worldstate.WorldUpdater;
 
-import org.junit.Before;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.apache.tuweni.bytes.Bytes;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.ArgumentCaptor;
@@ -42,9 +52,7 @@ public class MainnetTransactionProcessorTest {
 
   private static final int MAX_STACK_SIZE = 1024;
 
-  private MainnetTransactionProcessor transactionProcessor;
-
-  @Mock private GasCalculator gasCalculator;
+  private final GasCalculator gasCalculator = new LondonGasCalculator();
   @Mock private MainnetTransactionValidator transactionValidator;
   @Mock private AbstractMessageProcessor contractCreationProcessor;
   @Mock private AbstractMessageProcessor messageCallProcessor;
@@ -55,18 +63,78 @@ public class MainnetTransactionProcessorTest {
   @Mock private Transaction transaction;
   @Mock private BlockHashLookup blockHashLookup;
 
-  @Before
-  public void before() {
-    transactionProcessor =
-        new MainnetTransactionProcessor(
-            gasCalculator,
-            transactionValidator,
-            contractCreationProcessor,
-            messageCallProcessor,
-            false,
-            MAX_STACK_SIZE,
-            FeeMarket.legacy(),
-            CoinbaseFeePriceCalculator.frontier());
+  @Mock private EvmAccount senderAccount;
+  @Mock private MutableAccount mutableSenderAccount;
+
+  MainnetTransactionProcessor createTransactionProcessor(final boolean warmCoinbase) {
+    return new MainnetTransactionProcessor(
+        gasCalculator,
+        transactionValidator,
+        contractCreationProcessor,
+        messageCallProcessor,
+        false,
+        warmCoinbase,
+        MAX_STACK_SIZE,
+        FeeMarket.legacy(),
+        CoinbaseFeePriceCalculator.frontier());
+  }
+
+  @Test
+  public void shouldWarmCoinbaseIfRequested() {
+    Optional<Address> toAddresss =
+        Optional.of(Address.fromHexString("0x2222222222222222222222222222222222222222"));
+    when(transaction.getTo()).thenReturn(toAddresss);
+    Address senderAddress = Address.fromHexString("0x5555555555555555555555555555555555555555");
+    Address coinbaseAddress = Address.fromHexString("0x4242424242424242424242424242424242424242");
+
+    when(senderAccount.getMutable()).thenReturn(mutableSenderAccount);
+    when(transaction.getHash()).thenReturn(Hash.EMPTY);
+    when(transaction.getPayload()).thenReturn(Bytes.EMPTY);
+    when(transaction.getSender()).thenReturn(senderAddress);
+    when(transaction.getValue()).thenReturn(Wei.ZERO);
+    when(transactionValidator.validate(any(), any(), any())).thenReturn(ValidationResult.valid());
+    when(transactionValidator.validateForSender(any(), any(), any()))
+        .thenReturn(ValidationResult.valid());
+    when(worldState.getOrCreate(any())).thenReturn(senderAccount);
+    when(worldState.getOrCreateSenderAccount(any())).thenReturn(senderAccount);
+    when(worldState.updater()).thenReturn(worldState);
+
+    AtomicBoolean coinbaseWarmed = new AtomicBoolean(false);
+    doAnswer(
+            invocation -> {
+              MessageFrame messageFrame = invocation.getArgument(0);
+              coinbaseWarmed.set(messageFrame.warmUpAddress(coinbaseAddress));
+              messageFrame.getMessageFrameStack().pop();
+              return null;
+            })
+        .when(messageCallProcessor)
+        .process(any(), any());
+
+    var transactionProcessor = createTransactionProcessor(true);
+    transactionProcessor.processTransaction(
+        blockchain,
+        worldState,
+        blockHeader,
+        transaction,
+        coinbaseAddress,
+        blockHashLookup,
+        false,
+        ImmutableTransactionValidationParams.builder().build());
+
+    assertThat(coinbaseWarmed).isTrue();
+
+    transactionProcessor = createTransactionProcessor(false);
+    transactionProcessor.processTransaction(
+        blockchain,
+        worldState,
+        blockHeader,
+        transaction,
+        coinbaseAddress,
+        blockHashLookup,
+        false,
+        ImmutableTransactionValidationParams.builder().build());
+
+    assertThat(coinbaseWarmed).isFalse();
   }
 
   @Test
@@ -77,6 +145,8 @@ public void shouldCallTransactionValidatorWithExpectedTransactionValidationParam
     final TransactionValidationParams expectedValidationParams =
         ImmutableTransactionValidationParams.builder().build();
 
+    var transactionProcessor = createTransactionProcessor(false);
+
     transactionProcessor.processTransaction(
         blockchain,
         worldState,
