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

package/src/slot/upgradeStateToGloas.ts

@@ -1,24 +1,68 @@
+import {SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
 import {getCachedBeaconState} from "../cache/stateCache.js";
 import {CachedBeaconStateFulu, CachedBeaconStateGloas} from "../types.js";
 
 /**
  * Upgrade a state from Fulu to Gloas.
- * TODO GLOAS: Implement this
  */
 export function upgradeStateToGloas(stateFulu: CachedBeaconStateFulu): CachedBeaconStateGloas {
   const {config} = stateFulu;
 
-  const stateFuluNode = ssz.fulu.BeaconState.commitViewDU(stateFulu);
-  const stateGloasView = ssz.gloas.BeaconState.getViewDU(stateFuluNode);
+  ssz.fulu.BeaconState.commitViewDU(stateFulu);
+  const stateGloasCloned = stateFulu;
 
-  const stateGloas = getCachedBeaconState(stateGloasView, stateFulu);
+  const stateGloasView = ssz.gloas.BeaconState.defaultViewDU();
 
-  stateGloas.fork = ssz.phase0.Fork.toViewDU({
+  stateGloasView.genesisTime = stateGloasCloned.genesisTime;
+  stateGloasView.genesisValidatorsRoot = stateGloasCloned.genesisValidatorsRoot;
+  stateGloasView.slot = stateGloasCloned.slot;
+  stateGloasView.fork = ssz.phase0.Fork.toViewDU({
     previousVersion: stateFulu.fork.currentVersion,
     currentVersion: config.GLOAS_FORK_VERSION,
     epoch: stateFulu.epochCtx.epoch,
   });
+  stateGloasView.latestBlockHeader = stateGloasCloned.latestBlockHeader;
+  stateGloasView.blockRoots = stateGloasCloned.blockRoots;
+  stateGloasView.stateRoots = stateGloasCloned.stateRoots;
+  stateGloasView.historicalRoots = stateGloasCloned.historicalRoots;
+  stateGloasView.eth1Data = stateGloasCloned.eth1Data;
+  stateGloasView.eth1DataVotes = stateGloasCloned.eth1DataVotes;
+  stateGloasView.eth1DepositIndex = stateGloasCloned.eth1DepositIndex;
+  stateGloasView.validators = stateGloasCloned.validators;
+  stateGloasView.balances = stateGloasCloned.balances;
+  stateGloasView.randaoMixes = stateGloasCloned.randaoMixes;
+  stateGloasView.slashings = stateGloasCloned.slashings;
+  stateGloasView.previousEpochParticipation = stateGloasCloned.previousEpochParticipation;
+  stateGloasView.currentEpochParticipation = stateGloasCloned.currentEpochParticipation;
+  stateGloasView.justificationBits = stateGloasCloned.justificationBits;
+  stateGloasView.previousJustifiedCheckpoint = stateGloasCloned.previousJustifiedCheckpoint;
+  stateGloasView.currentJustifiedCheckpoint = stateGloasCloned.currentJustifiedCheckpoint;
+  stateGloasView.finalizedCheckpoint = stateGloasCloned.finalizedCheckpoint;
+  stateGloasView.inactivityScores = stateGloasCloned.inactivityScores;
+  stateGloasView.currentSyncCommittee = stateGloasCloned.currentSyncCommittee;
+  stateGloasView.nextSyncCommittee = stateGloasCloned.nextSyncCommittee;
+  stateGloasView.latestExecutionPayloadBid.blockHash = stateFulu.latestExecutionPayloadHeader.blockHash;
+  stateGloasView.nextWithdrawalIndex = stateGloasCloned.nextWithdrawalIndex;
+  stateGloasView.nextWithdrawalValidatorIndex = stateGloasCloned.nextWithdrawalValidatorIndex;
+  stateGloasView.historicalSummaries = stateGloasCloned.historicalSummaries;
+  stateGloasView.depositRequestsStartIndex = stateGloasCloned.depositRequestsStartIndex;
+  stateGloasView.depositBalanceToConsume = stateGloasCloned.depositBalanceToConsume;
+  stateGloasView.exitBalanceToConsume = stateGloasCloned.exitBalanceToConsume;
+  stateGloasView.earliestExitEpoch = stateGloasCloned.earliestExitEpoch;
+  stateGloasView.consolidationBalanceToConsume = stateGloasCloned.consolidationBalanceToConsume;
+  stateGloasView.earliestConsolidationEpoch = stateGloasCloned.earliestConsolidationEpoch;
+  stateGloasView.pendingDeposits = stateGloasCloned.pendingDeposits;
+  stateGloasView.pendingPartialWithdrawals = stateGloasCloned.pendingPartialWithdrawals;
+  stateGloasView.pendingConsolidations = stateGloasCloned.pendingConsolidations;
+  stateGloasView.proposerLookahead = stateGloasCloned.proposerLookahead;
+
+  for (let i = 0; i < SLOTS_PER_HISTORICAL_ROOT; i++) {
+    stateGloasView.executionPayloadAvailability.set(i, true);
+  }
+  stateGloasView.latestBlockHash = stateFulu.latestExecutionPayloadHeader.blockHash;
+
+  const stateGloas = getCachedBeaconState(stateGloasView, stateFulu);
 
   stateGloas.commit();
   // Clear cache to ensure the cache of fulu fields is not used by new gloas fields

package/src/stateTransition.ts

@@ -217,13 +217,13 @@ function processSlotsWithTransientCache(
   }
 
   while (postState.slot < slot) {
-    processSlot(postState);
+    const fork = postState.config.getForkSeq(postState.slot);
+    processSlot(fork, postState);
 
     // Process epoch on the first slot of the next epoch
+    // We use `fork` because at fork boundary we don't want to process
+    // "next fork" epoch before upgrading state
     if ((postState.slot + 1) % SLOTS_PER_EPOCH === 0) {
-      // At fork boundary we don't want to process "next fork" epoch before upgrading state
-      const fork = postState.config.getForkSeq(postState.slot);
-
       const epochTransitionTimer = metrics?.epochTransitionTime.startTimer();
 
       let epochTransitionCache: EpochTransitionCache;

package/src/util/electra.ts

@@ -1,11 +1,14 @@
 import {COMPOUNDING_WITHDRAWAL_PREFIX, GENESIS_SLOT, MIN_ACTIVATION_BALANCE} from "@lodestar/params";
 import {ValidatorIndex, ssz} from "@lodestar/types";
 import {G2_POINT_AT_INFINITY} from "../constants/constants.js";
-import {CachedBeaconStateElectra} from "../types.js";
+import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 import {hasEth1WithdrawalCredential} from "./capella.js";
+import {hasBuilderWithdrawalCredential} from "./gloas.ts";
 
 export function hasCompoundingWithdrawalCredential(withdrawalCredentials: Uint8Array): boolean {
-  return withdrawalCredentials[0] === COMPOUNDING_WITHDRAWAL_PREFIX;
+  return (
+    withdrawalCredentials[0] === COMPOUNDING_WITHDRAWAL_PREFIX || hasBuilderWithdrawalCredential(withdrawalCredentials)
+  );
 }
 
 export function hasExecutionWithdrawalCredential(withdrawalCredentials: Uint8Array): boolean {
@@ -14,7 +17,10 @@ export function hasExecutionWithdrawalCredential(withdrawalCredentials: Uint8Arr
   );
 }
 
-export function switchToCompoundingValidator(state: CachedBeaconStateElectra, index: ValidatorIndex): void {
+export function switchToCompoundingValidator(
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
+  index: ValidatorIndex
+): void {
   const validator = state.validators.get(index);
 
   // directly modifying the byte leads to ssz missing the modification resulting into
@@ -30,7 +36,10 @@ export function switchToCompoundingValidator(state: CachedBeaconStateElectra, in
   queueExcessActiveBalance(state, index);
 }
 
-export function queueExcessActiveBalance(state: CachedBeaconStateElectra, index: ValidatorIndex): void {
+export function queueExcessActiveBalance(
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
+  index: ValidatorIndex
+): void {
   const balance = state.balances.get(index);
   if (balance > MIN_ACTIVATION_BALANCE) {
     const validator = state.validators.getReadonly(index);
@@ -53,7 +62,7 @@ export function queueExcessActiveBalance(state: CachedBeaconStateElectra, index:
 /**
  * Since we share pubkey2index, pubkey maybe added by other epoch transition but we don't have that validator in this state
  */
-export function isPubkeyKnown(state: CachedBeaconStateElectra, pubkey: Uint8Array): boolean {
+export function isPubkeyKnown(state: CachedBeaconStateElectra | CachedBeaconStateGloas, pubkey: Uint8Array): boolean {
   return isValidatorKnown(state, state.epochCtx.getValidatorIndex(pubkey));
 }
 
@@ -61,7 +70,7 @@ export function isPubkeyKnown(state: CachedBeaconStateElectra, pubkey: Uint8Arra
  * Since we share pubkey2index, validatorIndex maybe not null but we don't have that validator in this state
  */
 export function isValidatorKnown(
-  state: CachedBeaconStateElectra,
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
   index: ValidatorIndex | null
 ): index is ValidatorIndex {
   return index !== null && index < state.validators.length;

package/src/util/epoch.ts

@@ -1,6 +1,6 @@
 import {EPOCHS_PER_SYNC_COMMITTEE_PERIOD, GENESIS_EPOCH, MAX_SEED_LOOKAHEAD, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {BeaconState, Epoch, Gwei, Slot, SyncPeriod} from "@lodestar/types";
-import {CachedBeaconStateElectra} from "../types.js";
+import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 import {getActivationExitChurnLimit, getConsolidationChurnLimit} from "./validator.js";
 
 /**
@@ -41,7 +41,10 @@ export function computeActivationExitEpoch(epoch: Epoch): Epoch {
   return epoch + 1 + MAX_SEED_LOOKAHEAD;
 }
 
-export function computeExitEpochAndUpdateChurn(state: CachedBeaconStateElectra, exitBalance: Gwei): number {
+export function computeExitEpochAndUpdateChurn(
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
+  exitBalance: Gwei
+): number {
   let earliestExitEpoch = Math.max(state.earliestExitEpoch, computeActivationExitEpoch(state.epochCtx.epoch));
   const perEpochChurn = getActivationExitChurnLimit(state.epochCtx);
 
@@ -65,7 +68,7 @@ export function computeExitEpochAndUpdateChurn(state: CachedBeaconStateElectra,
 }
 
 export function computeConsolidationEpochAndUpdateChurn(
-  state: CachedBeaconStateElectra,
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
   consolidationBalance: Gwei
 ): number {
   let earliestConsolidationEpoch = Math.max(

package/src/util/gloas.ts

@@ -0,0 +1,58 @@
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {
+  BUILDER_PAYMENT_THRESHOLD_DENOMINATOR,
+  BUILDER_PAYMENT_THRESHOLD_NUMERATOR,
+  BUILDER_WITHDRAWAL_PREFIX,
+  EFFECTIVE_BALANCE_INCREMENT,
+  SLOTS_PER_EPOCH,
+} from "@lodestar/params";
+import {gloas} from "@lodestar/types";
+import {AttestationData} from "@lodestar/types/phase0";
+import {CachedBeaconStateGloas} from "../types.ts";
+import {getBlockRootAtSlot} from "./blockRoot.ts";
+import {computeEpochAtSlot} from "./epoch.ts";
+import {RootCache} from "./rootCache.ts";
+
+export function hasBuilderWithdrawalCredential(withdrawalCredentials: Uint8Array): boolean {
+  return withdrawalCredentials[0] === BUILDER_WITHDRAWAL_PREFIX;
+}
+
+export function getBuilderPaymentQuorumThreshold(state: CachedBeaconStateGloas): number {
+  const quorum =
+    Math.floor((state.epochCtx.totalActiveBalanceIncrements * EFFECTIVE_BALANCE_INCREMENT) / SLOTS_PER_EPOCH) *
+    BUILDER_PAYMENT_THRESHOLD_NUMERATOR;
+
+  return Math.floor(quorum / BUILDER_PAYMENT_THRESHOLD_DENOMINATOR);
+}
+
+export function isBuilderPaymentWithdrawable(
+  state: CachedBeaconStateGloas,
+  withdrawal: gloas.BuilderPendingWithdrawal
+): boolean {
+  const builder = state.validators.getReadonly(withdrawal.builderIndex);
+  const currentEpoch = computeEpochAtSlot(state.slot);
+
+  return builder.withdrawableEpoch >= currentEpoch || !builder.slashed;
+}
+
+export function isAttestationSameSlot(state: CachedBeaconStateGloas, data: AttestationData): boolean {
+  if (data.slot === 0) return true;
+
+  const isMatchingBlockRoot = byteArrayEquals(data.beaconBlockRoot, getBlockRootAtSlot(state, data.slot));
+  const isCurrentBlockRoot = !byteArrayEquals(data.beaconBlockRoot, getBlockRootAtSlot(state, data.slot - 1));
+
+  return isMatchingBlockRoot && isCurrentBlockRoot;
+}
+
+export function isAttestationSameSlotRootCache(rootCache: RootCache, data: AttestationData): boolean {
+  if (data.slot === 0) return true;
+
+  const isMatchingBlockRoot = byteArrayEquals(data.beaconBlockRoot, rootCache.getBlockRootAtSlot(data.slot));
+  const isCurrentBlockRoot = !byteArrayEquals(data.beaconBlockRoot, rootCache.getBlockRootAtSlot(data.slot - 1));
+
+  return isMatchingBlockRoot && isCurrentBlockRoot;
+}
+
+export function isParentBlockFull(state: CachedBeaconStateGloas): boolean {
+  return byteArrayEquals(state.latestExecutionPayloadBid.blockHash, state.latestBlockHash);
+}

package/src/util/seed.ts

@@ -5,6 +5,7 @@ import {
 } from "@chainsafe/swap-or-not-shuffle";
 import {
   DOMAIN_BEACON_PROPOSER,
+  DOMAIN_PTC_ATTESTER,
   DOMAIN_SYNC_COMMITTEE,
   EFFECTIVE_BALANCE_INCREMENT,
   EPOCHS_PER_HISTORICAL_VECTOR,
@@ -12,6 +13,7 @@ import {
   MAX_EFFECTIVE_BALANCE,
   MAX_EFFECTIVE_BALANCE_ELECTRA,
   MIN_SEED_LOOKAHEAD,
+  PTC_SIZE,
   SHUFFLE_ROUND_COUNT,
   SLOTS_PER_EPOCH,
   SYNC_COMMITTEE_SIZE,
@@ -19,7 +21,7 @@ import {
 import {Bytes32, DomainType, Epoch, ValidatorIndex} from "@lodestar/types";
 import {assert, bytesToBigInt, bytesToInt, intToBytes} from "@lodestar/utils";
 import {EffectiveBalanceIncrements} from "../cache/effectiveBalanceIncrements.js";
-import {BeaconStateAllForks, CachedBeaconStateAllForks} from "../types.js";
+import {BeaconStateAllForks, BeaconStateGloas, CachedBeaconStateAllForks} from "../types.js";
 import {computeEpochAtSlot, computeStartSlotAtEpoch} from "./epoch.js";
 
 /**
@@ -266,6 +268,60 @@ export function getNextSyncCommitteeIndices(
   );
 }
 
+export function naiveGetPayloadTimlinessCommitteeIndices(
+  state: BeaconStateGloas,
+  shuffling: {committees: Uint32Array[][]},
+  effectiveBalanceIncrements: EffectiveBalanceIncrements,
+  epoch: Epoch
+): ValidatorIndex[][] {
+  const epochSeed = getSeed(state, epoch, DOMAIN_PTC_ATTESTER);
+  const startSlot = computeStartSlotAtEpoch(epoch);
+  const committeeIndices = [];
+
+  for (let slot = startSlot; slot < startSlot + SLOTS_PER_EPOCH; slot++) {
+    const slotCommittees = shuffling.committees[slot % SLOTS_PER_EPOCH];
+    const indices = naiveComputePayloadTimelinessCommitteeIndices(
+      effectiveBalanceIncrements,
+      slotCommittees.flatMap((c) => Array.from(c)),
+      digest(Buffer.concat([epochSeed, intToBytes(slot, 8)]))
+    );
+    committeeIndices.push(indices);
+  }
+
+  return committeeIndices;
+}
+
+export function naiveComputePayloadTimelinessCommitteeIndices(
+  effectiveBalanceIncrements: EffectiveBalanceIncrements,
+  indices: ArrayLike<ValidatorIndex>,
+  seed: Uint8Array
+): ValidatorIndex[] {
+  if (indices.length === 0) {
+    throw Error("Validator indices must not be empty");
+  }
+
+  const result = [];
+
+  const MAX_RANDOM_VALUE = 2 ** 16 - 1;
+  const MAX_EFFECTIVE_BALANCE_INCREMENT = MAX_EFFECTIVE_BALANCE_ELECTRA / EFFECTIVE_BALANCE_INCREMENT;
+
+  let i = 0;
+  while (result.length < PTC_SIZE) {
+    const candidateIndex = indices[i % indices.length];
+    const randomBytes = digest(Buffer.concat([seed, intToBytes(Math.floor(i / 16), 8, "le")]));
+    const offset = (i % 16) * 2;
+    const randomValue = bytesToInt(randomBytes.subarray(offset, offset + 2));
+
+    const effectiveBalanceIncrement = effectiveBalanceIncrements[candidateIndex];
+    if (effectiveBalanceIncrement * MAX_RANDOM_VALUE >= MAX_EFFECTIVE_BALANCE_INCREMENT * randomValue) {
+      result.push(candidateIndex);
+    }
+    i += 1;
+  }
+
+  return result;
+}
+
 /**
  * Return the shuffled validator index corresponding to ``seed`` (and ``index_count``).
  *

package/src/util/validator.ts

@@ -7,7 +7,7 @@ import {
 } from "@lodestar/params";
 import {Epoch, ValidatorIndex, phase0} from "@lodestar/types";
 import {intDiv} from "@lodestar/utils";
-import {BeaconStateAllForks, CachedBeaconStateElectra, EpochCache} from "../types.js";
+import {BeaconStateAllForks, CachedBeaconStateElectra, CachedBeaconStateGloas, EpochCache} from "../types.js";
 import {hasCompoundingWithdrawalCredential} from "./electra.js";
 
 /**
@@ -94,12 +94,31 @@ export function getMaxEffectiveBalance(withdrawalCredentials: Uint8Array): numbe
   return MIN_ACTIVATION_BALANCE;
 }
 
-export function getPendingBalanceToWithdraw(state: CachedBeaconStateElectra, validatorIndex: ValidatorIndex): number {
+export function getPendingBalanceToWithdraw(
+  fork: ForkSeq,
+  state: CachedBeaconStateElectra | CachedBeaconStateGloas,
+  validatorIndex: ValidatorIndex
+): number {
   let total = 0;
   for (const item of state.pendingPartialWithdrawals.getAllReadonly()) {
     if (item.validatorIndex === validatorIndex) {
       total += Number(item.amount);
     }
   }
+
+  if (fork >= ForkSeq.gloas) {
+    const stateGloas = state as CachedBeaconStateGloas;
+    for (const item of stateGloas.builderPendingWithdrawals.getAllReadonly()) {
+      if (item.builderIndex === validatorIndex) {
+        total += item.amount;
+      }
+    }
+    for (const item of stateGloas.builderPendingPayments.getAllReadonly()) {
+      if (item.withdrawal.builderIndex === validatorIndex) {
+        total += item.withdrawal.amount;
+      }
+    }
+  }
+
   return total;
 }