feat: placeholder PR for electra

packages/api/package.json

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

packages/api/src/beacon/client/validator.ts

@@ -5,8 +5,8 @@ import {IHttpClient, generateGenericJsonClient} from "../../utils/client/index.j
 /**
  * REST HTTP client for validator routes
  */
-export function getClient(_config: ChainForkConfig, httpClient: IHttpClient): Api {
-  const reqSerializers = getReqSerializers();
+export function getClient(config: ChainForkConfig, httpClient: IHttpClient): Api {
+  const reqSerializers = getReqSerializers(config);
   const returnTypes = getReturnTypes();
   // All routes return JSON, use a client auto-generator
   return generateGenericJsonClient<Api, ReqTypes>(routesData, reqSerializers, returnTypes, httpClient);

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

@@ -61,7 +61,7 @@ export function getReqSerializers(config: ChainForkConfig) {
   return {
     getGenesis: reqEmpty,
     ...block.getReqSerializers(config),
-    ...pool.getReqSerializers(),
+    ...pool.getReqSerializers(config),
     ...state.getReqSerializers(),
     ...rewards.getReqSerializers(),
   };

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

@@ -1,4 +1,6 @@
-import {phase0, altair, capella, CommitteeIndex, Slot, ssz} from "@lodestar/types";
+import {ChainForkConfig} from "@lodestar/config";
+import {ForkName} from "@lodestar/params";
+import {phase0, altair, capella, CommitteeIndex, Slot, ssz, allForks} from "@lodestar/types";
 import {ApiClientResponse} from "../../../interfaces.js";
 import {HttpStatusCode} from "../../../utils/client/httpStatusCode.js";
 import {
@@ -80,7 +82,7 @@ export type Api = {
    * @throws ApiError
    */
   submitPoolAttestations(
-    attestations: phase0.Attestation[]
+    attestations: allForks.Attestation[]
   ): Promise<ApiClientResponse<{[HttpStatusCode.OK]: void}, HttpStatusCode.BAD_REQUEST>>;
 
   /**
@@ -159,15 +161,15 @@ export type ReqTypes = {
   getPoolProposerSlashings: ReqEmpty;
   getPoolVoluntaryExits: ReqEmpty;
   getPoolBlsToExecutionChanges: ReqEmpty;
-  submitPoolAttestations: {body: unknown};
+  submitPoolAttestations: {body: unknown; headers: {"eth-consensus-version": ForkName}};
   submitPoolAttesterSlashings: {body: unknown};
   submitPoolProposerSlashings: {body: unknown};
   submitPoolVoluntaryExit: {body: unknown};
   submitPoolBlsToExecutionChange: {body: unknown};
   submitPoolSyncCommitteeSignatures: {body: unknown};
 };
 
-export function getReqSerializers(): ReqSerializers<Api, ReqTypes> {
+export function getReqSerializers(config: ChainForkConfig): ReqSerializers<Api, ReqTypes> {
   return {
     getPoolAttestations: {
       writeReq: (filters) => ({query: {slot: filters?.slot, committee_index: filters?.committeeIndex}}),
@@ -178,7 +180,19 @@ export function getReqSerializers(): ReqSerializers<Api, ReqTypes> {
     getPoolProposerSlashings: reqEmpty,
     getPoolVoluntaryExits: reqEmpty,
     getPoolBlsToExecutionChanges: reqEmpty,
-    submitPoolAttestations: reqOnlyBody(ArrayOf(ssz.phase0.Attestation), Schema.ObjectArray),
+    submitPoolAttestations: {
+      writeReq: (attestations) => {
+        const fork = config.getForkName(attestations[0].data.slot);
+        return {
+          body: ArrayOf(ssz.allForks[fork].Attestation).toJson(attestations),
+          headers: {"eth-consensus-version": fork},
+        };
+      },
+      parseReq: ({body, headers}) => [
+        ArrayOf(ssz.allForks[headers["eth-consensus-version"]].Attestation).fromJson(body),
+      ],
+      schema: {body: Schema.ObjectArray},
+    },
     submitPoolAttesterSlashings: reqOnlyBody(ssz.phase0.AttesterSlashing, Schema.Object),
     submitPoolProposerSlashings: reqOnlyBody(ssz.phase0.ProposerSlashing, Schema.Object),
     submitPoolVoluntaryExit: reqOnlyBody(ssz.phase0.SignedVoluntaryExit, Schema.Object),

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

@@ -89,10 +89,10 @@ export type EventData = {
     block: RootHex;
     executionOptimistic: boolean;
   };
-  [EventType.attestation]: phase0.Attestation;
+  [EventType.attestation]: {version: ForkName; data: allForks.Attestation};
   [EventType.voluntaryExit]: phase0.SignedVoluntaryExit;
   [EventType.proposerSlashing]: phase0.ProposerSlashing;
-  [EventType.attesterSlashing]: phase0.AttesterSlashing;
+  [EventType.attesterSlashing]: {version: ForkName; data: allForks.AttesterSlashing};
   [EventType.blsToExecutionChange]: capella.SignedBLSToExecutionChange;
   [EventType.finalizedCheckpoint]: {
     block: RootHex;
@@ -180,10 +180,10 @@ export function getTypeByEvent(): {[K in EventType]: TypeJson<EventData[K]>} {
       {jsonCase: "eth2"}
     ),
 
-    [EventType.attestation]: ssz.phase0.Attestation,
+    [EventType.attestation]: WithVersion((fork) => ssz.allForks[fork].Attestation),
     [EventType.voluntaryExit]: ssz.phase0.SignedVoluntaryExit,
     [EventType.proposerSlashing]: ssz.phase0.ProposerSlashing,
-    [EventType.attesterSlashing]: ssz.phase0.AttesterSlashing,
+    [EventType.attesterSlashing]: WithVersion((fork) => ssz.allForks[fork].AttesterSlashing),
     [EventType.blsToExecutionChange]: ssz.capella.SignedBLSToExecutionChange,
 
     [EventType.finalizedCheckpoint]: new ContainerType(

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

@@ -1,4 +1,5 @@
 import {ContainerType, fromHexString, toHexString, Type} from "@chainsafe/ssz";
+import {ChainForkConfig} from "@lodestar/config";
 import {ForkName, ForkBlobs, isForkBlobs, isForkExecution, ForkPreBlobs, ForkExecution} from "@lodestar/params";
 import {
   allForks,
@@ -338,10 +339,11 @@ export type Api = {
    */
   getAggregatedAttestation(
     attestationDataRoot: Root,
-    slot: Slot
+    slot: Slot,
+    index: CommitteeIndex
   ): Promise<
     ApiClientResponse<
-      {[HttpStatusCode.OK]: {data: phase0.Attestation}},
+      {[HttpStatusCode.OK]: {data: allForks.Attestation; version: ForkName}},
       HttpStatusCode.BAD_REQUEST | HttpStatusCode.NOT_FOUND
     >
   >;
@@ -354,7 +356,7 @@ export type Api = {
    * @throws ApiError
    */
   publishAggregateAndProofs(
-    signedAggregateAndProofs: phase0.SignedAggregateAndProof[]
+    signedAggregateAndProofs: allForks.SignedAggregateAndProof[] // TODO Electra: Add version
   ): Promise<ApiClientResponse<{[HttpStatusCode.OK]: void}, HttpStatusCode.BAD_REQUEST>>;
 
   publishContributionAndProofs(
@@ -498,8 +500,8 @@ export type ReqTypes = {
   produceBlindedBlock: {params: {slot: number}; query: {randao_reveal: string; graffiti: string}};
   produceAttestationData: {query: {slot: number; committee_index: number}};
   produceSyncCommitteeContribution: {query: {slot: number; subcommittee_index: number; beacon_block_root: string}};
-  getAggregatedAttestation: {query: {attestation_data_root: string; slot: number}};
-  publishAggregateAndProofs: {body: unknown};
+  getAggregatedAttestation: {query: {attestation_data_root: string; slot: number; index: number}};
+  publishAggregateAndProofs: {body: unknown; headers: {"eth-consensus-version": ForkName}};
   publishContributionAndProofs: {body: unknown};
   prepareBeaconCommitteeSubnet: {body: unknown};
   prepareSyncCommitteeSubnets: {body: unknown};
@@ -529,7 +531,7 @@ const SyncCommitteeSelection = new ContainerType(
   {jsonCase: "eth2"}
 );
 
-export function getReqSerializers(): ReqSerializers<Api, ReqTypes> {
+export function getReqSerializers(config: ChainForkConfig): ReqSerializers<Api, ReqTypes> {
   const BeaconCommitteeSubscription = new ContainerType(
     {
       validatorIndex: ssz.ValidatorIndex,
@@ -647,14 +649,26 @@ export function getReqSerializers(): ReqSerializers<Api, ReqTypes> {
     },
 
     getAggregatedAttestation: {
-      writeReq: (root, slot) => ({query: {attestation_data_root: toHexString(root), slot}}),
-      parseReq: ({query}) => [fromHexString(query.attestation_data_root), query.slot],
+      writeReq: (root, slot, index) => ({query: {attestation_data_root: toHexString(root), slot, index}}),
+      parseReq: ({query}) => [fromHexString(query.attestation_data_root), query.slot, query.index],
       schema: {
-        query: {attestation_data_root: Schema.StringRequired, slot: Schema.UintRequired},
+        query: {attestation_data_root: Schema.StringRequired, slot: Schema.UintRequired, index: Schema.UintRequired},
       },
     },
 
-    publishAggregateAndProofs: reqOnlyBody(ArrayOf(ssz.phase0.SignedAggregateAndProof), Schema.ObjectArray),
+    publishAggregateAndProofs: {
+      writeReq: (signedAggregateAndProofs) => {
+        const fork = config.getForkName(signedAggregateAndProofs[0].message.aggregate.data.slot);
+        return {
+          body: ArrayOf(ssz.allForks[fork].SignedAggregateAndProof).toJson(signedAggregateAndProofs),
+          headers: {"eth-consensus-version": fork},
+        };
+      },
+      parseReq: ({body, headers}) => [
+        ArrayOf(ssz.allForks[headers["eth-consensus-version"]].SignedAggregateAndProof).fromJson(body),
+      ],
+      schema: {body: Schema.ObjectArray},
+    },
     publishContributionAndProofs: reqOnlyBody(ArrayOf(ssz.altair.SignedContributionAndProof), Schema.ObjectArray),
     prepareBeaconCommitteeSubnet: reqOnlyBody(ArrayOf(BeaconCommitteeSubscription), Schema.ObjectArray),
     prepareSyncCommitteeSubnets: reqOnlyBody(ArrayOf(SyncCommitteeSubscription), Schema.ObjectArray),
@@ -786,7 +800,7 @@ export function getReturnTypes(): ReturnTypes<Api> {
 
     produceAttestationData: ContainerData(ssz.phase0.AttestationData),
     produceSyncCommitteeContribution: ContainerData(ssz.altair.SyncCommitteeContribution),
-    getAggregatedAttestation: ContainerData(ssz.phase0.Attestation),
+    getAggregatedAttestation: WithVersion((fork) => ssz.allForks[fork].Attestation),
     submitBeaconCommitteeSelections: ContainerData(ArrayOf(BeaconCommitteeSelection)),
     submitSyncCommitteeSelections: ContainerData(ArrayOf(SyncCommitteeSelection)),
     getLiveness: jsonType("snake"),

packages/api/src/beacon/server/validator.ts

@@ -4,7 +4,7 @@ import {ServerRoutes, getGenericJsonServer} from "../../utils/server/index.js";
 import {ServerApi} from "../../interfaces.js";
 
 export function getRoutes(config: ChainForkConfig, api: ServerApi<Api>): ServerRoutes<Api, ReqTypes> {
-  const reqSerializers = getReqSerializers();
+  const reqSerializers = getReqSerializers(config);
   const returnTypes = getReturnTypes();
 
   // Most of routes return JSON, use a server auto-generator

packages/api/test/unit/beacon/oapiSpec.test.ts

@@ -60,7 +60,7 @@ const reqSerializers = {
   ...routes.lightclient.getReqSerializers(),
   ...routes.node.getReqSerializers(),
   ...routes.proof.getReqSerializers(),
-  ...routes.validator.getReqSerializers(),
+  ...routes.validator.getReqSerializers(config),
 };
 
 const returnTypes = {

packages/api/test/unit/beacon/testData/events.ts

@@ -31,18 +31,21 @@ export const eventTestData: EventData = {
     block: "0x9a2fefd2fdb57f74993c7780ea5b9030d2897b615b89f808011ca5aebed54eaf",
     executionOptimistic: false,
   },
-  [EventType.attestation]: ssz.phase0.Attestation.fromJson({
-    aggregation_bits: "0x01",
-    signature:
-      "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505",
-    data: {
-      slot: "1",
-      index: "1",
-      beacon_block_root: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-      source: {epoch: "1", root: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},
-      target: {epoch: "1", root: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},
-    },
-  }),
+  [EventType.attestation]: {
+    version: ForkName.altair,
+    data: ssz.phase0.Attestation.fromJson({
+      aggregation_bits: "0x01",
+      signature:
+        "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505",
+      data: {
+        slot: "1",
+        index: "1",
+        beacon_block_root: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+        source: {epoch: "1", root: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},
+        target: {epoch: "1", root: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},
+      },
+    }),
+  },
   [EventType.voluntaryExit]: ssz.phase0.SignedVoluntaryExit.fromJson({
     message: {epoch: "1", validator_index: "1"},
     signature:
@@ -72,44 +75,47 @@ export const eventTestData: EventData = {
         "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
     },
   }),
-  [EventType.attesterSlashing]: ssz.phase0.AttesterSlashing.fromJson({
-    attestation_1: {
-      attesting_indices: ["0", "1"],
-      data: {
-        slot: "0",
-        index: "0",
-        beacon_block_root: "0x0000000000000000000000000000000000000000000000000000000000000000",
-        source: {
-          epoch: "0",
-          root: "0x0000000000000000000000000000000000000000000000000000000000000000",
-        },
-        target: {
-          epoch: "0",
-          root: "0x0000000000000000000000000000000000000000000000000000000000000000",
+  [EventType.attesterSlashing]: {
+    version: ForkName.altair,
+    data: ssz.phase0.AttesterSlashing.fromJson({
+      attestation_1: {
+        attesting_indices: ["0", "1"],
+        data: {
+          slot: "0",
+          index: "0",
+          beacon_block_root: "0x0000000000000000000000000000000000000000000000000000000000000000",
+          source: {
+            epoch: "0",
+            root: "0x0000000000000000000000000000000000000000000000000000000000000000",
+          },
+          target: {
+            epoch: "0",
+            root: "0x0000000000000000000000000000000000000000000000000000000000000000",
+          },
         },
+        signature:
+          "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
       },
-      signature:
-        "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-    },
-    attestation_2: {
-      attesting_indices: ["0", "1"],
-      data: {
-        slot: "0",
-        index: "0",
-        beacon_block_root: "0x0000000000000000000000000000000000000000000000000000000000000000",
-        source: {
-          epoch: "0",
-          root: "0x0000000000000000000000000000000000000000000000000000000000000000",
-        },
-        target: {
-          epoch: "0",
-          root: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      attestation_2: {
+        attesting_indices: ["0", "1"],
+        data: {
+          slot: "0",
+          index: "0",
+          beacon_block_root: "0x0000000000000000000000000000000000000000000000000000000000000000",
+          source: {
+            epoch: "0",
+            root: "0x0000000000000000000000000000000000000000000000000000000000000000",
+          },
+          target: {
+            epoch: "0",
+            root: "0x0000000000000000000000000000000000000000000000000000000000000000",
+          },
         },
+        signature:
+          "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
       },
-      signature:
-        "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-    },
-  }),
+    }),
+  },
   [EventType.blsToExecutionChange]: ssz.capella.SignedBLSToExecutionChange.fromJson({
     message: {
       validator_index: "1",

packages/api/test/unit/beacon/testData/validator.ts

@@ -134,8 +134,11 @@ export const testData: GenericServerTestCases<Api> = {
     res: {data: ssz.altair.SyncCommitteeContribution.defaultValue()},
   },
   getAggregatedAttestation: {
-    args: [ZERO_HASH, 32000],
-    res: {data: ssz.phase0.Attestation.defaultValue()},
+    args: [ZERO_HASH, 32000, 2],
+    res: {
+      data: ssz.phase0.Attestation.defaultValue(),
+      version: ForkName.altair,
+    },
   },
   publishAggregateAndProofs: {
     args: [[ssz.phase0.SignedAggregateAndProof.defaultValue()]],

packages/beacon-node/package.json

@@ -104,7 +104,7 @@
     "@chainsafe/libp2p-noise": "^15.0.0",
     "@chainsafe/persistent-merkle-tree": "^0.7.1",
     "@chainsafe/prometheus-gc-stats": "^1.0.0",
-    "@chainsafe/ssz": "^0.15.1",
+    "@chainsafe/ssz": "^0.16.0",
     "@chainsafe/threads": "^1.11.1",
     "@ethersproject/abi": "^5.7.0",
     "@fastify/bearer-auth": "^9.0.0",

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

@@ -1,6 +1,6 @@
 import {routes, ServerApi} from "@lodestar/api";
 import {Epoch, ssz} from "@lodestar/types";
-import {SYNC_COMMITTEE_SUBNET_SIZE} from "@lodestar/params";
+import {ForkName, SYNC_COMMITTEE_SUBNET_SIZE} from "@lodestar/params";
 import {validateApiAttestation} from "../../../../chain/validation/index.js";
 import {validateApiAttesterSlashing} from "../../../../chain/validation/attesterSlashing.js";
 import {validateApiProposerSlashing} from "../../../../chain/validation/proposerSlashing.js";
@@ -64,7 +64,7 @@ export function getBeaconPoolApi({
             // when a validator is configured with multiple beacon node urls, this attestation data may come from another beacon node
             // and the block hasn't been in our forkchoice since we haven't seen / processing that block
             // see https://github.com/ChainSafe/lodestar/issues/5098
-            const {indexedAttestation, subnet, attDataRootHex} = await validateGossipFnRetryUnknownRoot(
+            const {indexedAttestation, subnet, attDataRootHex, committeeIndex} = await validateGossipFnRetryUnknownRoot(
               validateFn,
               network,
               chain,
@@ -73,11 +73,11 @@ export function getBeaconPoolApi({
             );
 
             if (network.shouldAggregate(subnet, slot)) {
-              const insertOutcome = chain.attestationPool.add(attestation, attDataRootHex);
+              const insertOutcome = chain.attestationPool.add(committeeIndex, attestation, attDataRootHex);
               metrics?.opPool.attestationPoolInsertOutcome.inc({insertOutcome});
             }
 
-            chain.emitter.emit(routes.events.EventType.attestation, attestation);
+            chain.emitter.emit(routes.events.EventType.attestation, {data: attestation, version: ForkName.phase0});
 
             const sentPeers = await network.publishBeaconAttestation(attestation, subnet);
             metrics?.onPoolSubmitUnaggregatedAttestation(seenTimestampSec, indexedAttestation, subnet, sentPeers);