@lodestar/state-transition 1.39.0-dev.882891d89c → 1.39.0-dev.90493ebb47

package/src/block/processAttesterSlashing.ts

@@ -1,5 +1,6 @@
+import {BeaconConfig} from "@lodestar/config";
 import {ForkSeq} from "@lodestar/params";
-import {AttesterSlashing} from "@lodestar/types";
+import {AttesterSlashing, Slot} from "@lodestar/types";
 import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {getAttesterSlashableIndices, isSlashableAttestationData, isSlashableValidator} from "../util/index.js";
@@ -19,7 +20,14 @@ export function processAttesterSlashing(
   verifySignatures = true
 ): void {
   const {epochCtx} = state;
-  assertValidAttesterSlashing(epochCtx.index2pubkey, state, attesterSlashing, verifySignatures);
+  assertValidAttesterSlashing(
+    state.config,
+    epochCtx.index2pubkey,
+    state.slot,
+    state.validators.length,
+    attesterSlashing,
+    verifySignatures
+  );
 
   const intersectingIndices = getAttesterSlashableIndices(attesterSlashing);
 
@@ -39,8 +47,10 @@ export function processAttesterSlashing(
 }
 
 export function assertValidAttesterSlashing(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  stateSlot: Slot,
+  validatorsLen: number,
   attesterSlashing: AttesterSlashing,
   verifySignatures = true
 ): void {
@@ -55,7 +65,9 @@ export function assertValidAttesterSlashing(
   // be higher than the clock and the slashing would still be valid. Same applies to attestation data index, which
   // can be any arbitrary value. Must use bigint variants to hash correctly to all possible values
   for (const [i, attestation] of [attestation1, attestation2].entries()) {
-    if (!isValidIndexedAttestationBigint(state.config, index2pubkey, state, attestation, verifySignatures)) {
+    if (
+      !isValidIndexedAttestationBigint(config, index2pubkey, stateSlot, validatorsLen, attestation, verifySignatures)
+    ) {
       throw new Error(`AttesterSlashing attestation${i} is invalid`);
     }
   }

package/src/block/processBlsToExecutionChange.ts

@@ -1,7 +1,9 @@
 import {digest} from "@chainsafe/as-sha256";
 import {byteArrayEquals} from "@chainsafe/ssz";
+import {BeaconConfig} from "@lodestar/config";
 import {BLS_WITHDRAWAL_PREFIX, ETH1_ADDRESS_WITHDRAWAL_PREFIX} from "@lodestar/params";
 import {capella} from "@lodestar/types";
+import {Validator} from "@lodestar/types/phase0";
 import {toHex} from "@lodestar/utils";
 import {verifyBlsToExecutionChangeSignature} from "../signatureSets/index.js";
 import {CachedBeaconStateCapella} from "../types.js";
@@ -12,12 +14,18 @@ export function processBlsToExecutionChange(
 ): void {
   const addressChange = signedBlsToExecutionChange.message;
 
-  const validation = isValidBlsToExecutionChange(state, signedBlsToExecutionChange, true);
+  if (addressChange.validatorIndex >= state.validators.length) {
+    throw Error(
+      `withdrawalValidatorIndex ${addressChange.validatorIndex} >= state.validators len ${state.validators.length}`
+    );
+  }
+
+  const validator = state.validators.get(addressChange.validatorIndex);
+  const validation = isValidBlsToExecutionChange(state.config, validator, signedBlsToExecutionChange, true);
   if (!validation.valid) {
     throw validation.error;
   }
 
-  const validator = state.validators.get(addressChange.validatorIndex);
   const newWithdrawalCredentials = new Uint8Array(32);
   newWithdrawalCredentials[0] = ETH1_ADDRESS_WITHDRAWAL_PREFIX;
   newWithdrawalCredentials.set(addressChange.toExecutionAddress, 12);
@@ -27,22 +35,13 @@ export function processBlsToExecutionChange(
 }
 
 export function isValidBlsToExecutionChange(
-  state: CachedBeaconStateCapella,
+  config: BeaconConfig,
+  validator: Validator,
   signedBLSToExecutionChange: capella.SignedBLSToExecutionChange,
   verifySignature = true
 ): {valid: true} | {valid: false; error: Error} {
   const addressChange = signedBLSToExecutionChange.message;
 
-  if (addressChange.validatorIndex >= state.validators.length) {
-    return {
-      valid: false,
-      error: Error(
-        `withdrawalValidatorIndex ${addressChange.validatorIndex} > state.validators len ${state.validators.length}`
-      ),
-    };
-  }
-
-  const validator = state.validators.getReadonly(addressChange.validatorIndex);
   const {withdrawalCredentials} = validator;
   if (withdrawalCredentials[0] !== BLS_WITHDRAWAL_PREFIX) {
     return {
@@ -65,7 +64,7 @@ export function isValidBlsToExecutionChange(
     };
   }
 
-  if (verifySignature && !verifyBlsToExecutionChangeSignature(state, signedBLSToExecutionChange)) {
+  if (verifySignature && !verifyBlsToExecutionChangeSignature(config, signedBLSToExecutionChange)) {
     return {
       valid: false,
       error: Error(

package/src/block/processExecutionPayload.ts

@@ -3,7 +3,11 @@ import {ForkName, ForkSeq, isForkPostDeneb} from "@lodestar/params";
 import {BeaconBlockBody, BlindedBeaconBlockBody, deneb, isExecutionPayload} from "@lodestar/types";
 import {toHex, toRootHex} from "@lodestar/utils";
 import {CachedBeaconStateBellatrix, CachedBeaconStateCapella} from "../types.js";
-import {executionPayloadToPayloadHeader, getFullOrBlindedPayloadFromBody} from "../util/execution.js";
+import {
+  executionPayloadToPayloadHeader,
+  getFullOrBlindedPayloadFromBody,
+  isMergeTransitionComplete,
+} from "../util/execution.js";
 import {computeEpochAtSlot, computeTimeAtSlot, getRandaoMix} from "../util/index.js";
 import {BlockExternalData, ExecutionPayloadStatus} from "./externalData.js";
 
@@ -17,13 +21,15 @@ export function processExecutionPayload(
   const forkName = ForkName[ForkSeq[fork] as ForkName];
   // Verify consistency of the parent hash, block number, base fee per gas and gas limit
   // with respect to the previous execution payload header
-  const {latestExecutionPayloadHeader} = state;
-  if (!byteArrayEquals(payload.parentHash, latestExecutionPayloadHeader.blockHash)) {
-    throw Error(
-      `Invalid execution payload parentHash ${toRootHex(payload.parentHash)} latest blockHash ${toRootHex(
-        latestExecutionPayloadHeader.blockHash
-      )}`
-    );
+  if (isMergeTransitionComplete(state)) {
+    const {latestExecutionPayloadHeader} = state;
+    if (!byteArrayEquals(payload.parentHash, latestExecutionPayloadHeader.blockHash)) {
+      throw Error(
+        `Invalid execution payload parentHash ${toRootHex(payload.parentHash)} latest blockHash ${toRootHex(
+          latestExecutionPayloadHeader.blockHash
+        )}`
+      );
+    }
   }
 
   // Verify random

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,19 +84,15 @@ 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,
-      proposerSlashing
-    );
+    const signatureSets = getProposerSlashingSignatureSets(config, index2pubkey, stateSlot, 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

@@ -12,12 +12,12 @@ import {getRandaoMix} from "../util/index.js";
  * PERF: Fixed work independent of block contents.
  */
 export function processRandao(state: CachedBeaconStateAllForks, block: BeaconBlock, verifySignature = true): void {
-  const {epochCtx} = state;
+  const {epochCtx, config} = state;
   const epoch = epochCtx.epoch;
   const randaoReveal = block.body.randaoReveal;
 
   // verify RANDAO reveal
-  if (verifySignature && !verifyRandaoSignature(state.config, epochCtx.index2pubkey, state, block)) {
+  if (verifySignature && !verifyRandaoSignature(config, epochCtx.index2pubkey, block)) {
     throw new Error("RANDAO reveal is an invalid signature");
   }
 

package/src/block/processSyncCommittee.ts

@@ -3,6 +3,7 @@ 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";
 import {
@@ -28,7 +29,7 @@ export function processSyncAggregate(
     const signatureSet = getSyncCommitteeSignatureSet(
       state.config,
       state.epochCtx.index2pubkey,
-      state,
+      state.epochCtx.currentSyncCommitteeIndexed,
       block,
       participantIndices
     );
@@ -73,7 +74,7 @@ export function processSyncAggregate(
 export function getSyncCommitteeSignatureSet(
   config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  currentSyncCommitteeIndexed: SyncCommitteeCache,
   block: altair.BeaconBlock,
   /** Optional parameter to prevent computing it twice */
   participantIndices?: number[]
@@ -101,7 +102,7 @@ export function getSyncCommitteeSignatureSet(
   const rootSigned = block.parentRoot;
 
   if (!participantIndices) {
-    const committeeIndices = state.epochCtx.currentSyncCommitteeIndexed.validatorIndices;
+    const committeeIndices = currentSyncCommitteeIndexed.validatorIndices;
     participantIndices = syncAggregate.syncCommitteeBits.intersectValues(committeeIndices);
   }
 
@@ -115,7 +116,9 @@ export function getSyncCommitteeSignatureSet(
     throw Error("Empty sync committee signature is not infinity");
   }
 
-  const domain = config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE, previousSlot);
+  // the getDomain() api requires the state slot as 1st param, however it's the same to block.slot in state-transition
+  // and the same epoch when we verify blocks in batch in beacon-node. So we can safely use block.slot here.
+  const domain = config.getDomain(block.slot, DOMAIN_SYNC_COMMITTEE, previousSlot);
 
   return {
     type: SignatureSetType.aggregate,

package/src/block/processVoluntaryExit.ts

@@ -76,7 +76,7 @@ export function getVoluntaryExitValidity(
 
   if (
     verifySignature &&
-    !verifyVoluntaryExitSignature(state.config, epochCtx.index2pubkey, state, signedVoluntaryExit)
+    !verifyVoluntaryExitSignature(state.config, epochCtx.index2pubkey, state.slot, signedVoluntaryExit)
   ) {
     return VoluntaryExitValidity.invalidSignature;
   }