7702 refactor, remove CodeDelegationAccount abstraction

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/CodeDelegation.java

@@ -121,9 +121,9 @@ public SECPSignature signature() {
 
   @Override
   public Optional<Address> authorizer() {
-    // recId needs to be between 0 and 3, otherwise the signature is invalid
+    // recId needs to be between either 0 or 1, otherwise the signature is invalid
     // which means we can't recover the authorizer.
-    if (signature.getRecId() < 0 || signature.getRecId() > 3) {
+    if (signature.getRecId() > 1 || signature.getRecId() < 0) {
       return Optional.empty();
     }
 

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/CodeDelegationProcessor.java

@@ -20,7 +20,8 @@
 import org.hyperledger.besu.ethereum.core.CodeDelegation;
 import org.hyperledger.besu.ethereum.core.Transaction;
 import org.hyperledger.besu.evm.account.MutableAccount;
-import org.hyperledger.besu.evm.worldstate.EVMWorldUpdater;
+import org.hyperledger.besu.evm.worldstate.CodeDelegationService;
+import org.hyperledger.besu.evm.worldstate.WorldUpdater;
 
 import java.math.BigInteger;
 import java.util.Optional;
@@ -33,11 +34,15 @@ public class CodeDelegationProcessor {
 
   private final Optional<BigInteger> maybeChainId;
   private final BigInteger halfCurveOrder;
+  private final CodeDelegationService codeDelegationService;
 
   public CodeDelegationProcessor(
-      final Optional<BigInteger> maybeChainId, final BigInteger halfCurveOrder) {
+      final Optional<BigInteger> maybeChainId,
+      final BigInteger halfCurveOrder,
+      final CodeDelegationService codeDelegationService) {
     this.maybeChainId = maybeChainId;
     this.halfCurveOrder = halfCurveOrder;
+    this.codeDelegationService = codeDelegationService;
   }
 
   /**
@@ -57,12 +62,12 @@ public CodeDelegationProcessor(
    *   <li>Increase the nonce of `authority` by one.
    * </ol>
    *
-   * @param evmWorldUpdater The world state updater which is aware of code delegation.
+   * @param worldUpdater The world state updater which is aware of code delegation.
    * @param transaction The transaction being processed.
    * @return The result of the code delegation processing.
    */
   public CodeDelegationResult process(
-      final EVMWorldUpdater evmWorldUpdater, final Transaction transaction) {
+      final WorldUpdater worldUpdater, final Transaction transaction) {
     final CodeDelegationResult result = new CodeDelegationResult();
 
     transaction
@@ -71,15 +76,15 @@ public CodeDelegationResult process(
         .forEach(
             codeDelegation ->
                 processCodeDelegation(
-                    evmWorldUpdater,
+                    worldUpdater,
                     (org.hyperledger.besu.ethereum.core.CodeDelegation) codeDelegation,
                     result));
 
     return result;
   }
 
   private void processCodeDelegation(
-      final EVMWorldUpdater evmWorldUpdater,
+      final WorldUpdater worldUpdater,
       final CodeDelegation codeDelegation,
       final CodeDelegationResult result) {
     LOG.trace("Processing code delegation: {}", codeDelegation);
@@ -114,7 +119,7 @@ private void processCodeDelegation(
     LOG.trace("Set code delegation for authority: {}", authorizer.get());
 
     final Optional<MutableAccount> maybeAuthorityAccount =
-        Optional.ofNullable(evmWorldUpdater.getAccount(authorizer.get()));
+        Optional.ofNullable(worldUpdater.getAccount(authorizer.get()));
 
     result.addAccessedDelegatorAddress(authorizer.get());
 
@@ -125,11 +130,11 @@ private void processCodeDelegation(
       if (codeDelegation.nonce() != 0) {
         return;
       }
-      authority = evmWorldUpdater.createAccount(authorizer.get());
+      authority = worldUpdater.createAccount(authorizer.get());
     } else {
       authority = maybeAuthorityAccount.get();
 
-      if (!evmWorldUpdater.codeDelegationService().canSetCodeDelegation(authority)) {
+      if (!codeDelegationService.canSetCodeDelegation(authority)) {
         return;
       }
 
@@ -148,9 +153,7 @@ private void processCodeDelegation(
       result.incrementAlreadyExistingDelegators();
     }
 
-    evmWorldUpdater
-        .codeDelegationService()
-        .processCodeDelegation(authority, codeDelegation.address());
+    codeDelegationService.processCodeDelegation(authority, codeDelegation.address());
     authority.incrementNonce();
   }
 }

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetProtocolSpecs.java

@@ -71,6 +71,7 @@
 import org.hyperledger.besu.evm.internal.EvmConfiguration;
 import org.hyperledger.besu.evm.processor.ContractCreationProcessor;
 import org.hyperledger.besu.evm.processor.MessageCallProcessor;
+import org.hyperledger.besu.evm.worldstate.CodeDelegationService;
 import org.hyperledger.besu.evm.worldstate.WorldState;
 import org.hyperledger.besu.evm.worldstate.WorldUpdater;
 import org.hyperledger.besu.plugin.services.MetricsSystem;
@@ -744,9 +745,6 @@ static ProtocolSpecBuilder cancunDefinition(
                     .maxStackSize(evmConfiguration.evmStackSize())
                     .feeMarket(feeMarket)
                     .coinbaseFeePriceCalculator(CoinbaseFeePriceCalculator.eip1559())
-                    .codeDelegationProcessor(
-                        new CodeDelegationProcessor(
-                            chainId, SIGNATURE_ALGORITHM.get().getHalfCurveOrder()))
                     .build())
         // change to check for max blob gas per block for EIP-4844
         .transactionValidatorFactoryBuilder(
@@ -891,6 +889,29 @@ static ProtocolSpecBuilder pragueDefinition(
                         TransactionType.BLOB,
                         TransactionType.DELEGATE_CODE),
                     evm.getMaxInitcodeSize()))
+        // CodeDelegationProcessor
+        .transactionProcessorBuilder(
+            (gasCalculator,
+                feeMarket,
+                transactionValidator,
+                contractCreationProcessor,
+                messageCallProcessor) ->
+                MainnetTransactionProcessor.builder()
+                    .gasCalculator(gasCalculator)
+                    .transactionValidatorFactory(transactionValidator)
+                    .contractCreationProcessor(contractCreationProcessor)
+                    .messageCallProcessor(messageCallProcessor)
+                    .clearEmptyAccounts(true)
+                    .warmCoinbase(true)
+                    .maxStackSize(evmConfiguration.evmStackSize())
+                    .feeMarket(feeMarket)
+                    .coinbaseFeePriceCalculator(CoinbaseFeePriceCalculator.eip1559())
+                    .codeDelegationProcessor(
+                        new CodeDelegationProcessor(
+                            chainId,
+                            SIGNATURE_ALGORITHM.get().getHalfCurveOrder(),
+                            new CodeDelegationService()))
+                    .build())
 
         // TODO SLD EIP-7840 Can we dynamically wire in the appropriate GasCalculator instead of
         // overriding

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessor.java

@@ -19,10 +19,14 @@
 import static org.hyperledger.besu.ethereum.mainnet.PrivateStateUtils.KEY_TRANSACTION;
 import static org.hyperledger.besu.ethereum.mainnet.PrivateStateUtils.KEY_TRANSACTION_HASH;
 import static org.hyperledger.besu.evm.internal.Words.clampedAdd;
+import static org.hyperledger.besu.evm.worldstate.CodeDelegationHelper.getTargetAccount;
+import static org.hyperledger.besu.evm.worldstate.CodeDelegationHelper.hasCodeDelegation;
 
 import org.hyperledger.besu.collections.trie.BytesTrieSet;
 import org.hyperledger.besu.datatypes.AccessListEntry;
 import org.hyperledger.besu.datatypes.Address;
+import org.hyperledger.besu.datatypes.Hash;
+import org.hyperledger.besu.datatypes.TransactionType;
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.ethereum.core.ProcessableBlockHeader;
 import org.hyperledger.besu.ethereum.core.Transaction;
@@ -34,6 +38,7 @@
 import org.hyperledger.besu.ethereum.trie.MerkleTrieException;
 import org.hyperledger.besu.evm.Code;
 import org.hyperledger.besu.evm.account.Account;
+import org.hyperledger.besu.evm.account.CodeDelegationAccount;
 import org.hyperledger.besu.evm.account.MutableAccount;
 import org.hyperledger.besu.evm.blockhash.BlockHashLookup;
 import org.hyperledger.besu.evm.code.CodeInvalid;
@@ -45,7 +50,6 @@
 import org.hyperledger.besu.evm.processor.ContractCreationProcessor;
 import org.hyperledger.besu.evm.processor.MessageCallProcessor;
 import org.hyperledger.besu.evm.tracing.OperationTracer;
-import org.hyperledger.besu.evm.worldstate.EVMWorldUpdater;
 import org.hyperledger.besu.evm.worldstate.WorldUpdater;
 
 import java.util.Deque;
@@ -266,7 +270,6 @@ public TransactionProcessingResult processTransaction(
       final TransactionValidationParams transactionValidationParams,
       final PrivateMetadataUpdater privateMetadataUpdater,
       final Wei blobGasPrice) {
-    final EVMWorldUpdater evmWorldUpdater = new EVMWorldUpdater(worldState, gasCalculator);
     try {
       final var transactionValidator = transactionValidatorFactory.get();
       LOG.trace("Starting execution of {}", transaction);
@@ -285,7 +288,7 @@ public TransactionProcessingResult processTransaction(
       }
 
       final Address senderAddress = transaction.getSender();
-      final MutableAccount sender = evmWorldUpdater.getOrCreateSenderAccount(senderAddress);
+      final MutableAccount sender = worldState.getOrCreateSenderAccount(senderAddress);
 
       validationResult =
           transactionValidator.validateForSender(transaction, sender, transactionValidationParams);
@@ -294,7 +297,7 @@ public TransactionProcessingResult processTransaction(
         return TransactionProcessingResult.invalid(validationResult);
       }
 
-      operationTracer.tracePrepareTransaction(evmWorldUpdater, transaction);
+      operationTracer.tracePrepareTransaction(worldState, transaction);
 
       final Set<Address> warmAddressList = new BytesTrieSet<>(Address.SIZE);
 
@@ -321,19 +324,19 @@ public TransactionProcessingResult processTransaction(
           sender.getBalance());
 
       long codeDelegationRefund = 0L;
-      if (transaction.getCodeDelegationList().isPresent()) {
+      if (transaction.getType().equals(TransactionType.DELEGATE_CODE)) {
         if (maybeCodeDelegationProcessor.isEmpty()) {
           throw new RuntimeException("Code delegation processor is required for 7702 transactions");
         }
 
         final CodeDelegationResult codeDelegationResult =
-            maybeCodeDelegationProcessor.get().process(evmWorldUpdater, transaction);
+            maybeCodeDelegationProcessor.get().process(worldState, transaction);
         warmAddressList.addAll(codeDelegationResult.accessedDelegatorAddresses());
         codeDelegationRefund =
             gasCalculator.calculateDelegateCodeGasRefund(
                 (codeDelegationResult.alreadyExistingDelegators()));
 
-        evmWorldUpdater.commit();
+        worldState.commit();
       }
 
       final List<AccessListEntry> accessListEntries = transaction.getAccessList().orElse(List.of());
@@ -369,7 +372,7 @@ public TransactionProcessingResult processTransaction(
           transaction.getGasLimit(),
           intrinsicGas);
 
-      final WorldUpdater worldUpdater = evmWorldUpdater.updater();
+      final WorldUpdater worldUpdater = worldState.updater();
       final ImmutableMap.Builder<String, Object> contextVariablesBuilder =
           ImmutableMap.<String, Object>builder()
               .put(KEY_IS_PERSISTING_PRIVATE_STATE, isPersistingPrivateState)
@@ -425,32 +428,15 @@ public TransactionProcessingResult processTransaction(
       } else {
         @SuppressWarnings("OptionalGetWithoutIsPresent") // isContractCall tests isPresent
         final Address to = transaction.getTo().get();
-        final Optional<Account> maybeContract = Optional.ofNullable(evmWorldUpdater.get(to));
-
-        if (maybeContract.isPresent() && maybeContract.get().hasDelegatedCode()) {
-          warmAddressList.add(maybeContract.get().codeDelegationAddress().get());
-        }
+        final Code code = processCodeFromAccount(worldState, warmAddressList, worldState.get(to));
 
         initialFrame =
             commonMessageFrameBuilder
                 .type(MessageFrame.Type.MESSAGE_CALL)
                 .address(to)
                 .contract(to)
                 .inputData(transaction.getPayload())
-                .code(
-                    maybeContract
-                        .map(
-                            c -> {
-                              if (c.hasDelegatedCode()) {
-                                return messageCallProcessor.getCodeFromEVM(
-                                    c.getCodeDelegationTargetHash().get(),
-                                    c.getCodeDelegationTargetCode().get());
-                              }
-
-                              return messageCallProcessor.getCodeFromEVM(
-                                  c.getCodeHash(), c.getCode());
-                            })
-                        .orElse(CodeV0.EMPTY_CODE))
+                .code(code)
                 .accessListWarmAddresses(warmAddressList)
                 .build();
       }
@@ -529,12 +515,12 @@ public TransactionProcessingResult processTransaction(
 
       operationTracer.traceBeforeRewardTransaction(worldUpdater, transaction, coinbaseWeiDelta);
       if (!coinbaseWeiDelta.isZero() || !clearEmptyAccounts) {
-        final var coinbase = evmWorldUpdater.getOrCreate(miningBeneficiary);
+        final var coinbase = worldState.getOrCreate(miningBeneficiary);
         coinbase.incrementBalance(coinbaseWeiDelta);
       }
 
       operationTracer.traceEndTransaction(
-          evmWorldUpdater.updater(),
+          worldState.updater(),
           transaction,
           initialFrame.getState() == MessageFrame.State.COMPLETED_SUCCESS,
           initialFrame.getOutputData(),
@@ -543,10 +529,10 @@ public TransactionProcessingResult processTransaction(
           initialFrame.getSelfDestructs(),
           0L);
 
-      initialFrame.getSelfDestructs().forEach(evmWorldUpdater::deleteAccount);
+      initialFrame.getSelfDestructs().forEach(worldState::deleteAccount);
 
       if (clearEmptyAccounts) {
-        evmWorldUpdater.clearAccountsThatAreEmpty();
+        worldState.clearAccountsThatAreEmpty();
       }
 
       if (initialFrame.getState() == MessageFrame.State.COMPLETED_SUCCESS) {
@@ -574,7 +560,7 @@ public TransactionProcessingResult processTransaction(
       }
     } catch (final MerkleTrieException re) {
       operationTracer.traceEndTransaction(
-          evmWorldUpdater.updater(),
+          worldState.updater(),
           transaction,
           false,
           Bytes.EMPTY,
@@ -587,7 +573,7 @@ public TransactionProcessingResult processTransaction(
       throw re;
     } catch (final RuntimeException re) {
       operationTracer.traceEndTransaction(
-          evmWorldUpdater.updater(),
+          worldState.updater(),
           transaction,
           false,
           Bytes.EMPTY,
@@ -641,6 +627,35 @@ private String printableStackTraceFromThrowable(final RuntimeException re) {
     return builder.toString();
   }
 
+  private Code processCodeFromAccount(
+      final WorldUpdater worldUpdater, final Set<Address> warmAddressList, final Account contract) {
+    if (contract == null) {
+      return CodeV0.EMPTY_CODE;
+    }
+
+    final Hash codeHash = contract.getCodeHash();
+    if (codeHash == null || codeHash.equals(Hash.EMPTY)) {
+      return CodeV0.EMPTY_CODE;
+    }
+
+    if (hasCodeDelegation(contract.getCode())) {
+      return delegationTargetCode(worldUpdater, warmAddressList, contract);
+    }
+
+    return messageCallProcessor.getCodeFromEVM(contract.getCodeHash(), contract.getCode());
+  }
+
+  private Code delegationTargetCode(
+      final WorldUpdater worldUpdater, final Set<Address> warmAddressList, final Account contract) {
+    // we need to look up the target account and its code, but do NOT charge gas for it
+    final CodeDelegationAccount targetAccount =
+        getTargetAccount(worldUpdater, gasCalculator, contract);
+    warmAddressList.add(targetAccount.getTargetAddress());
+
+    return messageCallProcessor.getCodeFromEVM(
+        targetAccount.getCodeHash(), targetAccount.getCode());
+  }
+
   public static Builder builder() {
     return new Builder();
   }