@lodestar/state-transition 1.41.0-dev.eb7efb2b90 → 1.41.0-dev.f225223000

package/src/cache/pubkeyCache.ts

@@ -1,33 +1,74 @@
 import {PublicKey} from "@chainsafe/blst";
 import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
-import {phase0} from "@lodestar/types";
+import {ValidatorIndex, phase0} from "@lodestar/types";
 
-export type Index2PubkeyCache = PublicKey[];
+/**
+ * Unified pubkey cache coupling index→pubkey and pubkey→index lookups.
+ * Both directions are kept in sync atomically via `set()`.
+ */
+export interface PubkeyCache {
+  /** Get deserialized PublicKey by validator index */
+  get(index: ValidatorIndex): PublicKey | undefined;
+  /** Get deserialized PublicKey by validator index or throw if not found */
+  getOrThrow(index: ValidatorIndex): PublicKey;
+  /** Get validator index by pubkey bytes */
+  getIndex(pubkey: Uint8Array): ValidatorIndex | null;
+  /** Set both directions atomically. Takes raw pubkey bytes — deserialization is handled internally. */
+  set(index: ValidatorIndex, pubkey: Uint8Array): void;
+  /** Number of entries */
+  readonly size: number;
+}
+
+class StandardPubkeyCache implements PubkeyCache {
+  private readonly pubkey2index: PubkeyIndexMap;
+  private readonly index2pubkey: (PublicKey | undefined)[];
+
+  constructor(pubkey2index?: PubkeyIndexMap, index2pubkey?: (PublicKey | undefined)[]) {
+    this.pubkey2index = pubkey2index ?? new PubkeyIndexMap();
+    this.index2pubkey = index2pubkey ?? [];
+  }
+
+  get size(): number {
+    return this.pubkey2index.size;
+  }
+
+  get(index: ValidatorIndex): PublicKey | undefined {
+    return this.index2pubkey[index];
+  }
+
+  getOrThrow(index: ValidatorIndex): PublicKey {
+    const pubkey = this.get(index);
+    if (!pubkey) throw Error(`Missing pubkey for validator index ${index}`);
+    return pubkey;
+  }
+
+  getIndex(pubkey: Uint8Array): ValidatorIndex | null {
+    return this.pubkey2index.get(pubkey);
+  }
+
+  set(index: ValidatorIndex, pubkey: Uint8Array): void {
+    this.pubkey2index.set(pubkey, index);
+    // Pubkeys must be checked for group + inf. This must be done only once when the validator deposit is processed.
+    // Afterwards any public key in the state is considered validated.
+    // > Do not do any validation here
+    this.index2pubkey[index] = PublicKey.fromBytes(pubkey); // Optimize for aggregation
+  }
+}
+
+export function createPubkeyCache(): PubkeyCache {
+  return new StandardPubkeyCache();
+}
 
 /**
  * Checks the pubkey indices against a state and adds missing pubkeys
  *
- * Mutates `pubkey2index` and `index2pubkey`
+ * Mutates `pubkeyCache`
  *
- * If pubkey caches are empty: SLOW CODE - 🐢
+ * If pubkey cache is empty: SLOW CODE - 🐢
  */
-export function syncPubkeys(
-  validators: phase0.Validator[],
-  pubkey2index: PubkeyIndexMap,
-  index2pubkey: Index2PubkeyCache
-): void {
-  if (pubkey2index.size !== index2pubkey.length) {
-    throw new Error(`Pubkey indices have fallen out of sync: ${pubkey2index.size} != ${index2pubkey.length}`);
-  }
-
+export function syncPubkeys(pubkeyCache: PubkeyCache, validators: phase0.Validator[]): void {
   const newCount = validators.length;
-  index2pubkey.length = newCount;
-  for (let i = pubkey2index.size; i < newCount; i++) {
-    const pubkey = validators[i].pubkey;
-    pubkey2index.set(pubkey, i);
-    // Pubkeys must be checked for group + inf. This must be done only once when the validator deposit is processed.
-    // Afterwards any public key is the state consider validated.
-    // > Do not do any validation here
-    index2pubkey[i] = PublicKey.fromBytes(pubkey); // Optimize for aggregation
+  for (let i = pubkeyCache.size; i < newCount; i++) {
+    pubkeyCache.set(i, validators[i].pubkey);
   }
 }

package/src/cache/stateCache.ts

@@ -1,4 +1,3 @@
-import {PublicKey} from "@chainsafe/blst";
 import {BeaconConfig} from "@lodestar/config";
 import {loadState} from "../util/loadState/loadState.js";
 import {EpochCache, EpochCacheImmutableData, EpochCacheOpts} from "./epochCache.js";
@@ -168,7 +167,7 @@ export function createCachedBeaconState<T extends BeaconStateAllForks>(
  * Check loadState() api for more details
  * // TODO: rename to loadUnfinalizedCachedBeaconState() due to ELECTRA
  */
-export function loadCachedBeaconState<T extends BeaconStateAllForks & BeaconStateCache>(
+export function loadCachedBeaconState<T extends CachedBeaconStateAllForks>(
   cachedSeedState: T,
   stateBytes: Uint8Array,
   opts?: EpochCacheOpts,
@@ -180,22 +179,19 @@ export function loadCachedBeaconState<T extends BeaconStateAllForks & BeaconStat
     stateBytes,
     seedValidatorsBytes
   );
-  const {pubkey2index, index2pubkey} = cachedSeedState.epochCtx;
+  const {pubkeyCache} = cachedSeedState.epochCtx;
   // Get the validators sub tree once for all the loop
   const validators = migratedState.validators;
   for (const validatorIndex of modifiedValidators) {
     const validator = validators.getReadonly(validatorIndex);
-    const pubkey = validator.pubkey;
-    pubkey2index.set(pubkey, validatorIndex);
-    index2pubkey[validatorIndex] = PublicKey.fromBytes(pubkey);
+    pubkeyCache.set(validatorIndex, validator.pubkey);
   }
 
   return createCachedBeaconState(
     migratedState,
     {
       config: cachedSeedState.config,
-      pubkey2index,
-      index2pubkey,
+      pubkeyCache,
     },
     {...(opts ?? {}), ...{skipSyncPubkeys: true}}
   ) as T;

package/src/cache/syncCommitteeCache.ts

@@ -1,4 +1,3 @@
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {CompositeViewDU} from "@chainsafe/ssz";
 import {ValidatorIndex, ssz} from "@lodestar/types";
 import {toPubkeyHex} from "@lodestar/utils";
@@ -39,9 +38,9 @@ export function getSyncCommitteeCache(validatorIndices: Uint32Array): SyncCommit
 
 export function computeSyncCommitteeCache(
   syncCommittee: CompositeViewDU<typeof ssz.altair.SyncCommittee>,
-  pubkey2index: PubkeyIndexMap
+  pubkeyCache: {getIndex(pubkey: Uint8Array): number | null}
 ): SyncCommitteeCache {
-  const validatorIndices = computeSyncCommitteeValidatorIndices(syncCommittee, pubkey2index);
+  const validatorIndices = computeSyncCommitteeValidatorIndices(syncCommittee, pubkeyCache);
   const validatorIndexMap = computeValidatorSyncCommitteeIndexMap(validatorIndices);
   return {
     validatorIndices,
@@ -79,12 +78,12 @@ export function computeValidatorSyncCommitteeIndexMap(
  */
 function computeSyncCommitteeValidatorIndices(
   syncCommittee: CompositeViewDU<typeof ssz.altair.SyncCommittee>,
-  pubkey2index: PubkeyIndexMap
+  pubkeyCache: {getIndex(pubkey: Uint8Array): number | null}
 ): Uint32Array {
   const pubkeys = syncCommittee.pubkeys.getAllReadonly();
   const validatorIndices = new Uint32Array(pubkeys.length);
   for (const [i, pubkey] of pubkeys.entries()) {
-    const validatorIndex = pubkey2index.get(pubkey);
+    const validatorIndex = pubkeyCache.getIndex(pubkey);
     if (validatorIndex === null) {
       throw Error(`SyncCommittee pubkey is unknown ${toPubkeyHex(pubkey)}`);
     }

package/src/index.ts

@@ -25,7 +25,7 @@ export {
   createEmptyEpochCacheImmutableData,
 } from "./cache/epochCache.js";
 export {type EpochTransitionCache, beforeProcessEpoch} from "./cache/epochTransitionCache.js";
-export {type Index2PubkeyCache, syncPubkeys} from "./cache/pubkeyCache.js";
+export {type PubkeyCache, createPubkeyCache, syncPubkeys} from "./cache/pubkeyCache.js";
 // Main state caches
 export {
   type BeaconStateCache,
@@ -35,12 +35,14 @@ export {
   isStateValidatorsNodesPopulated,
   loadCachedBeaconState,
 } from "./cache/stateCache.js";
+export {type SyncCommitteeCache} from "./cache/syncCommitteeCache.js";
 export * from "./constants/index.js";
 export type {EpochTransitionStep} from "./epoch/index.js";
 export {type BeaconStateTransitionMetrics, getMetrics} from "./metrics.js";
 export * from "./rewards/index.js";
 export * from "./signatureSets/index.js";
 export * from "./stateTransition.js";
+export * from "./stateView/index.js";
 export type {
   BeaconStateAllForks,
   BeaconStateAltair,

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/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/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");
   }