Simplify blob sidecar availability checker

beacon/sync/src/main/java/tech/pegasys/teku/beacon/sync/historical/HistoricalBatchFetcher.java

@@ -36,7 +36,6 @@
 import tech.pegasys.teku.bls.BLSPublicKey;
 import tech.pegasys.teku.bls.BLSSignature;
 import tech.pegasys.teku.infrastructure.async.SafeFuture;
-import tech.pegasys.teku.infrastructure.exceptions.ExceptionUtil;
 import tech.pegasys.teku.infrastructure.unsigned.UInt64;
 import tech.pegasys.teku.networking.eth2.peers.Eth2Peer;
 import tech.pegasys.teku.networking.eth2.rpc.core.InvalidResponseException;
@@ -53,7 +52,6 @@
 import tech.pegasys.teku.spec.datastructures.state.Fork;
 import tech.pegasys.teku.spec.datastructures.state.beaconstate.BeaconState;
 import tech.pegasys.teku.spec.logic.common.util.AsyncBLSSignatureVerifier;
-import tech.pegasys.teku.spec.logic.versions.deneb.blobs.BlobSidecarsAndValidationResult;
 import tech.pegasys.teku.statetransition.blobs.BlobSidecarManager;
 import tech.pegasys.teku.storage.api.StorageUpdateChannel;
 import tech.pegasys.teku.storage.client.CombinedChainDataClient;
@@ -402,20 +400,30 @@ private void validateBlobSidecars(final SignedBeaconBlock block) {
     final List<BlobSidecar> blobSidecars =
         blobSidecarsBySlotToImport.getOrDefault(
             block.getSlotAndBlockRoot(), Collections.emptyList());
-    LOG.trace("Validating {} blob sidecars for block {}", blobSidecars.size(), block.getRoot());
-    final BlobSidecarsAndValidationResult validationResult =
-        blobSidecarManager.createAvailabilityCheckerAndValidateImmediately(block, blobSidecars);
-
-    if (validationResult.isFailure()) {
-      final String causeMessage =
-          validationResult
-              .getCause()
-              .map(cause -> " (" + ExceptionUtil.getRootCauseMessage(cause) + ")")
-              .orElse("");
+
+    final boolean blobsBlockHeaderRootMatchBlockRoot =
+        blobSidecars.stream()
+            .allMatch(
+                blobSidecar -> {
+                  final boolean signedHeaderMatchesBlock =
+                      blobSidecar
+                          .getSignedBeaconBlockHeader()
+                          .hashTreeRoot()
+                          .equals(block.hashTreeRoot());
+
+                  if (signedHeaderMatchesBlock) {
+                    // since we already validated block's signature, we can mark the blob sidecar's
+                    // signature as validated
+                    blobSidecar.markSignatureAsValidated();
+                  }
+                  return signedHeaderMatchesBlock;
+                });
+
+    if (!blobsBlockHeaderRootMatchBlockRoot) {
       throw new IllegalArgumentException(
           String.format(
-              "Blob sidecars validation for block %s failed: %s%s",
-              block.getRoot(), validationResult.getValidationResult(), causeMessage));
+              "Blob sidecars' signed beacon block header don't match signed block for %s",
+              block.toLogString()));
     }
   }
 

beacon/sync/src/test/java/tech/pegasys/teku/beacon/sync/historical/HistoricalBatchFetcherTest.java

@@ -48,7 +48,6 @@
 import tech.pegasys.teku.spec.datastructures.blocks.SlotAndBlockRoot;
 import tech.pegasys.teku.spec.generator.ChainBuilder;
 import tech.pegasys.teku.spec.logic.common.util.AsyncBLSSignatureVerifier;
-import tech.pegasys.teku.spec.logic.versions.deneb.blobs.BlobSidecarsAndValidationResult;
 import tech.pegasys.teku.statetransition.blobs.BlobSidecarManager;
 import tech.pegasys.teku.storage.api.StorageQueryChannel;
 import tech.pegasys.teku.storage.api.StorageUpdateChannel;
@@ -117,7 +116,7 @@ public void setup() {
             .map(SignedBlockAndState::getBlock)
             .collect(Collectors.toList());
     lastBlockInBatch = chainBuilder.getLatestBlockAndState().getBlock();
-    firstBlockInBatch = blockBatch.get(0);
+    firstBlockInBatch = blockBatch.getFirst();
     blobSidecarsBatch =
         chainBuilder
             .streamBlobSidecars(10, 20)
@@ -148,8 +147,6 @@ public void setup() {
 
     when(signatureVerifier.verify(any(), any(), anyList()))
         .thenReturn(SafeFuture.completedFuture(true));
-    when(blobSidecarManager.createAvailabilityCheckerAndValidateImmediately(any(), anyList()))
-        .thenAnswer(i -> BlobSidecarsAndValidationResult.validResult(i.getArgument(1)));
   }
 
   @Test
@@ -202,22 +199,19 @@ public void run_returnAllBlocksAndBlobSidecarsOnFirstRequest() {
             earliestBlobSidecarSlotCaptor.capture());
     assertThat(blockCaptor.getValue()).containsExactlyElementsOf(blockBatch);
     assertThat(blobSidecarCaptor.getValue()).isEqualTo(blobSidecarsBatch);
-    assertThat(earliestBlobSidecarSlotCaptor.getValue()).contains(blockBatch.get(0).getSlot());
+    assertThat(earliestBlobSidecarSlotCaptor.getValue()).contains(blockBatch.getFirst().getSlot());
   }
 
   @Test
   public void run_failsOnBlobSidecarsValidationFailure() {
     when(blobSidecarManager.isAvailabilityRequiredAtSlot(any())).thenReturn(true);
-    when(blobSidecarManager.createAvailabilityCheckerAndValidateImmediately(any(), anyList()))
-        .thenAnswer(
-            i ->
-                BlobSidecarsAndValidationResult.invalidResult(
-                    i.getArgument(1), new IllegalStateException("oopsy")));
 
     assertThat(peer.getOutstandingRequests()).isEqualTo(0);
     final SafeFuture<BeaconBlockSummary> future = fetcher.run();
     peer.completePendingRequests();
 
+    // TODO: find a way to provoke blob sidecar validation failure
+
     assertThat(future)
         .failsWithin(Duration.ZERO)
         .withThrowableThat()

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

@@ -801,7 +801,8 @@ void shouldCreateBlobSidecarsForBlockContents() {
               assertThat(blobSidecar.getSszKZGCommitment())
                   .isEqualTo(expectedCommitments.get(index));
               // verify the merkle proof
-              assertThat(miscHelpersDeneb.verifyBlobSidecarMerkleProof(blobSidecar)).isTrue();
+              assertThat(miscHelpersDeneb.verifyBlobKzgCommitmentInclusionProof(blobSidecar))
+                  .isTrue();
             });
   }
 
@@ -921,7 +922,8 @@ void shouldCreateBlobSidecarsForBlindedBlock(final boolean useLocalFallback) {
               assertThat(blobSidecar.getSszKZGCommitment())
                   .isEqualTo(expectedCommitments.get(index));
               // verify the merkle proof
-              assertThat(miscHelpersDeneb.verifyBlobSidecarMerkleProof(blobSidecar)).isTrue();
+              assertThat(miscHelpersDeneb.verifyBlobKzgCommitmentInclusionProof(blobSidecar))
+                  .isTrue();
             });
   }
 

data/beaconrestapi/src/main/java/tech/pegasys/teku/beaconrestapi/handlers/v1/events/EventSubscriber.java

@@ -45,7 +45,7 @@ public class EventSubscriber {
   private final AtomicBoolean processingQueue;
   private final AsyncRunner asyncRunner;
   private final AtomicLong excessiveQueueingDisconnectionTime = new AtomicLong(Long.MAX_VALUE);
-  private volatile AtomicInteger successiveFailureCounter = new AtomicInteger(0);
+  private final AtomicInteger successiveFailureCounter = new AtomicInteger(0);
 
   public EventSubscriber(
       final List<String> eventTypes,

eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/forkchoice/StubBlobSidecarManager.java

@@ -98,12 +98,6 @@ public SafeFuture<BlobSidecarsAndValidationResult> getAvailabilityCheckResult()
         return SafeFuture.completedFuture(validateImmediately(block, blobsAndProofs));
       }
 
-      @Override
-      public BlobSidecarsAndValidationResult validateImmediately(
-          final List<BlobSidecar> blobSidecars) {
-        throw new UnsupportedOperationException("Not available in fork choice reference tests");
-      }
-
       private BlobSidecarsAndValidationResult validateImmediately(
           final SignedBeaconBlock block, final BlobsAndProofs blobsAndProofs) {
         final List<KZGCommitment> kzgCommitments =
@@ -125,11 +119,5 @@ private BlobSidecarsAndValidationResult validateImmediately(
     };
   }
 
-  @Override
-  public BlobSidecarsAndValidationResult createAvailabilityCheckerAndValidateImmediately(
-      final SignedBeaconBlock block, final List<BlobSidecar> blobSidecars) {
-    throw new UnsupportedOperationException("Not available in fork choice reference tests");
-  }
-
   private record BlobsAndProofs(List<Blob> blobs, List<KZGProof> proofs) {}
 }

ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/blobs/versions/deneb/BlobSidecar.java

@@ -39,6 +39,10 @@ public class BlobSidecar
         SignedBeaconBlockHeader,
         SszBytes32Vector> {
 
+  private volatile boolean kzgValidated = false;
+  private volatile boolean kzgCommitmentInclusionProofValidated = false;
+  private volatile boolean signatureValidated = false;
+
   BlobSidecar(final BlobSidecarSchema blobSidecarSchema, final TreeNode backingTreeNode) {
     super(blobSidecarSchema, backingTreeNode);
   }
@@ -139,6 +143,30 @@ public String toLogString() {
         getKZGProof().toAbbreviatedString());
   }
 
+  public boolean isKzgValidated() {
+    return kzgValidated;
+  }
+
+  public boolean isKzgCommitmentInclusionProofValidated() {
+    return kzgCommitmentInclusionProofValidated;
+  }
+
+  public boolean isSignatureValidated() {
+    return signatureValidated;
+  }
+
+  public void markKzgAsValidated() {
+    kzgValidated = true;
+  }
+
+  public void markKzgCommitmentInclusionProofAsValidated() {
+    kzgCommitmentInclusionProofValidated = true;
+  }
+
+  public void markSignatureAsValidated() {
+    signatureValidated = true;
+  }
+
   @Override
   public BlobSidecarSchema getSchema() {
     return (BlobSidecarSchema) super.getSchema();

ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/helpers/MiscHelpers.java

@@ -366,20 +366,6 @@ public boolean verifyBlobKzgProofBatch(final KZG kzg, final List<BlobSidecar> bl
     return false;
   }
 
-  public void validateBlobSidecarsBatchAgainstBlock(
-      final List<BlobSidecar> blobSidecars,
-      final BeaconBlock block,
-      final List<KZGCommitment> kzgCommitmentsFromBlock) {
-    throw new UnsupportedOperationException("No Blob Sidecars before Deneb");
-  }
-
-  public void verifyBlobSidecarCompleteness(
-      final List<BlobSidecar> verifiedBlobSidecars,
-      final List<KZGCommitment> kzgCommitmentsFromBlock)
-      throws IllegalArgumentException {
-    throw new UnsupportedOperationException("No Blob Sidecars before Deneb");
-  }
-
   public VersionedHash kzgCommitmentToVersionedHash(final KZGCommitment kzgCommitment) {
     throw new UnsupportedOperationException("No KZGCommitments before Deneb");
   }

ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/deneb/blobs/BlobSidecarsAvailabilityChecker.java

@@ -15,9 +15,7 @@
 
 import static tech.pegasys.teku.spec.logic.versions.deneb.blobs.BlobSidecarsAndValidationResult.NOT_REQUIRED_RESULT_FUTURE;
 
-import java.util.List;
 import tech.pegasys.teku.infrastructure.async.SafeFuture;
-import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar;
 import tech.pegasys.teku.spec.datastructures.execution.ExecutionPayloadHeader;
 import tech.pegasys.teku.spec.datastructures.execution.NewPayloadRequest;
 import tech.pegasys.teku.spec.logic.versions.bellatrix.block.OptimisticExecutionPayloadExecutor;
@@ -35,12 +33,6 @@ public boolean initiateDataAvailabilityCheck() {
         public SafeFuture<BlobSidecarsAndValidationResult> getAvailabilityCheckResult() {
           return NOT_REQUIRED_RESULT_FUTURE;
         }
-
-        @Override
-        public BlobSidecarsAndValidationResult validateImmediately(
-            final List<BlobSidecar> blobSidecars) {
-          return BlobSidecarsAndValidationResult.NOT_REQUIRED;
-        }
       };
 
   BlobSidecarsAvailabilityChecker NOT_REQUIRED = NOOP;
@@ -55,7 +47,4 @@ public BlobSidecarsAndValidationResult validateImmediately(
   boolean initiateDataAvailabilityCheck();
 
   SafeFuture<BlobSidecarsAndValidationResult> getAvailabilityCheckResult();
-
-  /** Perform the data availability check immediately on the provided blob sidecars */
-  BlobSidecarsAndValidationResult validateImmediately(List<BlobSidecar> blobSidecars);
 }