@lodestar/state-transition 1.39.1 → 1.40.0-dev.1020f27ca9

package/src/block/processExecutionPayloadEnvelope.ts

@@ -1,10 +1,15 @@
 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 {
+  BUILDER_INDEX_SELF_BUILD,
+  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 {computeSigningRoot, computeTimeAtSlot} from "../util/index.ts";
 import {processConsolidationRequest} from "./processConsolidationRequest.ts";
 import {processDepositRequest} from "./processDepositRequest.ts";
 import {processWithdrawalRequest} from "./processWithdrawalRequest.ts";
@@ -19,13 +24,8 @@ export function processExecutionPayloadEnvelope(
   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");
-    }
+  if (verify && !verifyExecutionPayloadEnvelopeSignature(state, signedEnvelope)) {
+    throw Error(`Execution payload envelope has invalid signature builderIndex=${envelope.builderIndex}`);
   }
 
   validateExecutionPayloadEnvelope(state, envelope);
@@ -33,7 +33,7 @@ export function processExecutionPayloadEnvelope(
   const requests = envelope.executionRequests;
 
   for (const deposit of requests.deposits) {
-    processDepositRequest(state, deposit);
+    processDepositRequest(fork, state, deposit);
   }
 
   for (const withdrawal of requests.withdrawals) {
@@ -41,7 +41,7 @@ export function processExecutionPayloadEnvelope(
   }
 
   for (const consolidation of requests.consolidations) {
-    processConsolidationRequest(fork, state, consolidation);
+    processConsolidationRequest(state, consolidation);
   }
 
   // Queue the builder payment
@@ -50,9 +50,6 @@ export function processExecutionPayloadEnvelope(
   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);
   }
 
@@ -75,6 +72,7 @@ function validateExecutionPayloadEnvelope(
 ): void {
   const payload = envelope.payload;
 
+  // Cache latest block header state root
   if (byteArrayEquals(state.latestBlockHeader.stateRoot, ssz.Root.defaultValue())) {
     const previousStateRoot = state.hashTreeRoot();
     state.latestBlockHeader.stateRoot = previousStateRoot;
@@ -87,20 +85,18 @@ function validateExecutionPayloadEnvelope(
     );
   }
 
-  // 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
+  const committedBid = state.latestExecutionPayloadBid;
   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(
@@ -108,11 +104,18 @@ function validateExecutionPayloadEnvelope(
     );
   }
 
-  // Verify the withdrawals root
-  const envelopeWithdrawalsRoot = ssz.capella.Withdrawals.hashTreeRoot(envelope.payload.withdrawals);
-  if (!byteArrayEquals(state.latestWithdrawalsRoot, envelopeWithdrawalsRoot)) {
+  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 consistency with expected withdrawals
+  const payloadWithdrawalsRoot = ssz.capella.Withdrawals.hashTreeRoot(payload.withdrawals);
+  const expectedWithdrawalsRoot = state.payloadExpectedWithdrawals.hashTreeRoot();
+  if (!byteArrayEquals(payloadWithdrawalsRoot, expectedWithdrawalsRoot)) {
     throw new Error(
-      `Withdrawals root mismatch between envelope and latest withdrawals root envelope=${toRootHex(envelopeWithdrawalsRoot)} latestWithdrawalRoot=${toRootHex(state.latestWithdrawalsRoot)}`
+      `Withdrawals mismatch between payload and expected withdrawals payload=${toRootHex(payloadWithdrawalsRoot)} expected=${toRootHex(expectedWithdrawalsRoot)}`
     );
   }
 
@@ -137,13 +140,6 @@ function validateExecutionPayloadEnvelope(
     );
   }
 
-  // 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(
@@ -164,14 +160,22 @@ function validateExecutionPayloadEnvelope(
 
 function verifyExecutionPayloadEnvelopeSignature(
   state: CachedBeaconStateGloas,
-  pubkey: Uint8Array,
   signedEnvelope: gloas.SignedExecutionPayloadEnvelope
 ): boolean {
+  const builderIndex = signedEnvelope.message.builderIndex;
+
   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);
+    let publicKey: PublicKey;
+
+    if (builderIndex === BUILDER_INDEX_SELF_BUILD) {
+      const validatorIndex = state.latestBlockHeader.proposerIndex;
+      publicKey = state.epochCtx.index2pubkey[validatorIndex];
+    } else {
+      publicKey = PublicKey.fromBytes(state.builders.getReadonly(builderIndex).pubkey);
+    }
     const signature = Signature.fromBytes(signedEnvelope.signature, true);
 
     return verify(signingRoot, publicKey, signature);

package/src/block/processOperations.ts

@@ -75,7 +75,7 @@ export function processOperations(
     const bodyElectra = body as electra.BeaconBlockBody;
 
     for (const depositRequest of bodyElectra.executionRequests.deposits) {
-      processDepositRequest(stateElectra, depositRequest);
+      processDepositRequest(fork, stateElectra, depositRequest);
     }
 
     for (const elWithdrawalRequest of bodyElectra.executionRequests.withdrawals) {
@@ -83,7 +83,7 @@ export function processOperations(
     }
 
     for (const elConsolidationRequest of bodyElectra.executionRequests.consolidations) {
-      processConsolidationRequest(fork, stateElectra, elConsolidationRequest);
+      processConsolidationRequest(stateElectra, elConsolidationRequest);
     }
   }
 

package/src/block/processProposerSlashing.ts

@@ -1,5 +1,8 @@
+import {BeaconConfig} from "@lodestar/config";
 import {ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
-import {phase0, ssz} from "@lodestar/types";
+import {Slot, phase0, ssz} from "@lodestar/types";
+import {Validator} from "@lodestar/types/phase0";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {getProposerSlashingSignatureSets} from "../signatureSets/index.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateGloas} from "../types.js";
 import {computeEpochAtSlot, isSlashableValidator} from "../util/index.js";
@@ -18,7 +21,15 @@ export function processProposerSlashing(
   proposerSlashing: phase0.ProposerSlashing,
   verifySignatures = true
 ): void {
-  assertValidProposerSlashing(state, proposerSlashing, verifySignatures);
+  const proposer = state.validators.getReadonly(proposerSlashing.signedHeader1.message.proposerIndex);
+  assertValidProposerSlashing(
+    state.config,
+    state.epochCtx.index2pubkey,
+    state.slot,
+    proposerSlashing,
+    proposer,
+    verifySignatures
+  );
 
   if (fork >= ForkSeq.gloas) {
     const slot = Number(proposerSlashing.signedHeader1.message.slot);
@@ -45,8 +56,11 @@ export function processProposerSlashing(
 }
 
 export function assertValidProposerSlashing(
-  state: CachedBeaconStateAllForks,
+  config: BeaconConfig,
+  index2pubkey: Index2PubkeyCache,
+  stateSlot: Slot,
   proposerSlashing: phase0.ProposerSlashing,
+  proposer: Validator,
   verifySignatures = true
 ): void {
   const header1 = proposerSlashing.signedHeader1.message;
@@ -70,21 +84,17 @@ export function assertValidProposerSlashing(
   }
 
   // verify the proposer is slashable
-  const proposer = state.validators.getReadonly(header1.proposerIndex);
-  if (!isSlashableValidator(proposer, state.epochCtx.epoch)) {
+  // ideally we would get the proposer from state.validators using proposerIndex but that requires access to state
+  // instead of that we pass in the proposer directly from the consumer side
+  if (!isSlashableValidator(proposer, computeEpochAtSlot(stateSlot))) {
     throw new Error("ProposerSlashing proposer is not slashable");
   }
 
   // verify signatures
   if (verifySignatures) {
-    const signatureSets = getProposerSlashingSignatureSets(
-      state.config,
-      state.epochCtx.index2pubkey,
-      state.slot,
-      proposerSlashing
-    );
+    const signatureSets = getProposerSlashingSignatureSets(config, stateSlot, proposerSlashing);
     for (let i = 0; i < signatureSets.length; i++) {
-      if (!verifySignatureSet(signatureSets[i])) {
+      if (!verifySignatureSet(signatureSets[i], index2pubkey)) {
         throw new Error(`ProposerSlashing header${i + 1} signature invalid`);
       }
     }

package/src/block/processSyncCommittee.ts

@@ -2,7 +2,6 @@ import {byteArrayEquals} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_SYNC_COMMITTEE, SYNC_COMMITTEE_SIZE} from "@lodestar/params";
 import {altair, ssz} from "@lodestar/types";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {SyncCommitteeCache} from "../cache/syncCommitteeCache.js";
 import {G2_POINT_AT_INFINITY} from "../constants/index.js";
 import {CachedBeaconStateAllForks} from "../types.js";
@@ -28,13 +27,12 @@ export function processSyncAggregate(
     const participantIndices = block.body.syncAggregate.syncCommitteeBits.intersectValues(committeeIndices);
     const signatureSet = getSyncCommitteeSignatureSet(
       state.config,
-      state.epochCtx.index2pubkey,
       state.epochCtx.currentSyncCommitteeIndexed,
       block,
       participantIndices
     );
-    // When there's no participation we consider the signature valid and just ignore i
-    if (signatureSet !== null && !verifySignatureSet(signatureSet)) {
+    // When there's no participation we consider the signature valid and just ignore it
+    if (signatureSet !== null && !verifySignatureSet(signatureSet, state.epochCtx.index2pubkey)) {
       throw Error("Sync committee signature invalid");
     }
   }
@@ -73,7 +71,6 @@ export function processSyncAggregate(
 
 export function getSyncCommitteeSignatureSet(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   currentSyncCommitteeIndexed: SyncCommitteeCache,
   block: altair.BeaconBlock,
   /** Optional parameter to prevent computing it twice */
@@ -122,7 +119,7 @@ export function getSyncCommitteeSignatureSet(
 
   return {
     type: SignatureSetType.aggregate,
-    pubkeys: participantIndices.map((i) => index2pubkey[i]),
+    indices: participantIndices,
     signingRoot: computeSigningRoot(ssz.Root, rootSigned, domain),
     signature,
   };

package/src/block/processVoluntaryExit.ts

@@ -1,8 +1,16 @@
+import {PublicKey, Signature, verify} from "@chainsafe/blst";
 import {FAR_FUTURE_EPOCH, ForkSeq} from "@lodestar/params";
-import {phase0} from "@lodestar/types";
+import {phase0, ssz} from "@lodestar/types";
 import {verifyVoluntaryExitSignature} from "../signatureSets/index.js";
-import {CachedBeaconStateAllForks, CachedBeaconStateElectra} from "../types.js";
-import {getPendingBalanceToWithdraw, isActiveValidator} from "../util/index.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
+import {
+  convertValidatorIndexToBuilderIndex,
+  getPendingBalanceToWithdrawForBuilder,
+  initiateBuilderExit,
+  isActiveBuilder,
+  isBuilderIndex,
+} from "../util/gloas.js";
+import {computeSigningRoot, getCurrentEpoch, getPendingBalanceToWithdraw, isActiveValidator} from "../util/index.js";
 import {initiateValidatorExit} from "./index.js";
 
 export enum VoluntaryExitValidity {
@@ -16,7 +24,7 @@ export enum VoluntaryExitValidity {
 }
 
 /**
- * Process a VoluntaryExit operation. Initiates the exit of a validator.
+ * Process a VoluntaryExit operation. Initiates the exit of a validator or builder.
  *
  * PERF: Work depends on number of VoluntaryExit per block. On regular networks the average is 0 / block.
  */
@@ -26,6 +34,53 @@ export function processVoluntaryExit(
   signedVoluntaryExit: phase0.SignedVoluntaryExit,
   verifySignature = true
 ): void {
+  const voluntaryExit = signedVoluntaryExit.message;
+  const currentEpoch = getCurrentEpoch(state);
+
+  // Exits must specify an epoch when they become valid; they are not valid before then
+  if (currentEpoch < voluntaryExit.epoch) {
+    throw Error(`Voluntary exit epoch ${voluntaryExit.epoch} is after current epoch ${currentEpoch}`);
+  }
+
+  // Check if this is a builder exit
+  if (fork >= ForkSeq.gloas && isBuilderIndex(voluntaryExit.validatorIndex)) {
+    const stateGloas = state as CachedBeaconStateGloas;
+    const builderIndex = convertValidatorIndexToBuilderIndex(voluntaryExit.validatorIndex);
+    const builder = stateGloas.builders.getReadonly(builderIndex);
+
+    // Verify the builder is active
+    if (!isActiveBuilder(builder, state.finalizedCheckpoint.epoch)) {
+      throw Error(`Builder ${builderIndex} is not active`);
+    }
+
+    // Only exit builder if it has no pending withdrawals in the queue
+    if (getPendingBalanceToWithdrawForBuilder(stateGloas, builderIndex) !== 0) {
+      throw Error(`Builder ${builderIndex} has pending withdrawals`);
+    }
+
+    // Verify signature
+    if (verifySignature) {
+      const domain = state.config.getDomainForVoluntaryExit(state.slot);
+      const signingRoot = computeSigningRoot(ssz.phase0.VoluntaryExit, voluntaryExit, domain);
+
+      try {
+        const publicKey = PublicKey.fromBytes(builder.pubkey);
+        const signature = Signature.fromBytes(signedVoluntaryExit.signature, true);
+
+        if (!verify(signingRoot, publicKey, signature)) {
+          throw Error("BLS verify failed");
+        }
+      } catch (e) {
+        throw Error(`Builder ${builderIndex} invalid exit signature reason=${(e as Error).message}`);
+      }
+    }
+
+    // Initiate builder exit
+    initiateBuilderExit(stateGloas, builderIndex);
+    return;
+  }
+
+  // Handle validator exit
   const validity = getVoluntaryExitValidity(fork, state, signedVoluntaryExit, verifySignature);
   if (validity !== VoluntaryExitValidity.valid) {
     throw Error(`Invalid voluntary exit at forkSeq=${fork} reason=${validity}`);
@@ -69,7 +124,7 @@ export function getVoluntaryExitValidity(
   // only exit validator if it has no pending withdrawals in the queue
   if (
     fork >= ForkSeq.electra &&
-    getPendingBalanceToWithdraw(fork, state as CachedBeaconStateElectra, voluntaryExit.validatorIndex) !== 0
+    getPendingBalanceToWithdraw(state as CachedBeaconStateElectra, voluntaryExit.validatorIndex) !== 0
   ) {
     return VoluntaryExitValidity.pendingWithdrawals;
   }

package/src/block/processWithdrawalRequest.ts

@@ -42,7 +42,7 @@ export function processWithdrawalRequest(
   }
 
   // TODO Electra: Consider caching pendingPartialWithdrawals
-  const pendingBalanceToWithdraw = getPendingBalanceToWithdraw(fork, state, validatorIndex);
+  const pendingBalanceToWithdraw = getPendingBalanceToWithdraw(state, validatorIndex);
   const validatorBalance = state.balances.get(validatorIndex);
 
   if (isFullExitRequest) {