@lodestar/state-transition 1.41.0-dev.702f7932c2 → 1.41.0-dev.8578102bd2

package/src/lightClient/proofs.ts

@@ -0,0 +1,83 @@
+import {Tree} from "@chainsafe/persistent-merkle-tree";
+import {
+  BLOCK_BODY_EXECUTION_PAYLOAD_GINDEX,
+  FINALIZED_ROOT_GINDEX,
+  FINALIZED_ROOT_GINDEX_ELECTRA,
+  ForkName,
+  ForkPostBellatrix,
+  isForkPostElectra,
+} from "@lodestar/params";
+import {BeaconBlockBody, SSZTypesFor, ssz} from "@lodestar/types";
+import {BeaconStateAllForks, CachedBeaconStateAllForks} from "../types.js";
+import {SyncCommitteeWitness} from "./types.js";
+
+export function getSyncCommitteesWitness(fork: ForkName, state: BeaconStateAllForks): SyncCommitteeWitness {
+  const n1 = state.node;
+  let witness: Uint8Array[];
+  let currentSyncCommitteeRoot: Uint8Array;
+  let nextSyncCommitteeRoot: Uint8Array;
+
+  if (isForkPostElectra(fork)) {
+    const n2 = n1.left;
+    const n5 = n2.right;
+    const n10 = n5.left;
+    const n21 = n10.right;
+    const n43 = n21.right;
+
+    currentSyncCommitteeRoot = n43.left.root; // n86
+    nextSyncCommitteeRoot = n43.right.root; // n87
+
+    // Witness branch is sorted by descending gindex
+    witness = [
+      n21.left.root, // 42
+      n10.left.root, // 20
+      n5.right.root, // 11
+      n2.left.root, // 4
+      n1.right.root, // 3
+    ];
+  } else {
+    const n3 = n1.right; // [1]0110
+    const n6 = n3.left; // 1[0]110
+    const n13 = n6.right; // 10[1]10
+    const n27 = n13.right; // 101[1]0
+    currentSyncCommitteeRoot = n27.left.root; // n54 1011[0]
+    nextSyncCommitteeRoot = n27.right.root; // n55 1011[1]
+
+    // Witness branch is sorted by descending gindex
+    witness = [
+      n13.left.root, // 26
+      n6.left.root, // 12
+      n3.right.root, // 7
+      n1.left.root, // 2
+    ];
+  }
+
+  return {
+    witness,
+    currentSyncCommitteeRoot,
+    nextSyncCommitteeRoot,
+  };
+}
+
+export function getNextSyncCommitteeBranch(syncCommitteesWitness: SyncCommitteeWitness): Uint8Array[] {
+  // Witness branch is sorted by descending gindex
+  return [syncCommitteesWitness.currentSyncCommitteeRoot, ...syncCommitteesWitness.witness];
+}
+
+export function getCurrentSyncCommitteeBranch(syncCommitteesWitness: SyncCommitteeWitness): Uint8Array[] {
+  // Witness branch is sorted by descending gindex
+  return [syncCommitteesWitness.nextSyncCommitteeRoot, ...syncCommitteesWitness.witness];
+}
+
+export function getFinalizedRootProof(state: CachedBeaconStateAllForks): Uint8Array[] {
+  const finalizedRootGindex = state.epochCtx.isPostElectra() ? FINALIZED_ROOT_GINDEX_ELECTRA : FINALIZED_ROOT_GINDEX;
+  return new Tree(state.node).getSingleProof(BigInt(finalizedRootGindex));
+}
+
+export function getBlockBodyExecutionHeaderProof(
+  fork: ForkPostBellatrix,
+  body: BeaconBlockBody<ForkPostBellatrix>
+): Uint8Array[] {
+  const bodyView = (ssz[fork].BeaconBlockBody as SSZTypesFor<ForkPostBellatrix, "BeaconBlockBody">).toView(body);
+  return new Tree(bodyView.node).getSingleProof(BigInt(BLOCK_BODY_EXECUTION_PAYLOAD_GINDEX));
+}

package/src/lightClient/types.ts

@@ -0,0 +1,33 @@
+/**
+ * We aren't creating the sync committee proofs separately because our ssz library automatically adds leaves to composite types,
+ * so they're already included in the state proof, currently with no way to specify otherwise
+ *
+ * remove two offsets so the # of offsets in the state proof will be the # expected
+ * This is a hack, but properly setting the offsets in the state proof would require either removing witnesses needed for the committees
+ * or setting the roots of the committees in the state proof
+ * this will always be 1, syncProofLeavesLength
+ *
+ *
+ * With empty state (minimal)
+ * - `genesisTime = 0xffffffff`
+ * - `genesisValidatorsRoot = Buffer.alloc(32, 1)`
+ *
+ * Proof:
+ * ```
+ * offsets: [ 5, 4, 3, 2, 1 ]
+ * leaves: [
+ *   '0xffffffff00000000000000000000000000000000000000000000000000000000',
+ *   '0x0101010101010101010101010101010101010101010101010101010101010101',
+ *   '0xb11b8bcf59425d6c99019cca1d2c2e47b51a2f74917a67ad132274f43e13ec43',
+ *   '0x74bd1f2437cdf74b0904ee525d8da070a3fa27570942bf42cbab3dc5939600f0',
+ *   '0x7f06739e5a42360c56e519a511675901c95402ea9877edc0d9a87471b1374a6a',
+ *   '0x9f534204ba3c0b69fcb42a11987bfcbc5aea0463e5b0614312ded4b62cf3a380'
+ * ]
+ * ```
+ */
+export type SyncCommitteeWitness = {
+  /** Vector[Bytes32, 4] or Vector[Bytes32, 5] depending on the fork */
+  witness: Uint8Array[];
+  currentSyncCommitteeRoot: Uint8Array;
+  nextSyncCommitteeRoot: Uint8Array;
+};

package/src/rewards/attestationsRewards.ts

@@ -1,4 +1,3 @@
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {BeaconConfig} from "@lodestar/config";
 import {
   EFFECTIVE_BALANCE_INCREMENT,
@@ -16,6 +15,7 @@ import {
 import {ValidatorIndex, rewards} from "@lodestar/types";
 import {fromHex} from "@lodestar/utils";
 import {EpochTransitionCache, beforeProcessEpoch} from "../cache/epochTransitionCache.js";
+import {PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../types.js";
 import {
   FLAG_ELIGIBLE_ATTESTER,
@@ -34,7 +34,7 @@ const defaultAttestationsPenalty = {target: 0, source: 0};
 
 export async function computeAttestationsRewards(
   config: BeaconConfig,
-  pubkey2index: PubkeyIndexMap,
+  pubkeyCache: PubkeyCache,
   state: CachedBeaconStateAllForks,
   validatorIds?: (ValidatorIndex | string)[]
 ): Promise<rewards.AttestationsRewards> {
@@ -53,7 +53,7 @@ export async function computeAttestationsRewards(
   );
   const totalRewards = computeTotalAttestationsRewardsAltair(
     config,
-    pubkey2index,
+    pubkeyCache,
     stateAltair,
     transitionCache,
     idealRewards,
@@ -142,7 +142,7 @@ function computeIdealAttestationsRewardsAndPenaltiesAltair(
 // Same calculation as `getRewardsAndPenaltiesAltair` but returns the breakdown of rewards instead of aggregated
 function computeTotalAttestationsRewardsAltair(
   config: BeaconConfig,
-  pubkey2index: PubkeyIndexMap,
+  pubkeyCache: PubkeyCache,
   state: CachedBeaconStateAltair,
   transitionCache: EpochTransitionCache,
   idealRewards: rewards.IdealAttestationsReward[],
@@ -153,7 +153,7 @@ function computeTotalAttestationsRewardsAltair(
   const {flags} = transitionCache;
   const {epochCtx} = state;
   const validatorIndices = validatorIds
-    .map((id) => (typeof id === "number" ? id : pubkey2index.get(fromHex(id))))
+    .map((id) => (typeof id === "number" ? id : pubkeyCache.getIndex(fromHex(id))))
     .filter((index) => index !== undefined); // Validator indices to include in the result
 
   const inactivityPenaltyDenominator = config.INACTIVITY_SCORE_BIAS * INACTIVITY_PENALTY_QUOTIENT_ALTAIR;

package/src/rewards/syncCommitteeRewards.ts

@@ -1,12 +1,12 @@
 import {BeaconConfig} from "@lodestar/config";
 import {ForkName, SYNC_COMMITTEE_SIZE} from "@lodestar/params";
 import {BeaconBlock, ValidatorIndex, altair, rewards} from "@lodestar/types";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
+import {PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../cache/stateCache.js";
 
 export async function computeSyncCommitteeRewards(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
+  pubkeyCache: PubkeyCache,
   block: BeaconBlock,
   preState: CachedBeaconStateAllForks,
   validatorIds: (ValidatorIndex | string)[] = []
@@ -47,9 +47,10 @@ export async function computeSyncCommitteeRewards(
 
   if (validatorIds.length) {
     const filtersSet = new Set(validatorIds);
-    return rewards.filter(
-      (reward) => filtersSet.has(reward.validatorIndex) || filtersSet.has(index2pubkey[reward.validatorIndex].toHex())
-    );
+    return rewards.filter((reward) => {
+      const pubkeyHex = pubkeyCache.get(reward.validatorIndex)?.toHex();
+      return filtersSet.has(reward.validatorIndex) || (pubkeyHex !== undefined && filtersSet.has(pubkeyHex));
+    });
   }
 
   return rewards;

package/src/signatureSets/indexedPayloadAttestation.ts

@@ -1,26 +1,24 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_PTC_ATTESTER} from "@lodestar/params";
-import {Slot, gloas, ssz} from "@lodestar/types";
-import {CachedBeaconStateGloas} from "../types.js";
+import {gloas, ssz} from "@lodestar/types";
 import {ISignatureSet, computeSigningRoot, createAggregateSignatureSetFromComponents} from "../util/index.js";
 
 export function getIndexedPayloadAttestationSignatureSet(
-  state: CachedBeaconStateGloas,
+  config: BeaconConfig,
   indexedPayloadAttestation: gloas.IndexedPayloadAttestation
 ): ISignatureSet {
   return createAggregateSignatureSetFromComponents(
     indexedPayloadAttestation.attestingIndices,
-    getPayloadAttestationDataSigningRoot(state.config, state.slot, indexedPayloadAttestation.data),
+    getPayloadAttestationDataSigningRoot(config, indexedPayloadAttestation.data),
     indexedPayloadAttestation.signature
   );
 }
 
 export function getPayloadAttestationDataSigningRoot(
   config: BeaconConfig,
-  stateSlot: Slot,
   data: gloas.PayloadAttestationData
 ): Uint8Array {
-  const domain = config.getDomain(stateSlot, DOMAIN_PTC_ATTESTER);
+  const domain = config.getDomain(data.slot, DOMAIN_PTC_ATTESTER);
 
   return computeSigningRoot(ssz.gloas.PayloadAttestationData, data, domain);
 }

package/src/signatureSets/proposer.ts

@@ -1,17 +1,17 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
 import {SignedBeaconBlock, SignedBlindedBeaconBlock, Slot, isBlindedBeaconBlock, phase0, ssz} from "@lodestar/types";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
+import {PubkeyCache} from "../cache/pubkeyCache.js";
 import {computeSigningRoot} from "../util/index.js";
 import {ISignatureSet, SignatureSetType, verifySignatureSet} from "../util/signatureSets.js";
 
 export function verifyProposerSignature(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
+  pubkeyCache: PubkeyCache,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): boolean {
   const signatureSet = getBlockProposerSignatureSet(config, signedBlock);
-  return verifySignatureSet(signatureSet, index2pubkey);
+  return verifySignatureSet(signatureSet, pubkeyCache);
 }
 
 export function getBlockProposerSignatureSet(

package/src/signatureSets/randao.ts

@@ -1,7 +1,7 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_RANDAO} from "@lodestar/params";
 import {BeaconBlock, ssz} from "@lodestar/types";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
+import {PubkeyCache} from "../cache/pubkeyCache.js";
 import {
   ISignatureSet,
   SignatureSetType,
@@ -10,12 +10,8 @@ import {
   verifySignatureSet,
 } from "../util/index.js";
 
-export function verifyRandaoSignature(
-  config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
-  block: BeaconBlock
-): boolean {
-  return verifySignatureSet(getRandaoRevealSignatureSet(config, block), index2pubkey);
+export function verifyRandaoSignature(config: BeaconConfig, pubkeyCache: PubkeyCache, block: BeaconBlock): boolean {
+  return verifySignatureSet(getRandaoRevealSignatureSet(config, block), pubkeyCache);
 }
 
 /**

package/src/signatureSets/voluntaryExits.ts

@@ -1,6 +1,6 @@
 import {BeaconConfig} from "@lodestar/config";
 import {SignedBeaconBlock, Slot, phase0, ssz} from "@lodestar/types";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
+import {PubkeyCache} from "../cache/pubkeyCache.js";
 import {
   ISignatureSet,
   SignatureSetType,
@@ -11,11 +11,11 @@ import {
 
 export function verifyVoluntaryExitSignature(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
+  pubkeyCache: PubkeyCache,
   stateSlot: Slot,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): boolean {
-  return verifySignatureSet(getVoluntaryExitSignatureSet(config, stateSlot, signedVoluntaryExit), index2pubkey);
+  return verifySignatureSet(getVoluntaryExitSignatureSet(config, stateSlot, signedVoluntaryExit), pubkeyCache);
 }
 
 /**

package/src/slot/upgradeStateToGloas.ts

@@ -1,7 +1,12 @@
 import {SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
+import {toHex} from "@lodestar/utils";
+import {isValidDepositSignature} from "../block/processDeposit.js";
+import {applyDepositForBuilder} from "../block/processDepositRequest.js";
 import {getCachedBeaconState} from "../cache/stateCache.js";
 import {CachedBeaconStateFulu, CachedBeaconStateGloas} from "../types.js";
+import {isBuilderWithdrawalCredential} from "../util/gloas.js";
+import {isValidatorKnown} from "../util/index.js";
 
 /**
  * Upgrade a state from Fulu to Gloas.
@@ -64,6 +69,9 @@ export function upgradeStateToGloas(stateFulu: CachedBeaconStateFulu): CachedBea
 
   const stateGloas = getCachedBeaconState(stateGloasView, stateFulu);
 
+  // Process pending builder deposits at the fork boundary
+  onboardBuildersFromPendingDeposits(stateGloas);
+
   stateGloas.commit();
   // Clear cache to ensure the cache of fulu fields is not used by new gloas fields
   // biome-ignore lint/complexity/useLiteralKeys: It is a protected attribute
@@ -71,3 +79,69 @@ export function upgradeStateToGloas(stateFulu: CachedBeaconStateFulu): CachedBea
 
   return stateGloas;
 }
+
+/**
+ * Applies any pending deposits for builders to onboard builders during the fork transition
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.2/specs/gloas/fork.md#new-onboard_builders_from_pending_deposits
+ */
+function onboardBuildersFromPendingDeposits(state: CachedBeaconStateGloas): void {
+  // Track pubkeys of new validators to keep their deposits pending
+  const validatorPubkeys = new Set<string>();
+
+  // Track pubkeys of new builders added when applying deposits
+  const builderPubkeys = new Set<string>();
+
+  const remainingPendingDeposits = ssz.electra.PendingDeposits.defaultViewDU();
+  for (let i = 0; i < state.pendingDeposits.length; i++) {
+    const deposit = state.pendingDeposits.getReadonly(i);
+
+    const validatorIndex = state.epochCtx.getValidatorIndex(deposit.pubkey);
+    const pubkeyHex = toHex(deposit.pubkey);
+
+    // Deposits for existing validators stay in pending queue
+    if (isValidatorKnown(state, validatorIndex) || validatorPubkeys.has(pubkeyHex)) {
+      remainingPendingDeposits.push(deposit);
+      continue;
+    }
+
+    // If the pubkey is associated with a builder that was created in a previous iteration
+    // or it is a builder deposit, try to apply the deposit to the new/existing builder
+    const isExistingBuilder = builderPubkeys.has(pubkeyHex);
+    const hasBuilderCredentials = isBuilderWithdrawalCredential(deposit.withdrawalCredentials);
+    if (isExistingBuilder || hasBuilderCredentials) {
+      const buildersLenBefore = state.builders.length;
+      applyDepositForBuilder(
+        state,
+        deposit.pubkey,
+        deposit.withdrawalCredentials,
+        deposit.amount,
+        deposit.signature,
+        deposit.slot
+      );
+      // Track newly added builders for subsequent iterations
+      if (!isExistingBuilder && state.builders.length > buildersLenBefore) {
+        builderPubkeys.add(pubkeyHex);
+      }
+      continue;
+    }
+
+    // If there is a pending deposit for a new validator that has a valid signature, track the
+    // pubkey so that subsequent builder deposits for the same pubkey stay in pending (applied to
+    // the validator later) rather than creating a builder. Deposits with invalid signatures are
+    // dropped here since they would fail in apply_pending_deposit anyway.
+    if (
+      isValidDepositSignature(
+        state.config,
+        deposit.pubkey,
+        deposit.withdrawalCredentials,
+        deposit.amount,
+        deposit.signature
+      )
+    ) {
+      validatorPubkeys.add(pubkeyHex);
+      remainingPendingDeposits.push(deposit);
+    }
+  }
+
+  state.pendingDeposits = remainingPendingDeposits;
+}

package/src/stateTransition.ts

@@ -76,6 +76,7 @@ export enum StateHashTreeRootSource {
   prepareNextEpoch = "prepare_next_epoch",
   regenState = "regen_state",
   computeNewStateRoot = "compute_new_state_root",
+  computeEnvelopeStateRoot = "compute_envelope_state_root",
 }
 
 /**
@@ -111,7 +112,7 @@ export function stateTransition(
   postState = processSlotsWithTransientCache(postState, blockSlot, options, {metrics, validatorMonitor});
 
   // Verify proposer signature only
-  if (verifyProposer && !verifyProposerSignature(postState.config, postState.epochCtx.index2pubkey, signedBlock)) {
+  if (verifyProposer && !verifyProposerSignature(postState.config, postState.epochCtx.pubkeyCache, signedBlock)) {
     throw new Error("Invalid block signature");
   }