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

package/src/stateView/stateViewFactory.ts

@@ -1,68 +1,70 @@
-import {type PubkeyCache, pubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
+import bindings from "@chainsafe/lodestar-z";
+import {pubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {BeaconConfig} from "@lodestar/config";
 import {createCachedBeaconState} from "../cache/stateCache.js";
-import {BeaconStateAllForks} from "../cache/types.js";
 import {getStateTypeFromBytes} from "../util/sszBytes.js";
 import {BeaconStateView} from "./beaconStateView.js";
-import {IBeaconStateView} from "./interface.js";
+import {IBeaconStateView, IBeaconStateViewNative} from "./interface.js";
+import {NativeBeaconStateView} from "./nativeBeaconStateView.js";
 
 // ---- createBeaconStateView (startup path) ----
 
-type NodeJSOpts = {
-  useNative: false;
-  anchorState: BeaconStateAllForks;
+type CreateBeaconStateViewOpts = {
+  nativeStateTransition: boolean;
   config: BeaconConfig;
-  pubkeyCache: PubkeyCache;
-};
-
-type NativeOpts = {
-  useNative: true;
   stateBytes: Uint8Array;
 };
 
 /**
- * Create a BeaconStateView from a pre-deserialized state. Used at node startup.
+ * Create a BeaconStateView from raw SSZ bytes. Used at node startup.
  *
- * The caller is responsible for creating and populating `pubkeyCache` (it is also
- * passed separately to BeaconNode.init, so it must live outside this factory).
+ * Caller must reserve pubkey capacity before calling this function.
  *
- * Set `useNative: true` to use the native (Zig) implementation once available.
+ * Set `nativeStateTransition: true` to use the native (Zig) implementation.
  */
-export function createBeaconStateView(opts: NodeJSOpts | NativeOpts): IBeaconStateView {
-  if (opts.useNative) {
-    throw new Error("Native (Zig) BeaconStateView not yet implemented");
-    // TODO: return a new instance of NativeBeaconStateView
+export function createBeaconStateView(opts: CreateBeaconStateViewOpts): IBeaconStateView {
+  if (opts.nativeStateTransition) {
+    return createNativeBeaconStateView(opts.config, opts.stateBytes);
   }
-  const {anchorState, config, pubkeyCache} = opts;
-  const cachedState = createCachedBeaconState(anchorState, {config, pubkeyCache}, {skipSyncPubkeys: true});
+  const {config, stateBytes} = opts;
+  const state = getStateTypeFromBytes(config, stateBytes).deserializeToViewDU(stateBytes);
+  const cachedState = createCachedBeaconState(state, {config, pubkeyCache}, {skipSyncPubkeys: false});
   return new BeaconStateView(cachedState);
 }
 
 // ---- createBeaconStateViewForHistoricalRegen (regen path) ----
 
 type RegenNodeJSOpts = {
-  useNative: false;
+  nativeStateTransition: false;
   config: BeaconConfig;
   stateBytes: Uint8Array;
 };
 
 type RegenNativeOpts = {
-  useNative: true;
+  nativeStateTransition: true;
+  config: BeaconConfig;
   stateBytes: Uint8Array;
 };
 
 /**
  * Create a BeaconStateView from raw SSZ bytes. Used in the historical state regen worker thread.
  *
- * Set `useNative: true` to use the native (Zig) implementation once available.
+ * Set `nativeStateTransition: true` to use the native (Zig) implementation.
  */
 export function createBeaconStateViewForHistoricalRegen(opts: RegenNodeJSOpts | RegenNativeOpts): IBeaconStateView {
-  if (opts.useNative) {
-    throw new Error("Native (Zig) BeaconStateView not yet implemented");
-    // TODO: return a new instance of NativeBeaconStateView
+  if (opts.nativeStateTransition) {
+    return createNativeBeaconStateView(opts.config, opts.stateBytes);
   }
   const {config, stateBytes} = opts;
   const state = getStateTypeFromBytes(config, stateBytes).deserializeToViewDU(stateBytes);
   const cachedState = createCachedBeaconState(state, {config, pubkeyCache}, {skipSyncPubkeys: true});
   return new BeaconStateView(cachedState);
 }
+
+function createNativeBeaconStateView(config: BeaconConfig, stateBytes: Uint8Array): IBeaconStateView {
+  const nativeConfig = new bindings.BeaconConfig(config, config.genesisValidatorsRoot);
+  return new NativeBeaconStateView(
+    config,
+    bindings.BeaconStateView.createFromBytes(stateBytes, nativeConfig) as IBeaconStateViewNative
+  );
+}

package/src/util/gloas.ts

@@ -178,21 +178,6 @@ export function initiateBuilderExit(state: CachedBeaconStateGloas, builderIndex:
   builder.withdrawableEpoch = currentEpoch + state.config.MIN_BUILDER_WITHDRAWABILITY_DELAY;
 }
 
-/**
- * Find the index of a builder by their public key.
- * Returns null if not found.
- *
- * May consider builder pubkey cache if performance becomes an issue.
- */
-export function findBuilderIndexByPubkey(state: CachedBeaconStateGloas, pubkey: Uint8Array): BuilderIndex | null {
-  for (let i = 0; i < state.builders.length; i++) {
-    if (byteArrayEquals(state.builders.getReadonly(i).pubkey, pubkey)) {
-      return i;
-    }
-  }
-  return null;
-}
-
 /**
  * Use cached block roots to avoid repeated state root lookups while matching the spec's is_attestation_same_slot behavior.
  */
@@ -248,41 +233,6 @@ export function getPtcWindowEpochCacheData(state: CachedBeaconStateGloas): {
   };
 }
 
-/**
- * Add a new builder to the builders registry. Reuses slots from exited and fully withdrawn
- * builders when available, otherwise appends.
- *
- * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.11/specs/gloas/beacon-chain.md#new-add_builder_to_registry
- */
-export function addBuilderToRegistry(
-  state: CachedBeaconStateGloas,
-  pubkey: Uint8Array,
-  version: number,
-  executionAddress: Uint8Array,
-  amount: number,
-  slot: number
-): void {
-  const currentEpoch = computeEpochAtSlot(state.slot);
-  const depositEpoch = computeEpochAtSlot(slot);
-
-  let builderIndex = state.builders.length;
-  for (let i = 0; i < state.builders.length; i++) {
-    const builder = state.builders.getReadonly(i);
-    if (builder.withdrawableEpoch <= currentEpoch && builder.balance === 0) {
-      builderIndex = i;
-      break;
-    }
-  }
-
-  const newBuilder = createBuilderView(pubkey, version, executionAddress, amount, depositEpoch);
-
-  if (builderIndex < state.builders.length) {
-    state.builders.set(builderIndex, newBuilder);
-  } else {
-    state.builders.push(newBuilder);
-  }
-}
-
 /**
  * Append a new builder to the registry without scanning for a reusable slot.
  *
@@ -301,10 +251,9 @@ export function appendBuilderToRegistry(
 }
 
 /**
- * Build a Builder view for registry insertion. Shared by the scan-based {@link addBuilderToRegistry}
- * and the append-only {@link appendBuilderToRegistry} so both paths produce an identical view.
+ * Build a Builder view from builder fields.
  */
-function createBuilderView(
+export function createBuilderView(
   pubkey: Uint8Array,
   version: number,
   executionAddress: Uint8Array,

package/src/util/index.ts

@@ -28,7 +28,12 @@ export * from "./signatureSets.js";
 export * from "./signingRoot.js";
 export * from "./slot.js";
 export * from "./ssz.js";
-export {type StateBytesMetadata, readBeaconStateBytesMetadata} from "./sszBytes.js";
+export {
+  type StateBytesMetadata,
+  getValidatorCountFromStateBytes,
+  getValidatorPubkeyFromStateBytes,
+  readBeaconStateBytesMetadata,
+} from "./sszBytes.js";
 export * from "./syncCommittee.js";
 export * from "./validator.js";
 export * from "./weakSubjectivity.js";

package/src/util/sszBytes.ts

@@ -19,7 +19,8 @@ const ROOT_SIZE = 32;
  *   withdrawable_epoch: Epoch [fixed - 8 bytes]
  * ```
  */
-const VALIDATOR_EFFECTIVE_BALANCE_OFFSET = 48 + ROOT_SIZE;
+const PUBKEY_SIZE = 48;
+const VALIDATOR_EFFECTIVE_BALANCE_OFFSET = PUBKEY_SIZE + ROOT_SIZE;
 const VALIDATOR_ACTIVATION_EPOCH_OFFSET = VALIDATOR_EFFECTIVE_BALANCE_OFFSET + UINT64_SIZE + 1 + UINT64_SIZE;
 const VALIDATOR_EXIT_EPOCH_OFFSET = VALIDATOR_ACTIVATION_EPOCH_OFFSET + UINT64_SIZE;
 export const VALIDATOR_BYTES_SIZE = VALIDATOR_EXIT_EPOCH_OFFSET + UINT64_SIZE + UINT64_SIZE;
@@ -77,25 +78,15 @@ export function scanActiveValidatorsFromStateBytes(
   stateType: SSZTypesFor<ForkAll, "BeaconState">,
   epoch: Epoch
 ): {activeValidatorCount: number; totalActiveBalanceIncrements: number} | null {
+  const range = getValidatorsRangeFromStateBytes(stateBytes, stateType);
+  if (range === null) {
+    return null;
+  }
+
   const data = {
     uint8Array: stateBytes,
     dataView: new DataView(stateBytes.buffer, stateBytes.byteOffset, stateBytes.byteLength),
   };
-  let range: {start: number; end: number};
-  try {
-    const containerType = stateType as (typeof ssz)[ForkAll]["BeaconState"];
-    const ranges = containerType.getFieldRanges(data.dataView, 0, stateBytes.length);
-    range = ranges[Object.keys(containerType.fields).indexOf("validators")];
-  } catch {
-    return null;
-  }
-  if (!range || range.start < 0 || range.end > stateBytes.length || range.end < range.start) {
-    return null;
-  }
-  if ((range.end - range.start) % VALIDATOR_BYTES_SIZE !== 0) {
-    return null;
-  }
-
   let activeValidatorCount = 0;
   let totalActiveBalanceIncrements = 0;
   for (let offset = range.start; offset < range.end; offset += VALIDATOR_BYTES_SIZE) {
@@ -121,3 +112,48 @@ export function scanActiveValidatorsFromStateBytes(
   }
   return {activeValidatorCount, totalActiveBalanceIncrements: Math.max(1, totalActiveBalanceIncrements)};
 }
+
+export function getValidatorCountFromStateBytes(config: ChainForkConfig, stateBytes: Uint8Array): number | null {
+  const range = getValidatorsRangeFromStateBytes(stateBytes, getStateTypeFromBytes(config, stateBytes));
+  // A non-null range always holds a whole number of validator records, so the division is exact
+  return range === null ? null : (range.end - range.start) / VALIDATOR_BYTES_SIZE;
+}
+
+/** Returns a view into `stateBytes`, or null if the index is not in the registry. */
+export function getValidatorPubkeyFromStateBytes(
+  config: ChainForkConfig,
+  stateBytes: Uint8Array,
+  index: number
+): Uint8Array | null {
+  const range = getValidatorsRangeFromStateBytes(stateBytes, getStateTypeFromBytes(config, stateBytes));
+  if (range === null) {
+    return null;
+  }
+  const start = range.start + index * VALIDATOR_BYTES_SIZE;
+  if (index < 0 || start >= range.end) {
+    return null;
+  }
+  return stateBytes.subarray(start, start + PUBKEY_SIZE);
+}
+
+function getValidatorsRangeFromStateBytes(
+  stateBytes: Uint8Array,
+  stateType: SSZTypesFor<ForkAll, "BeaconState">
+): {start: number; end: number} | null {
+  let range: {start: number; end: number};
+  try {
+    const containerType = stateType as (typeof ssz)[ForkAll]["BeaconState"];
+    const dataView = new DataView(stateBytes.buffer, stateBytes.byteOffset, stateBytes.byteLength);
+    const ranges = containerType.getFieldRanges(dataView, 0, stateBytes.length);
+    range = ranges[Object.keys(containerType.fields).indexOf("validators")];
+  } catch {
+    return null;
+  }
+  if (!range || range.start < 0 || range.end > stateBytes.length || range.end < range.start) {
+    return null;
+  }
+  if ((range.end - range.start) % VALIDATOR_BYTES_SIZE !== 0) {
+    return null;
+  }
+  return range;
+}