Move bellatrix configuration to be comparable to altair (#6348)

Partially addresses #5680

Signed-off-by: Paul Harris <[email protected]>

ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/DelegatingSpecConfigBellatrix.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright ConsenSys Software Inc., 2022
+ *
+ * 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.config;
+
+import java.util.Optional;
+import org.apache.tuweni.bytes.Bytes32;
+import org.apache.tuweni.units.bigints.UInt256;
+import tech.pegasys.teku.infrastructure.bytes.Bytes4;
+import tech.pegasys.teku.infrastructure.unsigned.UInt64;
+
+public class DelegatingSpecConfigBellatrix extends DelegatingSpecConfigAltair
+    implements SpecConfigBellatrix {
+  private final SpecConfigBellatrix specConfigBellatrix;
+
+  public DelegatingSpecConfigBellatrix(final SpecConfigBellatrix specConfig) {
+    super(specConfig);
+    this.specConfigBellatrix = SpecConfigBellatrix.required(specConfig);
+  }
+
+  @Override
+  public Optional<SpecConfigBellatrix> toVersionBellatrix() {
+    return Optional.of(this);
+  }
+
+  @Override
+  public Bytes4 getBellatrixForkVersion() {
+    return specConfigBellatrix.getBellatrixForkVersion();
+  }
+
+  @Override
+  public UInt64 getBellatrixForkEpoch() {
+    return specConfigBellatrix.getBellatrixForkEpoch();
+  }
+
+  @Override
+  public UInt64 getInactivityPenaltyQuotientBellatrix() {
+    return specConfigBellatrix.getInactivityPenaltyQuotientBellatrix();
+  }
+
+  @Override
+  public int getMinSlashingPenaltyQuotientBellatrix() {
+    return specConfigBellatrix.getMinSlashingPenaltyQuotientBellatrix();
+  }
+
+  @Override
+  public int getProportionalSlashingMultiplierBellatrix() {
+    return specConfigBellatrix.getProportionalSlashingMultiplierBellatrix();
+  }
+
+  @Override
+  public int getMaxBytesPerTransaction() {
+    return specConfigBellatrix.getMaxBytesPerTransaction();
+  }
+
+  @Override
+  public int getMaxTransactionsPerPayload() {
+    return specConfigBellatrix.getMaxTransactionsPerPayload();
+  }
+
+  @Override
+  public int getBytesPerLogsBloom() {
+    return specConfigBellatrix.getBytesPerLogsBloom();
+  }
+
+  @Override
+  public int getMaxExtraDataBytes() {
+    return specConfigBellatrix.getMaxExtraDataBytes();
+  }
+
+  @Override
+  public UInt64 getTerminalBlockHashActivationEpoch() {
+    return specConfigBellatrix.getTerminalBlockHashActivationEpoch();
+  }
+
+  @Override
+  public Bytes32 getTerminalBlockHash() {
+    return specConfigBellatrix.getTerminalBlockHash();
+  }
+
+  @Override
+  public UInt256 getTerminalTotalDifficulty() {
+    return specConfigBellatrix.getTerminalTotalDifficulty();
+  }
+
+  @Override
+  public int getSafeSlotsToImportOptimistically() {
+    return specConfigBellatrix.getSafeSlotsToImportOptimistically();
+  }
+}

ethereum/spec/src/main/java/tech/pegasys/teku/spec/config/SpecConfigBellatrix.java

@@ -13,66 +13,15 @@
 
 package tech.pegasys.teku.spec.config;
 
-import java.util.Objects;
 import java.util.Optional;
 import org.apache.tuweni.bytes.Bytes32;
 import org.apache.tuweni.units.bigints.UInt256;
 import tech.pegasys.teku.infrastructure.bytes.Bytes4;
 import tech.pegasys.teku.infrastructure.unsigned.UInt64;
 
-public class SpecConfigBellatrix extends DelegatingSpecConfigAltair {
-
-  // Fork
-  private final Bytes4 bellatrixForkVersion;
-  private final UInt64 bellatrixForkEpoch;
-  private final UInt64 inactivityPenaltyQuotientBellatrix;
-  private final int minSlashingPenaltyQuotientBellatrix;
-  private final int proportionalSlashingMultiplierBellatrix;
-  private final int maxBytesPerTransaction;
-  private final int maxTransactionsPerPayload;
-  private final int bytesPerLogsBloom;
-  private final int maxExtraDataBytes;
-
-  // Transition
-  private final UInt256 terminalTotalDifficulty;
-  private final Bytes32 terminalBlockHash;
-  private final UInt64 terminalBlockHashActivationEpoch;
-
-  // Optimistic Sync
-  private final int safeSlotsToImportOptimistically;
-
-  public SpecConfigBellatrix(
-      final SpecConfigAltair specConfig,
-      final Bytes4 bellatrixForkVersion,
-      final UInt64 bellatrixForkEpoch,
-      final UInt64 inactivityPenaltyQuotientBellatrix,
-      final int minSlashingPenaltyQuotientBellatrix,
-      final int proportionalSlashingMultiplierBellatrix,
-      final int maxBytesPerTransaction,
-      final int maxTransactionsPerPayload,
-      final int bytesPerLogsBloom,
-      final int maxExtraDataBytes,
-      final UInt256 terminalTotalDifficulty,
-      final Bytes32 terminalBlockHash,
-      final UInt64 terminalBlockHashActivationEpoch,
-      final int safeSlotsToImportOptimistically) {
-    super(specConfig);
-    this.bellatrixForkVersion = bellatrixForkVersion;
-    this.bellatrixForkEpoch = bellatrixForkEpoch;
-    this.inactivityPenaltyQuotientBellatrix = inactivityPenaltyQuotientBellatrix;
-    this.minSlashingPenaltyQuotientBellatrix = minSlashingPenaltyQuotientBellatrix;
-    this.proportionalSlashingMultiplierBellatrix = proportionalSlashingMultiplierBellatrix;
-    this.maxBytesPerTransaction = maxBytesPerTransaction;
-    this.maxTransactionsPerPayload = maxTransactionsPerPayload;
-    this.bytesPerLogsBloom = bytesPerLogsBloom;
-    this.maxExtraDataBytes = maxExtraDataBytes;
-    this.terminalTotalDifficulty = terminalTotalDifficulty;
-    this.terminalBlockHash = terminalBlockHash;
-    this.terminalBlockHashActivationEpoch = terminalBlockHashActivationEpoch;
-    this.safeSlotsToImportOptimistically = safeSlotsToImportOptimistically;
-  }
+public interface SpecConfigBellatrix extends SpecConfigAltair {
 
-  public static SpecConfigBellatrix required(final SpecConfig specConfig) {
+  static SpecConfigBellatrix required(SpecConfig specConfig) {
     return specConfig
         .toVersionBellatrix()
         .orElseThrow(
@@ -82,103 +31,32 @@ public static SpecConfigBellatrix required(final SpecConfig specConfig) {
                         + specConfig.getClass().getSimpleName()));
   }
 
-  public Bytes4 getBellatrixForkVersion() {
-    return bellatrixForkVersion;
-  }
+  @Override
+  Optional<SpecConfigBellatrix> toVersionBellatrix();
 
-  public UInt64 getBellatrixForkEpoch() {
-    return bellatrixForkEpoch;
-  }
+  Bytes4 getBellatrixForkVersion();
 
-  public UInt64 getInactivityPenaltyQuotientBellatrix() {
-    return inactivityPenaltyQuotientBellatrix;
-  }
+  UInt64 getBellatrixForkEpoch();
 
-  public int getMinSlashingPenaltyQuotientBellatrix() {
-    return minSlashingPenaltyQuotientBellatrix;
-  }
+  UInt64 getInactivityPenaltyQuotientBellatrix();
 
-  public int getProportionalSlashingMultiplierBellatrix() {
-    return proportionalSlashingMultiplierBellatrix;
-  }
+  int getMinSlashingPenaltyQuotientBellatrix();
 
-  public int getMaxBytesPerTransaction() {
-    return maxBytesPerTransaction;
-  }
+  int getProportionalSlashingMultiplierBellatrix();
 
-  public int getMaxTransactionsPerPayload() {
-    return maxTransactionsPerPayload;
-  }
+  int getMaxBytesPerTransaction();
 
-  public int getBytesPerLogsBloom() {
-    return bytesPerLogsBloom;
-  }
+  int getMaxTransactionsPerPayload();
 
-  public int getMaxExtraDataBytes() {
-    return maxExtraDataBytes;
-  }
+  int getBytesPerLogsBloom();
 
-  public UInt256 getTerminalTotalDifficulty() {
-    return terminalTotalDifficulty;
-  }
+  int getMaxExtraDataBytes();
 
-  public Bytes32 getTerminalBlockHash() {
-    return terminalBlockHash;
-  }
-
-  public UInt64 getTerminalBlockHashActivationEpoch() {
-    return terminalBlockHashActivationEpoch;
-  }
+  UInt64 getTerminalBlockHashActivationEpoch();
 
-  public int getSafeSlotsToImportOptimistically() {
-    return safeSlotsToImportOptimistically;
-  }
+  Bytes32 getTerminalBlockHash();
 
-  @Override
-  public Optional<SpecConfigBellatrix> toVersionBellatrix() {
-    return Optional.of(this);
-  }
+  UInt256 getTerminalTotalDifficulty();
 
-  @Override
-  public boolean equals(final Object o) {
-    if (this == o) {
-      return true;
-    }
-    if (o == null || getClass() != o.getClass()) {
-      return false;
-    }
-    final SpecConfigBellatrix that = (SpecConfigBellatrix) o;
-    return Objects.equals(specConfig, that.specConfig)
-        && minSlashingPenaltyQuotientBellatrix == that.minSlashingPenaltyQuotientBellatrix
-        && proportionalSlashingMultiplierBellatrix == that.proportionalSlashingMultiplierBellatrix
-        && maxBytesPerTransaction == that.maxBytesPerTransaction
-        && maxTransactionsPerPayload == that.maxTransactionsPerPayload
-        && bytesPerLogsBloom == that.bytesPerLogsBloom
-        && maxExtraDataBytes == that.maxExtraDataBytes
-        && Objects.equals(bellatrixForkVersion, that.bellatrixForkVersion)
-        && Objects.equals(bellatrixForkEpoch, that.bellatrixForkEpoch)
-        && Objects.equals(
-            inactivityPenaltyQuotientBellatrix, that.inactivityPenaltyQuotientBellatrix)
-        && Objects.equals(terminalTotalDifficulty, that.terminalTotalDifficulty)
-        && Objects.equals(terminalBlockHash, that.terminalBlockHash)
-        && Objects.equals(terminalBlockHashActivationEpoch, that.terminalBlockHashActivationEpoch);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(
-        specConfig,
-        bellatrixForkVersion,
-        bellatrixForkEpoch,
-        inactivityPenaltyQuotientBellatrix,
-        minSlashingPenaltyQuotientBellatrix,
-        proportionalSlashingMultiplierBellatrix,
-        maxBytesPerTransaction,
-        maxTransactionsPerPayload,
-        bytesPerLogsBloom,
-        maxExtraDataBytes,
-        terminalTotalDifficulty,
-        terminalBlockHash,
-        terminalBlockHashActivationEpoch);
-  }
+  int getSafeSlotsToImportOptimistically();
 }