validator builder for tests (Consensys#8163)

Author: lucassaldanha

beacon/validator/src/test/java/tech/pegasys/teku/validator/coordinator/ValidatorApiHandlerTest.java

@@ -1267,7 +1267,7 @@ private void setupValidatorsState(
                       UInt64.valueOf(index),
                       dataStructureUtil.randomUInt64(),
                       statusOverrides.getOrDefault(publicKey, ValidatorStatus.active_ongoing),
-                      dataStructureUtil.randomValidator(publicKey));
+                      dataStructureUtil.validatorBuilder().publicKey(publicKey).build());
                 })
             .collect(Collectors.toList());
 

data/provider/src/test/java/tech/pegasys/teku/api/ChainDataProviderTest.java

@@ -718,10 +718,11 @@ void getExpectedWithdrawalsGeneratesList() {
     final List<Validator> validators = new ArrayList<>();
     while (validators.size() < 16) {
       validators.add(
-          dataStructureUtil.randomValidator(
-              dataStructureUtil.randomPublicKey(),
-              dataStructureUtil.randomEth1WithdrawalCredentials(),
-              specConfig.getMaxEffectiveBalance()));
+          dataStructureUtil
+              .validatorBuilder()
+              .withRandomEth1WithdrawalCredentials()
+              .effectiveBalance(specConfig.getMaxEffectiveBalance())
+              .build());
     }
     final UInt64 eff = specConfig.getMaxEffectiveBalance();
     capellaBuilder.balances(

ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/DataStructureUtil.java

@@ -16,7 +16,6 @@
 import static com.google.common.base.Preconditions.checkState;
 import static java.util.stream.Collectors.toList;
 import static tech.pegasys.teku.ethereum.pow.api.DepositConstants.DEPOSIT_CONTRACT_TREE_DEPTH;
-import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH;
 import static tech.pegasys.teku.spec.constants.NetworkConstants.SYNC_COMMITTEE_SUBNET_COUNT;
 import static tech.pegasys.teku.spec.schemas.ApiSchemas.SIGNED_VALIDATOR_REGISTRATIONS_SCHEMA;
 import static tech.pegasys.teku.spec.schemas.ApiSchemas.SIGNED_VALIDATOR_REGISTRATION_SCHEMA;
@@ -1660,33 +1659,16 @@ public VoluntaryExit randomVoluntaryExit(final UInt64 validatorIndex) {
     return new VoluntaryExit(randomUInt64(), validatorIndex);
   }
 
-  public Validator randomValidator() {
-    return randomValidator(randomPublicKey());
+  public ValidatorBuilder validatorBuilder() {
+    return new ValidatorBuilder(spec, this);
   }
 
-  public Validator randomValidator(final BLSPublicKey publicKey) {
-    return new Validator(
-        publicKey,
-        randomBytes32(),
-        getMaxEffectiveBalance(),
-        false,
-        FAR_FUTURE_EPOCH,
-        FAR_FUTURE_EPOCH,
-        FAR_FUTURE_EPOCH,
-        FAR_FUTURE_EPOCH);
-  }
-
-  public Validator randomValidator(
-      final BLSPublicKey publicKey, final Bytes32 withdrawalCredentials, final UInt64 balance) {
-    return new Validator(
-        publicKey,
-        withdrawalCredentials,
-        balance,
-        false,
-        FAR_FUTURE_EPOCH,
-        FAR_FUTURE_EPOCH,
-        FAR_FUTURE_EPOCH,
-        FAR_FUTURE_EPOCH);
+  /*
+   STOP! Before thinking about adding a new method to create a specific type of validator, consider using
+   DataStructureUtil.validatorBuilder() to create a custom validator that suit your needs.
+  */
+  public Validator randomValidator() {
+    return validatorBuilder().build();
   }
 
   public Fork randomFork() {
@@ -2458,6 +2440,20 @@ public ExecutionLayerExit randomExecutionLayerExit() {
         .create(randomEth1Address(), randomPublicKey());
   }
 
+  public ExecutionLayerExit executionLayerExit(
+      final Bytes20 sourceAddress, BLSPublicKey validatorPubKey) {
+    return getElectraSchemaDefinitions(randomSlot())
+        .getExecutionLayerExitSchema()
+        .create(sourceAddress, validatorPubKey);
+  }
+
+  public ExecutionLayerExit executionLayerExit(final Validator validator) {
+    final Bytes20 executionAddress = new Bytes20(validator.getWithdrawalCredentials().slice(12));
+    return getElectraSchemaDefinitions(randomSlot())
+        .getExecutionLayerExitSchema()
+        .create(executionAddress, validator.getPublicKey());
+  }
+
   public UInt64 randomBlobSidecarIndex() {
     return randomUInt64(spec.getMaxBlobsPerBlock().orElseThrow());
   }

ethereum/spec/src/testFixtures/java/tech/pegasys/teku/spec/util/ValidatorBuilder.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright Consensys Software Inc., 2024
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package tech.pegasys.teku.spec.util;
+
+import static tech.pegasys.teku.spec.config.SpecConfig.FAR_FUTURE_EPOCH;
+
+import org.apache.tuweni.bytes.Bytes32;
+import tech.pegasys.teku.bls.BLSPublicKey;
+import tech.pegasys.teku.infrastructure.unsigned.UInt64;
+import tech.pegasys.teku.spec.Spec;
+import tech.pegasys.teku.spec.datastructures.state.Validator;
+
+public class ValidatorBuilder {
+
+  private final DataStructureUtil dataStructureUtil;
+  private BLSPublicKey publicKey;
+  private Bytes32 withdrawalCredentials;
+  private UInt64 effectiveBalance;
+  private boolean slashed = false;
+  private UInt64 activationEligibilityEpoch = FAR_FUTURE_EPOCH;
+  private UInt64 activationEpoch = FAR_FUTURE_EPOCH;
+  private UInt64 exitEpoch = FAR_FUTURE_EPOCH;
+  private UInt64 withdrawableEpoch = FAR_FUTURE_EPOCH;
+
+  public ValidatorBuilder(final Spec spec, final DataStructureUtil dataStructureUtil) {
+    this.dataStructureUtil = dataStructureUtil;
+    this.publicKey = dataStructureUtil.randomPublicKey();
+    this.withdrawalCredentials = dataStructureUtil.randomBytes32();
+    this.effectiveBalance = spec.getGenesisSpec().getConfig().getMaxEffectiveBalance();
+  }
+
+  public ValidatorBuilder publicKey(final BLSPublicKey publicKey) {
+    this.publicKey = publicKey;
+    return this;
+  }
+
+  public ValidatorBuilder withdrawalCredentials(final Bytes32 withdrawalCredentials) {
+    this.withdrawalCredentials = withdrawalCredentials;
+    return this;
+  }
+
+  public ValidatorBuilder withRandomEth1WithdrawalCredentials() {
+    this.withdrawalCredentials = dataStructureUtil.randomEth1WithdrawalCredentials();
+    return this;
+  }
+
+  public ValidatorBuilder withRandomBlsWithdrawalCredentials() {
+    this.withdrawalCredentials = dataStructureUtil.randomBlsWithdrawalCredentials();
+    return this;
+  }
+
+  public ValidatorBuilder effectiveBalance(final UInt64 effectiveBalance) {
+    this.effectiveBalance = effectiveBalance;
+    return this;
+  }
+
+  public ValidatorBuilder slashed(final boolean slashed) {
+    this.slashed = slashed;
+    return this;
+  }
+
+  public ValidatorBuilder activationEligibilityEpoch(final UInt64 activationEligibilityEpoch) {
+    this.activationEligibilityEpoch = activationEligibilityEpoch;
+    return this;
+  }
+
+  public ValidatorBuilder activationEpoch(final UInt64 activationEpoch) {
+    this.activationEpoch = activationEpoch;
+    return this;
+  }
+
+  public ValidatorBuilder exitEpoch(final UInt64 exitEpoch) {
+    this.exitEpoch = exitEpoch;
+    return this;
+  }
+
+  public ValidatorBuilder withdrawableEpoch(final UInt64 withdrawableEpoch) {
+    this.withdrawableEpoch = withdrawableEpoch;
+    return this;
+  }
+
+  public Validator build() {
+    return new Validator(
+        publicKey,
+        withdrawalCredentials,
+        effectiveBalance,
+        slashed,
+        activationEligibilityEpoch,
+        activationEpoch,
+        exitEpoch,
+        withdrawableEpoch);
+  }
+}