chore: review epbs state transition changes (part 2)

packages/state-transition/src/block/index.ts

@@ -1,5 +1,5 @@
-import {ForkSeq} from "@lodestar/params";
-import {BeaconBlock, BlindedBeaconBlock, altair, capella, gloas} from "@lodestar/types";
+import {ForkPostGloas, ForkSeq} from "@lodestar/params";
+import {BeaconBlock, BlindedBeaconBlock, altair, capella} from "@lodestar/types";
 import {BeaconStateTransitionMetrics} from "../metrics.js";
 import {
   CachedBeaconStateAllForks,
@@ -76,7 +76,7 @@ export function processBlock(
   }
 
   if (fork >= ForkSeq.gloas) {
-    processExecutionPayloadBid(state as CachedBeaconStateGloas, block as gloas.BeaconBlock);
+    processExecutionPayloadBid(state as CachedBeaconStateGloas, block as BeaconBlock<ForkPostGloas>);
   }
 
   processRandao(state, block, verifySignatures);

packages/state-transition/src/block/processConsolidationRequest.ts

@@ -1,6 +1,6 @@
 import {FAR_FUTURE_EPOCH, ForkSeq, MIN_ACTIVATION_BALANCE, PENDING_CONSOLIDATIONS_LIMIT} from "@lodestar/params";
 import {electra, ssz} from "@lodestar/types";
-import {CachedBeaconStateElectra} from "../types.js";
+import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 import {hasEth1WithdrawalCredential} from "../util/capella.js";
 import {
   hasCompoundingWithdrawalCredential,
@@ -14,7 +14,7 @@ import {getConsolidationChurnLimit, getPendingBalanceToWithdraw, isActiveValidat
 // TODO Electra: Clean up necessary as there is a lot of overlap with isValidSwitchToCompoundRequest
 export function processConsolidationRequest(
   fork: ForkSeq,
-  state: CachedBeaconStateElectra,
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
   consolidationRequest: electra.ConsolidationRequest
 ): void {
   const {sourcePubkey, targetPubkey, sourceAddress} = consolidationRequest;
@@ -104,7 +104,7 @@ export function processConsolidationRequest(
  * Determine if we should set consolidation target validator to compounding credential
  */
 function isValidSwitchToCompoundRequest(
-  state: CachedBeaconStateElectra,
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
   consolidationRequest: electra.ConsolidationRequest
 ): boolean {
   const {sourcePubkey, targetPubkey, sourceAddress} = consolidationRequest;

packages/state-transition/src/block/processDepositRequest.ts

@@ -1,8 +1,11 @@
 import {UNSET_DEPOSIT_REQUESTS_START_INDEX} from "@lodestar/params";
 import {electra, ssz} from "@lodestar/types";
-import {CachedBeaconStateElectra} from "../types.js";
+import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 
-export function processDepositRequest(state: CachedBeaconStateElectra, depositRequest: electra.DepositRequest): void {
+export function processDepositRequest(
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
+  depositRequest: electra.DepositRequest
+): void {
   if (state.depositRequestsStartIndex === UNSET_DEPOSIT_REQUESTS_START_INDEX) {
     state.depositRequestsStartIndex = depositRequest.index;
   }

packages/state-transition/src/block/processExecutionPayloadBid.ts

@@ -98,9 +98,7 @@ export function processExecutionPayloadBid(state: CachedBeaconStateGloas, block:
     state.builderPendingPayments.set(SLOTS_PER_EPOCH + (bid.slot % SLOTS_PER_EPOCH), pendingPaymentView);
   }
 
-  state.latestExecutionPayloadBid = ssz.gloas.ExecutionPayloadBid.toViewDU({
-    ...bid,
-  });
+  state.latestExecutionPayloadBid = ssz.gloas.ExecutionPayloadBid.toViewDU(bid);
 }
 
 function verifyExecutionPayloadBidSignature(

packages/state-transition/src/block/processExecutionPayloadEnvelope.ts

@@ -1,9 +1,9 @@
 import {PublicKey, Signature, verify} from "@chainsafe/blst";
 import {byteArrayEquals} from "@chainsafe/ssz";
-import {DOMAIN_BEACON_BUILDER, ForkSeq, SLOTS_PER_EPOCH, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
+import {DOMAIN_BEACON_BUILDER, SLOTS_PER_EPOCH, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
 import {gloas, ssz} from "@lodestar/types";
-import {toHex} from "@lodestar/utils";
-import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.ts";
+import {toHex, toRootHex} from "@lodestar/utils";
+import {CachedBeaconStateGloas} from "../types.ts";
 import {computeExitEpochAndUpdateChurn, computeSigningRoot, computeTimeAtSlot} from "../util/index.ts";
 import {processConsolidationRequest} from "./processConsolidationRequest.ts";
 import {processDepositRequest} from "./processDepositRequest.ts";
@@ -17,6 +17,7 @@ export function processExecutionPayloadEnvelope(
 ): void {
   const envelope = signedEnvelope.message;
   const payload = envelope.payload;
+  const fork = state.config.getForkSeq(envelope.slot);
 
   if (verify) {
     const builderIndex = envelope.builderIndex;
@@ -32,18 +33,15 @@ export function processExecutionPayloadEnvelope(
   const requests = envelope.executionRequests;
 
   for (const deposit of requests.deposits) {
-    // TODO GLOAS: Fix type or properly cast it to the correct state type
-    processDepositRequest(state as unknown as CachedBeaconStateElectra, deposit);
+    processDepositRequest(state, deposit);
   }
 
   for (const withdrawal of requests.withdrawals) {
-    // TODO GLOAS: Fix type or properly cast it to the correct state type
-    processWithdrawalRequest(ForkSeq.gloas, state as unknown as CachedBeaconStateElectra, withdrawal);
+    processWithdrawalRequest(fork, state, withdrawal);
   }
 
   for (const consolidation of requests.consolidations) {
-    // TODO GLOAS: Fix type or properly cast it to the correct state type
-    processConsolidationRequest(ForkSeq.gloas, state as unknown as CachedBeaconStateElectra, consolidation);
+    processConsolidationRequest(fork, state, consolidation);
   }
 
   // Queue the builder payment
@@ -66,7 +64,7 @@ export function processExecutionPayloadEnvelope(
 
   if (verify && !byteArrayEquals(envelope.stateRoot, state.hashTreeRoot())) {
     throw new Error(
-      `Envelope's state root does not match state envelope=${envelope.stateRoot} state=${state.hashTreeRoot()}`
+      `Envelope's state root does not match state envelope=${toRootHex(envelope.stateRoot)} state=${toRootHex(state.hashTreeRoot())}`
     );
   }
 }
@@ -85,7 +83,7 @@ function validateExecutionPayloadEnvelope(
   // Verify consistency with the beacon block
   if (!byteArrayEquals(envelope.beaconBlockRoot, state.latestBlockHeader.hashTreeRoot())) {
     throw new Error(
-      `Envelope's block is not the latest block header envelope=${toHex(envelope.beaconBlockRoot)} latestBlockHeader=${toHex(state.latestBlockHeader.hashTreeRoot())}`
+      `Envelope's block is not the latest block header envelope=${toRootHex(envelope.beaconBlockRoot)} latestBlockHeader=${toRootHex(state.latestBlockHeader.hashTreeRoot())}`
     );
   }
 
@@ -106,15 +104,15 @@ function validateExecutionPayloadEnvelope(
   const envelopeKzgRoot = ssz.deneb.BlobKzgCommitments.hashTreeRoot(envelope.blobKzgCommitments);
   if (!byteArrayEquals(committedBid.blobKzgCommitmentsRoot, envelopeKzgRoot)) {
     throw new Error(
-      `Kzg commitment root mismatch between envelope and committed bid envelope=${toHex(envelopeKzgRoot)} committedBid=${toHex(committedBid.blobKzgCommitmentsRoot)}`
+      `Kzg commitment root mismatch between envelope and committed bid envelope=${toRootHex(envelopeKzgRoot)} committedBid=${toRootHex(committedBid.blobKzgCommitmentsRoot)}`
     );
   }
 
   // Verify the withdrawals root
   const envelopeWithdrawalsRoot = ssz.capella.Withdrawals.hashTreeRoot(envelope.payload.withdrawals);
   if (!byteArrayEquals(state.latestWithdrawalsRoot, envelopeWithdrawalsRoot)) {
     throw new Error(
-      `Withdrawals root mismatch between envelope and latest withdrawals root envelope=${toHex(envelopeWithdrawalsRoot)} latestWithdrawalRoot=${toHex(state.latestWithdrawalsRoot)}`
+      `Withdrawals root mismatch between envelope and latest withdrawals root envelope=${toRootHex(envelopeWithdrawalsRoot)} latestWithdrawalRoot=${toRootHex(state.latestWithdrawalsRoot)}`
     );
   }
 
@@ -128,14 +126,14 @@ function validateExecutionPayloadEnvelope(
   // Verify the block hash
   if (!byteArrayEquals(committedBid.blockHash, payload.blockHash)) {
     throw new Error(
-      `Block hash mismatch between envelope's payload and committed bid envelope=${toHex(payload.blockHash)} committedBid=${toHex(committedBid.blockHash)}`
+      `Block hash mismatch between envelope's payload and committed bid envelope=${toRootHex(payload.blockHash)} committedBid=${toRootHex(committedBid.blockHash)}`
     );
   }
 
   // Verify consistency of the parent hash with respect to the previous execution payload
   if (!byteArrayEquals(payload.parentHash, state.latestBlockHash)) {
     throw new Error(
-      `Parent hash mismatch between envelope's payload and state envelope=${toHex(payload.parentHash)} state=${toHex(state.latestBlockHash)}`
+      `Parent hash mismatch between envelope's payload and state envelope=${toRootHex(payload.parentHash)} state=${toRootHex(state.latestBlockHash)}`
     );
   }
 
@@ -154,9 +152,10 @@ function validateExecutionPayloadEnvelope(
   }
 
   // Verify commitments are under limit
-  if (envelope.blobKzgCommitments.length > state.config.getMaxBlobsPerBlock(state.epochCtx.epoch)) {
+  const maxBlobsPerBlock = state.config.getMaxBlobsPerBlock(state.epochCtx.epoch);
+  if (envelope.blobKzgCommitments.length > maxBlobsPerBlock) {
     throw new Error(
-      `Kzg commitments exceed limit commitment.length=${envelope.blobKzgCommitments.length} limit=${state.config.getBlobParameters(state.epochCtx.epoch).maxBlobsPerBlock}`
+      `Kzg commitments exceed limit commitment.length=${envelope.blobKzgCommitments.length} limit=${maxBlobsPerBlock}`
     );
   }
 

packages/state-transition/src/block/processWithdrawalRequest.ts

@@ -7,15 +7,15 @@ import {
 } from "@lodestar/params";
 import {electra, phase0, ssz} from "@lodestar/types";
 import {toHex} from "@lodestar/utils";
-import {CachedBeaconStateElectra} from "../types.js";
+import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 import {hasCompoundingWithdrawalCredential, hasExecutionWithdrawalCredential} from "../util/electra.js";
 import {computeExitEpochAndUpdateChurn} from "../util/epoch.js";
 import {getPendingBalanceToWithdraw, isActiveValidator} from "../util/validator.js";
 import {initiateValidatorExit} from "./initiateValidatorExit.js";
 
 export function processWithdrawalRequest(
   fork: ForkSeq,
-  state: CachedBeaconStateElectra,
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
   withdrawalRequest: electra.WithdrawalRequest
 ): void {
   const amount = Number(withdrawalRequest.amount);
@@ -81,7 +81,7 @@ export function processWithdrawalRequest(
 function isValidatorEligibleForWithdrawOrExit(
   validator: phase0.Validator,
   sourceAddress: Uint8Array,
-  state: CachedBeaconStateElectra
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas
 ): boolean {
   const {withdrawalCredentials} = validator;
   const addressStr = toHex(withdrawalCredentials.subarray(12));

packages/state-transition/src/block/processWithdrawals.ts

@@ -155,7 +155,7 @@ export function getExpectedWithdrawals(
         ? allBuilderPendingWithdrawals[i]
         : stateGloas.builderPendingWithdrawals.getReadonly(i);
 
-      if (withdrawal.withdrawableEpoch > epoch || withdrawals.length === MAX_WITHDRAWALS_PER_PAYLOAD) {
+      if (withdrawal.withdrawableEpoch > epoch || withdrawals.length + 1 === MAX_WITHDRAWALS_PER_PAYLOAD) {
         break;
       }
 
@@ -173,14 +173,16 @@ export function getExpectedWithdrawals(
             balance - MIN_ACTIVATION_BALANCE < withdrawal.amount ? balance - MIN_ACTIVATION_BALANCE : withdrawal.amount;
         }
 
-        withdrawals.push({
-          index: withdrawalIndex,
-          validatorIndex: withdrawal.builderIndex,
-          address: withdrawal.feeRecipient,
-          amount: BigInt(withdrawableBalance),
-        });
-        withdrawalIndex++;
-        withdrawnBalances.set(withdrawal.builderIndex, totalWithdrawn + withdrawableBalance);
+        if (withdrawableBalance > 0) {
+          withdrawals.push({
+            index: withdrawalIndex,
+            validatorIndex: withdrawal.builderIndex,
+            address: withdrawal.feeRecipient,
+            amount: BigInt(withdrawableBalance),
+          });
+          withdrawalIndex++;
+          withdrawnBalances.set(withdrawal.builderIndex, totalWithdrawn + withdrawableBalance);
+        }
       }
       processedBuilderWithdrawalsCount++;
     }

packages/state-transition/src/epoch/index.ts

@@ -158,6 +158,14 @@ export function processEpoch(
     }
   }
 
+  if (fork >= ForkSeq.gloas) {
+    const timer = metrics?.epochTransitionStepTime.startTimer({
+      step: EpochTransitionStep.processBuilderPendingPayments,
+    });
+    processBuilderPendingPayments(state as CachedBeaconStateGloas);
+    timer?.();
+  }
+
   {
     const timer = metrics?.epochTransitionStepTime.startTimer({
       step: EpochTransitionStep.processEffectiveBalanceUpdates,
@@ -203,12 +211,4 @@ export function processEpoch(
     processProposerLookahead(fork, state as CachedBeaconStateFulu, cache);
     timer?.();
   }
-
-  if (fork >= ForkSeq.gloas) {
-    const timer = metrics?.epochTransitionStepTime.startTimer({
-      step: EpochTransitionStep.processBuilderPendingPayments,
-    });
-    processBuilderPendingPayments(state as CachedBeaconStateGloas);
-    timer?.();
-  }
 }

packages/state-transition/src/util/electra.ts

@@ -1,7 +1,7 @@
 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";
 
@@ -17,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
@@ -33,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);
@@ -56,15 +62,15 @@ 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));
 }
 
 /**
  * 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;

packages/state-transition/src/util/epoch.ts

@@ -68,7 +68,7 @@ export function computeExitEpochAndUpdateChurn(
 }
 
 export function computeConsolidationEpochAndUpdateChurn(
-  state: CachedBeaconStateElectra,
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
   consolidationBalance: Gwei
 ): number {
   let earliestConsolidationEpoch = Math.max(

packages/state-transition/src/util/execution.ts

@@ -63,7 +63,6 @@ export function isMergeTransitionBlock(state: BeaconStateExecutions, body: bella
  * Merge is complete when the state includes execution layer data:
  * state.latestExecutionPayloadHeader NOT EMPTY
  */
-// TODO GLOAS: See if we need to update this for gloas
 export function isMergeTransitionComplete(state: BeaconStateExecutions): boolean {
   if (!isCapellaStateType(state)) {
     return !ssz.bellatrix.ExecutionPayloadHeader.equals(