rename electra fork to peerdas for rebase and make csc in metadata uint8

packages/beacon-node/src/api/impl/beacon/blocks/index.ts

@@ -9,7 +9,7 @@ import {
 import {ForkExecution, SLOTS_PER_HISTORICAL_ROOT, isForkExecution, ForkName} from "@lodestar/params";
 import {sleep, fromHex, toHex} from "@lodestar/utils";
 import {
-  electra,
+  peerdas,
   deneb,
   isSignedBlockContents,
   ProducedBlockSource,
@@ -72,13 +72,13 @@ export function getBeaconBlockApi({
     let blockForImport: BlockInput,
       signedBlock: SignedBeaconBlock,
       blobSidecars: deneb.BlobSidecars,
-      dataColumnSidecars: electra.DataColumnSidecars;
+      dataColumnSidecars: peerdas.DataColumnSidecars;
 
     if (isSignedBlockContents(signedBlockOrContents)) {
       ({signedBlock} = signedBlockOrContents);
       const fork = config.getForkName(signedBlock.message.slot);
       let blockData: BlockInputData;
-      if (fork === ForkName.electra) {
+      if (fork === ForkName.peerdas) {
         dataColumnSidecars = computeDataColumnSidecars(config, signedBlock, signedBlockOrContents);
         blockData = {
           fork,

packages/beacon-node/src/chain/blocks/importBlock.ts

@@ -135,7 +135,7 @@ export async function importBlock(
             versionedHash: toHexString(kzgCommitmentToVersionedHash(kzgCommitment)),
           });
         }
-      } else if (blockData.fork === ForkName.electra) {
+      } else if (blockData.fork === ForkName.peerdas) {
         // TODO peerDAS build and emit the event for the datacolumns
       }
     }

packages/beacon-node/src/chain/blocks/types.ts

@@ -1,6 +1,6 @@
 import {CachedBeaconStateAllForks, computeEpochAtSlot} from "@lodestar/state-transition";
 import {MaybeValidExecutionStatus, DataAvailabilityStatus} from "@lodestar/fork-choice";
-import {deneb, Slot, RootHex, SignedBeaconBlock, electra, ColumnIndex} from "@lodestar/types";
+import {deneb, Slot, RootHex, SignedBeaconBlock, peerdas, ColumnIndex} from "@lodestar/types";
 import {ForkSeq, ForkName} from "@lodestar/params";
 import {ChainForkConfig} from "@lodestar/config";
 
@@ -45,19 +45,19 @@ export enum GossipedInputType {
 export type BlobsCacheMap = Map<number, {blobSidecar: deneb.BlobSidecar; blobBytes: Uint8Array | null}>;
 export type DataColumnsCacheMap = Map<
   number,
-  {dataColumnSidecar: electra.DataColumnSidecar; dataColumnBytes: Uint8Array | null}
+  {dataColumnSidecar: peerdas.DataColumnSidecar; dataColumnBytes: Uint8Array | null}
 >;
 
 type ForkBlobsInfo = {fork: ForkName.deneb};
 type BlobsData = {blobs: deneb.BlobSidecars; blobsBytes: (Uint8Array | null)[]; blobsSource: BlobsSource};
 export type BlockInputDataBlobs = ForkBlobsInfo & BlobsData;
 
-type ForkDataColumnsInfo = {fork: ForkName.electra};
+type ForkDataColumnsInfo = {fork: ForkName.peerdas};
 type DataColumnsData = {
   // marker of that columns are to be custodied
   dataColumnsLen: number;
   dataColumnsIndex: Uint8Array;
-  dataColumns: electra.DataColumnSidecars;
+  dataColumns: peerdas.DataColumnSidecars;
   dataColumnsBytes: (Uint8Array | null)[];
   dataColumnsSource: DataColumnsSource;
 };

packages/beacon-node/src/chain/blocks/verifyBlocksDataAvailability.ts

@@ -115,7 +115,7 @@ async function maybeValidateBlobs(
         // but other checks to match blobs with block data still need to be performed
         const skipProofsCheck = opts.validBlobSidecars === BlobSidecarValidation.Individual;
         validateBlobSidecars(blockSlot, beaconBlockRoot, blobKzgCommitments, blobs, {skipProofsCheck});
-      } else if (blockData.fork === ForkName.electra) {
+      } else if (blockData.fork === ForkName.peerdas) {
         const {dataColumns} = blockData;
         const skipProofsCheck = opts.validBlobSidecars === BlobSidecarValidation.Individual;
         // might require numColumns, custodyColumns from blockData as input to below

packages/beacon-node/src/chain/blocks/writeBlockInputToDb.ts

@@ -1,6 +1,6 @@
 import {ForkName} from "@lodestar/params";
 import {toHex} from "@lodestar/utils";
-import {electra, ssz} from "@lodestar/types";
+import {peerdas, ssz} from "@lodestar/types";
 import {BeaconChain} from "../chain.js";
 import {BlockInput, BlockInputType} from "./types.js";
 
@@ -48,11 +48,11 @@ export async function writeBlockInputToDb(this: BeaconChain, blocksInput: BlockI
         });
       } else {
         const {dataColumnsLen, dataColumnsIndex, dataColumns: dataColumnSidecars} = blockData;
-        const blobsLen = (block.message as electra.BeaconBlock).body.blobKzgCommitments.length;
+        const blobsLen = (block.message as peerdas.BeaconBlock).body.blobKzgCommitments.length;
 
         const dataColumnsSize =
-          ssz.electra.DataColumnSidecar.minSize +
-          blobsLen * (ssz.electra.Cell.fixedSize + ssz.deneb.KZGCommitment.fixedSize + ssz.deneb.KZGProof.fixedSize);
+          ssz.peerdas.DataColumnSidecar.minSize +
+          blobsLen * (ssz.peerdas.Cell.fixedSize + ssz.deneb.KZGCommitment.fixedSize + ssz.deneb.KZGProof.fixedSize);
         const slot = block.message.slot;
         const writeData = {
           blockRoot,
@@ -99,8 +99,8 @@ export async function removeEagerlyPersistedBlockInputs(this: BeaconChain, block
           blobsToRemove.push({blockRoot, slot, blobSidecars});
         } else {
           const {dataColumnsLen, dataColumnsIndex, dataColumns: dataColumnSidecars} = blockData;
-          const blobsLen = (block.message as electra.BeaconBlock).body.blobKzgCommitments.length;
-          const dataColumnsSize = ssz.electra.Cell.fixedSize * blobsLen;
+          const blobsLen = (block.message as peerdas.BeaconBlock).body.blobKzgCommitments.length;
+          const dataColumnsSize = ssz.peerdas.Cell.fixedSize * blobsLen;
 
           dataColumnsToRemove.push({
             blockRoot,

packages/beacon-node/src/chain/seenCache/seenGossipBlockInput.ts

@@ -1,5 +1,5 @@
 import {toHexString} from "@chainsafe/ssz";
-import {deneb, RootHex, SignedBeaconBlock, ssz, electra} from "@lodestar/types";
+import {deneb, RootHex, SignedBeaconBlock, ssz, peerdas} from "@lodestar/types";
 import {ChainForkConfig} from "@lodestar/config";
 import {pruneSetToMax} from "@lodestar/utils";
 import {BLOBSIDECAR_FIXED_SIZE, isForkBlobs, ForkName, NUMBER_OF_COLUMNS} from "@lodestar/params";
@@ -31,7 +31,7 @@ type GossipedBlockInput =
   | {type: GossipedInputType.blob; blobSidecar: deneb.BlobSidecar; blobBytes: Uint8Array | null}
   | {
       type: GossipedInputType.dataColumn;
-      dataColumnSidecar: electra.DataColumnSidecar;
+      dataColumnSidecar: peerdas.DataColumnSidecar;
       dataColumnBytes: Uint8Array | null;
     };
 
@@ -127,8 +127,8 @@ export class SeenGossipBlockInput {
 
       blockHex = toHexString(blockRoot);
       blockCache = this.blockInputCache.get(blockHex) ?? getEmptyBlockInputCacheEntry(fork);
-      if (blockCache.cachedData?.fork !== ForkName.electra) {
-        throw Error(`blob data at non electra fork=${blockCache.fork}`);
+      if (blockCache.cachedData?.fork !== ForkName.peerdas) {
+        throw Error(`blob data at non peerdas fork=${blockCache.fork}`);
       }
 
       // TODO: freetheblobs check if its the same blob or a duplicate and throw/take actions
@@ -215,7 +215,7 @@ export class SeenGossipBlockInput {
             },
           };
         }
-      } else if (cachedData.fork === ForkName.electra) {
+      } else if (cachedData.fork === ForkName.peerdas) {
         const {dataColumnsCache} = cachedData;
 
         // block is available, check if all blobs have shown up
@@ -330,7 +330,7 @@ export class SeenGossipBlockInput {
           },
           blockInputMeta: {pending: GossipedInputType.block, haveBlobs: blobsCache.size, expectedBlobs: null},
         };
-      } else if (fork === ForkName.electra) {
+      } else if (fork === ForkName.peerdas) {
         const {dataColumnsCache} = cachedData;
 
         return {
@@ -376,7 +376,7 @@ export function getEmptyBlockInputCacheEntry(fork: ForkName): BlockInputCacheTyp
     const blobsCache = new Map();
     const cachedData: CachedData = {fork, blobsCache, availabilityPromise, resolveAvailability};
     return {fork, blockInputPromise, resolveBlockInput, cachedData};
-  } else if (fork === ForkName.electra) {
+  } else if (fork === ForkName.peerdas) {
     let resolveAvailability: ((blobs: BlockInputDataDataColumns) => void) | null = null;
     const availabilityPromise = new Promise<BlockInputDataDataColumns>((resolveCB) => {
       resolveAvailability = resolveCB;

packages/beacon-node/src/chain/validation/dataColumnSidecar.ts

@@ -4,7 +4,7 @@ import {
   DATA_COLUMN_SIDECAR_SUBNET_COUNT,
   NUMBER_OF_COLUMNS,
 } from "@lodestar/params";
-import {ssz, deneb, electra, Slot, Root} from "@lodestar/types";
+import {ssz, deneb, peerdas, Slot, Root} from "@lodestar/types";
 import {verifyMerkleBranch} from "@lodestar/utils";
 
 import {DataColumnSidecarGossipError, DataColumnSidecarErrorCode} from "../errors/dataColumnSidecarError.js";
@@ -13,7 +13,7 @@ import {IBeaconChain} from "../interface.js";
 
 export async function validateGossipDataColumnSidecar(
   chain: IBeaconChain,
-  dataColumnSideCar: electra.DataColumnSidecar,
+  dataColumnSideCar: peerdas.DataColumnSidecar,
   gossipIndex: number
 ): Promise<void> {
   const dataColumnSlot = dataColumnSideCar.signedBlockHeader.message.slot;
@@ -48,14 +48,14 @@ export function validateDataColumnsSidecars(
   _blockSlot: Slot,
   _blockRoot: Root,
   _expectedKzgCommitments: deneb.BlobKzgCommitments,
-  _dataColumnSidecars: electra.DataColumnSidecars,
+  _dataColumnSidecars: peerdas.DataColumnSidecars,
   _opts: {skipProofsCheck: boolean} = {skipProofsCheck: false}
 ): void {
   // stubbed
   return;
 }
 
-function validateInclusionProof(dataColumnSidecar: electra.DataColumnSidecar): boolean {
+function validateInclusionProof(dataColumnSidecar: peerdas.DataColumnSidecar): boolean {
   return verifyMerkleBranch(
     ssz.deneb.BlobKzgCommitments.hashTreeRoot(dataColumnSidecar.kzgCommitments),
     dataColumnSidecar.kzgCommitmentsInclusionProof,

packages/beacon-node/src/db/buckets.ts

@@ -62,8 +62,8 @@ export enum Bucket {
   // lightClient_bestLightClientUpdate = 55, // SyncPeriod -> LightClientUpdate // DEPRECATED on v1.5.0
   lightClient_bestLightClientUpdate = 56, // SyncPeriod -> [Slot, LightClientUpdate]
 
-  allForks_dataColumnSidecars = 57, // ELECTRA BeaconBlockRoot -> DataColumnSidecars
-  allForks_dataColumnSidecarsArchive = 58, // ELECTRA BeaconBlockSlot -> DataColumnSidecars
+  allForks_dataColumnSidecars = 57, // PEERDAS BeaconBlockRoot -> DataColumnSidecars
+  allForks_dataColumnSidecarsArchive = 58, // PEERDAS BeaconBlockSlot -> DataColumnSidecars
 }
 
 export function getBucketNameByValue<T extends Bucket>(enumValue: T): keyof typeof Bucket {

packages/beacon-node/src/db/repositories/dataColumnSidecars.ts

@@ -15,7 +15,7 @@ export const dataColumnSidecarsWrapperSsz = new ContainerType(
     // // each byte[i] tells what index (1 based) the column i is stored, 0 means not custodied
     // max value to represent will be 128 which can be represented in a byte
     dataColumnsIndex: new ByteVectorType(NUMBER_OF_COLUMNS),
-    dataColumnSidecars: ssz.electra.DataColumnSidecars,
+    dataColumnSidecars: ssz.peerdas.DataColumnSidecars,
   },
   {typeName: "DataColumnSidecarsWrapper", jsonCase: "eth2"}
 );

packages/beacon-node/src/network/gossip/interface.ts

@@ -11,7 +11,7 @@ import {
   phase0,
   SignedBeaconBlock,
   Slot,
-  electra,
+  peerdas,
 } from "@lodestar/types";
 import {BeaconConfig} from "@lodestar/config";
 import {Logger} from "@lodestar/utils";
@@ -83,7 +83,7 @@ export type SSZTypeOfGossipTopic<T extends GossipTopic> = T extends {type: infer
 export type GossipTypeMap = {
   [GossipType.beacon_block]: SignedBeaconBlock;
   [GossipType.blob_sidecar]: deneb.BlobSidecar;
-  [GossipType.data_column_sidecar]: electra.DataColumnSidecar;
+  [GossipType.data_column_sidecar]: peerdas.DataColumnSidecar;
   [GossipType.beacon_aggregate_and_proof]: phase0.SignedAggregateAndProof;
   [GossipType.beacon_attestation]: phase0.Attestation;
   [GossipType.voluntary_exit]: phase0.SignedVoluntaryExit;
@@ -99,7 +99,7 @@ export type GossipTypeMap = {
 export type GossipFnByType = {
   [GossipType.beacon_block]: (signedBlock: SignedBeaconBlock) => Promise<void> | void;
   [GossipType.blob_sidecar]: (blobSidecar: deneb.BlobSidecar) => Promise<void> | void;
-  [GossipType.data_column_sidecar]: (blobSidecar: electra.DataColumnSidecar) => Promise<void> | void;
+  [GossipType.data_column_sidecar]: (blobSidecar: peerdas.DataColumnSidecar) => Promise<void> | void;
   [GossipType.beacon_aggregate_and_proof]: (aggregateAndProof: phase0.SignedAggregateAndProof) => Promise<void> | void;
   [GossipType.beacon_attestation]: (attestation: phase0.Attestation) => Promise<void> | void;
   [GossipType.voluntary_exit]: (voluntaryExit: phase0.SignedVoluntaryExit) => Promise<void> | void;

packages/beacon-node/src/network/gossip/topic.ts

@@ -90,7 +90,7 @@ export function getGossipSSZType(topic: GossipTopic) {
     case GossipType.blob_sidecar:
       return ssz.deneb.BlobSidecar;
     case GossipType.data_column_sidecar:
-      return ssz.electra.DataColumnSidecar;
+      return ssz.peerdas.DataColumnSidecar;
     case GossipType.beacon_aggregate_and_proof:
       return ssz.phase0.SignedAggregateAndProof;
     case GossipType.beacon_attestation:
@@ -224,8 +224,8 @@ export function getCoreTopicsAtFork(
     {type: GossipType.attester_slashing},
   ];
 
-  // After Electra also track data_column_sidecar_{index}
-  if (ForkSeq[fork] >= ForkSeq.electra) {
+  // After Peerdas also track data_column_sidecar_{index}
+  if (ForkSeq[fork] >= ForkSeq.peerdas) {
     for (let index = 0; index < DATA_COLUMN_SIDECAR_SUBNET_COUNT; index++) {
       topics.push({type: GossipType.data_column_sidecar, index});
     }

packages/beacon-node/src/network/interface.ts

@@ -26,7 +26,7 @@ import {
   capella,
   deneb,
   phase0,
-  electra,
+  peerdas,
 } from "@lodestar/types";
 import {PeerIdStr} from "../util/peerId.js";
 import {CustodyConfig} from "../util/dataColumns.js";
@@ -77,17 +77,17 @@ export interface INetwork extends INetworkCorePublic {
   sendBlobSidecarsByRoot(peerId: PeerIdStr, request: deneb.BlobSidecarsByRootRequest): Promise<deneb.BlobSidecar[]>;
   sendDataColumnSidecarsByRange(
     peerId: PeerIdStr,
-    request: electra.DataColumnSidecarsByRangeRequest
-  ): Promise<electra.DataColumnSidecar[]>;
+    request: peerdas.DataColumnSidecarsByRangeRequest
+  ): Promise<peerdas.DataColumnSidecar[]>;
   sendDataColumnSidecarsByRoot(
     peerId: PeerIdStr,
-    request: electra.DataColumnSidecarsByRootRequest
-  ): Promise<electra.DataColumnSidecar[]>;
+    request: peerdas.DataColumnSidecarsByRootRequest
+  ): Promise<peerdas.DataColumnSidecar[]>;
 
   // Gossip
   publishBeaconBlock(signedBlock: SignedBeaconBlock): Promise<number>;
   publishBlobSidecar(blobSidecar: deneb.BlobSidecar): Promise<number>;
-  publishDataColumnSidecar(dataColumnSideCar: electra.DataColumnSidecar): Promise<number>;
+  publishDataColumnSidecar(dataColumnSideCar: peerdas.DataColumnSidecar): Promise<number>;
   publishBeaconAggregateAndProof(aggregateAndProof: phase0.SignedAggregateAndProof): Promise<number>;
   publishBeaconAttestation(attestation: phase0.Attestation, subnet: number): Promise<number>;
   publishVoluntaryExit(voluntaryExit: phase0.SignedVoluntaryExit): Promise<number>;

packages/beacon-node/src/network/metadata.ts

@@ -1,7 +1,7 @@
 import {BitArray} from "@chainsafe/ssz";
 import {ForkSeq} from "@lodestar/params";
 import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {altair, Epoch, phase0, ssz, electra} from "@lodestar/types";
+import {altair, Epoch, phase0, ssz, peerdas} from "@lodestar/types";
 import {BeaconConfig} from "@lodestar/config";
 import {FAR_FUTURE_EPOCH} from "../constants/index.js";
 import {getCurrentAndNextFork} from "./forks.js";
@@ -19,7 +19,7 @@ export enum SubnetType {
 }
 
 export type MetadataOpts = {
-  metadata?: electra.Metadata;
+  metadata?: peerdas.Metadata;
 };
 
 export type MetadataModules = {
@@ -35,13 +35,13 @@ export type MetadataModules = {
 export class MetadataController {
   private onSetValue: (key: string, value: Uint8Array) => void;
   private config: BeaconConfig;
-  private _metadata: electra.Metadata;
+  private _metadata: peerdas.Metadata;
 
   constructor(opts: MetadataOpts, modules: MetadataModules) {
     this.config = modules.config;
     this.onSetValue = modules.onSetValue;
     this._metadata = opts.metadata ?? {
-      ...ssz.electra.Metadata.defaultValue(),
+      ...ssz.peerdas.Metadata.defaultValue(),
       csc: Math.max(this.config.CUSTODY_REQUIREMENT, this.config.NODE_CUSTODY_REQUIREMENT),
     };
   }
@@ -58,7 +58,7 @@ export class MetadataController {
       this.onSetValue(ENRKey.syncnets, ssz.phase0.AttestationSubnets.serialize(this._metadata.syncnets));
     }
 
-    if (this.config.getForkSeq(computeStartSlotAtEpoch(currentEpoch)) >= ForkSeq.electra) {
+    if (this.config.getForkSeq(computeStartSlotAtEpoch(currentEpoch)) >= ForkSeq.peerdas) {
       this.onSetValue(ENRKey.csc, ssz.Uint8.serialize(this._metadata.csc));
     }
   }
@@ -96,7 +96,7 @@ export class MetadataController {
   }
 
   /** Consumers that need the phase0.Metadata type can just ignore the .syncnets property */
-  get json(): electra.Metadata {
+  get json(): peerdas.Metadata {
     return this._metadata;
   }
 

packages/beacon-node/src/network/network.ts

@@ -17,7 +17,7 @@ import {
   LightClientFinalityUpdate,
   LightClientOptimisticUpdate,
   LightClientUpdate,
-  electra,
+  peerdas,
   ColumnIndex,
 } from "@lodestar/types";
 import {routes} from "@lodestar/api";
@@ -335,7 +335,7 @@ export class Network implements INetwork {
     });
   }
 
-  async publishDataColumnSidecar(dataColumnSidecar: electra.DataColumnSidecar): Promise<number> {
+  async publishDataColumnSidecar(dataColumnSidecar: peerdas.DataColumnSidecar): Promise<number> {
     const slot = dataColumnSidecar.signedBlockHeader.message.slot;
     const fork = this.config.getForkName(slot);
     const index = dataColumnSidecar.index % DATA_COLUMN_SIDECAR_SUBNET_COUNT;
@@ -551,8 +551,8 @@ export class Network implements INetwork {
 
   async sendDataColumnSidecarsByRange(
     peerId: PeerIdStr,
-    request: electra.DataColumnSidecarsByRangeRequest
-  ): Promise<electra.DataColumnSidecar[]> {
+    request: peerdas.DataColumnSidecarsByRangeRequest
+  ): Promise<peerdas.DataColumnSidecar[]> {
     return collectMaxResponseTyped(
       this.sendReqRespRequest(peerId, ReqRespMethod.DataColumnSidecarsByRange, [Version.V1], request),
       // request's count represent the slots, so the actual max count received could be slots * blobs per slot
@@ -563,8 +563,8 @@ export class Network implements INetwork {
 
   async sendDataColumnSidecarsByRoot(
     peerId: PeerIdStr,
-    request: electra.DataColumnSidecarsByRootRequest
-  ): Promise<electra.DataColumnSidecar[]> {
+    request: peerdas.DataColumnSidecarsByRootRequest
+  ): Promise<peerdas.DataColumnSidecar[]> {
     return collectMaxResponseTyped(
       this.sendReqRespRequest(peerId, ReqRespMethod.DataColumnSidecarsByRoot, [Version.V1], request),
       request.length,