@lodestar/state-transition 1.35.0-dev.98d359db41 → 1.35.0-dev.b42a298a7c

package/src/block/processExecutionPayload.ts

@@ -1,84 +0,0 @@
-import {byteArrayEquals} from "@chainsafe/ssz";
-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,
-  isMergeTransitionComplete,
-} from "../util/execution.js";
-import {computeEpochAtSlot, getRandaoMix} from "../util/index.js";
-import {BlockExternalData, ExecutionPayloadStatus} from "./externalData.js";
-
-export function processExecutionPayload(
-  fork: ForkSeq,
-  state: CachedBeaconStateBellatrix | CachedBeaconStateCapella,
-  body: BeaconBlockBody | BlindedBeaconBlockBody,
-  externalData: Omit<BlockExternalData, "dataAvailabilityStatus">
-): void {
-  const payload = getFullOrBlindedPayloadFromBody(body);
-  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
-  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
-  const expectedRandom = getRandaoMix(state, state.epochCtx.epoch);
-  if (!byteArrayEquals(payload.prevRandao, expectedRandom)) {
-    throw Error(`Invalid execution payload random ${toHex(payload.prevRandao)} expected=${toHex(expectedRandom)}`);
-  }
-
-  // Verify timestamp
-  //
-  // Note: inlined function in if statement
-  // def compute_timestamp_at_slot(state: BeaconState, slot: Slot) -> uint64:
-  //   slots_since_genesis = slot - GENESIS_SLOT
-  //   return uint64(state.genesis_time + slots_since_genesis * SECONDS_PER_SLOT)
-  if (payload.timestamp !== state.genesisTime + state.slot * state.config.SECONDS_PER_SLOT) {
-    throw Error(`Invalid timestamp ${payload.timestamp} genesisTime=${state.genesisTime} slot=${state.slot}`);
-  }
-
-  if (isForkPostDeneb(forkName)) {
-    const maxBlobsPerBlock = state.config.getMaxBlobsPerBlock(computeEpochAtSlot(state.slot));
-    const blobKzgCommitmentsLen = (body as deneb.BeaconBlockBody).blobKzgCommitments?.length ?? 0;
-    if (blobKzgCommitmentsLen > maxBlobsPerBlock) {
-      throw Error(`blobKzgCommitmentsLen of ${blobKzgCommitmentsLen} exceeds limit=${maxBlobsPerBlock}`);
-    }
-  }
-
-  // Verify the execution payload is valid
-  //
-  // if executionEngine is null, executionEngine.onPayload MUST be called after running processBlock to get the
-  // correct randao mix. Since executionEngine will be an async call in most cases it is called afterwards to keep
-  // the state transition sync
-  //
-  // Equivalent to `assert executionEngine.notifyNewPayload(payload)`
-  if (isExecutionPayload(payload)) {
-    switch (externalData.executionPayloadStatus) {
-      case ExecutionPayloadStatus.preMerge:
-        throw Error("executionPayloadStatus preMerge");
-      case ExecutionPayloadStatus.invalid:
-        throw Error("Invalid execution payload");
-      case ExecutionPayloadStatus.valid:
-        break; // ok
-    }
-  }
-
-  const payloadHeader = isExecutionPayload(payload) ? executionPayloadToPayloadHeader(fork, payload) : payload;
-
-  // TODO Deneb: Types are not happy by default. Since it's a generic type going through ViewDU
-  // transformation then into all forks compatible probably some weird intersection incompatibility happens
-  state.latestExecutionPayloadHeader = state.config
-    .getPostBellatrixForkTypes(state.slot)
-    .ExecutionPayloadHeader.toViewDU(payloadHeader) as typeof state.latestExecutionPayloadHeader;
-}

package/src/block/processOperations.ts

@@ -1,83 +0,0 @@
-import {ForkSeq} from "@lodestar/params";
-import {BeaconBlockBody, capella, electra} from "@lodestar/types";
-import {BeaconStateTransitionMetrics} from "../metrics.js";
-import {CachedBeaconStateAllForks, CachedBeaconStateCapella, CachedBeaconStateElectra} from "../types.js";
-import {getEth1DepositCount} from "../util/deposit.js";
-import {processAttestations} from "./processAttestations.js";
-import {processAttesterSlashing} from "./processAttesterSlashing.js";
-import {processBlsToExecutionChange} from "./processBlsToExecutionChange.js";
-import {processConsolidationRequest} from "./processConsolidationRequest.js";
-import {processDeposit} from "./processDeposit.js";
-import {processDepositRequest} from "./processDepositRequest.js";
-import {processProposerSlashing} from "./processProposerSlashing.js";
-import {processVoluntaryExit} from "./processVoluntaryExit.js";
-import {processWithdrawalRequest} from "./processWithdrawalRequest.js";
-import {ProcessBlockOpts} from "./types.js";
-
-export {
-  processProposerSlashing,
-  processAttesterSlashing,
-  processAttestations,
-  processDeposit,
-  processVoluntaryExit,
-  processWithdrawalRequest,
-  processBlsToExecutionChange,
-  processDepositRequest,
-  processConsolidationRequest,
-};
-
-export function processOperations(
-  fork: ForkSeq,
-  state: CachedBeaconStateAllForks,
-  body: BeaconBlockBody,
-  opts: ProcessBlockOpts = {verifySignatures: true},
-  metrics?: BeaconStateTransitionMetrics | null
-): void {
-  // verify that outstanding deposits are processed up to the maximum number of deposits
-  const maxDeposits = getEth1DepositCount(state);
-  if (body.deposits.length !== maxDeposits) {
-    throw new Error(
-      `Block contains incorrect number of deposits: depositCount=${body.deposits.length} expected=${maxDeposits}`
-    );
-  }
-
-  for (const proposerSlashing of body.proposerSlashings) {
-    processProposerSlashing(fork, state, proposerSlashing, opts.verifySignatures);
-  }
-  for (const attesterSlashing of body.attesterSlashings) {
-    processAttesterSlashing(fork, state, attesterSlashing, opts.verifySignatures);
-  }
-
-  processAttestations(fork, state, body.attestations, opts.verifySignatures, metrics);
-
-  for (const deposit of body.deposits) {
-    processDeposit(fork, state, deposit);
-  }
-
-  for (const voluntaryExit of body.voluntaryExits) {
-    processVoluntaryExit(fork, state, voluntaryExit, opts.verifySignatures);
-  }
-
-  if (fork >= ForkSeq.capella) {
-    for (const blsToExecutionChange of (body as capella.BeaconBlockBody).blsToExecutionChanges) {
-      processBlsToExecutionChange(state as CachedBeaconStateCapella, blsToExecutionChange);
-    }
-  }
-
-  if (fork >= ForkSeq.electra) {
-    const stateElectra = state as CachedBeaconStateElectra;
-    const bodyElectra = body as electra.BeaconBlockBody;
-
-    for (const depositRequest of bodyElectra.executionRequests.deposits) {
-      processDepositRequest(stateElectra, depositRequest);
-    }
-
-    for (const elWithdrawalRequest of bodyElectra.executionRequests.withdrawals) {
-      processWithdrawalRequest(fork, stateElectra, elWithdrawalRequest);
-    }
-
-    for (const elConsolidationRequest of bodyElectra.executionRequests.consolidations) {
-      processConsolidationRequest(stateElectra, elConsolidationRequest);
-    }
-  }
-}

package/src/block/processProposerSlashing.ts

@@ -1,66 +0,0 @@
-import {ForkSeq} 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 {verifySignatureSet} from "../util/signatureSets.js";
-import {slashValidator} from "./slashValidator.js";
-
-/**
- * Process a ProposerSlashing operation. Initiates the exit of a validator, decreases the balance of the slashed
- * validator and increases the block proposer balance.
- *
- * PERF: Work depends on number of ProposerSlashing per block. On regular networks the average is 0 / block.
- */
-export function processProposerSlashing(
-  fork: ForkSeq,
-  state: CachedBeaconStateAllForks,
-  proposerSlashing: phase0.ProposerSlashing,
-  verifySignatures = true
-): void {
-  assertValidProposerSlashing(state, proposerSlashing, verifySignatures);
-
-  slashValidator(fork, state, proposerSlashing.signedHeader1.message.proposerIndex);
-}
-
-export function assertValidProposerSlashing(
-  state: CachedBeaconStateAllForks,
-  proposerSlashing: phase0.ProposerSlashing,
-  verifySignatures = true
-): void {
-  const header1 = proposerSlashing.signedHeader1.message;
-  const header2 = proposerSlashing.signedHeader2.message;
-
-  // verify header slots match
-  if (header1.slot !== header2.slot) {
-    throw new Error(`ProposerSlashing slots do not match: slot1=${header1.slot} slot2=${header2.slot}`);
-  }
-
-  // verify header proposer indices match
-  if (header1.proposerIndex !== header2.proposerIndex) {
-    throw new Error(
-      `ProposerSlashing proposer indices do not match: proposerIndex1=${header1.proposerIndex} proposerIndex2=${header2.proposerIndex}`
-    );
-  }
-
-  // verify headers are different
-  if (ssz.phase0.BeaconBlockHeaderBigint.equals(header1, header2)) {
-    throw new Error("ProposerSlashing headers are equal");
-  }
-
-  // verify the proposer is slashable
-  const proposer = state.validators.getReadonly(header1.proposerIndex);
-  if (!isSlashableValidator(proposer, state.epochCtx.epoch)) {
-    throw new Error("ProposerSlashing proposer is not slashable");
-  }
-
-  // verify signatures
-  if (verifySignatures) {
-    const signatureSets = getProposerSlashingSignatureSets(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

@@ -1,27 +0,0 @@
-import {digest} from "@chainsafe/as-sha256";
-import {EPOCHS_PER_HISTORICAL_VECTOR} from "@lodestar/params";
-import {BeaconBlock} from "@lodestar/types";
-import {xor} from "@lodestar/utils";
-import {verifyRandaoSignature} from "../signatureSets/index.js";
-import {CachedBeaconStateAllForks} from "../types.js";
-import {getRandaoMix} from "../util/index.js";
-
-/**
- * Commit a randao reveal to generate pseudorandomness seeds
- *
- * PERF: Fixed work independent of block contents.
- */
-export function processRandao(state: CachedBeaconStateAllForks, block: BeaconBlock, verifySignature = true): void {
-  const {epochCtx} = state;
-  const epoch = epochCtx.epoch;
-  const randaoReveal = block.body.randaoReveal;
-
-  // verify RANDAO reveal
-  if (verifySignature && !verifyRandaoSignature(state, block)) {
-    throw new Error("RANDAO reveal is an invalid signature");
-  }
-
-  // mix in RANDAO reveal
-  const randaoMix = xor(getRandaoMix(state, epoch), digest(randaoReveal));
-  state.randaoMixes.set(epoch % EPOCHS_PER_HISTORICAL_VECTOR, randaoMix);
-}

package/src/block/processSyncCommittee.ts

@@ -1,117 +0,0 @@
-import {byteArrayEquals} from "@chainsafe/ssz";
-import {DOMAIN_SYNC_COMMITTEE, SYNC_COMMITTEE_SIZE} from "@lodestar/params";
-import {altair, ssz} from "@lodestar/types";
-import {G2_POINT_AT_INFINITY} from "../constants/index.js";
-import {CachedBeaconStateAllForks} from "../types.js";
-import {
-  ISignatureSet,
-  SignatureSetType,
-  computeSigningRoot,
-  decreaseBalance,
-  increaseBalance,
-  verifySignatureSet,
-} from "../util/index.js";
-
-export function processSyncAggregate(
-  state: CachedBeaconStateAllForks,
-  block: altair.BeaconBlock,
-  verifySignatures = true
-): void {
-  const committeeIndices = state.epochCtx.currentSyncCommitteeIndexed.validatorIndices;
-
-  // different from the spec but not sure how to get through signature verification for default/empty SyncAggregate in the spec test
-  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);
-    // 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");
-    }
-  }
-
-  const {syncParticipantReward, syncProposerReward} = state.epochCtx;
-  const {syncCommitteeBits} = block.body.syncAggregate;
-  const proposerIndex = state.epochCtx.getBeaconProposer(state.slot);
-  let proposerBalance = state.balances.get(proposerIndex);
-
-  for (let i = 0; i < SYNC_COMMITTEE_SIZE; i++) {
-    const index = committeeIndices[i];
-
-    if (syncCommitteeBits.get(i)) {
-      // Positive rewards for participants
-      if (index === proposerIndex) {
-        proposerBalance += syncParticipantReward;
-      } else {
-        increaseBalance(state, index, syncParticipantReward);
-      }
-      // Proposer reward
-      proposerBalance += syncProposerReward;
-      state.proposerRewards.syncAggregate += syncProposerReward;
-    } else {
-      // Negative rewards for non participants
-      if (index === proposerIndex) {
-        proposerBalance = Math.max(0, proposerBalance - syncParticipantReward);
-      } else {
-        decreaseBalance(state, index, syncParticipantReward);
-      }
-    }
-  }
-
-  // Apply proposer balance
-  state.balances.set(proposerIndex, proposerBalance);
-}
-
-export function getSyncCommitteeSignatureSet(
-  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;
-
-  // The spec uses the state to get the previous slot
-  // ```python
-  // previous_slot = max(state.slot, Slot(1)) - Slot(1)
-  // ```
-  // However we need to run the function getSyncCommitteeSignatureSet() for all the blocks in a epoch
-  // with the same state when verifying blocks in batch on RangeSync. Therefore we use the block.slot.
-  const previousSlot = Math.max(block.slot, 1) - 1;
-
-  // The spec uses the state to get the root at previousSlot
-  // ```python
-  // get_block_root_at_slot(state, previous_slot)
-  // ```
-  // However we need to run the function getSyncCommitteeSignatureSet() for all the blocks in a epoch
-  // with the same state when verifying blocks in batch on RangeSync.
-  //
-  // On skipped slots state block roots just copy the latest block, so using the parentRoot here is equivalent.
-  // So getSyncCommitteeSignatureSet() can be called with a state in any slot (with the correct shuffling)
-  const rootSigned = block.parentRoot;
-
-  if (!participantIndices) {
-    const committeeIndices = state.epochCtx.currentSyncCommitteeIndexed.validatorIndices;
-    participantIndices = syncAggregate.syncCommitteeBits.intersectValues(committeeIndices);
-  }
-
-  // When there's no participation we consider the signature valid and just ignore it
-  if (participantIndices.length === 0) {
-    // Must set signature as G2_POINT_AT_INFINITY when participating bits are empty
-    // https://github.com/ethereum/eth2.0-specs/blob/30f2a076377264677e27324a8c3c78c590ae5e20/specs/altair/bls.md#eth2_fast_aggregate_verify
-    if (byteArrayEquals(signature, G2_POINT_AT_INFINITY)) {
-      return null;
-    }
-    throw Error("Empty sync committee signature is not infinity");
-  }
-
-  const domain = state.config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE, previousSlot);
-
-  return {
-    type: SignatureSetType.aggregate,
-    pubkeys: participantIndices.map((i) => epochCtx.index2pubkey[i]),
-    signingRoot: computeSigningRoot(ssz.Root, rootSigned, domain),
-    signature,
-  };
-}

package/src/block/processVoluntaryExit.ts

@@ -1,55 +0,0 @@
-import {FAR_FUTURE_EPOCH, ForkSeq} from "@lodestar/params";
-import {phase0} from "@lodestar/types";
-import {verifyVoluntaryExitSignature} from "../signatureSets/index.js";
-import {CachedBeaconStateAllForks, CachedBeaconStateElectra} from "../types.js";
-import {getPendingBalanceToWithdraw, isActiveValidator} from "../util/index.js";
-import {initiateValidatorExit} from "./index.js";
-
-/**
- * Process a VoluntaryExit operation. Initiates the exit of a validator.
- *
- * PERF: Work depends on number of VoluntaryExit per block. On regular networks the average is 0 / block.
- */
-export function processVoluntaryExit(
-  fork: ForkSeq,
-  state: CachedBeaconStateAllForks,
-  signedVoluntaryExit: phase0.SignedVoluntaryExit,
-  verifySignature = true
-): void {
-  if (!isValidVoluntaryExit(fork, state, signedVoluntaryExit, verifySignature)) {
-    throw Error(`Invalid voluntary exit at forkSeq=${fork}`);
-  }
-
-  const validator = state.validators.get(signedVoluntaryExit.message.validatorIndex);
-  initiateValidatorExit(fork, state, validator);
-}
-
-export function isValidVoluntaryExit(
-  fork: ForkSeq,
-  state: CachedBeaconStateAllForks,
-  signedVoluntaryExit: phase0.SignedVoluntaryExit,
-  verifySignature = true
-): boolean {
-  const {config, epochCtx} = state;
-  const voluntaryExit = signedVoluntaryExit.message;
-  const validator = state.validators.get(voluntaryExit.validatorIndex);
-  const currentEpoch = epochCtx.epoch;
-
-  return (
-    // verify the validator is active
-    isActiveValidator(validator, currentEpoch) &&
-    // verify exit has not been initiated
-    validator.exitEpoch === FAR_FUTURE_EPOCH &&
-    // exits must specify an epoch when they become valid; they are not valid before then
-    currentEpoch >= voluntaryExit.epoch &&
-    // verify the validator had been active long enough
-    currentEpoch >= validator.activationEpoch + config.SHARD_COMMITTEE_PERIOD &&
-    (fork >= ForkSeq.electra
-      ? // only exit validator if it has no pending withdrawals in the queue
-        getPendingBalanceToWithdraw(state as CachedBeaconStateElectra, voluntaryExit.validatorIndex) === 0
-      : // there are no pending withdrawals in previous forks
-        true) &&
-    // verify signature
-    (!verifySignature || verifyVoluntaryExitSignature(state, signedVoluntaryExit))
-  );
-}

package/src/block/processWithdrawalRequest.ts

@@ -1,98 +0,0 @@
-import {
-  FAR_FUTURE_EPOCH,
-  FULL_EXIT_REQUEST_AMOUNT,
-  ForkSeq,
-  MIN_ACTIVATION_BALANCE,
-  PENDING_PARTIAL_WITHDRAWALS_LIMIT,
-} from "@lodestar/params";
-import {electra, phase0, ssz} from "@lodestar/types";
-import {toHex} from "@lodestar/utils";
-import {CachedBeaconStateElectra} 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,
-  withdrawalRequest: electra.WithdrawalRequest
-): void {
-  const amount = Number(withdrawalRequest.amount);
-  const {pendingPartialWithdrawals, validators, epochCtx} = state;
-  // no need to use unfinalized pubkey cache from 6110 as validator won't be active anyway
-  const {pubkey2index, config} = epochCtx;
-  const isFullExitRequest = amount === FULL_EXIT_REQUEST_AMOUNT;
-
-  // If partial withdrawal queue is full, only full exits are processed
-  if (pendingPartialWithdrawals.length >= PENDING_PARTIAL_WITHDRAWALS_LIMIT && !isFullExitRequest) {
-    return;
-  }
-
-  // bail out if validator is not in beacon state
-  // note that we don't need to check for 6110 unfinalized vals as they won't be eligible for withdraw/exit anyway
-  const validatorIndex = pubkey2index.get(withdrawalRequest.validatorPubkey);
-  if (validatorIndex === null) {
-    return;
-  }
-
-  const validator = validators.get(validatorIndex);
-  if (!isValidatorEligibleForWithdrawOrExit(validator, withdrawalRequest.sourceAddress, state)) {
-    return;
-  }
-
-  // TODO Electra: Consider caching pendingPartialWithdrawals
-  const pendingBalanceToWithdraw = getPendingBalanceToWithdraw(state, validatorIndex);
-  const validatorBalance = state.balances.get(validatorIndex);
-
-  if (isFullExitRequest) {
-    // only exit validator if it has no pending withdrawals in the queue
-    if (pendingBalanceToWithdraw === 0) {
-      initiateValidatorExit(fork, state, validator);
-    }
-    return;
-  }
-
-  // partial withdrawal request
-  const hasSufficientEffectiveBalance = validator.effectiveBalance >= MIN_ACTIVATION_BALANCE;
-  const hasExcessBalance = validatorBalance > MIN_ACTIVATION_BALANCE + pendingBalanceToWithdraw;
-
-  // Only allow partial withdrawals with compounding withdrawal credentials
-  if (
-    hasCompoundingWithdrawalCredential(validator.withdrawalCredentials) &&
-    hasSufficientEffectiveBalance &&
-    hasExcessBalance
-  ) {
-    const amountToWithdraw = BigInt(
-      Math.min(validatorBalance - MIN_ACTIVATION_BALANCE - pendingBalanceToWithdraw, amount)
-    );
-    const exitQueueEpoch = computeExitEpochAndUpdateChurn(state, amountToWithdraw);
-    const withdrawableEpoch = exitQueueEpoch + config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY;
-
-    const pendingPartialWithdrawal = ssz.electra.PendingPartialWithdrawal.toViewDU({
-      validatorIndex,
-      amount: amountToWithdraw,
-      withdrawableEpoch,
-    });
-    state.pendingPartialWithdrawals.push(pendingPartialWithdrawal);
-  }
-}
-
-function isValidatorEligibleForWithdrawOrExit(
-  validator: phase0.Validator,
-  sourceAddress: Uint8Array,
-  state: CachedBeaconStateElectra
-): boolean {
-  const {withdrawalCredentials} = validator;
-  const addressStr = toHex(withdrawalCredentials.subarray(12));
-  const sourceAddressStr = toHex(sourceAddress);
-  const {epoch: currentEpoch, config} = state.epochCtx;
-
-  return (
-    hasExecutionWithdrawalCredential(withdrawalCredentials) &&
-    addressStr === sourceAddressStr &&
-    isActiveValidator(validator, currentEpoch) &&
-    validator.exitEpoch === FAR_FUTURE_EPOCH &&
-    currentEpoch >= validator.activationEpoch + config.SHARD_COMMITTEE_PERIOD
-  );
-}