feat: electra fork rebasejul1 - DONOT MERGE

packages/api/package.json

@@ -71,7 +71,7 @@
   },
   "dependencies": {
     "@chainsafe/persistent-merkle-tree": "^0.7.1",
-    "@chainsafe/ssz": "^0.15.1",
+    "@chainsafe/ssz": "^0.16.0",
     "@lodestar/config": "^1.19.0",
     "@lodestar/params": "^1.19.0",
     "@lodestar/types": "^1.19.0",

packages/api/src/beacon/routes/beacon/block.ts

@@ -11,8 +11,10 @@ import {
   BeaconBlockBody,
   SignedBeaconBlockOrContents,
   SignedBlindedBeaconBlock,
+  SignedBlockContents,
+  sszTypesFor,
 } from "@lodestar/types";
-import {ForkName, ForkPreExecution, ForkSeq, isForkExecution} from "@lodestar/params";
+import {ForkName, ForkPreExecution, isForkBlobs, isForkExecution} from "@lodestar/params";
 import {Endpoint, RequestCodec, RouteDefinitions, Schema} from "../../../utils/index.js";
 import {EmptyMeta, EmptyResponseCodec, EmptyResponseData, WithVersion} from "../../../utils/codecs.js";
 import {
@@ -37,19 +39,10 @@ export const BlockHeadersResponseType = new ListCompositeType(BlockHeaderRespons
 export const RootResponseType = new ContainerType({
   root: ssz.Root,
 });
-export const SignedBlockContentsType = new ContainerType(
-  {
-    signedBlock: ssz.deneb.SignedBeaconBlock,
-    kzgProofs: ssz.deneb.KZGProofs,
-    blobs: ssz.deneb.Blobs,
-  },
-  {jsonCase: "eth2"}
-);
 
 export type BlockHeaderResponse = ValueOf<typeof BlockHeaderResponseType>;
 export type BlockHeadersResponse = ValueOf<typeof BlockHeadersResponseType>;
 export type RootResponse = ValueOf<typeof RootResponseType>;
-export type SignedBlockContents = ValueOf<typeof SignedBlockContentsType>;
 
 export type BlockId = RootHex | Slot | "head" | "genesis" | "finalized" | "justified";
 
@@ -297,11 +290,12 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
           const slot = isSignedBlockContents(signedBlockOrContents)
             ? signedBlockOrContents.signedBlock.message.slot
             : signedBlockOrContents.message.slot;
+          const fork = config.getForkName(slot);
+
           return {
-            body:
-              config.getForkSeq(slot) < ForkSeq.deneb
-                ? config.getForkTypes(slot).SignedBeaconBlock.toJson(signedBlockOrContents as SignedBeaconBlock)
-                : SignedBlockContentsType.toJson(signedBlockOrContents as SignedBlockContents),
+            body: isForkBlobs(fork)
+              ? sszTypesFor(fork).SignedBlockContents.toJson(signedBlockOrContents as SignedBlockContents)
+              : sszTypesFor(fork).SignedBeaconBlock.toJson(signedBlockOrContents as SignedBeaconBlock),
             headers: {
               [MetaHeader.Version]: config.getForkName(slot),
             },
@@ -321,36 +315,33 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
                 : (body as SignedBeaconBlock).message.slot
             );
           }
-          const forkSeq = config.forks[forkName].seq;
           return {
-            signedBlockOrContents:
-              forkSeq < ForkSeq.deneb
-                ? ssz[forkName].SignedBeaconBlock.fromJson(body)
-                : SignedBlockContentsType.fromJson(body),
+            signedBlockOrContents: isForkBlobs(forkName)
+              ? sszTypesFor(forkName).SignedBlockContents.fromJson(body)
+              : ssz[forkName].SignedBeaconBlock.fromJson(body),
           };
         },
         writeReqSsz: ({signedBlockOrContents}) => {
           const slot = isSignedBlockContents(signedBlockOrContents)
             ? signedBlockOrContents.signedBlock.message.slot
             : signedBlockOrContents.message.slot;
+          const fork = config.getForkName(slot);
+
           return {
-            body:
-              config.getForkSeq(slot) < ForkSeq.deneb
-                ? config.getForkTypes(slot).SignedBeaconBlock.serialize(signedBlockOrContents as SignedBeaconBlock)
-                : SignedBlockContentsType.serialize(signedBlockOrContents as SignedBlockContents),
+            body: isForkBlobs(fork)
+              ? sszTypesFor(fork).SignedBlockContents.serialize(signedBlockOrContents as SignedBlockContents)
+              : sszTypesFor(fork).SignedBeaconBlock.serialize(signedBlockOrContents as SignedBeaconBlock),
             headers: {
               [MetaHeader.Version]: config.getForkName(slot),
             },
           };
         },
         parseReqSsz: ({body, headers}) => {
           const forkName = toForkName(fromHeaders(headers, MetaHeader.Version));
-          const forkSeq = config.forks[forkName].seq;
           return {
-            signedBlockOrContents:
-              forkSeq < ForkSeq.deneb
-                ? ssz[forkName].SignedBeaconBlock.deserialize(body)
-                : SignedBlockContentsType.deserialize(body),
+            signedBlockOrContents: isForkBlobs(forkName)
+              ? sszTypesFor(forkName).SignedBlockContents.deserialize(body)
+              : ssz[forkName].SignedBeaconBlock.deserialize(body),
           };
         },
         schema: {
@@ -371,51 +362,48 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
           const slot = isSignedBlockContents(signedBlockOrContents)
             ? signedBlockOrContents.signedBlock.message.slot
             : signedBlockOrContents.message.slot;
+          const fork = config.getForkName(slot);
           return {
-            body:
-              config.getForkSeq(slot) < ForkSeq.deneb
-                ? config.getForkTypes(slot).SignedBeaconBlock.toJson(signedBlockOrContents as SignedBeaconBlock)
-                : SignedBlockContentsType.toJson(signedBlockOrContents as SignedBlockContents),
+            body: isForkBlobs(fork)
+              ? sszTypesFor(fork).SignedBlockContents.toJson(signedBlockOrContents as SignedBlockContents)
+              : sszTypesFor(fork).SignedBeaconBlock.toJson(signedBlockOrContents as SignedBeaconBlock),
             headers: {
-              [MetaHeader.Version]: config.getForkName(slot),
+              [MetaHeader.Version]: fork,
             },
             query: {broadcast_validation: broadcastValidation},
           };
         },
         parseReqJson: ({body, headers, query}) => {
           const forkName = toForkName(fromHeaders(headers, MetaHeader.Version));
-          const forkSeq = config.forks[forkName].seq;
           return {
-            signedBlockOrContents:
-              forkSeq < ForkSeq.deneb
-                ? ssz[forkName].SignedBeaconBlock.fromJson(body)
-                : SignedBlockContentsType.fromJson(body),
+            signedBlockOrContents: isForkBlobs(forkName)
+              ? sszTypesFor(forkName).SignedBlockContents.fromJson(body)
+              : ssz[forkName].SignedBeaconBlock.fromJson(body),
             broadcastValidation: query.broadcast_validation as BroadcastValidation,
           };
         },
         writeReqSsz: ({signedBlockOrContents, broadcastValidation}) => {
           const slot = isSignedBlockContents(signedBlockOrContents)
             ? signedBlockOrContents.signedBlock.message.slot
             : signedBlockOrContents.message.slot;
+          const fork = config.getForkName(slot);
+
           return {
-            body:
-              config.getForkSeq(slot) < ForkSeq.deneb
-                ? config.getForkTypes(slot).SignedBeaconBlock.serialize(signedBlockOrContents as SignedBeaconBlock)
-                : SignedBlockContentsType.serialize(signedBlockOrContents as SignedBlockContents),
+            body: isForkBlobs(fork)
+              ? sszTypesFor(fork).SignedBlockContents.serialize(signedBlockOrContents as SignedBlockContents)
+              : sszTypesFor(fork).SignedBeaconBlock.serialize(signedBlockOrContents as SignedBeaconBlock),
             headers: {
-              [MetaHeader.Version]: config.getForkName(slot),
+              [MetaHeader.Version]: fork,
             },
             query: {broadcast_validation: broadcastValidation},
           };
         },
         parseReqSsz: ({body, headers, query}) => {
           const forkName = toForkName(fromHeaders(headers, MetaHeader.Version));
-          const forkSeq = config.forks[forkName].seq;
           return {
-            signedBlockOrContents:
-              forkSeq < ForkSeq.deneb
-                ? ssz[forkName].SignedBeaconBlock.deserialize(body)
-                : SignedBlockContentsType.deserialize(body),
+            signedBlockOrContents: isForkBlobs(forkName)
+              ? sszTypesFor(forkName).SignedBlockContents.deserialize(body)
+              : ssz[forkName].SignedBeaconBlock.deserialize(body),
             broadcastValidation: query.broadcast_validation as BroadcastValidation,
           };
         },

packages/api/src/beacon/routes/beacon/pool.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import {ValueOf} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
+import {ForkSeq} from "@lodestar/params";
 import {phase0, capella, CommitteeIndex, Slot, ssz} from "@lodestar/types";
 import {Schema, Endpoint, RouteDefinitions} from "../../../utils/index.js";
 import {
@@ -12,18 +13,25 @@ import {
   EmptyRequest,
   EmptyResponseCodec,
   EmptyResponseData,
+  WithVersion,
 } from "../../../utils/codecs.js";
+import {MetaHeader, VersionCodec, VersionMeta} from "../../../utils/metadata.js";
+import {toForkName} from "../../../utils/fork.js";
+import {fromHeaders} from "../../../utils/headers.js";
 
 // See /packages/api/src/routes/index.ts for reasoning and instructions to add new routes
 
-const AttestationListType = ArrayOf(ssz.phase0.Attestation);
+const AttestationListTypePhase0 = ArrayOf(ssz.phase0.Attestation);
+const AttestationListTypeElectra = ArrayOf(ssz.electra.Attestation);
 const AttesterSlashingListType = ArrayOf(ssz.phase0.AttesterSlashing);
 const ProposerSlashingListType = ArrayOf(ssz.phase0.ProposerSlashing);
 const SignedVoluntaryExitListType = ArrayOf(ssz.phase0.SignedVoluntaryExit);
 const SignedBLSToExecutionChangeListType = ArrayOf(ssz.capella.SignedBLSToExecutionChange);
 const SyncCommitteeMessageListType = ArrayOf(ssz.altair.SyncCommitteeMessage);
 
-type AttestationList = ValueOf<typeof AttestationListType>;
+type AttestationListPhase0 = ValueOf<typeof AttestationListTypePhase0>;
+type AttestationListElectra = ValueOf<typeof AttestationListTypeElectra>;
+type AttestationList = AttestationListPhase0 | AttestationListElectra;
 type AttesterSlashingList = ValueOf<typeof AttesterSlashingListType>;
 type ProposerSlashingList = ValueOf<typeof ProposerSlashingListType>;
 type SignedVoluntaryExitList = ValueOf<typeof SignedVoluntaryExitListType>;
@@ -40,7 +48,7 @@ export type Endpoints = {
     {slot?: Slot; committeeIndex?: CommitteeIndex},
     {query: {slot?: number; committee_index?: number}},
     AttestationList,
-    EmptyMeta
+    VersionMeta
   >;
 
   /**
@@ -106,7 +114,7 @@ export type Endpoints = {
   submitPoolAttestations: Endpoint<
     "POST",
     {signedAttestations: AttestationList},
-    {body: unknown},
+    {body: unknown; headers: {[MetaHeader.Version]: string}},
     EmptyResponseData,
     EmptyMeta
   >;
@@ -172,7 +180,7 @@ export type Endpoints = {
   >;
 };
 
-export function getDefinitions(_config: ChainForkConfig): RouteDefinitions<Endpoints> {
+export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoints> {
   return {
     getPoolAttestations: {
       url: "/eth/v1/beacon/pool/attestations",
@@ -183,8 +191,10 @@ export function getDefinitions(_config: ChainForkConfig): RouteDefinitions<Endpo
         schema: {query: {slot: Schema.Uint, committee_index: Schema.Uint}},
       },
       resp: {
-        data: AttestationListType,
-        meta: EmptyMetaCodec,
+        data: WithVersion((fork) =>
+          ForkSeq[fork] >= ForkSeq.electra ? AttestationListTypeElectra : AttestationListTypePhase0
+        ),
+        meta: VersionCodec,
       },
     },
     getPoolAttesterSlashings: {
@@ -227,12 +237,53 @@ export function getDefinitions(_config: ChainForkConfig): RouteDefinitions<Endpo
       url: "/eth/v1/beacon/pool/attestations",
       method: "POST",
       req: {
-        writeReqJson: ({signedAttestations}) => ({body: AttestationListType.toJson(signedAttestations)}),
-        parseReqJson: ({body}) => ({signedAttestations: AttestationListType.fromJson(body)}),
-        writeReqSsz: ({signedAttestations}) => ({body: AttestationListType.serialize(signedAttestations)}),
-        parseReqSsz: ({body}) => ({signedAttestations: AttestationListType.deserialize(body)}),
+        writeReqJson: ({signedAttestations}) => {
+          const fork = config.getForkName(signedAttestations[0].data.slot);
+          return {
+            body:
+              ForkSeq[fork] >= ForkSeq.electra
+                ? AttestationListTypeElectra.toJson(signedAttestations as AttestationListElectra)
+                : AttestationListTypePhase0.toJson(signedAttestations as AttestationListPhase0),
+            headers: {[MetaHeader.Version]: fork},
+          };
+        },
+        parseReqJson: ({body, headers}) => {
+          const versionHeader = fromHeaders(headers, MetaHeader.Version, false);
+          const fork =
+            versionHeader !== undefined
+              ? toForkName(versionHeader)
+              : config.getForkName(Number((body as {data: {slot: string}}[])[0]?.data.slot ?? 0));
+
+          return {
+            signedAttestations:
+              ForkSeq[fork] >= ForkSeq.electra
+                ? AttestationListTypeElectra.fromJson(body)
+                : AttestationListTypePhase0.fromJson(body),
+          };
+        },
+        writeReqSsz: ({signedAttestations}) => {
+          const fork = config.getForkName(signedAttestations[0].data.slot);
+          return {
+            body:
+              ForkSeq[fork] >= ForkSeq.electra
+                ? AttestationListTypeElectra.serialize(signedAttestations as AttestationListElectra)
+                : AttestationListTypePhase0.serialize(signedAttestations as AttestationListPhase0),
+            headers: {[MetaHeader.Version]: fork},
+          };
+        },
+        parseReqSsz: ({body, headers}) => {
+          const versionHeader = fromHeaders(headers, MetaHeader.Version, true);
+          const fork = toForkName(versionHeader);
+          return {
+            signedAttestations:
+              ForkSeq[fork] >= ForkSeq.electra
+                ? AttestationListTypeElectra.deserialize(body)
+                : AttestationListTypePhase0.deserialize(body),
+          };
+        },
         schema: {
           body: Schema.ObjectArray,
+          headers: {[MetaHeader.Version]: Schema.String},
         },
       },
       resp: EmptyResponseCodec,

packages/api/src/beacon/routes/events.ts

@@ -13,6 +13,9 @@ import {
   LightClientOptimisticUpdate,
   LightClientFinalityUpdate,
   SSEPayloadAttributes,
+  Attestation,
+  AttesterSlashing,
+  sszTypesFor,
 } from "@lodestar/types";
 import {ForkName} from "@lodestar/params";
 
@@ -104,10 +107,10 @@ export type EventData = {
     block: RootHex;
     executionOptimistic: boolean;
   };
-  [EventType.attestation]: phase0.Attestation;
+  [EventType.attestation]: {version: ForkName; data: Attestation};
   [EventType.voluntaryExit]: phase0.SignedVoluntaryExit;
   [EventType.proposerSlashing]: phase0.ProposerSlashing;
-  [EventType.attesterSlashing]: phase0.AttesterSlashing;
+  [EventType.attesterSlashing]: {version: ForkName; data: AttesterSlashing};
   [EventType.blsToExecutionChange]: capella.SignedBLSToExecutionChange;
   [EventType.finalizedCheckpoint]: {
     block: RootHex;
@@ -225,10 +228,10 @@ export function getTypeByEvent(): {[K in EventType]: TypeJson<EventData[K]>} {
       {jsonCase: "eth2"}
     ),
 
-    [EventType.attestation]: ssz.phase0.Attestation,
+    [EventType.attestation]: WithVersion((fork) => sszTypesFor(fork).Attestation),
     [EventType.voluntaryExit]: ssz.phase0.SignedVoluntaryExit,
     [EventType.proposerSlashing]: ssz.phase0.ProposerSlashing,
-    [EventType.attesterSlashing]: ssz.phase0.AttesterSlashing,
+    [EventType.attesterSlashing]: WithVersion((fork) => sszTypesFor(fork).AttesterSlashing),
     [EventType.blsToExecutionChange]: ssz.capella.SignedBLSToExecutionChange,
 
     [EventType.finalizedCheckpoint]: new ContainerType(