@lodestar/beacon-node 1.43.0-dev.aef3645690 → 1.43.0-dev.ca1fc40294

package/src/chain/stateCache/datastore/db.ts

@@ -1,6 +1,6 @@
 import {SLOTS_PER_EPOCH} from "@lodestar/params";
 import {Epoch, phase0, ssz} from "@lodestar/types";
-import {MapDef, byteArrayEquals} from "@lodestar/utils";
+import {MapDef} from "@lodestar/utils";
 import {IBeaconDb} from "../../../db/interface.js";
 import {
   getLastProcessedSlotFromBeaconStateSerialized,
@@ -14,8 +14,8 @@ import {CPStateDatastore, DatastoreKey} from "./types.js";
 export class DbCPStateDatastore implements CPStateDatastore {
   constructor(private readonly db: IBeaconDb) {}
 
-  async write(cpKey: phase0.Checkpoint, stateBytes: Uint8Array, payloadPresent: boolean): Promise<DatastoreKey> {
-    const serializedCheckpoint = checkpointToDatastoreKey(cpKey, payloadPresent);
+  async write(cpKey: phase0.Checkpoint, stateBytes: Uint8Array): Promise<DatastoreKey> {
+    const serializedCheckpoint = checkpointToDatastoreKey(cpKey);
     await this.db.checkpointState.putBinary(serializedCheckpoint, stateBytes);
     return serializedCheckpoint;
   }
@@ -40,30 +40,18 @@ export class DbCPStateDatastore implements CPStateDatastore {
   }
 }
 
-function extractCheckpointBytes(key: DatastoreKey): Uint8Array {
-  const fixedSize = ssz.phase0.Checkpoint.minSize;
-  return key.subarray(0, fixedSize);
-}
-
 export function datastoreKeyToCheckpoint(key: DatastoreKey): phase0.Checkpoint {
-  return ssz.phase0.Checkpoint.deserialize(extractCheckpointBytes(key));
-}
-
-export function checkpointToDatastoreKey(cp: phase0.Checkpoint, payloadPresent: boolean): DatastoreKey {
-  const cpBytes = ssz.phase0.Checkpoint.serialize(cp);
-  const key = new Uint8Array(cpBytes.length + 1);
-  key.set(cpBytes);
-  key[cpBytes.length] = payloadPresent ? 1 : 0;
-  return key;
+  return ssz.phase0.Checkpoint.deserialize(key);
 }
 
-function isPayloadCheckpointState(key: DatastoreKey): boolean {
-  return key.at(-1) === 1;
+export function checkpointToDatastoreKey(cp: phase0.Checkpoint): DatastoreKey {
+  return ssz.phase0.Checkpoint.serialize(cp);
 }
 
 /**
- * Get the latest "safe" checkpoint state the node can use to boot from
- *   - its last processed block slot should be at epoch boundary (CRCS) or last slot of previous epoch (PRCS)
+ * Get the latest safe checkpoint state the node can use to boot from
+ *   - it should be the checkpoint state that's unique in its epoch
+ *   - its last processed block slot should be at epoch boundary or last slot of previous epoch
  *   - state slot should be at epoch boundary
  *   - state slot should be equal to epoch * SLOTS_PER_EPOCH
  *
@@ -82,20 +70,9 @@ export async function getLatestSafeDatastoreKey(
 
   const dataStoreKeyByEpoch: Map<Epoch, DatastoreKey> = new Map();
   for (const [epoch, keys] of checkpointsByEpoch.entries()) {
+    // only consider epochs with a single checkpoint to avoid ambiguity from forks
     if (keys.length === 1) {
-      // PRCS (skipped slot) or CRCS and no payloadPresent
-      // Pre-gloas always fall into this case
       dataStoreKeyByEpoch.set(epoch, keys[0]);
-    } else if (keys.length === 2) {
-      // CRCS without payload and CRCS with payload
-      // ie Two keys for the same checkpoint with different payloadPresent suffix (FULL/EMPTY)
-      // TODO GLOAS: Here we pick FULL key, there is a chance that payload is orphaned hence we not be able to sync
-      const cp0 = extractCheckpointBytes(keys[0]);
-      const cp1 = extractCheckpointBytes(keys[1]);
-      if (byteArrayEquals(cp0, cp1)) {
-        const fullKey = isPayloadCheckpointState(keys[0]) ? keys[0] : keys[1];
-        dataStoreKeyByEpoch.set(epoch, fullKey);
-      }
     }
   }
 

package/src/chain/stateCache/datastore/file.ts

@@ -1,13 +1,12 @@
 import path from "node:path";
-import {phase0} from "@lodestar/types";
+import {phase0, ssz} from "@lodestar/types";
 import {fromHex, toHex} from "@lodestar/utils";
 import {ensureDir, readFile, readFileNames, removeFile, writeIfNotExist} from "../../../util/file.js";
-import {checkpointToDatastoreKey, getLatestSafeDatastoreKey} from "./db.js";
+import {getLatestSafeDatastoreKey} from "./db.js";
 import {CPStateDatastore, DatastoreKey} from "./types.js";
 
 const CHECKPOINT_STATES_FOLDER = "checkpoint_states";
-/** 41 bytes (40 checkpoint + 1 payloadPresent) = 82 hex chars + "0x" prefix = 84 */
-const CHECKPOINT_FILE_NAME_LENGTH = 84;
+const CHECKPOINT_FILE_NAME_LENGTH = 82;
 
 /**
  * Implementation of CPStateDatastore using file system, this is beneficial for debugging.
@@ -29,8 +28,8 @@ export class FileCPStateDatastore implements CPStateDatastore {
     }
   }
 
-  async write(cpKey: phase0.Checkpoint, stateBytes: Uint8Array, payloadPresent: boolean): Promise<DatastoreKey> {
-    const serializedCheckpoint = checkpointToDatastoreKey(cpKey, payloadPresent);
+  async write(cpKey: phase0.Checkpoint, stateBytes: Uint8Array): Promise<DatastoreKey> {
+    const serializedCheckpoint = ssz.phase0.Checkpoint.serialize(cpKey);
     const filePath = path.join(this.folderPath, toHex(serializedCheckpoint));
     await writeIfNotExist(filePath, stateBytes);
     return serializedCheckpoint;

package/src/chain/stateCache/datastore/types.ts

@@ -1,12 +1,11 @@
 import {phase0} from "@lodestar/types";
 
-// With db implementation, persistedKey is serialized data of a checkpoint + 1
-// ie a fixed size of `ssz.phase0.Checkpoint.minSize + 1`
+// With db implementation, persistedKey is serialized data of a checkpoint
 export type DatastoreKey = Uint8Array;
 
 // Make this generic to support testing
 export interface CPStateDatastore {
-  write: (cpKey: phase0.Checkpoint, stateBytes: Uint8Array, payloadPresent: boolean) => Promise<DatastoreKey>;
+  write: (cpKey: phase0.Checkpoint, stateBytes: Uint8Array) => Promise<DatastoreKey>;
   remove: (key: DatastoreKey) => Promise<void>;
   read: (key: DatastoreKey) => Promise<Uint8Array | null>;
   readLatestSafe: () => Promise<Uint8Array | null>;

package/src/chain/stateCache/fifoBlockStateCache.ts

@@ -20,11 +20,6 @@ export type FIFOBlockStateCacheOpts = {
  *                                                                                             clock slot
  */
 export const DEFAULT_MAX_BLOCK_STATES = 64;
-/**
- * For Gloas (ePBS), each block can have two states: block state and payload state.
- * Double the cache size to maintain the same effective block depth.
- */
-export const DEFAULT_MAX_BLOCK_STATES_GLOAS = 128;
 
 /**
  * New implementation of BlockStateCache that keeps the most recent n states consistently
@@ -46,7 +41,7 @@ export const DEFAULT_MAX_BLOCK_STATES_GLOAS = 128;
  * The maintained key order would be: 11 -> 13 -> 12 -> 10, and state 10 will be pruned first.
  */
 export class FIFOBlockStateCache implements BlockStateCache {
-  private maxStates: number;
+  readonly maxStates: number;
 
   private readonly cache: MapTracker<string, IBeaconStateView>;
   /**
@@ -172,10 +167,6 @@ export class FIFOBlockStateCache implements BlockStateCache {
     }
   }
 
-  upgradeToGloas(): void {
-    this.maxStates = DEFAULT_MAX_BLOCK_STATES_GLOAS;
-  }
-
   /**
    * No need for this implementation
    * This is only to conform to the old api