@lodestar/state-transition 1.50.0-dev.9c3f7bebe9 → 1.50.0-dev.9c7f3c203f

package/src/block/indexedBuilderState.ts

@@ -0,0 +1,65 @@
+import {BuilderIndex, Epoch, PubkeyHex} from "@lodestar/types";
+import {Builder} from "@lodestar/types/gloas";
+import {toPubkeyHex} from "@lodestar/utils";
+import {CachedBeaconStateGloas} from "../types.js";
+import {computeEpochAtSlot} from "../util/epoch.js";
+import {createBuilderView} from "../util/gloas.js";
+
+/**
+ * Block-scoped pubkey -> index map and ascending reuse candidates for `state.builders`, built in one pass.
+ * Only valid while builder pubkeys change exclusively via `addBuilderToRegistry()` and no builder becomes
+ * newly reusable (candidates are re-checked lazily, never added). Do not use across blocks/slots.
+ */
+export class IndexedBuilderState {
+  private readonly currentEpoch: Epoch;
+  private readonly indexByPubkey = new Map<PubkeyHex, BuilderIndex>();
+  private readonly reusableIndexCandidates: BuilderIndex[] = [];
+  private candidateCursor = 0;
+
+  constructor(readonly state: CachedBeaconStateGloas) {
+    state.builders.commit();
+    const builders = state.builders.getAllReadonlyValues();
+    this.currentEpoch = computeEpochAtSlot(state.slot);
+    for (const [index, builder] of builders.entries()) {
+      const pubkeyHex = toPubkeyHex(builder.pubkey);
+      this.indexByPubkey.set(pubkeyHex, index);
+      if (canReuseBuilder(builder, this.currentEpoch)) {
+        this.reusableIndexCandidates.push(index);
+      }
+    }
+  }
+
+  findBuilderIndexByPubkey(pubkey: Uint8Array): BuilderIndex | null {
+    return this.indexByPubkey.get(toPubkeyHex(pubkey)) ?? null;
+  }
+
+  addBuilderToRegistry(pubkey: Uint8Array, version: number, executionAddress: Uint8Array, amount: number): void {
+    const builder = createBuilderView(pubkey, version, executionAddress, amount, this.currentEpoch);
+    const reusableIndex = this.findReusableBuilderIndex();
+    const index = reusableIndex ?? this.state.builders.length;
+    if (reusableIndex !== null) {
+      const oldBuilder = this.state.builders.getReadonly(index);
+      this.indexByPubkey.delete(toPubkeyHex(oldBuilder.pubkey));
+      this.state.builders.set(index, builder);
+    } else {
+      this.state.builders.push(builder);
+    }
+    this.indexByPubkey.set(toPubkeyHex(pubkey), index);
+  }
+
+  private findReusableBuilderIndex(): BuilderIndex | null {
+    while (this.candidateCursor < this.reusableIndexCandidates.length) {
+      const index = this.reusableIndexCandidates[this.candidateCursor++];
+      const builder = this.state.builders.getReadonly(index);
+      // Top-ups can invalidate initial candidates
+      if (canReuseBuilder(builder, this.currentEpoch)) {
+        return index;
+      }
+    }
+    return null;
+  }
+}
+
+function canReuseBuilder(builder: Builder, currentEpoch: Epoch): boolean {
+  return builder.withdrawableEpoch <= currentEpoch && builder.balance === 0;
+}

package/src/block/processBuilderDepositRequest.ts

@@ -1,13 +1,8 @@
 import {FAR_FUTURE_EPOCH, PAYLOAD_BUILDER_VERSION} from "@lodestar/params";
 import {gloas} from "@lodestar/types";
-import {CachedBeaconStateGloas} from "../types.js";
 import {computeEpochAtSlot} from "../util/epoch.js";
-import {
-  addBuilderToRegistry,
-  findBuilderIndexByPubkey,
-  isBuilderWithdrawalCredential,
-  isValidBuilderDepositSignature,
-} from "../util/gloas.js";
+import {isBuilderWithdrawalCredential, isValidBuilderDepositSignature} from "../util/gloas.js";
+import {IndexedBuilderState} from "./indexedBuilderState.js";
 
 /**
  * Process a builder deposit request from the execution layer: register a new builder
@@ -16,9 +11,10 @@ import {
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.11/specs/gloas/beacon-chain.md#new-process_builder_deposit_request
  */
 export function processBuilderDepositRequest(
-  state: CachedBeaconStateGloas,
+  indexedState: IndexedBuilderState,
   request: gloas.BuilderDepositRequest
 ): void {
+  const {state} = indexedState;
   const {pubkey, withdrawalCredentials, amount, signature} = request;
 
   // Ignore deposits with unexpected withdrawal credential prefixes.
@@ -26,18 +22,11 @@ export function processBuilderDepositRequest(
     return;
   }
 
-  const builderIndex = findBuilderIndexByPubkey(state, pubkey);
+  const builderIndex = indexedState.findBuilderIndexByPubkey(pubkey);
 
   if (builderIndex === null) {
     if (isValidBuilderDepositSignature(state.config, pubkey, withdrawalCredentials, amount, signature)) {
-      addBuilderToRegistry(
-        state,
-        pubkey,
-        PAYLOAD_BUILDER_VERSION,
-        withdrawalCredentials.subarray(12),
-        amount,
-        state.slot
-      );
+      indexedState.addBuilderToRegistry(pubkey, PAYLOAD_BUILDER_VERSION, withdrawalCredentials.subarray(12), amount);
     }
     return;
   }

package/src/block/processBuilderExitRequest.ts

@@ -1,12 +1,7 @@
 import {gloas} from "@lodestar/types";
 import {byteArrayEquals} from "@lodestar/utils";
-import {CachedBeaconStateGloas} from "../types.js";
-import {
-  findBuilderIndexByPubkey,
-  getPendingBalanceToWithdrawForBuilder,
-  initiateBuilderExit,
-  isActiveBuilder,
-} from "../util/gloas.js";
+import {getPendingBalanceToWithdrawForBuilder, initiateBuilderExit, isActiveBuilder} from "../util/gloas.js";
+import {IndexedBuilderState} from "./indexedBuilderState.js";
 
 /**
  * Apply a builder exit request. Authorizes the exit via `source_address` (the builder's
@@ -17,8 +12,9 @@ import {
  *
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.11/specs/gloas/beacon-chain.md#new-process_builder_exit_request
  */
-export function processBuilderExitRequest(state: CachedBeaconStateGloas, request: gloas.BuilderExitRequest): void {
-  const builderIndex = findBuilderIndexByPubkey(state, request.pubkey);
+export function processBuilderExitRequest(indexedState: IndexedBuilderState, request: gloas.BuilderExitRequest): void {
+  const {state} = indexedState;
+  const builderIndex = indexedState.findBuilderIndexByPubkey(request.pubkey);
   if (builderIndex === null) {
     return;
   }

package/src/block/processParentExecutionPayload.ts

@@ -3,6 +3,7 @@ import {BeaconBlock, gloas, ssz} from "@lodestar/types";
 import {byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {CachedBeaconStateGloas} from "../types.js";
 import {computeEpochAtSlot} from "../util/epoch.js";
+import {IndexedBuilderState} from "./indexedBuilderState.js";
 import {processBuilderDepositRequest} from "./processBuilderDepositRequest.js";
 import {processBuilderExitRequest} from "./processBuilderExitRequest.js";
 import {processConsolidationRequest} from "./processConsolidationRequest.js";
@@ -53,29 +54,8 @@ export function applyParentExecutionPayload(state: CachedBeaconStateGloas, reque
   const parentEpoch = computeEpochAtSlot(parentSlot);
   const currentEpoch = computeEpochAtSlot(state.slot);
 
-  // Process execution requests from parent's payload. The execution
-  // requests are processed at state.slot (child's slot), not the parent's slot.
-  for (const deposit of requests.deposits) {
-    processDepositRequest(fork, state, deposit);
-  }
-
-  for (const withdrawal of requests.withdrawals) {
-    processWithdrawalRequest(fork, state, withdrawal);
-  }
-
-  for (const consolidation of requests.consolidations) {
-    processConsolidationRequest(state, consolidation);
-  }
-
-  for (const builderDeposit of requests.builderDeposits) {
-    processBuilderDepositRequest(state, builderDeposit);
-  }
-
-  for (const builderExit of requests.builderExits) {
-    processBuilderExitRequest(state, builderExit);
-  }
-
-  // Settle the builder payment
+  // Settle the builder payment before the requests so that a builder exit request
+  // is rejected while the payment is pending
   if (parentEpoch === currentEpoch) {
     settleBuilderPayment(state, SLOTS_PER_EPOCH + (parentSlot % SLOTS_PER_EPOCH));
   } else if (parentEpoch === currentEpoch - 1) {
@@ -92,6 +72,30 @@ export function applyParentExecutionPayload(state: CachedBeaconStateGloas, reque
     );
   }
 
+  // Process execution requests from parent's payload. The execution
+  // requests are processed at state.slot (child's slot), not the parent's slot.
+  for (const deposit of requests.deposits) {
+    processDepositRequest(fork, state, deposit);
+  }
+
+  for (const withdrawal of requests.withdrawals) {
+    processWithdrawalRequest(fork, state, withdrawal);
+  }
+
+  for (const consolidation of requests.consolidations) {
+    processConsolidationRequest(state, consolidation);
+  }
+
+  if (requests.builderDeposits.length > 0 || requests.builderExits.length > 0) {
+    const indexedState = new IndexedBuilderState(state);
+    for (const builderDeposit of requests.builderDeposits) {
+      processBuilderDepositRequest(indexedState, builderDeposit);
+    }
+    for (const builderExit of requests.builderExits) {
+      processBuilderExitRequest(indexedState, builderExit);
+    }
+  }
+
   // Update parent payload availability and latest block hash
   state.executionPayloadAvailability.set(parentSlot % SLOTS_PER_HISTORICAL_ROOT, true);
   state.latestBlockHash = parentBid.blockHash;

package/src/index.ts

@@ -1,4 +1,5 @@
 export {type BlockExternalData, DataAvailabilityStatus, ExecutionPayloadStatus} from "./block/externalData.js";
+export {IndexedBuilderState} from "./block/indexedBuilderState.js";
 export {getAttestationParticipationStatus, processAttestationsAltair} from "./block/processAttestationsAltair.js";
 export {assertValidAttesterSlashing} from "./block/processAttesterSlashing.js";
 export {isValidBlsToExecutionChange} from "./block/processBlsToExecutionChange.js";
@@ -43,7 +44,7 @@ export * from "./signatureSets/index.js";
 export * from "./stateTransition.js";
 export {BeaconStateView} from "./stateView/beaconStateView.js";
 export {
-  type ComputeNewStateRootInput,
+  type BlockSTFInput,
   type ComputeNewStateRootResult,
   type IBeaconStateView,
   type IBeaconStateViewAltair,
@@ -54,6 +55,7 @@ export {
   type IBeaconStateViewFulu,
   type IBeaconStateViewGloas,
   type IBeaconStateViewHeze,
+  type IBeaconStateViewNative,
   isStatePostAltair,
   isStatePostBellatrix,
   isStatePostCapella,
@@ -63,6 +65,7 @@ export {
   isStatePostGloas,
   isStatePostHeze,
 } from "./stateView/interface.js";
+export {NativeBeaconStateView} from "./stateView/nativeBeaconStateView.js";
 export {createBeaconStateView, createBeaconStateViewForHistoricalRegen} from "./stateView/stateViewFactory.js";
 export type {
   BeaconStateAllForks,

package/src/rewards/attestationsRewards.ts

@@ -18,6 +18,8 @@ import {
 import {ValidatorIndex, rewards} from "@lodestar/types";
 import {fromHex} from "@lodestar/utils";
 import {EpochTransitionCache, beforeProcessEpoch} from "../cache/epochTransitionCache.js";
+import {processInactivityUpdates} from "../epoch/processInactivityUpdates.js";
+import {processJustificationAndFinalization} from "../epoch/processJustificationAndFinalization.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../types.js";
 import {
   FLAG_ELIGIBLE_ATTESTER,
@@ -45,8 +47,13 @@ export async function computeAttestationsRewards(
     throw Error("Unsupported fork. Attestations rewards calculation is not available in phase0");
   }
 
-  const stateAltair = state as CachedBeaconStateAltair;
+  // Rewards are computed after justification and inactivity updates in epoch processing, so apply both to a clone
+  // before reading finality and inactivity scores, see
+  // https://github.com/ethereum/consensus-specs/blob/v1.7.0-beta.2/specs/altair/beacon-chain.md#epoch-processing
+  const stateAltair = state.clone() as CachedBeaconStateAltair;
   const transitionCache = beforeProcessEpoch(stateAltair);
+  processJustificationAndFinalization(stateAltair, transitionCache);
+  processInactivityUpdates(stateAltair, transitionCache);
 
   const [idealRewards, penalties] = computeIdealAttestationsRewardsAndPenaltiesAltair(
     config,

package/src/signatureSets/index.ts

@@ -12,7 +12,7 @@ import {getPayloadAttestationDataSigningRoot} from "./indexedPayloadAttestation.
 import {getBlockProposerSignatureSet} from "./proposer.js";
 import {getProposerSlashingsSignatureSets} from "./proposerSlashings.js";
 import {getRandaoRevealSignatureSet} from "./randao.js";
-import {getVoluntaryExitsSignatureSets} from "./voluntaryExits.js";
+import {getVoluntaryExitSignatureSet} from "./voluntaryExits.js";
 
 export * from "./attesterSlashings.js";
 export * from "./blsToExecutionChange.js";
@@ -49,7 +49,9 @@ export function getBlockSignatureSets(
     ...getProposerSlashingsSignatureSets(config, signedBlock),
     ...getAttesterSlashingsSignatureSets(config, signedBlock),
     ...getAttestationsSignatureSets(config, signedBlock, indexedAttestations),
-    ...getVoluntaryExitsSignatureSets(config, state, signedBlock),
+    ...signedBlock.message.body.voluntaryExits.map((voluntaryExit) =>
+      getVoluntaryExitSignatureSet(config, state, voluntaryExit)
+    ),
   ];
 
   if (!opts?.skipProposerSignature) {

package/src/signatureSets/voluntaryExits.ts

@@ -1,14 +1,11 @@
 import {BeaconConfig} from "@lodestar/config";
-import {ForkSeq} from "@lodestar/params";
-import {SignedBeaconBlock, Slot, phase0, ssz} from "@lodestar/types";
-import {IBeaconStateView, IBeaconStateViewGloas, isStatePostGloas} from "../stateView/interface.js";
+import {phase0, ssz} from "@lodestar/types";
+import {IBeaconStateView} from "../stateView/interface.js";
 import {
   ISignatureSet,
   SignatureSetType,
   computeSigningRoot,
   computeStartSlotAtEpoch,
-  convertValidatorIndexToBuilderIndex,
-  isBuilderIndex,
   verifySignatureSet,
 } from "../util/index.js";
 
@@ -27,36 +24,9 @@ export function getVoluntaryExitSignatureSet(
   config: BeaconConfig,
   state: IBeaconStateView,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
-): ISignatureSet {
-  const fork = config.getForkSeq(state.slot);
-
-  if (fork >= ForkSeq.gloas && isBuilderVoluntaryExit(signedVoluntaryExit)) {
-    if (!isStatePostGloas(state)) {
-      throw new Error(`Expected gloas+ state for builder voluntary exit signature, got fork=${state.forkName}`);
-    }
-    return getBuilderVoluntaryExitSignatureSet(config, state, signedVoluntaryExit);
-  }
-
-  return getValidatorVoluntaryExitSignatureSet(config, state.slot, signedVoluntaryExit);
-}
-
-export function getVoluntaryExitsSignatureSets(
-  config: BeaconConfig,
-  state: IBeaconStateView,
-  signedBlock: SignedBeaconBlock
-): ISignatureSet[] {
-  return signedBlock.message.body.voluntaryExits.map((voluntaryExit) =>
-    getVoluntaryExitSignatureSet(config, state, voluntaryExit)
-  );
-}
-
-export function getValidatorVoluntaryExitSignatureSet(
-  config: BeaconConfig,
-  stateSlot: Slot,
-  signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): ISignatureSet {
   const messageSlot = computeStartSlotAtEpoch(signedVoluntaryExit.message.epoch);
-  const domain = config.getDomainForVoluntaryExit(stateSlot, messageSlot);
+  const domain = config.getDomainForVoluntaryExit(state.slot, messageSlot);
 
   return {
     type: SignatureSetType.indexed,
@@ -65,25 +35,3 @@ export function getValidatorVoluntaryExitSignatureSet(
     signature: signedVoluntaryExit.signature,
   };
 }
-
-export function getBuilderVoluntaryExitSignatureSet(
-  config: BeaconConfig,
-  state: IBeaconStateViewGloas,
-  signedVoluntaryExit: phase0.SignedVoluntaryExit
-): ISignatureSet {
-  const messageSlot = computeStartSlotAtEpoch(signedVoluntaryExit.message.epoch);
-  const domain = config.getDomainForVoluntaryExit(state.slot, messageSlot);
-  const builderIndex = convertValidatorIndexToBuilderIndex(signedVoluntaryExit.message.validatorIndex);
-  const builder = state.getBuilder(builderIndex);
-
-  return {
-    type: SignatureSetType.single,
-    pubkey: builder.pubkey,
-    signingRoot: computeSigningRoot(ssz.phase0.VoluntaryExit, signedVoluntaryExit.message, domain),
-    signature: signedVoluntaryExit.signature,
-  };
-}
-
-export function isBuilderVoluntaryExit(signedVoluntaryExit: phase0.SignedVoluntaryExit): boolean {
-  return isBuilderIndex(signedVoluntaryExit.message.validatorIndex);
-}