@lodestar/beacon-node 1.38.0-dev.8475d71f09 → 1.38.0-dev.889b1c4475

package/src/chain/validation/attesterSlashing.ts

@@ -43,7 +43,7 @@ export async function validateAttesterSlashing(
   // [REJECT] All of the conditions within process_attester_slashing pass validation.
   try {
     // verifySignature = false, verified in batch below
-    assertValidAttesterSlashing(state, attesterSlashing, false);
+    assertValidAttesterSlashing(chain.index2pubkey, state, attesterSlashing, false);
   } catch (e) {
     throw new AttesterSlashingError(GossipAction.REJECT, {
       code: AttesterSlashingErrorCode.INVALID,
@@ -51,7 +51,7 @@ export async function validateAttesterSlashing(
     });
   }
 
-  const signatureSets = getAttesterSlashingSignatureSets(state, attesterSlashing);
+  const signatureSets = getAttesterSlashingSignatureSets(chain.index2pubkey, state, attesterSlashing);
   if (!(await chain.bls.verifySignatureSets(signatureSets, {batchable: true, priority: prioritizeBls}))) {
     throw new AttesterSlashingError(GossipAction.REJECT, {
       code: AttesterSlashingErrorCode.INVALID,

package/src/chain/validation/blobSidecar.ts

@@ -137,7 +137,11 @@ export async function validateGossipBlobSidecar(
   // [REJECT] The proposer signature, signed_beacon_block.signature, is valid with respect to the proposer_index pubkey.
   const signature = blobSidecar.signedBlockHeader.signature;
   if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blobSlot, blockHex, signature)) {
-    const signatureSet = getBlockHeaderProposerSignatureSetByParentStateSlot(blockState, blobSidecar.signedBlockHeader);
+    const signatureSet = getBlockHeaderProposerSignatureSetByParentStateSlot(
+      chain.index2pubkey,
+      blockState,
+      blobSidecar.signedBlockHeader
+    );
     // Don't batch so verification is not delayed
     if (!(await chain.bls.verifySignatureSets([signatureSet], {verifyOnMainThread: true}))) {
       throw new BlobSidecarGossipError(GossipAction.REJECT, {
@@ -240,7 +244,11 @@ export async function validateBlockBlobSidecars(
     const signature = firstSidecarSignedBlockHeader.signature;
     if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blockSlot, blockRootHex, signature)) {
       const headState = await chain.getHeadState();
-      const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(headState, firstSidecarSignedBlockHeader);
+      const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(
+        chain.index2pubkey,
+        headState,
+        firstSidecarSignedBlockHeader
+      );
 
       if (
         !(await chain.bls.verifySignatureSets([signatureSet], {

package/src/chain/validation/block.ts

@@ -6,7 +6,6 @@ import {
   computeTimeAtSlot,
   getBlockProposerSignatureSet,
   isExecutionBlockBodyType,
-  isExecutionEnabled,
   isExecutionStateType,
 } from "@lodestar/state-transition";
 import {SignedBeaconBlock, deneb} from "@lodestar/types";
@@ -140,7 +139,7 @@ export async function validateGossipBlock(
   if (fork === ForkName.bellatrix) {
     if (!isExecutionBlockBodyType(block.body)) throw Error("Not merge block type");
     const executionPayload = block.body.executionPayload;
-    if (isExecutionStateType(blockState) && isExecutionEnabled(blockState, block)) {
+    if (isExecutionStateType(blockState)) {
       const expectedTimestamp = computeTimeAtSlot(config, blockSlot, chain.genesisTime);
       if (executionPayload.timestamp !== computeTimeAtSlot(config, blockSlot, chain.genesisTime)) {
         throw new BlockGossipError(GossipAction.REJECT, {
@@ -154,7 +153,7 @@ export async function validateGossipBlock(
 
   // [REJECT] The proposer signature, signed_beacon_block.signature, is valid with respect to the proposer_index pubkey.
   if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blockSlot, blockRoot, signedBlock.signature)) {
-    const signatureSet = getBlockProposerSignatureSet(blockState, signedBlock);
+    const signatureSet = getBlockProposerSignatureSet(chain.index2pubkey, blockState, signedBlock);
     // Don't batch so verification is not delayed
     if (!(await chain.bls.verifySignatureSets([signatureSet], {verifyOnMainThread: true}))) {
       throw new BlockGossipError(GossipAction.REJECT, {

package/src/chain/validation/dataColumnSidecar.ts

@@ -135,6 +135,7 @@ export async function validateGossipDataColumnSidecar(
   const signature = dataColumnSidecar.signedBlockHeader.signature;
   if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blockHeader.slot, blockRootHex, signature)) {
     const signatureSet = getBlockHeaderProposerSignatureSetByParentStateSlot(
+      chain.index2pubkey,
       blockState,
       dataColumnSidecar.signedBlockHeader
     );
@@ -336,7 +337,11 @@ export async function validateBlockDataColumnSidecars(
     const signature = firstSidecarSignedBlockHeader.signature;
     if (!chain.seenBlockInputCache.isVerifiedProposerSignature(slot, rootHex, signature)) {
       const headState = await chain.getHeadState();
-      const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(headState, firstSidecarSignedBlockHeader);
+      const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(
+        chain.index2pubkey,
+        headState,
+        firstSidecarSignedBlockHeader
+      );
 
       if (
         !(await chain.bls.verifySignatureSets([signatureSet], {

package/src/chain/validation/proposerSlashing.ts

@@ -44,7 +44,7 @@ async function validateProposerSlashing(
     });
   }
 
-  const signatureSets = getProposerSlashingSignatureSets(state, proposerSlashing);
+  const signatureSets = getProposerSlashingSignatureSets(chain.index2pubkey, state, proposerSlashing);
   if (!(await chain.bls.verifySignatureSets(signatureSets, {batchable: true, priority: prioritizeBls}))) {
     throw new ProposerSlashingError(GossipAction.REJECT, {
       code: ProposerSlashingErrorCode.INVALID,

package/src/chain/validation/signatureSets/contributionAndProof.ts

@@ -2,16 +2,17 @@ import {DOMAIN_CONTRIBUTION_AND_PROOF} from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
   ISignatureSet,
+  Index2PubkeyCache,
   SignatureSetType,
   computeSigningRoot,
 } from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getContributionAndProofSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedContributionAndProof: altair.SignedContributionAndProof
 ): ISignatureSet {
-  const {epochCtx} = state;
   const domain = state.config.getDomain(
     state.slot,
     DOMAIN_CONTRIBUTION_AND_PROOF,
@@ -20,7 +21,7 @@ export function getContributionAndProofSignatureSet(
   const signingData = signedContributionAndProof.message;
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[signedContributionAndProof.message.aggregatorIndex],
+    pubkey: index2pubkey[signedContributionAndProof.message.aggregatorIndex],
     signingRoot: computeSigningRoot(ssz.altair.ContributionAndProof, signingData, domain),
     signature: signedContributionAndProof.signature,
   };

package/src/chain/validation/signatureSets/syncCommittee.ts

@@ -2,12 +2,14 @@ import {DOMAIN_SYNC_COMMITTEE} from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
   ISignatureSet,
+  Index2PubkeyCache,
   SignatureSetType,
   computeSigningRoot,
 } from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getSyncCommitteeSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   syncCommittee: altair.SyncCommitteeMessage
 ): ISignatureSet {
@@ -15,7 +17,7 @@ export function getSyncCommitteeSignatureSet(
 
   return {
     type: SignatureSetType.single,
-    pubkey: state.epochCtx.index2pubkey[syncCommittee.validatorIndex],
+    pubkey: index2pubkey[syncCommittee.validatorIndex],
     signingRoot: computeSigningRoot(ssz.Root, syncCommittee.beaconBlockRoot, domain),
     signature: syncCommittee.signature,
   };

package/src/chain/validation/signatureSets/syncCommitteeSelectionProof.ts

@@ -2,16 +2,18 @@ import {DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF} from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
   ISignatureSet,
+  Index2PubkeyCache,
   SignatureSetType,
   computeSigningRoot,
 } from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getSyncCommitteeSelectionProofSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   contributionAndProof: altair.ContributionAndProof
 ): ISignatureSet {
-  const {epochCtx, config} = state;
+  const {config} = state;
   const slot = contributionAndProof.contribution.slot;
   const domain = config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF, slot);
   const signingData: altair.SyncAggregatorSelectionData = {
@@ -20,7 +22,7 @@ export function getSyncCommitteeSelectionProofSignatureSet(
   };
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[contributionAndProof.aggregatorIndex],
+    pubkey: index2pubkey[contributionAndProof.aggregatorIndex],
     signingRoot: computeSigningRoot(ssz.altair.SyncAggregatorSelectionData, signingData, domain),
     signature: contributionAndProof.selectionProof,
   };

package/src/chain/validation/syncCommittee.ts

@@ -89,7 +89,7 @@ async function validateSyncCommitteeSigOnly(
   syncCommittee: altair.SyncCommitteeMessage,
   prioritizeBls = false
 ): Promise<void> {
-  const signatureSet = getSyncCommitteeSignatureSet(headState, syncCommittee);
+  const signatureSet = getSyncCommitteeSignatureSet(chain.index2pubkey, headState, syncCommittee);
   if (!(await chain.bls.verifySignatureSets([signatureSet], {batchable: true, priority: prioritizeBls}))) {
     throw new SyncCommitteeError(GossipAction.REJECT, {
       code: SyncCommitteeErrorCode.INVALID_SIGNATURE,

package/src/chain/validation/syncCommitteeContributionAndProof.ts

@@ -21,6 +21,7 @@ export async function validateSyncCommitteeGossipContributionAndProof(
   const contributionAndProof = signedContributionAndProof.message;
   const {contribution, aggregatorIndex} = contributionAndProof;
   const {subcommitteeIndex, slot} = contribution;
+  const {index2pubkey} = chain;
 
   const headState = chain.getHeadState();
   validateGossipSyncCommitteeExceptSig(chain, headState, subcommitteeIndex, {
@@ -73,16 +74,14 @@ export async function validateSyncCommitteeGossipContributionAndProof(
   // i.e. state.validators[contribution_and_proof.aggregator_index].pubkey in get_sync_subcommittee_pubkeys(state, contribution.subcommittee_index).
   // > Checked in validateGossipSyncCommitteeExceptSig()
 
-  const participantPubkeys = syncCommitteeParticipantIndices.map(
-    (validatorIndex) => headState.epochCtx.index2pubkey[validatorIndex]
-  );
+  const participantPubkeys = syncCommitteeParticipantIndices.map((validatorIndex) => index2pubkey[validatorIndex]);
   const signatureSets = [
     // [REJECT] The contribution_and_proof.selection_proof is a valid signature of the SyncAggregatorSelectionData
     // derived from the contribution by the validator with index contribution_and_proof.aggregator_index.
-    getSyncCommitteeSelectionProofSignatureSet(headState, contributionAndProof),
+    getSyncCommitteeSelectionProofSignatureSet(index2pubkey, headState, contributionAndProof),
 
     // [REJECT] The aggregator signature, signed_contribution_and_proof.signature, is valid.
-    getContributionAndProofSignatureSet(headState, signedContributionAndProof),
+    getContributionAndProofSignatureSet(index2pubkey, headState, signedContributionAndProof),
 
     // [REJECT] The aggregate signature is valid for the message beacon_block_root and aggregate pubkey derived from
     // the participation info in aggregation_bits for the subcommittee specified by the contribution.subcommittee_index.

package/src/chain/validation/voluntaryExit.ts

@@ -59,7 +59,7 @@ async function validateVoluntaryExit(
     });
   }
 
-  const signatureSet = getVoluntaryExitSignatureSet(state, voluntaryExit);
+  const signatureSet = getVoluntaryExitSignatureSet(chain.index2pubkey, state, voluntaryExit);
   if (!(await chain.bls.verifySignatureSets([signatureSet], {batchable: true, priority: prioritizeBls}))) {
     throw new VoluntaryExitError(GossipAction.REJECT, {
       code: VoluntaryExitErrorCode.INVALID_SIGNATURE,

package/src/eth1/index.ts

@@ -1,9 +1,6 @@
 import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {Root} from "@lodestar/types";
-import {fromHex} from "@lodestar/utils";
 import {Eth1DepositDataTracker, Eth1DepositDataTrackerModules} from "./eth1DepositDataTracker.js";
-import {Eth1MergeBlockTracker, Eth1MergeBlockTrackerModules} from "./eth1MergeBlockTracker.js";
-import {Eth1DataAndDeposits, IEth1ForBlockProduction, IEth1Provider, PowMergeBlock, TDProgress} from "./interface.js";
+import {Eth1DataAndDeposits, IEth1ForBlockProduction, IEth1Provider} from "./interface.js";
 import {Eth1Options} from "./options.js";
 import {Eth1Provider} from "./provider/eth1Provider.js";
 export {Eth1Provider};
@@ -23,23 +20,6 @@ export type {IEth1ForBlockProduction, IEth1Provider};
 //
 // - Fetch ALL deposit events from the deposit contract to build the deposit tree and validate future merkle proofs.
 //   Then it must follow deposit events at a distance roughly similar to the `ETH1_FOLLOW_DISTANCE` parameter above.
-//
-// - [New bellatrix]: After BELLATRIX_FORK_EPOCH, it must fetch the block with hash
-//   `state.eth1_data.block_hash` to compute `terminal_total_difficulty`. Note this may change with
-//   https://github.com/ethereum/consensus-specs/issues/2603.
-//
-// - [New bellatrix]: On block production post BELLATRIX_FORK_EPOCH, pre merge, the beacon node must find the merge block
-//   crossing the `terminal_total_difficulty` boundary and include it in the block. After the merge block production
-//   will just use `execution_engine.assemble_block` without fetching individual blocks.
-//
-// - [New bellatrix]: Fork-choice must validate the merge block ensuring it crossed the `terminal_total_difficulty`
-//   boundary, so it must fetch the POW block referenced in the merge block + its POW parent block.
-//
-// With the merge the beacon node has to follow the eth1 chain at two distances:
-// 1. At `ETH1_FOLLOW_DISTANCE` for eth1Data to be re-org safe
-// 2. At the head to get the first merge block, tolerating possible re-orgs
-//
-// Then both streams of blocks should not be merged since it's harder to guard against re-orgs from (2) to (1).
 
 export function initializeEth1ForBlockProduction(
   opts: Eth1Options,
@@ -59,12 +39,8 @@ export function initializeEth1ForBlockProduction(
 
 export class Eth1ForBlockProduction implements IEth1ForBlockProduction {
   private readonly eth1DepositDataTracker: Eth1DepositDataTracker | null;
-  private readonly eth1MergeBlockTracker: Eth1MergeBlockTracker;
 
-  constructor(
-    opts: Eth1Options,
-    modules: Eth1DepositDataTrackerModules & Eth1MergeBlockTrackerModules & {eth1Provider?: IEth1Provider}
-  ) {
+  constructor(opts: Eth1Options, modules: Eth1DepositDataTrackerModules & {eth1Provider?: IEth1Provider}) {
     const eth1Provider =
       modules.eth1Provider ||
       new Eth1Provider(
@@ -77,8 +53,6 @@ export class Eth1ForBlockProduction implements IEth1ForBlockProduction {
     this.eth1DepositDataTracker = opts.disableEth1DepositDataTracker
       ? null
       : new Eth1DepositDataTracker(opts, modules, eth1Provider);
-
-    this.eth1MergeBlockTracker = new Eth1MergeBlockTracker(modules, eth1Provider);
   }
 
   async getEth1DataAndDeposits(state: CachedBeaconStateAllForks): Promise<Eth1DataAndDeposits> {
@@ -88,23 +62,6 @@ export class Eth1ForBlockProduction implements IEth1ForBlockProduction {
     return this.eth1DepositDataTracker.getEth1DataAndDeposits(state);
   }
 
-  async getTerminalPowBlock(): Promise<Root | null> {
-    const block = await this.eth1MergeBlockTracker.getTerminalPowBlock();
-    return block && fromHex(block.blockHash);
-  }
-
-  getPowBlock(powBlockHash: string): Promise<PowMergeBlock | null> {
-    return this.eth1MergeBlockTracker.getPowBlock(powBlockHash);
-  }
-
-  getTDProgress(): TDProgress | null {
-    return this.eth1MergeBlockTracker.getTDProgress();
-  }
-
-  startPollingMergeBlock(): void {
-    this.eth1MergeBlockTracker.startPollingMergeBlock();
-  }
-
   isPollingEth1Data(): boolean {
     return this.eth1DepositDataTracker?.isPollingEth1Data() ?? false;
   }
@@ -127,30 +84,10 @@ export class Eth1ForBlockProductionDisabled implements IEth1ForBlockProduction {
     return {eth1Data: state.eth1Data, deposits: []};
   }
 
-  /**
-   * Will miss the oportunity to propose the merge block but will still produce valid blocks
-   */
-  async getTerminalPowBlock(): Promise<Root | null> {
-    return null;
-  }
-
-  /** Will not be able to validate the merge block */
-  async getPowBlock(_powBlockHash: string): Promise<PowMergeBlock | null> {
-    throw Error("eth1 must be enabled to verify merge block");
-  }
-
-  getTDProgress(): TDProgress | null {
-    return null;
-  }
-
   isPollingEth1Data(): boolean {
     return false;
   }
 
-  startPollingMergeBlock(): void {
-    // Ignore
-  }
-
   stopPollingEth1Data(): void {
     // Ignore
   }

package/src/eth1/interface.ts

@@ -1,6 +1,6 @@
 import {BeaconConfig} from "@lodestar/config";
 import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {Root, RootHex, phase0} from "@lodestar/types";
+import {phase0} from "@lodestar/types";
 
 export type EthJsonRpcBlockRaw = {
   /** the block number. null when its pending block. `"0x1b4"` */
@@ -47,22 +47,6 @@ export type Eth1DataAndDeposits = {
 export interface IEth1ForBlockProduction {
   getEth1DataAndDeposits(state: CachedBeaconStateAllForks): Promise<Eth1DataAndDeposits>;
 
-  /** Returns the most recent POW block that satisfies the merge block condition */
-  getTerminalPowBlock(): Promise<Root | null>;
-  /** Get a POW block by hash checking the local cache first */
-  getPowBlock(powBlockHash: string): Promise<PowMergeBlock | null>;
-
-  /** Get current TD progress for log notifier */
-  getTDProgress(): TDProgress | null;
-
-  /**
-   * Should only start polling for mergeBlock if:
-   * - after BELLATRIX_FORK_EPOCH
-   * - Beacon node synced
-   * - head state not isMergeTransitionComplete
-   */
-  startPollingMergeBlock(): void;
-
   isPollingEth1Data(): boolean;
 
   /**
@@ -78,34 +62,6 @@ export type Eth1Block = {
   timestamp: number;
 };
 
-export type PowMergeBlock = {
-  number: number;
-  blockHash: RootHex;
-  parentHash: RootHex;
-  totalDifficulty: bigint;
-};
-
-export type PowMergeBlockTimestamp = PowMergeBlock & {
-  /** in seconds */
-  timestamp: number;
-};
-
-export type TDProgress =
-  | {
-      ttdHit: false;
-      /** Power of ten by which tdDiffScaled is scaled down */
-      tdFactor: bigint;
-      /** (TERMINAL_TOTAL_DIFFICULTY - block.totalDifficulty) / tdFactor */
-      tdDiffScaled: number;
-      /** TERMINAL_TOTAL_DIFFICULTY */
-      ttd: bigint;
-      /** totalDifficulty of latest fetched eth1 block */
-      td: bigint;
-      /** timestamp in sec of latest fetched eth1 block */
-      timestamp: number;
-    }
-  | {ttdHit: true};
-
 export type BatchDepositEvents = {
   depositEvents: phase0.DepositEvent[];
   blockNumber: number;

package/src/execution/engine/http.ts

@@ -194,15 +194,12 @@ export class ExecutionEngineHttp implements IExecutionEngine {
    *   1. {status: INVALID_BLOCK_HASH, latestValidHash: null, validationError:
    *      errorMessage | null} if the blockHash validation has failed
    *
-   *   2. {status: INVALID_TERMINAL_BLOCK, latestValidHash: null, validationError:
-   *      errorMessage | null} if terminal block conditions are not satisfied
-   *
-   *   3. {status: SYNCING, latestValidHash: null, validationError: null} if the payload
+   *   2. {status: SYNCING, latestValidHash: null, validationError: null} if the payload
    *      extends the canonical chain and requisite data for its validation is missing
    *      with the payload status obtained from the Payload validation process if the payload
    *      has been fully validated while processing the call
    *
-   *   4. {status: ACCEPTED, latestValidHash: null, validationError: null} if the
+   *   3. {status: ACCEPTED, latestValidHash: null, validationError: null} if the
    *      following conditions are met:
    *        i) the blockHash of the payload is valid
    *        ii) the payload doesn't extend the canonical chain
@@ -330,16 +327,11 @@ export class ExecutionEngineHttp implements IExecutionEngine {
    *      errorMessage | null}, payloadId: null}
    *      obtained from the Payload validation process if the payload is deemed INVALID
    *
-   *   3. {payloadStatus: {status: INVALID_TERMINAL_BLOCK, latestValidHash: null,
-   *      validationError: errorMessage | null}, payloadId: null}
-   *      either obtained from the Payload validation process or as a result of validating a
-   *      PoW block referenced by forkchoiceState.headBlockHash
-   *
-   *   4. {payloadStatus: {status: VALID, latestValidHash: forkchoiceState.headBlockHash,
+   *   3. {payloadStatus: {status: VALID, latestValidHash: forkchoiceState.headBlockHash,
    *      validationError: null}, payloadId: null}
    *      if the payload is deemed VALID and a build process hasn't been started
    *
-   *   5. {payloadStatus: {status: VALID, latestValidHash: forkchoiceState.headBlockHash,
+   *   4. {payloadStatus: {status: VALID, latestValidHash: forkchoiceState.headBlockHash,
    *      validationError: null}, payloadId: buildProcessId}
    *      if the payload is deemed VALID and the build process has begun.
    *

package/src/execution/engine/mock.ts

@@ -9,7 +9,7 @@ import {
   ForkSeq,
 } from "@lodestar/params";
 import {ExecutionPayload, RootHex, bellatrix, deneb, ssz} from "@lodestar/types";
-import {fromHex, toHex, toRootHex} from "@lodestar/utils";
+import {fromHex, toRootHex} from "@lodestar/utils";
 import {ZERO_HASH_HEX} from "../../constants/index.js";
 import {quantityToNum} from "../../eth1/provider/utils.js";
 import {INTEROP_BLOCK_HASH} from "../../node/utils/interop/state.js";
@@ -70,7 +70,7 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
   finalizedBlockHash = ZERO_HASH_HEX;
   readonly payloadIdCache = new PayloadIdCache();
 
-  /** Known valid blocks, both pre-merge and post-merge */
+  /** Known valid blocks */
   private readonly validBlocks = new Map<RootHex, ExecutionBlock>();
   /** Preparing payloads to be retrieved via engine_getPayloadV1 */
   private readonly preparingPayloads = new Map<number, PreparedPayload>();
@@ -135,18 +135,6 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
     return [] as ExecutionPayloadBodyRpc[];
   }
 
-  /**
-   * Mock manipulator to add more known blocks to this mock.
-   */
-  addPowBlock(powBlock: bellatrix.PowBlock): void {
-    this.validBlocks.set(toHex(powBlock.blockHash), {
-      parentHash: toHex(powBlock.parentHash),
-      blockHash: toHex(powBlock.blockHash),
-      timestamp: 0,
-      blockNumber: 0,
-    });
-  }
-
   /**
    * Mock manipulator to add predefined responses before execution engine client calls
    */
@@ -258,7 +246,7 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
     //    section of the EIP. Additionally, if this validation fails, client software MUST NOT update the forkchoice
     //    state and MUST NOT begin a payload build process.
     //
-    // > TODO
+    // > N/A: All networks have completed the merge transition
 
     // 4. Before updating the forkchoice state, client software MUST ensure the validity of the payload referenced by
     //    forkchoiceState.headBlockHash, and MAY validate the payload while processing the call. The validation process

package/src/metrics/metrics/lodestar.ts

@@ -1668,58 +1668,6 @@ export function createLodestarMetrics(
         name: "lodestar_eth1_logs_batch_size_dynamic",
         help: "Dynamic batch size to fetch deposit logs",
       }),
-
-      // Merge Search info
-      eth1MergeStatus: register.gauge({
-        name: "lodestar_eth1_merge_status",
-        help: "Eth1 Merge Status 0 PRE_MERGE 1 SEARCHING 2 FOUND 3 POST_MERGE",
-      }),
-      eth1MergeTDFactor: register.gauge({
-        name: "lodestar_eth1_merge_td_factor",
-        help: "TTD set for the merge",
-      }),
-      eth1MergeTTD: register.gauge({
-        name: "lodestar_eth1_merge_ttd",
-        help: "TTD set for the merge scaled down by td_factor",
-      }),
-
-      eth1PollMergeBlockErrors: register.gauge({
-        name: "lodestar_eth1_poll_merge_block_errors_total",
-        help: "Total count of errors polling merge block",
-      }),
-      getTerminalPowBlockPromiseCacheHit: register.gauge({
-        name: "lodestar_eth1_get_terminal_pow_block_promise_cache_hit_total",
-        help: "Total count of skipped runs in poll merge block, because a previous promise existed",
-      }),
-      eth1ParentBlocksFetched: register.gauge({
-        name: "lodestar_eth1_parent_blocks_fetched_total",
-        help: "Total count of parent blocks fetched searching for merge block",
-      }),
-
-      // Latest block details
-      eth1LatestBlockTD: register.gauge({
-        name: "lodestar_eth1_latest_block_ttd",
-        help: "Eth1 latest Block td scaled down by td_factor",
-      }),
-      eth1LatestBlockNumber: register.gauge({
-        name: "lodestar_eth1_latest_block_number",
-        help: "Eth1 latest block number",
-      }),
-      eth1LatestBlockTimestamp: register.gauge({
-        name: "lodestar_eth1_latest_block_timestamp",
-        help: "Eth1 latest block timestamp",
-      }),
-
-      // Merge details
-      eth1MergeBlockDetails: register.gauge<{
-        terminalBlockHash: string;
-        terminalBlockNumber: string;
-        terminalBlockTD: string;
-      }>({
-        name: "lodestar_eth1_merge_block_details",
-        help: "If found then 1 with terminal block details",
-        labelNames: ["terminalBlockHash", "terminalBlockNumber", "terminalBlockTD"],
-      }),
     },
 
     eth1HttpClient: {

package/src/network/gossip/encoding.ts

@@ -1,10 +1,10 @@
 import {Message} from "@libp2p/interface";
 // snappyjs is better for compression for smaller payloads
-import {compress, uncompress} from "snappyjs";
 import xxhashFactory from "xxhash-wasm";
 import {digest} from "@chainsafe/as-sha256";
 import {RPC} from "@chainsafe/libp2p-gossipsub/message";
 import {DataTransform} from "@chainsafe/libp2p-gossipsub/types";
+import snappyWasm from "@chainsafe/snappy-wasm";
 import {ForkName} from "@lodestar/params";
 import {intToBytes} from "@lodestar/utils";
 import {MESSAGE_DOMAIN_VALID_SNAPPY} from "./constants.js";
@@ -17,6 +17,10 @@ const xxhash = await xxhashFactory();
 // Use salt to prevent msgId from being mined for collisions
 const h64Seed = BigInt(Math.floor(Math.random() * 1e9));
 
+// create singleton snappy encoder + decoder
+const encoder = new snappyWasm.Encoder();
+const decoder = new snappyWasm.Decoder();
+
 // Shared buffer to convert msgId to string
 const sharedMsgIdBuf = Buffer.alloc(20);
 
@@ -82,11 +86,12 @@ export class DataTransformSnappy implements DataTransform {
    * - `outboundTransform()`: compress snappy payload
    */
   inboundTransform(topicStr: string, data: Uint8Array): Uint8Array {
-    const uncompressedData = uncompress(data, this.maxSizePerMessage);
+    // check uncompressed data length before we actually decompress
+    const uncompressedDataLength = snappyWasm.decompress_len(data);
+    if (uncompressedDataLength > this.maxSizePerMessage) {
+      throw Error(`ssz_snappy decoded data length ${uncompressedDataLength} > ${this.maxSizePerMessage}`);
+    }
 
-    // check uncompressed data length before we extract beacon block root, slot or
-    // attestation data at later steps
-    const uncompressedDataLength = uncompressedData.length;
     const topic = this.gossipTopicCache.getTopic(topicStr);
     const sszType = getGossipSSZType(topic);
     this.metrics?.dataTransform.inbound.inc({type: topic.type});
@@ -98,6 +103,10 @@ export class DataTransformSnappy implements DataTransform {
       throw Error(`ssz_snappy decoded data length ${uncompressedDataLength} > ${sszType.maxSize}`);
     }
 
+    // Only after sanity length checks, we can decompress the data
+    // Using Buffer.alloc() instead of Buffer.allocUnsafe() to mitigate high GC pressure observed in some environments
+    const uncompressedData = Buffer.alloc(uncompressedDataLength);
+    decoder.decompress_into(data, uncompressedData);
     return uncompressedData;
   }
 
@@ -111,7 +120,10 @@ export class DataTransformSnappy implements DataTransform {
     if (data.length > this.maxSizePerMessage) {
       throw Error(`ssz_snappy encoded data length ${data.length} > ${this.maxSizePerMessage}`);
     }
-    // No need to parse topic, everything is snappy compressed
-    return compress(data);
+
+    // Using Buffer.alloc() instead of Buffer.allocUnsafe() to mitigate high GC pressure observed in some environments
+    const compressedData = Buffer.alloc(snappyWasm.max_compress_len(data.length));
+    const compressedLen = encoder.compress_into(data, compressedData);
+    return compressedData.subarray(0, compressedLen);
   }
 }