@lodestar/beacon-node 1.51.0-dev.b41e3a7363 → 1.51.0-dev.b8de7b3528

package/src/chain/blocks/payloadEnvelopeProcessor.ts

@@ -1,32 +1,37 @@
+import {DataAvailabilityStatus} from "@lodestar/state-transition";
 import {Metrics} from "../../metrics/metrics.js";
 import {JobItemQueue} from "../../util/queue/index.js";
 import type {BeaconChain} from "../chain.js";
 import {PayloadEnvelopeInput} from "../seenCache/seenPayloadEnvelopeInput.js";
-import {processExecutionPayload} from "./importExecutionPayload.js";
+import {importExecutionPayload} from "./importExecutionPayload.js";
 import {ImportPayloadOpts} from "./types.js";
+import {verifyPayloadsDataAvailability} from "./verifyPayloadsDataAvailability.js";
 
 // TODO GLOAS: Set to be equal to DEFAULT_MAX_PENDING_UNFINALIZED_PAYLOAD_ENVELOPE_WRITES for now
 const QUEUE_MAX_LENGTH = 16;
 
 /**
- * PayloadEnvelopeProcessor processes payload envelope jobs in a queued fashion, one after the other.
+ * PayloadEnvelopeProcessor imports payload envelopes in a queued fashion, one after the other.
  *
- * Jobs are enqueued only on envelope arrival (gossip or API). The envelope may reach us before
- * the sampled data columns; importExecutionPayload awaits `verifyPayloadsDataAvailability`
- * internally, so a queued job can pend for up to one slot while waiting for columns. Duplicate
- * triggers for the same payloadInput are deduped by sharing the in-flight import promise: every
- * caller observes the real import outcome. Resolving duplicates early instead would let
+ * Jobs are triggered only on envelope arrival (gossip or API). The envelope may reach us before the
+ * sampled data columns, the data availability wait runs before the job is queued. Duplicate
+ * triggers for the same payloadInput are deduped by sharing the in-flight promise: every caller
+ * observes the real import outcome. Resolving duplicates early instead would let
  * BlockInputSync mark a still-pending payload as processed, re-queue it, and spin re-processing
  * the same root until OOM while the import is blocked (e.g. EL syncing).
  */
 export class PayloadEnvelopeProcessor {
-  readonly jobQueue: JobItemQueue<[PayloadEnvelopeInput, ImportPayloadOpts], void>;
+  readonly jobQueue: JobItemQueue<[PayloadEnvelopeInput, DataAvailabilityStatus, ImportPayloadOpts], void>;
   private readonly imports = new WeakMap<PayloadEnvelopeInput, Promise<void>>();
 
-  constructor(chain: BeaconChain, metrics: Metrics | null, signal: AbortSignal) {
-    this.jobQueue = new JobItemQueue<[PayloadEnvelopeInput, ImportPayloadOpts], void>(
-      (payloadInput, opts) => {
-        return processExecutionPayload.call(chain, payloadInput, signal, opts);
+  constructor(
+    private readonly chain: BeaconChain,
+    metrics: Metrics | null,
+    private readonly signal: AbortSignal
+  ) {
+    this.jobQueue = new JobItemQueue<[PayloadEnvelopeInput, DataAvailabilityStatus, ImportPayloadOpts], void>(
+      (payloadInput, dataAvailabilityStatus, opts) => {
+        return importExecutionPayload.call(chain, payloadInput, dataAvailabilityStatus, opts);
       },
       {maxLength: QUEUE_MAX_LENGTH, noYieldIfOneItem: true, signal},
       metrics?.payloadEnvelopeProcessorQueue ?? undefined
@@ -35,19 +40,11 @@ export class PayloadEnvelopeProcessor {
 
   async processPayloadEnvelopeJob(payloadInput: PayloadEnvelopeInput, opts: ImportPayloadOpts = {}): Promise<void> {
     const existing = this.imports.get(payloadInput);
-    if (existing) {
+    if (existing !== undefined) {
       return existing;
     }
 
-    await this.jobQueue.waitForSpace();
-
-    // Re-check after await, as another call may have queued this payload.
-    const queued = this.imports.get(payloadInput);
-    if (queued) {
-      return queued;
-    }
-
-    const importPromise = this.jobQueue.push(payloadInput, opts);
+    const importPromise = this.waitForDataAndImport(payloadInput, opts);
     this.imports.set(payloadInput, importPromise);
 
     try {
@@ -59,4 +56,18 @@ export class PayloadEnvelopeProcessor {
       throw e;
     }
   }
+
+  private async waitForDataAndImport(payloadInput: PayloadEnvelopeInput, opts: ImportPayloadOpts): Promise<void> {
+    const {dataAvailabilityStatuses} = await verifyPayloadsDataAvailability(
+      this.chain.config,
+      [payloadInput],
+      this.signal
+    );
+
+    while (this.jobQueue.jobLen >= QUEUE_MAX_LENGTH) {
+      await this.jobQueue.waitForSpace();
+    }
+
+    return this.jobQueue.push(payloadInput, dataAvailabilityStatuses[0], opts);
+  }
 }

package/src/chain/blocks/verifyBlock.ts

@@ -175,16 +175,29 @@ export async function verifyBlocksInEpoch(
     const [
       segmentExecStatus,
       {blockDAStatuses, payloadDAStatuses, availableTime},
-      {postStates, proposerBalanceDeltas, verifyStateTime},
       {verifySignaturesTime},
+      {postStates, proposerBalanceDeltas, verifyStateTime},
     ] = await Promise.all([
       verifyExecutionPayloadsPromise,
 
       // data availability (fork-specific; see daAvailabilityPromise above)
       daAvailabilityPromise,
 
+      // All signatures at once. Must be called before verifyBlocksStateTransitionOnly()
+      // so we hand the BLS job to the worker pool before the main thread
+      // is busy with the state transition.
+      verifyBlocksSignatures(
+        this.config,
+        this.bls,
+        this.logger,
+        this.metrics,
+        preState0,
+        blocks,
+        indexedAttestationsByBlock,
+        opts
+      ),
+
       // Run state transition only
-      // TODO: Ensure it yields to allow flushing to workers and engine API
       verifyBlocksStateTransitionOnly(
         preState0,
         blockInputs,
@@ -198,22 +211,17 @@ export async function verifyBlocksInEpoch(
         opts
       ),
 
-      // All signatures at once
-      verifyBlocksSignatures(
-        this.config,
-        this.bls,
-        this.logger,
-        this.metrics,
-        preState0,
-        blocks,
-        indexedAttestationsByBlock,
-        opts
-      ),
-
       // TODO GLOAS: can verify payload signatures in batch too
       // maybe chain with the above verifyBlocksSignatures()
     ]);
 
+    if (blockInputs.length === 1 && opts.seenTimestampSec !== undefined) {
+      const consensusVerifiedTime = Math.max(verifyStateTime, verifySignaturesTime);
+      this.metrics?.gossipBlock.receivedToConsensusVerifiedTime.observe(
+        consensusVerifiedTime / 1000 - opts.seenTimestampSec
+      );
+    }
+
     for (const blockInput of blockInputs) {
       const block = blockInput.getBlock();
       const {slot, proposerIndex} = block.message;

package/src/chain/blocks/verifyBlocksSignatures.ts

@@ -36,10 +36,9 @@ export async function verifyBlocksSignatures(
     ? preState0.currentSyncCommitteeIndexed
     : new SyncCommitteeCacheEmpty();
 
-  // Verifies signatures after running state transition, so all SyncCommittee signed roots are known at this point.
-  // We must ensure block.slot <= state.slot before running getAllBlockSignatureSets().
-  // NOTE: If in the future multiple blocks signatures are verified at once, all blocks must be in the same epoch
-  // so the attester and proposer shufflings are correct.
+  // Runs concurrently with the state transition. Signature sets are built from preState0, which
+  // verifyBlocksInEpoch() guarantees is in the same epoch as every block, so the proposer and attester shufflings
+  // and the sync committee are the ones the blocks were signed under.
   for (const [i, block] of blocks.entries()) {
     // Use [i] to make clear that the index has to be correct to blame the right block below on BlockError()
     isValidPromises[i] = opts.validSignatures
@@ -50,7 +49,10 @@ export async function verifyBlocksSignatures(
         bls.verifySignatureSets(
           getBlockSignatureSets(config, currentSyncCommitteeIndexed, preState0, block, indexedAttestationsByBlock[i], {
             skipProposerSignature: opts.validProposerSignature,
-          })
+          }),
+          // Prioritize block verification over attestations, since
+          // attestations already buffer up to `MAX_BUFFER_WAIT_MS`
+          {priority: true}
         );
 
     // getBlockSignatureSets() takes 45ms in benchmarks for 2022Q2 mainnet blocks (100 sigs). When syncing a 32 blocks

package/src/chain/blocks/verifyPayloadsDataAvailability.ts

@@ -22,9 +22,7 @@ export async function verifyPayloadsDataAvailability(
   const promises: Promise<gloas.DataColumnSidecar[]>[] = [];
   for (const payloadInput of payloadInputs) {
     if (!payloadInput.hasAllData()) {
-      // Sync and reconstruction keep pulling the data columns from the network while we wait. The wait is
-      // capped at one slot because the payload queue is serial: a longer wait lets consecutive unavailable
-      // payloads push every later payload import further behind with each slot.
+      // Sync and reconstruction keep pulling the data columns from the network while we wait
       promises.push(
         payloadInput.waitForAllData(config.getSlotDurationMs(payloadInput.forkName), signal).catch((e) => {
           if (e instanceof TimeoutError) {

package/src/chain/bls/interface.ts

@@ -22,6 +22,8 @@ export type VerifySignatureOpts = {
   verifyOnMainThread?: boolean;
   /**
    * Some signature sets are more important than others, and should be verified first.
+   * Non-batchable priority jobs are posted to an idle worker before this call returns, so the caller
+   * can run synchronous work right after without delaying the verification.
    */
   priority?: boolean;
 };

package/src/chain/bls/multithread/index.ts

@@ -333,16 +333,20 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
       }
     }
 
+    // First hand work to an idle worker before returning to the caller.
+    // Deferring the post to the next macrotask would make the worker
+    // sit idle while waiting for the next synchronous work
+    else if (job.opts.priority) {
+      this.jobs.unshift(job);
+      void this.runJob();
+    }
+
     // Push job and schedule to call `runJob` in the next macro event loop cycle.
     // This is useful to allow batching job submitted from a synchronous for loop,
     // and to prevent large stacks since runJob may be called recursively.
     else {
-      if (job.opts.priority) {
-        this.jobs.unshift(job);
-      } else {
-        this.jobs.push(job);
-      }
-      callInNextEventLoop(this.runJob);
+      this.jobs.push(job);
+      callInNextEventLoop(() => void this.runJob());
     }
   }
 
@@ -377,7 +381,7 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
     let completedJobsCount = 0;
 
     if (this.jobs.length > 0) {
-      callInNextEventLoop(this.runJob);
+      callInNextEventLoop(() => void this.runJob());
     }
 
     try {
@@ -423,7 +427,7 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
       if (workReqs.length === 0) {
         worker.status = {code: WorkerStatusCode.idle, workerApi};
         this.workersBusy--;
-        callInNextEventLoop(this.runJob);
+        callInNextEventLoop(() => void this.runJob());
         return;
       }
 
@@ -499,7 +503,7 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
     this.workersBusy--;
 
     // Potentially run a new job
-    callInNextEventLoop(this.runJob);
+    callInNextEventLoop(() => void this.runJob());
   };
 
   /**
@@ -542,7 +546,7 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
         this.jobs.unshift(job);
       }
       this.bufferedJobs = null;
-      callInNextEventLoop(this.runJob);
+      callInNextEventLoop(() => void this.runJob());
     }
   };
 

package/src/chain/bls/multithread/types.ts

@@ -1,4 +1,4 @@
-import {type BlsSignatureSet} from "@chainsafe/lodestar-z/bls-verifier";
+import {type BlsSignatureSet} from "@lodestar/native/bls-verifier";
 import {SameMessageSignatureSet, VerifySignatureOpts} from "../interface.js";
 
 export type WorkerData = {

package/src/chain/bls/multithread/worker.ts

@@ -1,10 +1,6 @@
 import worker from "node:worker_threads";
-import {
-  type BlsSignatureSet,
-  verifySignatureSets,
-  verifySignatureSetsSameMessage,
-} from "@chainsafe/lodestar-z/bls-verifier";
 import {expose} from "@chainsafe/threads/worker";
+import {type BlsSignatureSet, verifySignatureSets, verifySignatureSetsSameMessage} from "@lodestar/native/bls-verifier";
 import {
   BlsWorkReq,
   BlsWorkResult,

package/src/chain/bls/singleThread.ts

@@ -1,4 +1,4 @@
-import {verifySignatureSetsSameMessage} from "@chainsafe/lodestar-z/bls-verifier";
+import {verifySignatureSetsSameMessage} from "@lodestar/native/bls-verifier";
 import {ISignatureSet} from "@lodestar/state-transition";
 import {Metrics} from "../../metrics/index.js";
 import {IBlsVerifier, SameMessageSignatureSet} from "./interface.js";

package/src/chain/bls/utils.ts

@@ -2,7 +2,7 @@ import {
   BLS_VERIFIER_MAX_BATCH_SIZE,
   BLS_VERIFIER_MAX_SAME_MESSAGE_BATCH_SIZE,
   verifySignatureSets,
-} from "@chainsafe/lodestar-z/bls-verifier";
+} from "@lodestar/native/bls-verifier";
 import {ISignatureSet, SignatureSetType, toBlsSignatureSet} from "@lodestar/state-transition";
 import {SameMessageSignatureSet} from "./interface.js";
 

package/src/chain/chain.ts

@@ -1,6 +1,5 @@
 import path from "node:path";
 import {PrivateKey} from "@libp2p/interface";
-import {type PubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {Type} from "@chainsafe/ssz";
 import {routes} from "@lodestar/api";
 import {BeaconConfig} from "@lodestar/config";
@@ -14,6 +13,7 @@ import {
   UpdateHeadOpt,
 } from "@lodestar/fork-choice";
 import {LoggerNode} from "@lodestar/logger/node";
+import {type PubkeyCache} from "@lodestar/native/pubkeys";
 import {
   EFFECTIVE_BALANCE_INCREMENT,
   type ForkPostFulu,

package/src/chain/interface.ts

@@ -1,7 +1,7 @@
-import {type PubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {Type} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
 import {CheckpointWithHex, IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
+import {type PubkeyCache} from "@lodestar/native/pubkeys";
 import {EpochShuffling, IBeaconStateView} from "@lodestar/state-transition";
 import {
   BeaconBlock,
@@ -77,8 +77,7 @@ import {PayloadEnvelopeInput, SeenPayloadEnvelopeInput} from "./seenCache/seenPa
 import {ShufflingCache} from "./shufflingCache.js";
 import {ValidatorMonitor} from "./validatorMonitor.js";
 
-export {BlockType, type AssembledBlockType};
-export {type ProposerPreparationData};
+export {type AssembledBlockType, BlockType, type ProposerPreparationData};
 export type BlockHash = RootHex;
 
 export type StateGetOpts = {

package/src/chain/opPools/aggregatedAttestationPool.ts

@@ -1,7 +1,7 @@
-import {Signature, aggregateSignatures} from "@chainsafe/lodestar-z/blst";
 import {BitArray} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
 import {IForkChoice} from "@lodestar/fork-choice";
+import {Signature, aggregateSignatures} from "@lodestar/native/blst";
 import {
   ForkName,
   ForkSeq,
@@ -20,6 +20,7 @@ import {
 } from "@lodestar/params";
 import {
   EffectiveBalanceIncrements,
+  G2_POINT_AT_INFINITY,
   IBeaconStateView,
   RootCache,
   computeEpochAtSlot,
@@ -30,7 +31,7 @@ import {
   isStatePostGloas,
 } from "@lodestar/state-transition";
 import {Attestation, Epoch, RootHex, Slot, electra, isElectraAttestation, phase0, ssz} from "@lodestar/types";
-import {Logger, MapDef, assert, toRootHex} from "@lodestar/utils";
+import {Logger, MapDef, assert, byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
 import {IntersectResult, intersectUint8Arrays} from "../../util/bitArray.js";
 import {getShufflingDependentRoot} from "../../util/dependentRoot.js";
@@ -409,20 +410,34 @@ export class AggregatedAttestationPool {
 
     const sortedConsolidationsByScore = Array.from(consolidations.entries())
       .sort((a, b) => b[1] - a[1])
-      .map(([consolidation, _]) => consolidation)
-      .slice(0, MAX_ATTESTATIONS_ELECTRA);
+      .map(([consolidation, _]) => consolidation);
 
     // on chain aggregation is expensive, only do it after all
     const packedAttestationsMetrics = this.metrics?.opPool.aggregatedAttestationPool.packedAttestations;
-    const packedAttestations: electra.Attestation[] = new Array(sortedConsolidationsByScore.length);
-    for (const [i, consolidation] of sortedConsolidationsByScore.entries()) {
-      packedAttestations[i] = aggregateConsolidation(consolidation);
+    const packedAttestations: electra.Attestation[] = [];
+    for (const consolidation of sortedConsolidationsByScore) {
+      if (packedAttestations.length >= MAX_ATTESTATIONS_ELECTRA) {
+        break;
+      }
+
+      const attestation = aggregateConsolidation(consolidation);
+      // The point at infinity is not a valid aggregate signature, exclude it from the block
+      if (byteArrayEquals(attestation.signature, G2_POINT_AT_INFINITY)) {
+        this.logger?.debug("Excluding aggregate with infinity signature", {
+          slot: stateSlot,
+          attestationSlot: attestation.data.slot,
+          committees: consolidation.byCommittee.size,
+        });
+        continue;
+      }
+
+      const i = packedAttestations.push(attestation) - 1;
 
       // record metrics of packed attestations
       packedAttestationsMetrics?.committeeCount.set({index: i}, consolidation.byCommittee.size);
       packedAttestationsMetrics?.totalAttesters.set({index: i}, consolidation.totalAttesters);
       packedAttestationsMetrics?.nonParticipation.set({index: i}, consolidation.notSeenAttesters);
-      packedAttestationsMetrics?.inclusionDistance.set({index: i}, stateSlot - packedAttestations[i].data.slot);
+      packedAttestationsMetrics?.inclusionDistance.set({index: i}, stateSlot - attestation.data.slot);
       packedAttestationsMetrics?.newSeenAttesters.set({index: i}, consolidation.newSeenAttesters);
       packedAttestationsMetrics?.totalEffectiveBalance.set({index: i}, consolidation.totalNewSeenEffectiveBalance);
     }
@@ -462,7 +477,8 @@ export class AggregatedAttestationPool {
         attestations.push(...attestationGroup.getAttestations());
       }
     }
-    return attestations;
+    // The point at infinity is not a valid aggregate signature, do not serve such an aggregate
+    return attestations.filter((attestation) => !byteArrayEquals(attestation.signature, G2_POINT_AT_INFINITY));
   }
 
   private onScrapeMetrics(metrics: Metrics): void {

package/src/chain/opPools/attestationPool.ts

@@ -1,9 +1,10 @@
-import {Signature, aggregateSignatures} from "@chainsafe/lodestar-z/blst";
 import {BitArray} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
+import {Signature, aggregateSignatures} from "@lodestar/native/blst";
 import {MAX_COMMITTEES_PER_SLOT, isForkPostElectra} from "@lodestar/params";
+import {G2_POINT_AT_INFINITY} from "@lodestar/state-transition";
 import {Attestation, RootHex, SingleAttestation, Slot, isElectraSingleAttestation} from "@lodestar/types";
-import {MapDef, assert} from "@lodestar/utils";
+import {MapDef, assert, byteArrayEquals} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
 import {IClock} from "../../util/clock.js";
 import {InsertOutcome, OpPoolError, OpPoolErrorCode} from "./types.js";
@@ -180,7 +181,13 @@ export class AttestationPool {
       assert.true(!isElectraAggregate(aggregate), "Aggregate should be type AggregateFastPhase0");
     }
 
-    return fastToAttestation(aggregate);
+    const attestation = fastToAttestation(aggregate);
+    // The point at infinity is not a valid aggregate signature, do not serve such an aggregate
+    if (byteArrayEquals(attestation.signature, G2_POINT_AT_INFINITY)) {
+      return null;
+    }
+
+    return attestation;
   }
 
   /**
@@ -209,7 +216,12 @@ export class AttestationPool {
       if (aggregateByRoot) {
         for (const aggFastByIndex of aggregateByRoot.values()) {
           for (const aggFast of aggFastByIndex.values()) {
-            attestations.push(fastToAttestation(aggFast));
+            const attestation = fastToAttestation(aggFast);
+            // The point at infinity is not a valid aggregate signature, do not serve such an aggregate
+            if (byteArrayEquals(attestation.signature, G2_POINT_AT_INFINITY)) {
+              continue;
+            }
+            attestations.push(attestation);
           }
         }
       }

package/src/chain/opPools/payloadAttestationPool.ts

@@ -1,9 +1,10 @@
-import {Signature, aggregateSignatures} from "@chainsafe/lodestar-z/blst";
 import {BitArray} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
+import {Signature, aggregateSignatures} from "@lodestar/native/blst";
 import {MAX_COMMITTEES_PER_SLOT, MAX_PAYLOAD_ATTESTATIONS, PTC_SIZE} from "@lodestar/params";
+import {G2_POINT_AT_INFINITY} from "@lodestar/state-transition";
 import {RootHex, Slot, gloas} from "@lodestar/types";
-import {MapDef, toRootHex} from "@lodestar/utils";
+import {MapDef, byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
 import {IClock} from "../../util/clock.js";
 import {InsertOutcome, OpPoolError, OpPoolErrorCode} from "./types.js";
@@ -112,11 +113,19 @@ export class PayloadAttestationPool {
       return [];
     }
 
-    return Array.from(aggregateByDataRoot.values())
-      .slice()
+    const payloadAttestations: gloas.PayloadAttestation[] = [];
+    for (const aggregate of aggregateByDataRoot.values()) {
+      const payloadAttestation = fastToPayloadAttestation(aggregate);
+      // The point at infinity is not a valid aggregate signature, exclude it from the block
+      if (byteArrayEquals(payloadAttestation.signature, G2_POINT_AT_INFINITY)) {
+        continue;
+      }
+      payloadAttestations.push(payloadAttestation);
+    }
+
+    return payloadAttestations
       .sort((a, b) => b.aggregationBits.getTrueBitIndexes().length - a.aggregationBits.getTrueBitIndexes().length)
-      .slice(0, MAX_PAYLOAD_ATTESTATIONS)
-      .map(fastToPayloadAttestation);
+      .slice(0, MAX_PAYLOAD_ATTESTATIONS);
   }
 
   getAll(slot?: Slot): gloas.PayloadAttestation[] {
@@ -139,9 +148,11 @@ export class PayloadAttestationPool {
       }
     }
 
+    // The point at infinity is not a valid aggregate signature, do not serve such an aggregate
     return aggregates
       .sort((a, b) => b.aggregationBits.getTrueBitIndexes().length - a.aggregationBits.getTrueBitIndexes().length)
-      .map(fastToPayloadAttestation);
+      .map(fastToPayloadAttestation)
+      .filter((attestation) => !byteArrayEquals(attestation.signature, G2_POINT_AT_INFINITY));
   }
 
   prune(clockSlot: Slot): void {

package/src/chain/opPools/syncCommitteeMessagePool.ts

@@ -1,9 +1,10 @@
-import {Signature, aggregateSignatures} from "@chainsafe/lodestar-z/blst";
 import {BitArray} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
+import {Signature, aggregateSignatures} from "@lodestar/native/blst";
 import {SYNC_COMMITTEE_SIZE, SYNC_COMMITTEE_SUBNET_COUNT} from "@lodestar/params";
+import {G2_POINT_AT_INFINITY} from "@lodestar/state-transition";
 import {Root, Slot, SubcommitteeIndex, SubnetID, altair} from "@lodestar/types";
-import {MapDef, toRootHex} from "@lodestar/utils";
+import {MapDef, byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {IClock} from "../../util/clock.js";
 import {InsertOutcome, OpPoolError, OpPoolErrorCode} from "./types.js";
 import {pruneBySlot, signatureFromBytesNoCheck} from "./utils.js";
@@ -110,10 +111,16 @@ export class SyncCommitteeMessagePool {
       return null;
     }
 
+    const signature = contribution.signature.toBytes();
+    // The point at infinity is not a valid contribution signature, do not serve such a contribution
+    if (byteArrayEquals(signature, G2_POINT_AT_INFINITY)) {
+      return null;
+    }
+
     return {
       ...contribution,
       aggregationBits: contribution.aggregationBits,
-      signature: contribution.signature.toBytes(),
+      signature,
     };
   }
 

package/src/chain/opPools/syncContributionAndProofPool.ts

@@ -1,10 +1,10 @@
-import {Signature, aggregateSignatures} from "@chainsafe/lodestar-z/blst";
 import {BitArray} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
+import {Signature, aggregateSignatures} from "@lodestar/native/blst";
 import {SYNC_COMMITTEE_SIZE, SYNC_COMMITTEE_SUBNET_SIZE} from "@lodestar/params";
 import {G2_POINT_AT_INFINITY} from "@lodestar/state-transition";
 import {Root, Slot, SubnetID, altair, ssz} from "@lodestar/types";
-import {Logger, MapDef, toRootHex} from "@lodestar/utils";
+import {Logger, MapDef, byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
 import {IClock} from "../../util/clock.js";
 import {InsertOutcome, OpPoolError, OpPoolErrorCode} from "./types.js";
@@ -234,8 +234,18 @@ export function aggregate(
   }
 
   metrics?.opPool.syncContributionAndProofPool.getAggregateParticipants.set(participationCount);
+
+  const syncCommitteeSignature = aggregateSignatures(signatures).toBytes();
+  // The point at infinity is only a valid sync aggregate signature with empty participation bits
+  if (byteArrayEquals(syncCommitteeSignature, G2_POINT_AT_INFINITY)) {
+    return {
+      syncCommitteeBits: BitArray.fromBitLen(SYNC_COMMITTEE_SIZE),
+      syncCommitteeSignature,
+    };
+  }
+
   return {
     syncCommitteeBits,
-    syncCommitteeSignature: aggregateSignatures(signatures).toBytes(),
+    syncCommitteeSignature,
   };
 }

package/src/chain/opPools/utils.ts

@@ -1,6 +1,6 @@
-import {Signature} from "@chainsafe/lodestar-z/blst";
 import {BeaconConfig} from "@lodestar/config";
 import {DbBatch, Id, Repository} from "@lodestar/db";
+import {Signature} from "@lodestar/native/blst";
 import {BLS_WITHDRAWAL_PREFIX, DOMAIN_BEACON_ATTESTER, DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
 import {IBeaconStateView, computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {AttesterSlashing, Domain, Slot, capella, phase0} from "@lodestar/types";

package/src/chain/validation/executionPayloadBid.ts

@@ -179,6 +179,20 @@ async function validateExecutionPayloadBid(
     });
   }
 
+  // [IGNORE] this bid is the highest value bid seen for the tuple
+  // `(bid.slot, bid.parent_block_hash, bid.parent_block_root)`.
+  // As a DoS prevention measure, the bid must also exceed the current highest bid by a minimum
+  // increment, see https://github.com/ethereum/consensus-specs/pull/4831. This prevents spam
+  // from builders submitting numerous bids with minimal value increments.
+  const bestBid = chain.executionPayloadBidPool.getBestBid(bid.slot, bidParentBlockHash, bidParentBlockRoot);
+  if (bestBid !== null && bid.value < getMinBidValue(bestBid.signedBid.message.value)) {
+    throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
+      code: ExecutionPayloadBidErrorCode.BID_TOO_LOW,
+      bidValue: bid.value,
+      currentHighestBid: bestBid.signedBid.message.value,
+    });
+  }
+
   // [IGNORE] `bid.parent_block_root` is the hash tree root of a known beacon block in fork choice.
   // Moved earlier than the spec ordering so we can derive the proposer dependent root for the
   // proposer-preferences lookup below from a known fork-choice block.
@@ -352,19 +366,6 @@ async function validateExecutionPayloadBid(
     });
   }
 
-  // [IGNORE] this bid is the highest value bid seen for the tuple
-  // `(bid.slot, bid.parent_block_hash, bid.parent_block_root)`.
-  // As a DoS prevention measure, the bid must also exceed the current highest bid by a minimum
-  // increment, see https://github.com/ethereum/consensus-specs/pull/4831. This prevents spam
-  // from builders submitting numerous bids with minimal value increments.
-  const bestBid = chain.executionPayloadBidPool.getBestBid(bid.slot, bidParentBlockHash, bidParentBlockRoot);
-  if (bestBid !== null && bid.value < getMinBidValue(bestBid.signedBid.message.value)) {
-    throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
-      code: ExecutionPayloadBidErrorCode.BID_TOO_LOW,
-      bidValue: bid.value,
-      currentHighestBid: bestBid.signedBid.message.value,
-    });
-  }
   // [IGNORE] `bid.value` is less or equal than the builder's excess balance --
   // i.e. `can_builder_cover_bid(state, builder_index, amount)` returns `True`.
   if (!state.canBuilderCoverBid(bid.builderIndex, bid.value)) {