@lodestar/state-transition 1.38.0-dev.bc1fed4d3d → 1.38.0-dev.ebc352f211

package/src/signatureSets/proposer.ts

@@ -1,22 +1,25 @@
 import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
 import {SignedBeaconBlock, SignedBlindedBeaconBlock, Slot, isBlindedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {computeSigningRoot} from "../util/index.js";
 import {ISignatureSet, SignatureSetType, verifySignatureSet} from "../util/signatureSets.js";
 
 export function verifyProposerSignature(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): boolean {
-  const signatureSet = getBlockProposerSignatureSet(state, signedBlock);
+  const signatureSet = getBlockProposerSignatureSet(index2pubkey, state, signedBlock);
   return verifySignatureSet(signatureSet);
 }
 
 export function getBlockProposerSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): ISignatureSet {
-  const {config, epochCtx} = state;
+  const {config} = state;
   const domain = config.getDomain(state.slot, DOMAIN_BEACON_PROPOSER, signedBlock.message.slot);
 
   const blockType = isBlindedBeaconBlock(signedBlock.message)
@@ -25,37 +28,40 @@ export function getBlockProposerSignatureSet(
 
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[signedBlock.message.proposerIndex],
+    pubkey: index2pubkey[signedBlock.message.proposerIndex],
     signingRoot: computeSigningRoot(blockType, signedBlock.message, domain),
     signature: signedBlock.signature,
   };
 }
 
 export function getBlockHeaderProposerSignatureSetByParentStateSlot(
+  index2pubkey: Index2PubkeyCache,
   parentState: CachedBeaconStateAllForks,
   signedBlockHeader: phase0.SignedBeaconBlockHeader
 ) {
-  return getBlockHeaderProposerSignatureSet(parentState, signedBlockHeader, parentState.slot);
+  return getBlockHeaderProposerSignatureSet(index2pubkey, parentState, signedBlockHeader, parentState.slot);
 }
 
 export function getBlockHeaderProposerSignatureSetByHeaderSlot(
+  index2pubkey: Index2PubkeyCache,
   headState: CachedBeaconStateAllForks,
   signedBlockHeader: phase0.SignedBeaconBlockHeader
 ) {
-  return getBlockHeaderProposerSignatureSet(headState, signedBlockHeader, signedBlockHeader.message.slot);
+  return getBlockHeaderProposerSignatureSet(index2pubkey, headState, signedBlockHeader, signedBlockHeader.message.slot);
 }
 
 function getBlockHeaderProposerSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlockHeader: phase0.SignedBeaconBlockHeader,
   domainSlot: Slot
 ): ISignatureSet {
-  const {config, epochCtx} = state;
+  const {config} = state;
   const domain = config.getDomain(domainSlot, DOMAIN_BEACON_PROPOSER, signedBlockHeader.message.slot);
 
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[signedBlockHeader.message.proposerIndex],
+    pubkey: index2pubkey[signedBlockHeader.message.proposerIndex],
     signingRoot: computeSigningRoot(ssz.phase0.BeaconBlockHeader, signedBlockHeader.message, domain),
     signature: signedBlockHeader.signature,
   };

package/src/signatureSets/proposerSlashings.ts

@@ -1,5 +1,6 @@
 import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
 import {SignedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {ISignatureSet, SignatureSetType, computeSigningRoot} from "../util/index.js";
 
@@ -7,11 +8,11 @@ import {ISignatureSet, SignatureSetType, computeSigningRoot} from "../util/index
  * Extract signatures to allow validating all block signatures at once
  */
 export function getProposerSlashingSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   proposerSlashing: phase0.ProposerSlashing
 ): ISignatureSet[] {
-  const {epochCtx} = state;
-  const pubkey = epochCtx.index2pubkey[proposerSlashing.signedHeader1.message.proposerIndex];
+  const pubkey = index2pubkey[proposerSlashing.signedHeader1.message.proposerIndex];
 
   // In state transition, ProposerSlashing headers are only partially validated. Their slot could be higher than the
   // clock and the slashing would still be valid. Must use bigint variants to hash correctly to all possible values
@@ -32,10 +33,11 @@ export function getProposerSlashingSignatureSets(
 }
 
 export function getProposerSlashingsSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock
 ): ISignatureSet[] {
   return signedBlock.message.body.proposerSlashings.flatMap((proposerSlashing) =>
-    getProposerSlashingSignatureSets(state, proposerSlashing)
+    getProposerSlashingSignatureSets(index2pubkey, state, proposerSlashing)
   );
 }

package/src/signatureSets/randao.ts

@@ -1,5 +1,6 @@
 import {DOMAIN_RANDAO} from "@lodestar/params";
 import {BeaconBlock, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {
   ISignatureSet,
@@ -9,22 +10,29 @@ import {
   verifySignatureSet,
 } from "../util/index.js";
 
-export function verifyRandaoSignature(state: CachedBeaconStateAllForks, block: BeaconBlock): boolean {
-  return verifySignatureSet(getRandaoRevealSignatureSet(state, block));
+export function verifyRandaoSignature(
+  index2pubkey: Index2PubkeyCache,
+  state: CachedBeaconStateAllForks,
+  block: BeaconBlock
+): boolean {
+  return verifySignatureSet(getRandaoRevealSignatureSet(index2pubkey, state, block));
 }
 
 /**
  * Extract signatures to allow validating all block signatures at once
  */
-export function getRandaoRevealSignatureSet(state: CachedBeaconStateAllForks, block: BeaconBlock): ISignatureSet {
-  const {epochCtx} = state;
+export function getRandaoRevealSignatureSet(
+  index2pubkey: Index2PubkeyCache,
+  state: CachedBeaconStateAllForks,
+  block: BeaconBlock
+): ISignatureSet {
   // should not get epoch from epochCtx
   const epoch = computeEpochAtSlot(block.slot);
   const domain = state.config.getDomain(state.slot, DOMAIN_RANDAO, block.slot);
 
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[block.proposerIndex],
+    pubkey: index2pubkey[block.proposerIndex],
     signingRoot: computeSigningRoot(ssz.Epoch, epoch, domain),
     signature: block.body.randaoReveal,
   };

package/src/signatureSets/voluntaryExits.ts

@@ -1,4 +1,5 @@
 import {SignedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {
   ISignatureSet,
@@ -9,36 +10,38 @@ import {
 } from "../util/index.js";
 
 export function verifyVoluntaryExitSignature(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): boolean {
-  return verifySignatureSet(getVoluntaryExitSignatureSet(state, signedVoluntaryExit));
+  return verifySignatureSet(getVoluntaryExitSignatureSet(index2pubkey, state, signedVoluntaryExit));
 }
 
 /**
  * Extract signatures to allow validating all block signatures at once
  */
 export function getVoluntaryExitSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): ISignatureSet {
-  const {epochCtx} = state;
   const slot = computeStartSlotAtEpoch(signedVoluntaryExit.message.epoch);
   const domain = state.config.getDomainForVoluntaryExit(state.slot, slot);
 
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[signedVoluntaryExit.message.validatorIndex],
+    pubkey: index2pubkey[signedVoluntaryExit.message.validatorIndex],
     signingRoot: computeSigningRoot(ssz.phase0.VoluntaryExit, signedVoluntaryExit.message, domain),
     signature: signedVoluntaryExit.signature,
   };
 }
 
 export function getVoluntaryExitsSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock
 ): ISignatureSet[] {
   return signedBlock.message.body.voluntaryExits.map((voluntaryExit) =>
-    getVoluntaryExitSignatureSet(state, voluntaryExit)
+    getVoluntaryExitSignatureSet(index2pubkey, state, voluntaryExit)
   );
 }

package/src/slot/index.ts

@@ -1,7 +1,7 @@
 import {byteArrayEquals} from "@chainsafe/ssz";
-import {SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
+import {ForkSeq, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
 import {ZERO_HASH} from "../constants/index.js";
-import {CachedBeaconStateAllForks} from "../types.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateGloas} from "../types.js";
 
 export {upgradeStateToAltair} from "./upgradeStateToAltair.js";
 export {upgradeStateToBellatrix} from "./upgradeStateToBellatrix.js";
@@ -14,7 +14,7 @@ export {upgradeStateToGloas} from "./upgradeStateToGloas.js";
 /**
  * Dial state to next slot. Common for all forks
  */
-export function processSlot(state: CachedBeaconStateAllForks): void {
+export function processSlot(fork: ForkSeq, state: CachedBeaconStateAllForks): void {
   // Cache state root
   // Note: .hashTreeRoot() automatically commits() pending changes
   const previousStateRoot = state.hashTreeRoot();
@@ -29,4 +29,12 @@ export function processSlot(state: CachedBeaconStateAllForks): void {
   // Note: .hashTreeRoot() automatically commits() pending changes
   const previousBlockRoot = state.latestBlockHeader.hashTreeRoot();
   state.blockRoots.set(state.slot % SLOTS_PER_HISTORICAL_ROOT, previousBlockRoot);
+
+  if (fork >= ForkSeq.gloas) {
+    // Unset the next payload availability
+    (state as CachedBeaconStateGloas).executionPayloadAvailability.set(
+      (state.slot + 1) % SLOTS_PER_HISTORICAL_ROOT,
+      false
+    );
+  }
 }

package/src/slot/upgradeStateToAltair.ts

@@ -135,7 +135,8 @@ function translateParticipation(
       data,
       attestation.inclusionDelay,
       epochCtx.epoch,
-      rootCache
+      rootCache,
+      null
     );
 
     const committeeIndices = epochCtx.getBeaconCommittee(data.slot, data.index);

package/src/slot/upgradeStateToGloas.ts

@@ -1,24 +1,68 @@
+import {SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
 import {getCachedBeaconState} from "../cache/stateCache.js";
 import {CachedBeaconStateFulu, CachedBeaconStateGloas} from "../types.js";
 
 /**
  * Upgrade a state from Fulu to Gloas.
- * TODO GLOAS: Implement this
  */
 export function upgradeStateToGloas(stateFulu: CachedBeaconStateFulu): CachedBeaconStateGloas {
   const {config} = stateFulu;
 
-  const stateFuluNode = ssz.fulu.BeaconState.commitViewDU(stateFulu);
-  const stateGloasView = ssz.gloas.BeaconState.getViewDU(stateFuluNode);
+  ssz.fulu.BeaconState.commitViewDU(stateFulu);
+  const stateGloasCloned = stateFulu;
 
-  const stateGloas = getCachedBeaconState(stateGloasView, stateFulu);
+  const stateGloasView = ssz.gloas.BeaconState.defaultViewDU();
 
-  stateGloas.fork = ssz.phase0.Fork.toViewDU({
+  stateGloasView.genesisTime = stateGloasCloned.genesisTime;
+  stateGloasView.genesisValidatorsRoot = stateGloasCloned.genesisValidatorsRoot;
+  stateGloasView.slot = stateGloasCloned.slot;
+  stateGloasView.fork = ssz.phase0.Fork.toViewDU({
     previousVersion: stateFulu.fork.currentVersion,
     currentVersion: config.GLOAS_FORK_VERSION,
     epoch: stateFulu.epochCtx.epoch,
   });
+  stateGloasView.latestBlockHeader = stateGloasCloned.latestBlockHeader;
+  stateGloasView.blockRoots = stateGloasCloned.blockRoots;
+  stateGloasView.stateRoots = stateGloasCloned.stateRoots;
+  stateGloasView.historicalRoots = stateGloasCloned.historicalRoots;
+  stateGloasView.eth1Data = stateGloasCloned.eth1Data;
+  stateGloasView.eth1DataVotes = stateGloasCloned.eth1DataVotes;
+  stateGloasView.eth1DepositIndex = stateGloasCloned.eth1DepositIndex;
+  stateGloasView.validators = stateGloasCloned.validators;
+  stateGloasView.balances = stateGloasCloned.balances;
+  stateGloasView.randaoMixes = stateGloasCloned.randaoMixes;
+  stateGloasView.slashings = stateGloasCloned.slashings;
+  stateGloasView.previousEpochParticipation = stateGloasCloned.previousEpochParticipation;
+  stateGloasView.currentEpochParticipation = stateGloasCloned.currentEpochParticipation;
+  stateGloasView.justificationBits = stateGloasCloned.justificationBits;
+  stateGloasView.previousJustifiedCheckpoint = stateGloasCloned.previousJustifiedCheckpoint;
+  stateGloasView.currentJustifiedCheckpoint = stateGloasCloned.currentJustifiedCheckpoint;
+  stateGloasView.finalizedCheckpoint = stateGloasCloned.finalizedCheckpoint;
+  stateGloasView.inactivityScores = stateGloasCloned.inactivityScores;
+  stateGloasView.currentSyncCommittee = stateGloasCloned.currentSyncCommittee;
+  stateGloasView.nextSyncCommittee = stateGloasCloned.nextSyncCommittee;
+  stateGloasView.latestExecutionPayloadBid.blockHash = stateFulu.latestExecutionPayloadHeader.blockHash;
+  stateGloasView.nextWithdrawalIndex = stateGloasCloned.nextWithdrawalIndex;
+  stateGloasView.nextWithdrawalValidatorIndex = stateGloasCloned.nextWithdrawalValidatorIndex;
+  stateGloasView.historicalSummaries = stateGloasCloned.historicalSummaries;
+  stateGloasView.depositRequestsStartIndex = stateGloasCloned.depositRequestsStartIndex;
+  stateGloasView.depositBalanceToConsume = stateGloasCloned.depositBalanceToConsume;
+  stateGloasView.exitBalanceToConsume = stateGloasCloned.exitBalanceToConsume;
+  stateGloasView.earliestExitEpoch = stateGloasCloned.earliestExitEpoch;
+  stateGloasView.consolidationBalanceToConsume = stateGloasCloned.consolidationBalanceToConsume;
+  stateGloasView.earliestConsolidationEpoch = stateGloasCloned.earliestConsolidationEpoch;
+  stateGloasView.pendingDeposits = stateGloasCloned.pendingDeposits;
+  stateGloasView.pendingPartialWithdrawals = stateGloasCloned.pendingPartialWithdrawals;
+  stateGloasView.pendingConsolidations = stateGloasCloned.pendingConsolidations;
+  stateGloasView.proposerLookahead = stateGloasCloned.proposerLookahead;
+
+  for (let i = 0; i < SLOTS_PER_HISTORICAL_ROOT; i++) {
+    stateGloasView.executionPayloadAvailability.set(i, true);
+  }
+  stateGloasView.latestBlockHash = stateFulu.latestExecutionPayloadHeader.blockHash;
+
+  const stateGloas = getCachedBeaconState(stateGloasView, stateFulu);
 
   stateGloas.commit();
   // Clear cache to ensure the cache of fulu fields is not used by new gloas fields

package/src/stateTransition.ts

@@ -111,7 +111,7 @@ export function stateTransition(
   postState = processSlotsWithTransientCache(postState, blockSlot, options, {metrics, validatorMonitor});
 
   // Verify proposer signature only
-  if (verifyProposer && !verifyProposerSignature(postState, signedBlock)) {
+  if (verifyProposer && !verifyProposerSignature(postState.epochCtx.index2pubkey, postState, signedBlock)) {
     throw new Error("Invalid block signature");
   }
 
@@ -217,13 +217,13 @@ function processSlotsWithTransientCache(
   }
 
   while (postState.slot < slot) {
-    processSlot(postState);
+    const fork = postState.config.getForkSeq(postState.slot);
+    processSlot(fork, postState);
 
     // Process epoch on the first slot of the next epoch
+    // We use `fork` because at fork boundary we don't want to process
+    // "next fork" epoch before upgrading state
     if ((postState.slot + 1) % SLOTS_PER_EPOCH === 0) {
-      // At fork boundary we don't want to process "next fork" epoch before upgrading state
-      const fork = postState.config.getForkSeq(postState.slot);
-
       const epochTransitionTimer = metrics?.epochTransitionTime.startTimer();
 
       let epochTransitionCache: EpochTransitionCache;

package/src/util/electra.ts

@@ -1,11 +1,14 @@
 import {COMPOUNDING_WITHDRAWAL_PREFIX, GENESIS_SLOT, MIN_ACTIVATION_BALANCE} from "@lodestar/params";
 import {ValidatorIndex, ssz} from "@lodestar/types";
 import {G2_POINT_AT_INFINITY} from "../constants/constants.js";
-import {CachedBeaconStateElectra} from "../types.js";
+import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 import {hasEth1WithdrawalCredential} from "./capella.js";
+import {hasBuilderWithdrawalCredential} from "./gloas.ts";
 
 export function hasCompoundingWithdrawalCredential(withdrawalCredentials: Uint8Array): boolean {
-  return withdrawalCredentials[0] === COMPOUNDING_WITHDRAWAL_PREFIX;
+  return (
+    withdrawalCredentials[0] === COMPOUNDING_WITHDRAWAL_PREFIX || hasBuilderWithdrawalCredential(withdrawalCredentials)
+  );
 }
 
 export function hasExecutionWithdrawalCredential(withdrawalCredentials: Uint8Array): boolean {
@@ -14,7 +17,10 @@ export function hasExecutionWithdrawalCredential(withdrawalCredentials: Uint8Arr
   );
 }
 
-export function switchToCompoundingValidator(state: CachedBeaconStateElectra, index: ValidatorIndex): void {
+export function switchToCompoundingValidator(
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
+  index: ValidatorIndex
+): void {
   const validator = state.validators.get(index);
 
   // directly modifying the byte leads to ssz missing the modification resulting into
@@ -30,7 +36,10 @@ export function switchToCompoundingValidator(state: CachedBeaconStateElectra, in
   queueExcessActiveBalance(state, index);
 }
 
-export function queueExcessActiveBalance(state: CachedBeaconStateElectra, index: ValidatorIndex): void {
+export function queueExcessActiveBalance(
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
+  index: ValidatorIndex
+): void {
   const balance = state.balances.get(index);
   if (balance > MIN_ACTIVATION_BALANCE) {
     const validator = state.validators.getReadonly(index);
@@ -53,7 +62,7 @@ export function queueExcessActiveBalance(state: CachedBeaconStateElectra, index:
 /**
  * Since we share pubkey2index, pubkey maybe added by other epoch transition but we don't have that validator in this state
  */
-export function isPubkeyKnown(state: CachedBeaconStateElectra, pubkey: Uint8Array): boolean {
+export function isPubkeyKnown(state: CachedBeaconStateElectra | CachedBeaconStateGloas, pubkey: Uint8Array): boolean {
   return isValidatorKnown(state, state.epochCtx.getValidatorIndex(pubkey));
 }
 
@@ -61,7 +70,7 @@ export function isPubkeyKnown(state: CachedBeaconStateElectra, pubkey: Uint8Arra
  * Since we share pubkey2index, validatorIndex maybe not null but we don't have that validator in this state
  */
 export function isValidatorKnown(
-  state: CachedBeaconStateElectra,
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
   index: ValidatorIndex | null
 ): index is ValidatorIndex {
   return index !== null && index < state.validators.length;

package/src/util/epoch.ts

@@ -1,6 +1,6 @@
 import {EPOCHS_PER_SYNC_COMMITTEE_PERIOD, GENESIS_EPOCH, MAX_SEED_LOOKAHEAD, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {BeaconState, Epoch, Gwei, Slot, SyncPeriod} from "@lodestar/types";
-import {CachedBeaconStateElectra} from "../types.js";
+import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 import {getActivationExitChurnLimit, getConsolidationChurnLimit} from "./validator.js";
 
 /**
@@ -41,7 +41,10 @@ export function computeActivationExitEpoch(epoch: Epoch): Epoch {
   return epoch + 1 + MAX_SEED_LOOKAHEAD;
 }
 
-export function computeExitEpochAndUpdateChurn(state: CachedBeaconStateElectra, exitBalance: Gwei): number {
+export function computeExitEpochAndUpdateChurn(
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
+  exitBalance: Gwei
+): number {
   let earliestExitEpoch = Math.max(state.earliestExitEpoch, computeActivationExitEpoch(state.epochCtx.epoch));
   const perEpochChurn = getActivationExitChurnLimit(state.epochCtx);
 
@@ -65,7 +68,7 @@ export function computeExitEpochAndUpdateChurn(state: CachedBeaconStateElectra,
 }
 
 export function computeConsolidationEpochAndUpdateChurn(
-  state: CachedBeaconStateElectra,
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
   consolidationBalance: Gwei
 ): number {
   let earliestConsolidationEpoch = Math.max(

package/src/util/execution.ts

@@ -2,7 +2,6 @@ import {ForkName, ForkPostBellatrix, ForkPreGloas, ForkSeq} from "@lodestar/para
 import {
   BeaconBlock,
   BeaconBlockBody,
-  BlindedBeaconBlock,
   BlindedBeaconBlockBody,
   ExecutionPayload,
   ExecutionPayloadHeader,
@@ -10,75 +9,16 @@ import {
   capella,
   deneb,
   isBlindedBeaconBlockBody,
-  isExecutionPayload,
   ssz,
 } from "@lodestar/types";
 import {
   BeaconStateAllForks,
-  BeaconStateBellatrix,
   BeaconStateCapella,
   BeaconStateExecutions,
   CachedBeaconStateAllForks,
   CachedBeaconStateExecutions,
 } from "../types.js";
 
-/**
- * Execution enabled = merge is done.
- * When (A) state has execution data OR (B) block has execution data
- */
-export function isExecutionEnabled(state: BeaconStateExecutions, block: BeaconBlock | BlindedBeaconBlock): boolean {
-  if (isMergeTransitionComplete(state)) {
-    return true;
-  }
-
-  // Throws if not post-bellatrix block. A fork-guard in isExecutionEnabled() prevents this from happening
-  const payload = getFullOrBlindedPayload(block);
-  // Note: spec says to check all payload is zero-ed. However a state-root cannot be zero for any non-empty payload
-  // TODO: Consider comparing with the payload root if this assumption is not correct.
-  // return !byteArrayEquals(payload.stateRoot, ZERO_HASH);
-
-  // UPDATE: stateRoot comparision should have been enough with zero hash, but spec tests were failing
-  // Revisit this later to fix specs and make this efficient
-  return isExecutionPayload(payload)
-    ? !ssz.bellatrix.ExecutionPayload.equals(payload, ssz.bellatrix.ExecutionPayload.defaultValue())
-    : !ssz.bellatrix.ExecutionPayloadHeader.equals(
-        state.latestExecutionPayloadHeader,
-        // TODO: Performance
-        ssz.bellatrix.ExecutionPayloadHeader.defaultValue()
-      );
-}
-
-/**
- * Merge block is the SINGLE block that transitions from POW to POS.
- * state has no execution data AND this block has execution data
- */
-export function isMergeTransitionBlock(state: BeaconStateExecutions, body: bellatrix.BeaconBlockBody): boolean {
-  return (
-    !isMergeTransitionComplete(state) &&
-    !ssz.bellatrix.ExecutionPayload.equals(body.executionPayload, ssz.bellatrix.ExecutionPayload.defaultValue())
-  );
-}
-
-/**
- * Merge is complete when the state includes execution layer data:
- * state.latestExecutionPayloadHeader NOT EMPTY
- */
-export function isMergeTransitionComplete(state: BeaconStateExecutions): boolean {
-  if (!isCapellaStateType(state)) {
-    return !ssz.bellatrix.ExecutionPayloadHeader.equals(
-      (state as BeaconStateBellatrix).latestExecutionPayloadHeader,
-      // TODO: Performance
-      ssz.bellatrix.ExecutionPayloadHeader.defaultValue()
-    );
-  }
-
-  return !ssz.capella.ExecutionPayloadHeader.equals(
-    state.latestExecutionPayloadHeader,
-    // TODO: Performance
-    ssz.capella.ExecutionPayloadHeader.defaultValue()
-  );
-}
-
 /** Type guard for bellatrix.BeaconState */
 export function isExecutionStateType(state: BeaconStateAllForks): state is BeaconStateExecutions {
   return (state as BeaconStateExecutions).latestExecutionPayloadHeader !== undefined;

package/src/util/gloas.ts

@@ -0,0 +1,58 @@
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {
+  BUILDER_PAYMENT_THRESHOLD_DENOMINATOR,
+  BUILDER_PAYMENT_THRESHOLD_NUMERATOR,
+  BUILDER_WITHDRAWAL_PREFIX,
+  EFFECTIVE_BALANCE_INCREMENT,
+  SLOTS_PER_EPOCH,
+} from "@lodestar/params";
+import {gloas} from "@lodestar/types";
+import {AttestationData} from "@lodestar/types/phase0";
+import {CachedBeaconStateGloas} from "../types.ts";
+import {getBlockRootAtSlot} from "./blockRoot.ts";
+import {computeEpochAtSlot} from "./epoch.ts";
+import {RootCache} from "./rootCache.ts";
+
+export function hasBuilderWithdrawalCredential(withdrawalCredentials: Uint8Array): boolean {
+  return withdrawalCredentials[0] === BUILDER_WITHDRAWAL_PREFIX;
+}
+
+export function getBuilderPaymentQuorumThreshold(state: CachedBeaconStateGloas): number {
+  const quorum =
+    Math.floor((state.epochCtx.totalActiveBalanceIncrements * EFFECTIVE_BALANCE_INCREMENT) / SLOTS_PER_EPOCH) *
+    BUILDER_PAYMENT_THRESHOLD_NUMERATOR;
+
+  return Math.floor(quorum / BUILDER_PAYMENT_THRESHOLD_DENOMINATOR);
+}
+
+export function isBuilderPaymentWithdrawable(
+  state: CachedBeaconStateGloas,
+  withdrawal: gloas.BuilderPendingWithdrawal
+): boolean {
+  const builder = state.validators.getReadonly(withdrawal.builderIndex);
+  const currentEpoch = computeEpochAtSlot(state.slot);
+
+  return builder.withdrawableEpoch >= currentEpoch || !builder.slashed;
+}
+
+export function isAttestationSameSlot(state: CachedBeaconStateGloas, data: AttestationData): boolean {
+  if (data.slot === 0) return true;
+
+  const isMatchingBlockRoot = byteArrayEquals(data.beaconBlockRoot, getBlockRootAtSlot(state, data.slot));
+  const isCurrentBlockRoot = !byteArrayEquals(data.beaconBlockRoot, getBlockRootAtSlot(state, data.slot - 1));
+
+  return isMatchingBlockRoot && isCurrentBlockRoot;
+}
+
+export function isAttestationSameSlotRootCache(rootCache: RootCache, data: AttestationData): boolean {
+  if (data.slot === 0) return true;
+
+  const isMatchingBlockRoot = byteArrayEquals(data.beaconBlockRoot, rootCache.getBlockRootAtSlot(data.slot));
+  const isCurrentBlockRoot = !byteArrayEquals(data.beaconBlockRoot, rootCache.getBlockRootAtSlot(data.slot - 1));
+
+  return isMatchingBlockRoot && isCurrentBlockRoot;
+}
+
+export function isParentBlockFull(state: CachedBeaconStateGloas): boolean {
+  return byteArrayEquals(state.latestExecutionPayloadBid.blockHash, state.latestBlockHash);
+}

package/src/util/seed.ts

@@ -5,6 +5,7 @@ import {
 } from "@chainsafe/swap-or-not-shuffle";
 import {
   DOMAIN_BEACON_PROPOSER,
+  DOMAIN_PTC_ATTESTER,
   DOMAIN_SYNC_COMMITTEE,
   EFFECTIVE_BALANCE_INCREMENT,
   EPOCHS_PER_HISTORICAL_VECTOR,
@@ -12,6 +13,7 @@ import {
   MAX_EFFECTIVE_BALANCE,
   MAX_EFFECTIVE_BALANCE_ELECTRA,
   MIN_SEED_LOOKAHEAD,
+  PTC_SIZE,
   SHUFFLE_ROUND_COUNT,
   SLOTS_PER_EPOCH,
   SYNC_COMMITTEE_SIZE,
@@ -19,7 +21,7 @@ import {
 import {Bytes32, DomainType, Epoch, ValidatorIndex} from "@lodestar/types";
 import {assert, bytesToBigInt, bytesToInt, intToBytes} from "@lodestar/utils";
 import {EffectiveBalanceIncrements} from "../cache/effectiveBalanceIncrements.js";
-import {BeaconStateAllForks, CachedBeaconStateAllForks} from "../types.js";
+import {BeaconStateAllForks, BeaconStateGloas, CachedBeaconStateAllForks} from "../types.js";
 import {computeEpochAtSlot, computeStartSlotAtEpoch} from "./epoch.js";
 
 /**
@@ -266,6 +268,60 @@ export function getNextSyncCommitteeIndices(
   );
 }
 
+export function naiveGetPayloadTimlinessCommitteeIndices(
+  state: BeaconStateGloas,
+  shuffling: {committees: Uint32Array[][]},
+  effectiveBalanceIncrements: EffectiveBalanceIncrements,
+  epoch: Epoch
+): ValidatorIndex[][] {
+  const epochSeed = getSeed(state, epoch, DOMAIN_PTC_ATTESTER);
+  const startSlot = computeStartSlotAtEpoch(epoch);
+  const committeeIndices = [];
+
+  for (let slot = startSlot; slot < startSlot + SLOTS_PER_EPOCH; slot++) {
+    const slotCommittees = shuffling.committees[slot % SLOTS_PER_EPOCH];
+    const indices = naiveComputePayloadTimelinessCommitteeIndices(
+      effectiveBalanceIncrements,
+      slotCommittees.flatMap((c) => Array.from(c)),
+      digest(Buffer.concat([epochSeed, intToBytes(slot, 8)]))
+    );
+    committeeIndices.push(indices);
+  }
+
+  return committeeIndices;
+}
+
+export function naiveComputePayloadTimelinessCommitteeIndices(
+  effectiveBalanceIncrements: EffectiveBalanceIncrements,
+  indices: ArrayLike<ValidatorIndex>,
+  seed: Uint8Array
+): ValidatorIndex[] {
+  if (indices.length === 0) {
+    throw Error("Validator indices must not be empty");
+  }
+
+  const result = [];
+
+  const MAX_RANDOM_VALUE = 2 ** 16 - 1;
+  const MAX_EFFECTIVE_BALANCE_INCREMENT = MAX_EFFECTIVE_BALANCE_ELECTRA / EFFECTIVE_BALANCE_INCREMENT;
+
+  let i = 0;
+  while (result.length < PTC_SIZE) {
+    const candidateIndex = indices[i % indices.length];
+    const randomBytes = digest(Buffer.concat([seed, intToBytes(Math.floor(i / 16), 8, "le")]));
+    const offset = (i % 16) * 2;
+    const randomValue = bytesToInt(randomBytes.subarray(offset, offset + 2));
+
+    const effectiveBalanceIncrement = effectiveBalanceIncrements[candidateIndex];
+    if (effectiveBalanceIncrement * MAX_RANDOM_VALUE >= MAX_EFFECTIVE_BALANCE_INCREMENT * randomValue) {
+      result.push(candidateIndex);
+    }
+    i += 1;
+  }
+
+  return result;
+}
+
 /**
  * Return the shuffled validator index corresponding to ``seed`` (and ``index_count``).
  *