Merge branch 'main' into zkbesu

# Conflicts:
#	.github/workflows/acceptance-tests.yml
#	.github/workflows/pre-review.yml
#	build.gradle

acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/condition/perm/AllowListContainsKeyAndValue.java

@@ -24,11 +24,16 @@
 import java.nio.file.Path;
 import java.util.Collection;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 public class AllowListContainsKeyAndValue implements Condition {
   private final ALLOWLIST_TYPE allowlistType;
   private final Collection<String> allowlistValues;
   private final Path configFilePath;
 
+  private static final Logger LOG = LoggerFactory.getLogger(AllowListContainsKeyAndValue.class);
+
   public AllowListContainsKeyAndValue(
       final ALLOWLIST_TYPE allowlistType,
       final Collection<String> allowlistValues,
@@ -47,6 +52,7 @@ public void verify(final Node node) {
               allowlistType, allowlistValues, configFilePath);
     } catch (final Exception e) {
       result = false;
+      LOG.error("Error verifying allowlist contains key and value", e);
     }
     assertThat(result).isTrue();
   }

acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/node/configuration/BesuNodeFactory.java

@@ -511,31 +511,6 @@ public BesuNode createIbft2Node(
     return create(builder.build());
   }
 
-  public BesuNode createQbftNodeWithTLS(final String name, final String type) throws IOException {
-    return create(
-        new BesuNodeConfigurationBuilder()
-            .name(name)
-            .miningEnabled()
-            .p2pTLSEnabled(name, type)
-            .jsonRpcConfiguration(node.createJsonRpcWithQbftEnabledConfig(false))
-            .webSocketConfiguration(node.createWebSocketEnabledConfig())
-            .devMode(false)
-            .genesisConfigProvider(GenesisConfigurationFactory::createQbftGenesisConfig)
-            .build());
-  }
-
-  public BesuNode createQbftNodeWithTLSJKS(final String name) throws IOException {
-    return createQbftNodeWithTLS(name, KeyStoreWrapper.KEYSTORE_TYPE_JKS);
-  }
-
-  public BesuNode createQbftNodeWithTLSPKCS12(final String name) throws IOException {
-    return createQbftNodeWithTLS(name, KeyStoreWrapper.KEYSTORE_TYPE_PKCS12);
-  }
-
-  public BesuNode createQbftNodeWithTLSPKCS11(final String name) throws IOException {
-    return createQbftNodeWithTLS(name, KeyStoreWrapper.KEYSTORE_TYPE_PKCS11);
-  }
-
   public BesuNode createQbftNode(
       final String name, final boolean fixedPort, final DataStorageFormat storageFormat)
       throws IOException {

acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/privacy/PrivacyNode.java

@@ -276,7 +276,7 @@ private PrivacyStorageProvider createKeyValueStorageProvider(
       final Path dataLocation, final Path dbLocation) {
     final var besuConfiguration = new BesuConfigurationImpl();
     besuConfiguration
-        .init(dataLocation, dbLocation, null)
+        .init(dataLocation, dbLocation, besuConfig.getDataStorageConfiguration())
         .withMiningParameters(besuConfig.getMiningParameters());
     return new PrivacyKeyValueStorageProviderBuilder()
         .withStorageFactory(

acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/acceptance/bootstrap/ClusterThreadNodeRunnerAcceptanceTest.java

@@ -38,7 +38,7 @@ public void setUp() throws Exception {
     final BesuNodeRunner besuNodeRunner = new ThreadBesuNodeRunner();
     noDiscoveryCluster = new Cluster(clusterConfiguration, net, besuNodeRunner);
     final BesuNode noDiscoveryNode = besu.createNodeWithNoDiscovery("noDiscovery");
-    fullNode = besu.createArchiveNode("node2");
+    fullNode = besu.createArchiveNode("archive");
     noDiscoveryCluster.start(noDiscoveryNode, fullNode);
   }
 

acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/acceptance/ethereum/SetCodeTransactionAcceptanceTest.java → acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/acceptance/ethereum/CodeDelegationTransactionAcceptanceTest.java

@@ -18,9 +18,9 @@
 
 import org.hyperledger.besu.crypto.SECP256K1;
 import org.hyperledger.besu.datatypes.Address;
+import org.hyperledger.besu.datatypes.CodeDelegation;
 import org.hyperledger.besu.datatypes.TransactionType;
 import org.hyperledger.besu.datatypes.Wei;
-import org.hyperledger.besu.ethereum.core.SetCodeAuthorization;
 import org.hyperledger.besu.ethereum.core.Transaction;
 import org.hyperledger.besu.tests.acceptance.dsl.AcceptanceTestBase;
 import org.hyperledger.besu.tests.acceptance.dsl.account.Account;
@@ -39,7 +39,7 @@
 import org.junit.jupiter.api.Test;
 import org.web3j.protocol.core.methods.response.TransactionReceipt;
 
-public class SetCodeTransactionAcceptanceTest extends AcceptanceTestBase {
+public class CodeDelegationTransactionAcceptanceTest extends AcceptanceTestBase {
   private static final String GENESIS_FILE = "/dev/dev_prague.json";
   private static final SECP256K1 secp256k1 = new SECP256K1();
 
@@ -74,7 +74,6 @@ void setUp() throws IOException {
   @AfterEach
   void tearDown() {
     besuNode.close();
-    cluster.close();
   }
 
   /**
@@ -88,17 +87,18 @@ void tearDown() {
   public void shouldTransferAllEthOfAuthorizerToSponsor() throws IOException {
 
     // 7702 transaction
-    final org.hyperledger.besu.datatypes.SetCodeAuthorization authorization =
-        SetCodeAuthorization.builder()
+    final CodeDelegation authorization =
+        org.hyperledger.besu.ethereum.core.CodeDelegation.builder()
             .chainId(BigInteger.valueOf(20211))
             .address(SEND_ALL_ETH_CONTRACT_ADDRESS)
+            .nonce(0)
             .signAndBuild(
                 secp256k1.createKeyPair(
                     secp256k1.createPrivateKey(AUTHORIZER_PRIVATE_KEY.toUnsignedBigInteger())));
 
     final Transaction tx =
         Transaction.builder()
-            .type(TransactionType.SET_CODE)
+            .type(TransactionType.DELEGATE_CODE)
             .chainId(BigInteger.valueOf(20211))
             .nonce(0)
             .maxPriorityFeePerGas(Wei.of(1000000000))
@@ -108,7 +108,7 @@ public void shouldTransferAllEthOfAuthorizerToSponsor() throws IOException {
             .value(Wei.ZERO)
             .payload(Bytes32.leftPad(Bytes.fromHexString(transactionSponsor.getAddress())))
             .accessList(List.of())
-            .setCodeTransactionPayloads(List.of(authorization))
+            .codeDelegations(List.of(authorization))
             .signAndBuild(
                 secp256k1.createKeyPair(
                     secp256k1.createPrivateKey(
@@ -134,40 +134,39 @@ public void shouldTransferAllEthOfAuthorizerToSponsor() throws IOException {
 
   /**
    * The authorizer creates an authorization for a contract that sends all its ETH to any given
-   * address. But the nonce is 1 and the authorization list is processed before the nonce increase
-   * of the sender. Therefore, the authorization should be invalid and will be ignored. No balance
-   * change, except for a decrease for paying the transaction cost should occur.
+   * address. The nonce is 1 and the authorization list is processed after the nonce increase of the
+   * sender. Therefore, the authorization should be valid. The authorizer balance should be 0 and
+   * the transaction sponsor's * balance should be 180000 ETH minus the transaction costs.
    */
   @Test
-  public void shouldCheckNonceBeforeNonceIncreaseOfSender() throws IOException {
-
+  public void shouldCheckNonceAfterNonceIncreaseOfSender() throws IOException {
+    final long GAS_LIMIT = 1000000L;
     cluster.verify(authorizer.balanceEquals(Amount.ether(90000)));
 
-    final org.hyperledger.besu.datatypes.SetCodeAuthorization authorization =
-        SetCodeAuthorization.builder()
+    final CodeDelegation authorization =
+        org.hyperledger.besu.ethereum.core.CodeDelegation.builder()
             .chainId(BigInteger.valueOf(20211))
-            .nonces(
-                Optional.of(
-                    1L)) // nonce is 1, but because it is validated before the nonce increase, it
-            // should be 0
+            .nonce(
+                1L) // nonce is 1, but because it is validated before the nonce increase, it should
+            // be 0
             .address(SEND_ALL_ETH_CONTRACT_ADDRESS)
             .signAndBuild(
                 secp256k1.createKeyPair(
                     secp256k1.createPrivateKey(AUTHORIZER_PRIVATE_KEY.toUnsignedBigInteger())));
 
     final Transaction tx =
         Transaction.builder()
-            .type(TransactionType.SET_CODE)
+            .type(TransactionType.DELEGATE_CODE)
             .chainId(BigInteger.valueOf(20211))
             .nonce(0)
             .maxPriorityFeePerGas(Wei.of(1000000000))
             .maxFeePerGas(Wei.fromHexString("0x02540BE400"))
-            .gasLimit(1000000)
+            .gasLimit(GAS_LIMIT)
             .to(Address.fromHexStringStrict(authorizer.getAddress()))
             .value(Wei.ZERO)
             .payload(Bytes32.leftPad(Bytes.fromHexString(otherAccount.getAddress())))
             .accessList(List.of())
-            .setCodeTransactionPayloads(List.of(authorization))
+            .codeDelegations(List.of(authorization))
             .signAndBuild(
                 secp256k1.createKeyPair(
                     secp256k1.createPrivateKey(AUTHORIZER_PRIVATE_KEY.toUnsignedBigInteger())));
@@ -180,14 +179,25 @@ public void shouldCheckNonceBeforeNonceIncreaseOfSender() throws IOException {
         besuNode.execute(ethTransactions.getTransactionReceipt(txHash));
     assertThat(maybeTransactionReceipt).isPresent();
 
-    // verify that the balance of the other account has not changed
-    cluster.verify(otherAccount.balanceEquals(0));
-
     final String gasPriceWithout0x =
         maybeTransactionReceipt.get().getEffectiveGasPrice().substring(2);
-    final BigInteger txCost =
-        maybeTransactionReceipt.get().getGasUsed().multiply(new BigInteger(gasPriceWithout0x, 16));
-    BigInteger expectedSenderBalance = new BigInteger("90000000000000000000000").subtract(txCost);
-    cluster.verify(authorizer.balanceEquals(Amount.wei(expectedSenderBalance)));
+    final BigInteger gasPrice = new BigInteger(gasPriceWithout0x, 16);
+    final BigInteger txCost = maybeTransactionReceipt.get().getGasUsed().multiply(gasPrice);
+
+    final BigInteger authorizerBalance = besuNode.execute(ethTransactions.getBalance(authorizer));
+
+    // The remaining balance of the authorizer should the gas limit multiplied by the gas price
+    // minus the transaction cost.
+    // The following executes this calculation in reverse.
+    assertThat(GAS_LIMIT).isEqualTo(authorizerBalance.add(txCost).divide(gasPrice).longValue());
+
+    // The other accounts balance should be the initial 9000 ETH balance from the authorizer minus
+    // the remaining balance of the authorizer and minus the transaction cost
+    cluster.verify(
+        otherAccount.balanceEquals(
+            Amount.wei(
+                new BigInteger("90000000000000000000000")
+                    .subtract(authorizerBalance)
+                    .subtract(txCost))));
   }
 }

acceptance-tests/tests/src/test/resources/jsonrpc/engine/prague/test-cases/16_prague_getPayloadV4.json

@@ -40,8 +40,8 @@
         "consolidationRequests": [
           {
             "sourceAddress": "0x23618e81e3f5cdf7f54c3d65f7fbc0abf5b21e8f",
-            "sourcePubKey": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
-            "targetPubKey": "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
+            "sourcePubkey": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+            "targetPubkey": "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
           }
         ],
         "blockNumber": "0x4",

besu/build.gradle

@@ -105,6 +105,8 @@ dependencies {
   testImplementation 'org.mockito:mockito-core'
   testImplementation 'org.testcontainers:testcontainers'
   testImplementation 'tech.pegasys.discovery:discovery'
+  testImplementation 'com.google.dagger:dagger'
 
   annotationProcessor 'com.google.dagger:dagger-compiler'
+  testAnnotationProcessor 'com.google.dagger:dagger-compiler'
 }

besu/src/main/java/org/hyperledger/besu/cli/BesuCommand.java

@@ -84,7 +84,6 @@
 import org.hyperledger.besu.cli.util.CommandLineUtils;
 import org.hyperledger.besu.cli.util.ConfigDefaultValueProviderStrategy;
 import org.hyperledger.besu.cli.util.VersionProvider;
-import org.hyperledger.besu.components.BesuComponent;
 import org.hyperledger.besu.config.CheckpointConfigOptions;
 import org.hyperledger.besu.config.GenesisConfigFile;
 import org.hyperledger.besu.config.GenesisConfigOptions;
@@ -865,40 +864,35 @@ static class PrivacyOptionGroup {
   private BesuController besuController;
   private BesuConfigurationImpl pluginCommonConfiguration;
 
-  private BesuComponent besuComponent;
   private final Supplier<ObservableMetricsSystem> metricsSystem =
-      Suppliers.memoize(
-          () ->
-              besuComponent == null || besuComponent.getObservableMetricsSystem() == null
-                  ? MetricsSystemFactory.create(metricsConfiguration())
-                  : besuComponent.getObservableMetricsSystem());
+      Suppliers.memoize(() -> MetricsSystemFactory.create(metricsConfiguration()));
+
   private Vertx vertx;
   private EnodeDnsConfiguration enodeDnsConfiguration;
   private KeyValueStorageProvider keyValueStorageProvider;
 
   /**
    * Besu command constructor.
    *
-   * @param besuComponent BesuComponent which acts as our application context
    * @param rlpBlockImporter RlpBlockImporter supplier
    * @param jsonBlockImporterFactory instance of {@code Function<BesuController, JsonBlockImporter>}
    * @param rlpBlockExporterFactory instance of {@code Function<Blockchain, RlpBlockExporter>}
    * @param runnerBuilder instance of RunnerBuilder
    * @param controllerBuilder instance of BesuController.Builder
    * @param besuPluginContext instance of BesuPluginContextImpl
    * @param environment Environment variables map
+   * @param commandLogger instance of Logger for outputting to the CLI
    */
   public BesuCommand(
-      final BesuComponent besuComponent,
       final Supplier<RlpBlockImporter> rlpBlockImporter,
       final Function<BesuController, JsonBlockImporter> jsonBlockImporterFactory,
       final Function<Blockchain, RlpBlockExporter> rlpBlockExporterFactory,
       final RunnerBuilder runnerBuilder,
       final BesuController.Builder controllerBuilder,
       final BesuPluginContextImpl besuPluginContext,
-      final Map<String, String> environment) {
+      final Map<String, String> environment,
+      final Logger commandLogger) {
     this(
-        besuComponent,
         rlpBlockImporter,
         jsonBlockImporterFactory,
         rlpBlockExporterFactory,
@@ -914,13 +908,13 @@ public BesuCommand(
         new TransactionSelectionServiceImpl(),
         new TransactionPoolValidatorServiceImpl(),
         new TransactionSimulationServiceImpl(),
-        new BlockchainServiceImpl());
+        new BlockchainServiceImpl(),
+        commandLogger);
   }
 
   /**
    * Overloaded Besu command constructor visible for testing.
    *
-   * @param besuComponent BesuComponent which acts as our application context
    * @param rlpBlockImporter RlpBlockImporter supplier
    * @param jsonBlockImporterFactory instance of {@code Function<BesuController, JsonBlockImporter>}
    * @param rlpBlockExporterFactory instance of {@code Function<Blockchain, RlpBlockExporter>}
@@ -937,10 +931,10 @@ public BesuCommand(
    * @param transactionValidatorServiceImpl instance of TransactionValidatorServiceImpl
    * @param transactionSimulationServiceImpl instance of TransactionSimulationServiceImpl
    * @param blockchainServiceImpl instance of BlockchainServiceImpl
+   * @param commandLogger instance of Logger for outputting to the CLI
    */
   @VisibleForTesting
   protected BesuCommand(
-      final BesuComponent besuComponent,
       final Supplier<RlpBlockImporter> rlpBlockImporter,
       final Function<BesuController, JsonBlockImporter> jsonBlockImporterFactory,
       final Function<Blockchain, RlpBlockExporter> rlpBlockExporterFactory,
@@ -956,9 +950,10 @@ protected BesuCommand(
       final TransactionSelectionServiceImpl transactionSelectionServiceImpl,
       final TransactionPoolValidatorServiceImpl transactionValidatorServiceImpl,
       final TransactionSimulationServiceImpl transactionSimulationServiceImpl,
-      final BlockchainServiceImpl blockchainServiceImpl) {
-    this.besuComponent = besuComponent;
-    this.logger = besuComponent.getBesuCommandLogger();
+      final BlockchainServiceImpl blockchainServiceImpl,
+      final Logger commandLogger) {
+
+    this.logger = commandLogger;
     this.rlpBlockImporter = rlpBlockImporter;
     this.rlpBlockExporterFactory = rlpBlockExporterFactory;
     this.jsonBlockImporterFactory = jsonBlockImporterFactory;
@@ -970,8 +965,13 @@ protected BesuCommand(
     this.securityModuleService = securityModuleService;
     this.permissioningService = permissioningService;
     this.privacyPluginService = privacyPluginService;
-    this.pluginCommonConfiguration = new BesuConfigurationImpl();
-    besuPluginContext.addService(BesuConfiguration.class, pluginCommonConfiguration);
+    if (besuPluginContext.getService(BesuConfigurationImpl.class).isPresent()) {
+      this.pluginCommonConfiguration =
+          besuPluginContext.getService(BesuConfigurationImpl.class).get();
+    } else {
+      this.pluginCommonConfiguration = new BesuConfigurationImpl();
+      besuPluginContext.addService(BesuConfiguration.class, this.pluginCommonConfiguration);
+    }
     this.rpcEndpointServiceImpl = rpcEndpointServiceImpl;
     this.transactionSelectionServiceImpl = transactionSelectionServiceImpl;
     this.transactionValidatorServiceImpl = transactionValidatorServiceImpl;
@@ -1821,9 +1821,7 @@ private void ensureAllNodesAreInAllowlist(
    */
   public BesuController buildController() {
     try {
-      return this.besuComponent == null
-          ? getControllerBuilder().build()
-          : getControllerBuilder().besuComponent(this.besuComponent).build();
+      return setupControllerBuilder().build();
     } catch (final Exception e) {
       throw new ExecutionException(this.commandLine, e.getMessage(), e);
     }
@@ -1834,7 +1832,7 @@ public BesuController buildController() {
    *
    * @return instance of BesuControllerBuilder
    */
-  public BesuControllerBuilder getControllerBuilder() {
+  public BesuControllerBuilder setupControllerBuilder() {
     pluginCommonConfiguration
         .init(dataDir(), dataDir().resolve(DATABASE_PATH), getDataStorageConfiguration())
         .withMiningParameters(miningParametersSupplier.get())
@@ -2800,7 +2798,7 @@ && getDataStorageConfiguration().getBonsaiLimitTrieLogsEnabled()) {
     builder.setTxPoolImplementation(buildTransactionPoolConfiguration().getTxPoolImplementation());
     builder.setWorldStateUpdateMode(unstableEvmOptions.toDomainObject().worldUpdaterMode());
 
-    builder.setPluginContext(besuComponent.getBesuPluginContext());
+    builder.setPluginContext(this.besuPluginContext);
 
     return builder.build();
   }