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

package/src/block/processExecutionPayloadBid.ts

@@ -0,0 +1,120 @@
+import {PublicKey, Signature, verify} from "@chainsafe/blst";
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {
+  DOMAIN_BEACON_BUILDER,
+  FAR_FUTURE_EPOCH,
+  ForkPostGloas,
+  MIN_ACTIVATION_BALANCE,
+  SLOTS_PER_EPOCH,
+} from "@lodestar/params";
+import {BeaconBlock, gloas, ssz} from "@lodestar/types";
+import {toHex, toRootHex} from "@lodestar/utils";
+import {G2_POINT_AT_INFINITY} from "../constants/constants.ts";
+import {CachedBeaconStateGloas} from "../types.ts";
+import {hasBuilderWithdrawalCredential} from "../util/gloas.ts";
+import {computeSigningRoot, getCurrentEpoch, getRandaoMix, isActiveValidator} from "../util/index.ts";
+
+export function processExecutionPayloadBid(state: CachedBeaconStateGloas, block: BeaconBlock<ForkPostGloas>): void {
+  const signedBid = block.body.signedExecutionPayloadBid;
+  const bid = signedBid.message;
+  const {builderIndex, value: amount} = bid;
+  const builder = state.validators.getReadonly(builderIndex);
+
+  // For self-builds, amount must be zero regardless of withdrawal credential prefix
+  if (builderIndex === block.proposerIndex) {
+    if (amount !== 0) {
+      throw Error(`Invalid execution payload bid: self-build with non-zero amount ${amount}`);
+    }
+    if (!byteArrayEquals(signedBid.signature, G2_POINT_AT_INFINITY)) {
+      throw Error("Invalid execution payload bid: self-build with non-zero signature");
+    }
+    // Non-self builds require builder withdrawal credential
+  } else {
+    if (!hasBuilderWithdrawalCredential(builder.withdrawalCredentials)) {
+      throw Error(`Invalid execution payload bid: builder ${builderIndex} does not have builder withdrawal credential`);
+    }
+
+    if (!verifyExecutionPayloadBidSignature(state, builder.pubkey, signedBid)) {
+      throw Error(`Invalid execution payload bid: invalid signature for builder ${builderIndex}`);
+    }
+  }
+
+  if (!isActiveValidator(builder, getCurrentEpoch(state))) {
+    throw Error(`Invalid execution payload bid: builder ${builderIndex} is not active`);
+  }
+
+  if (builder.slashed) {
+    throw Error(`Invalid execution payload bid: builder ${builderIndex} is slashed`);
+  }
+
+  const pendingPayments = state.builderPendingPayments
+    .getAllReadonly()
+    .filter((payment) => payment.withdrawal.builderIndex === builderIndex)
+    .reduce((acc, payment) => acc + payment.withdrawal.amount, 0);
+  const pendingWithdrawals = state.builderPendingWithdrawals
+    .getAllReadonly()
+    .filter((withdrawal) => withdrawal.builderIndex === builderIndex)
+    .reduce((acc, withdrawal) => acc + withdrawal.amount, 0);
+
+  if (
+    amount !== 0 &&
+    state.balances.get(builderIndex) < amount + pendingPayments + pendingWithdrawals + MIN_ACTIVATION_BALANCE
+  ) {
+    throw Error("Insufficient builder balance");
+  }
+
+  if (bid.slot !== block.slot) {
+    throw Error(`Bid slot ${bid.slot} does not match block slot ${block.slot}`);
+  }
+
+  if (!byteArrayEquals(bid.parentBlockHash, state.latestBlockHash)) {
+    throw Error(
+      `Parent block hash ${toRootHex(bid.parentBlockHash)} of bid does not match state's latest block hash ${toRootHex(state.latestBlockHash)}`
+    );
+  }
+
+  if (!byteArrayEquals(bid.parentBlockRoot, block.parentRoot)) {
+    throw Error(
+      `Parent block root ${toRootHex(bid.parentBlockRoot)} of bid does not match block's parent root ${toRootHex(block.parentRoot)}`
+    );
+  }
+
+  const stateRandao = getRandaoMix(state, getCurrentEpoch(state));
+  if (!byteArrayEquals(bid.prevRandao, stateRandao)) {
+    throw Error(`Prev randao ${toHex(bid.prevRandao)} of bid does not match state's randao mix ${toHex(stateRandao)}`);
+  }
+
+  if (amount > 0) {
+    const pendingPaymentView = ssz.gloas.BuilderPendingPayment.toViewDU({
+      weight: 0,
+      withdrawal: ssz.gloas.BuilderPendingWithdrawal.toViewDU({
+        feeRecipient: bid.feeRecipient,
+        amount,
+        builderIndex,
+        withdrawableEpoch: FAR_FUTURE_EPOCH,
+      }),
+    });
+
+    state.builderPendingPayments.set(SLOTS_PER_EPOCH + (bid.slot % SLOTS_PER_EPOCH), pendingPaymentView);
+  }
+
+  state.latestExecutionPayloadBid = ssz.gloas.ExecutionPayloadBid.toViewDU(bid);
+}
+
+function verifyExecutionPayloadBidSignature(
+  state: CachedBeaconStateGloas,
+  pubkey: Uint8Array,
+  signedBid: gloas.SignedExecutionPayloadBid
+): boolean {
+  const domain = state.config.getDomain(state.slot, DOMAIN_BEACON_BUILDER);
+  const signingRoot = computeSigningRoot(ssz.gloas.ExecutionPayloadBid, signedBid.message, domain);
+
+  try {
+    const publicKey = PublicKey.fromBytes(pubkey);
+    const signature = Signature.fromBytes(signedBid.signature, true);
+
+    return verify(signingRoot, publicKey, signature);
+  } catch (_e) {
+    return false; // Catch all BLS errors: failed key validation, failed signature validation, invalid signature
+  }
+}

package/src/block/processExecutionPayloadEnvelope.ts

@@ -0,0 +1,181 @@
+import {PublicKey, Signature, verify} from "@chainsafe/blst";
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {DOMAIN_BEACON_BUILDER, SLOTS_PER_EPOCH, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
+import {gloas, ssz} from "@lodestar/types";
+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";
+import {processWithdrawalRequest} from "./processWithdrawalRequest.ts";
+
+// This function does not call execution engine to verify payload. Need to call it from other place
+export function processExecutionPayloadEnvelope(
+  state: CachedBeaconStateGloas,
+  signedEnvelope: gloas.SignedExecutionPayloadEnvelope,
+  verify: boolean
+): void {
+  const envelope = signedEnvelope.message;
+  const payload = envelope.payload;
+  const fork = state.config.getForkSeq(envelope.slot);
+
+  if (verify) {
+    const builderIndex = envelope.builderIndex;
+    const pubkey = state.validators.getReadonly(builderIndex).pubkey;
+
+    if (!verifyExecutionPayloadEnvelopeSignature(state, pubkey, signedEnvelope)) {
+      throw new Error("Payload Envelope has invalid signature");
+    }
+  }
+
+  validateExecutionPayloadEnvelope(state, envelope);
+
+  const requests = envelope.executionRequests;
+
+  for (const deposit of requests.deposits) {
+    processDepositRequest(state, deposit);
+  }
+
+  for (const withdrawal of requests.withdrawals) {
+    processWithdrawalRequest(fork, state, withdrawal);
+  }
+
+  for (const consolidation of requests.consolidations) {
+    processConsolidationRequest(fork, state, consolidation);
+  }
+
+  // Queue the builder payment
+  const paymentIndex = SLOTS_PER_EPOCH + (state.slot % SLOTS_PER_EPOCH);
+  const payment = state.builderPendingPayments.get(paymentIndex).clone();
+  const amount = payment.withdrawal.amount;
+
+  if (amount > 0) {
+    const exitQueueEpoch = computeExitEpochAndUpdateChurn(state, BigInt(amount));
+
+    payment.withdrawal.withdrawableEpoch = exitQueueEpoch + state.config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY;
+    state.builderPendingWithdrawals.push(payment.withdrawal);
+  }
+
+  state.builderPendingPayments.set(paymentIndex, ssz.gloas.BuilderPendingPayment.defaultViewDU());
+
+  // Cache the execution payload hash
+  state.executionPayloadAvailability.set(state.slot % SLOTS_PER_HISTORICAL_ROOT, true);
+  state.latestBlockHash = payload.blockHash;
+
+  if (verify && !byteArrayEquals(envelope.stateRoot, state.hashTreeRoot())) {
+    throw new Error(
+      `Envelope's state root does not match state envelope=${toRootHex(envelope.stateRoot)} state=${toRootHex(state.hashTreeRoot())}`
+    );
+  }
+}
+
+function validateExecutionPayloadEnvelope(
+  state: CachedBeaconStateGloas,
+  envelope: gloas.ExecutionPayloadEnvelope
+): void {
+  const payload = envelope.payload;
+
+  if (byteArrayEquals(state.latestBlockHeader.stateRoot, ssz.Root.defaultValue())) {
+    const previousStateRoot = state.hashTreeRoot();
+    state.latestBlockHeader.stateRoot = previousStateRoot;
+  }
+
+  // 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=${toRootHex(envelope.beaconBlockRoot)} latestBlockHeader=${toRootHex(state.latestBlockHeader.hashTreeRoot())}`
+    );
+  }
+
+  // Verify consistency with the beacon block
+  if (envelope.slot !== state.slot) {
+    throw new Error(`Slot mismatch between envelope and state envelope=${envelope.slot} state=${state.slot}`);
+  }
+
+  const committedBid = state.latestExecutionPayloadBid;
+  // Verify consistency with the committed bid
+  if (envelope.builderIndex !== committedBid.builderIndex) {
+    throw new Error(
+      `Builder index mismatch between envelope and committed bid envelope=${envelope.builderIndex} committedBid=${committedBid.builderIndex}`
+    );
+  }
+
+  // Verify consistency with the committed bid
+  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=${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=${toRootHex(envelopeWithdrawalsRoot)} latestWithdrawalRoot=${toRootHex(state.latestWithdrawalsRoot)}`
+    );
+  }
+
+  // Verify the gas_limit
+  if (Number(committedBid.gasLimit) !== payload.gasLimit) {
+    throw new Error(
+      `Gas limit mismatch between envelope's payload and committed bid envelope=${payload.gasLimit} committedBid=${Number(committedBid.gasLimit)}`
+    );
+  }
+
+  // Verify the block hash
+  if (!byteArrayEquals(committedBid.blockHash, payload.blockHash)) {
+    throw new Error(
+      `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=${toRootHex(payload.parentHash)} state=${toRootHex(state.latestBlockHash)}`
+    );
+  }
+
+  // Verify prev_randao matches committed bid
+  if (!byteArrayEquals(committedBid.prevRandao, payload.prevRandao)) {
+    throw new Error(
+      `Prev randao mismatch between committed bid and payload committedBid=${toHex(committedBid.prevRandao)} payload=${toHex(payload.prevRandao)}`
+    );
+  }
+
+  // Verify timestamp
+  if (payload.timestamp !== computeTimeAtSlot(state.config, state.slot, state.genesisTime)) {
+    throw new Error(
+      `Timestamp mismatch between envelope's payload and state envelope=${payload.timestamp} state=${computeTimeAtSlot(state.config, state.slot, state.genesisTime)}`
+    );
+  }
+
+  // Verify commitments are under limit
+  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=${maxBlobsPerBlock}`
+    );
+  }
+
+  // Skipped: Verify the execution payload is valid
+}
+
+function verifyExecutionPayloadEnvelopeSignature(
+  state: CachedBeaconStateGloas,
+  pubkey: Uint8Array,
+  signedEnvelope: gloas.SignedExecutionPayloadEnvelope
+): boolean {
+  const domain = state.config.getDomain(state.slot, DOMAIN_BEACON_BUILDER);
+  const signingRoot = computeSigningRoot(ssz.gloas.ExecutionPayloadEnvelope, signedEnvelope.message, domain);
+
+  try {
+    const publicKey = PublicKey.fromBytes(pubkey);
+    const signature = Signature.fromBytes(signedEnvelope.signature, true);
+
+    return verify(signingRoot, publicKey, signature);
+  } catch (_e) {
+    return false; // Catch all BLS errors: failed key validation, failed signature validation, invalid signature
+  }
+}

package/src/block/processOperations.ts

@@ -1,7 +1,12 @@
 import {ForkSeq} from "@lodestar/params";
-import {BeaconBlockBody, capella, electra} from "@lodestar/types";
+import {BeaconBlockBody, capella, electra, gloas} from "@lodestar/types";
 import {BeaconStateTransitionMetrics} from "../metrics.js";
-import {CachedBeaconStateAllForks, CachedBeaconStateCapella, CachedBeaconStateElectra} from "../types.js";
+import {
+  CachedBeaconStateAllForks,
+  CachedBeaconStateCapella,
+  CachedBeaconStateElectra,
+  CachedBeaconStateGloas,
+} from "../types.js";
 import {getEth1DepositCount} from "../util/deposit.js";
 import {processAttestations} from "./processAttestations.js";
 import {processAttesterSlashing} from "./processAttesterSlashing.js";
@@ -9,6 +14,7 @@ import {processBlsToExecutionChange} from "./processBlsToExecutionChange.js";
 import {processConsolidationRequest} from "./processConsolidationRequest.js";
 import {processDeposit} from "./processDeposit.js";
 import {processDepositRequest} from "./processDepositRequest.js";
+import {processPayloadAttestation} from "./processPayloadAttestation.ts";
 import {processProposerSlashing} from "./processProposerSlashing.js";
 import {processVoluntaryExit} from "./processVoluntaryExit.js";
 import {processWithdrawalRequest} from "./processWithdrawalRequest.js";
@@ -64,7 +70,7 @@ export function processOperations(
     }
   }
 
-  if (fork >= ForkSeq.electra) {
+  if (fork >= ForkSeq.electra && fork < ForkSeq.gloas) {
     const stateElectra = state as CachedBeaconStateElectra;
     const bodyElectra = body as electra.BeaconBlockBody;
 
@@ -77,7 +83,13 @@ export function processOperations(
     }
 
     for (const elConsolidationRequest of bodyElectra.executionRequests.consolidations) {
-      processConsolidationRequest(stateElectra, elConsolidationRequest);
+      processConsolidationRequest(fork, stateElectra, elConsolidationRequest);
+    }
+  }
+
+  if (fork >= ForkSeq.gloas) {
+    for (const payloadAttestation of (body as gloas.BeaconBlockBody).payloadAttestations) {
+      processPayloadAttestation(state as CachedBeaconStateGloas, payloadAttestation);
     }
   }
 }

package/src/block/processPayloadAttestation.ts

@@ -0,0 +1,25 @@
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {gloas} from "@lodestar/types";
+import {CachedBeaconStateGloas} from "../types.ts";
+import {isValidIndexedPayloadAttestation} from "./isValidIndexedPayloadAttestation.ts";
+
+export function processPayloadAttestation(
+  state: CachedBeaconStateGloas,
+  payloadAttestation: gloas.PayloadAttestation
+): void {
+  const data = payloadAttestation.data;
+
+  if (!byteArrayEquals(data.beaconBlockRoot, state.latestBlockHeader.parentRoot)) {
+    throw Error("Payload attestation is referring to the wrong block");
+  }
+
+  if (data.slot + 1 !== state.slot) {
+    throw Error("Payload attestation is not from previous slot");
+  }
+
+  const indexedPayloadAttestation = state.epochCtx.getIndexedPayloadAttestation(data.slot, payloadAttestation);
+
+  if (!isValidIndexedPayloadAttestation(state, indexedPayloadAttestation, true)) {
+    throw Error("Invalid payload attestation");
+  }
+}

package/src/block/processProposerSlashing.ts

@@ -1,8 +1,8 @@
-import {ForkSeq} from "@lodestar/params";
+import {ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {phase0, ssz} from "@lodestar/types";
 import {getProposerSlashingSignatureSets} from "../signatureSets/index.js";
-import {CachedBeaconStateAllForks} from "../types.js";
-import {isSlashableValidator} from "../util/index.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateGloas} from "../types.js";
+import {computeEpochAtSlot, isSlashableValidator} from "../util/index.js";
 import {verifySignatureSet} from "../util/signatureSets.js";
 import {slashValidator} from "./slashValidator.js";
 
@@ -20,6 +20,27 @@ export function processProposerSlashing(
 ): void {
   assertValidProposerSlashing(state, proposerSlashing, verifySignatures);
 
+  if (fork >= ForkSeq.gloas) {
+    const slot = Number(proposerSlashing.signedHeader1.message.slot);
+    const proposalEpoch = computeEpochAtSlot(slot);
+    const currentEpoch = state.epochCtx.epoch;
+    const previousEpoch = currentEpoch - 1;
+
+    const paymentIndex =
+      proposalEpoch === currentEpoch
+        ? SLOTS_PER_EPOCH + (slot % SLOTS_PER_EPOCH)
+        : proposalEpoch === previousEpoch
+          ? slot % SLOTS_PER_EPOCH
+          : undefined;
+
+    if (paymentIndex !== undefined) {
+      (state as CachedBeaconStateGloas).builderPendingPayments.set(
+        paymentIndex,
+        ssz.gloas.BuilderPendingPayment.defaultViewDU()
+      );
+    }
+  }
+
   slashValidator(fork, state, proposerSlashing.signedHeader1.message.proposerIndex);
 }
 
@@ -56,7 +77,7 @@ export function assertValidProposerSlashing(
 
   // verify signatures
   if (verifySignatures) {
-    const signatureSets = getProposerSlashingSignatureSets(state, proposerSlashing);
+    const signatureSets = getProposerSlashingSignatureSets(state.epochCtx.index2pubkey, state, proposerSlashing);
     for (let i = 0; i < signatureSets.length; i++) {
       if (!verifySignatureSet(signatureSets[i])) {
         throw new Error(`ProposerSlashing header${i + 1} signature invalid`);

package/src/block/processRandao.ts

@@ -17,7 +17,7 @@ export function processRandao(state: CachedBeaconStateAllForks, block: BeaconBlo
   const randaoReveal = block.body.randaoReveal;
 
   // verify RANDAO reveal
-  if (verifySignature && !verifyRandaoSignature(state, block)) {
+  if (verifySignature && !verifyRandaoSignature(epochCtx.index2pubkey, state, block)) {
     throw new Error("RANDAO reveal is an invalid signature");
   }
 

package/src/block/processSyncCommittee.ts

@@ -1,6 +1,7 @@
 import {byteArrayEquals} from "@chainsafe/ssz";
 import {DOMAIN_SYNC_COMMITTEE, SYNC_COMMITTEE_SIZE} from "@lodestar/params";
 import {altair, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {G2_POINT_AT_INFINITY} from "../constants/index.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {
@@ -23,7 +24,7 @@ export function processSyncAggregate(
   if (verifySignatures) {
     // This is to conform to the spec - we want the signature to be verified
     const participantIndices = block.body.syncAggregate.syncCommitteeBits.intersectValues(committeeIndices);
-    const signatureSet = getSyncCommitteeSignatureSet(state, block, participantIndices);
+    const signatureSet = getSyncCommitteeSignatureSet(state.epochCtx.index2pubkey, state, block, participantIndices);
     // When there's no participation we consider the signature valid and just ignore i
     if (signatureSet !== null && !verifySignatureSet(signatureSet)) {
       throw Error("Sync committee signature invalid");
@@ -63,12 +64,12 @@ export function processSyncAggregate(
 }
 
 export function getSyncCommitteeSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   block: altair.BeaconBlock,
   /** Optional parameter to prevent computing it twice */
   participantIndices?: number[]
 ): ISignatureSet | null {
-  const {epochCtx} = state;
   const {syncAggregate} = block.body;
   const signature = syncAggregate.syncCommitteeSignature;
 
@@ -110,7 +111,7 @@ export function getSyncCommitteeSignatureSet(
 
   return {
     type: SignatureSetType.aggregate,
-    pubkeys: participantIndices.map((i) => epochCtx.index2pubkey[i]),
+    pubkeys: participantIndices.map((i) => index2pubkey[i]),
     signingRoot: computeSigningRoot(ssz.Root, rootSigned, domain),
     signature,
   };

package/src/block/processVoluntaryExit.ts

@@ -69,12 +69,12 @@ export function getVoluntaryExitValidity(
   // only exit validator if it has no pending withdrawals in the queue
   if (
     fork >= ForkSeq.electra &&
-    getPendingBalanceToWithdraw(state as CachedBeaconStateElectra, voluntaryExit.validatorIndex) !== 0
+    getPendingBalanceToWithdraw(fork, state as CachedBeaconStateElectra, voluntaryExit.validatorIndex) !== 0
   ) {
     return VoluntaryExitValidity.pendingWithdrawals;
   }
 
-  if (verifySignature && !verifyVoluntaryExitSignature(state, signedVoluntaryExit)) {
+  if (verifySignature && !verifyVoluntaryExitSignature(epochCtx.index2pubkey, state, signedVoluntaryExit)) {
     return VoluntaryExitValidity.invalidSignature;
   }
 

package/src/block/processWithdrawalRequest.ts

@@ -7,7 +7,7 @@ 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";
@@ -15,7 +15,7 @@ import {initiateValidatorExit} from "./initiateValidatorExit.js";
 
 export function processWithdrawalRequest(
   fork: ForkSeq,
-  state: CachedBeaconStateElectra,
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
   withdrawalRequest: electra.WithdrawalRequest
 ): void {
   const amount = Number(withdrawalRequest.amount);
@@ -42,7 +42,7 @@ export function processWithdrawalRequest(
   }
 
   // TODO Electra: Consider caching pendingPartialWithdrawals
-  const pendingBalanceToWithdraw = getPendingBalanceToWithdraw(state, validatorIndex);
+  const pendingBalanceToWithdraw = getPendingBalanceToWithdraw(fork, state, validatorIndex);
   const validatorBalance = state.balances.get(validatorIndex);
 
   if (isFullExitRequest) {
@@ -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));