feat: implement focil EIP-7805

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

@@ -15,6 +15,7 @@ import {
   altair,
   capella,
   electra,
+  focil,
   phase0,
   ssz,
   sszTypesFor,
@@ -76,6 +77,8 @@ export enum EventType {
   payloadAttributes = "payload_attributes",
   /** The node has received a valid blobSidecar (from P2P or API) */
   blobSidecar = "blob_sidecar",
+  /** The node has received a valid inclusion list (from P2P or API) */
+  inclusionList = "inclusion_list",
 }
 
 export const eventTypes: {[K in EventType]: K} = {
@@ -94,6 +97,7 @@ export const eventTypes: {[K in EventType]: K} = {
   [EventType.lightClientFinalityUpdate]: EventType.lightClientFinalityUpdate,
   [EventType.payloadAttributes]: EventType.payloadAttributes,
   [EventType.blobSidecar]: EventType.blobSidecar,
+  [EventType.inclusionList]: EventType.inclusionList,
 };
 
 export type EventData = {
@@ -138,6 +142,7 @@ export type EventData = {
   [EventType.lightClientFinalityUpdate]: {version: ForkName; data: LightClientFinalityUpdate};
   [EventType.payloadAttributes]: {version: ForkName; data: SSEPayloadAttributes};
   [EventType.blobSidecar]: BlobSidecarSSE;
+  [EventType.inclusionList]: {version: ForkName; data: focil.SignedInclusionList};
 };
 
 export type BeaconEvent = {[K in EventType]: {type: K; message: EventData[K]}}[EventType];
@@ -291,6 +296,8 @@ export function getTypeByEvent(config: ChainForkConfig): {[K in EventType]: Type
     [EventType.lightClientFinalityUpdate]: WithVersion(
       (fork) => getLightClientForkTypes(fork).LightClientFinalityUpdate
     ),
+
+    [EventType.inclusionList]: WithVersion(() => ssz.focil.SignedInclusionList),
   };
 }
 

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

@@ -14,6 +14,8 @@ import {
   UintBn64,
   ValidatorIndex,
   altair,
+  bellatrix,
+  focil,
   phase0,
   ssz,
   sszTypesFor,
@@ -104,6 +106,20 @@ export const AttesterDutyType = new ContainerType(
   {jsonCase: "eth2"}
 );
 
+export const InclusionListDutyType = new ContainerType(
+  {
+    /** The validator's public key, uniquely identifying them */
+    pubkey: ssz.BLSPubkey,
+    /** Index of validator in validator registry */
+    validatorIndex: ssz.ValidatorIndex,
+    /** The slot at which the validator must propose the inclusion list*/
+    slot: ssz.Slot,
+    /** Inclusion List Committee Root */
+    inclusionListCommitteeRoot: ssz.Root,
+  },
+  {jsonCase: "eth2"}
+);
+
 export const ProposerDutyType = new ContainerType(
   {
     slot: ssz.Slot,
@@ -202,6 +218,7 @@ export const ValidatorIndicesType = ArrayOf(ssz.ValidatorIndex);
 export const AttesterDutyListType = ArrayOf(AttesterDutyType);
 export const ProposerDutyListType = ArrayOf(ProposerDutyType);
 export const SyncDutyListType = ArrayOf(SyncDutyType);
+export const InclusionListDutyListType = ArrayOf(InclusionListDutyType);
 export const SignedAggregateAndProofListPhase0Type = ArrayOf(ssz.phase0.SignedAggregateAndProof);
 export const SignedAggregateAndProofListElectraType = ArrayOf(ssz.electra.SignedAggregateAndProof);
 export const SignedContributionAndProofListType = ArrayOf(ssz.altair.SignedContributionAndProof);
@@ -220,6 +237,8 @@ export type ProposerDuty = ValueOf<typeof ProposerDutyType>;
 export type ProposerDutyList = ValueOf<typeof ProposerDutyListType>;
 export type SyncDuty = ValueOf<typeof SyncDutyType>;
 export type SyncDutyList = ValueOf<typeof SyncDutyListType>;
+export type InclusionListDuty = ValueOf<typeof InclusionListDutyType>;
+export type InclusionListDutyList = ValueOf<typeof InclusionListDutyListType>;
 export type SignedAggregateAndProofListPhase0 = ValueOf<typeof SignedAggregateAndProofListPhase0Type>;
 export type SignedAggregateAndProofListElectra = ValueOf<typeof SignedAggregateAndProofListElectraType>;
 export type SignedAggregateAndProofList = SignedAggregateAndProofListPhase0 | SignedAggregateAndProofListElectra;
@@ -288,6 +307,23 @@ export type Endpoints = {
     ExecutionOptimisticMeta
   >;
 
+  /**
+   * Get inclusion list committee duties
+   * Requests the beacon node to provide a set of inclusion list committee duties for a particular epoch.
+   */
+  getInclusionListCommitteeDuties: Endpoint<
+    "POST",
+    {
+      /** Should only be allowed 1 epoch ahead */
+      epoch: Epoch;
+      /** An array of the validator indices for which to obtain the duties */
+      indices: ValidatorIndices;
+    },
+    {params: {epoch: Epoch}; body: unknown},
+    InclusionListDutyList,
+    ExecutionOptimisticAndDependentRootMeta
+  >;
+
   /**
    * Requests a beacon node to produce a valid block, which can then be signed by a validator.
    * Metadata in the response indicates the type of block produced, and the supported types of block
@@ -392,6 +428,21 @@ export type Endpoints = {
     EmptyMeta
   >;
 
+  /**
+   * Produce an inclusion list
+   * Requests the beacon node to produce an inclusion list.
+   */
+  produceInclusionList: Endpoint<
+    "GET",
+    {
+      /** The slot for which an inclusion list should be created */
+      slot: Slot;
+    },
+    {query: {slot: number}},
+    bellatrix.Transactions,
+    VersionMeta
+  >;
+
   /**
    * Get aggregated attestation
    * Aggregates all attestations matching given attestation data root and slot
@@ -459,6 +510,18 @@ export type Endpoints = {
     EmptyMeta
   >;
 
+  /**
+   * Publish inclusion list
+   * Verifies given inclusion list and publishes it on appropriate gossipsub topic.
+   */
+  publishInclusionList: Endpoint<
+    "POST",
+    {signedInclusionList: focil.SignedInclusionList},
+    {body: unknown; headers: {[MetaHeader.Version]: string}},
+    EmptyResponseData,
+    EmptyMeta
+  >;
+
   /**
    * Signal beacon node to prepare for a committee subnet
    * After beacon node receives this request,
@@ -616,6 +679,24 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
         meta: ExecutionOptimisticCodec,
       },
     },
+    getInclusionListCommitteeDuties: {
+      url: "/eth/v1/validator/duties/inclusion_list/{epoch}",
+      method: "POST",
+      req: {
+        writeReqJson: ({epoch, indices}) => ({params: {epoch}, body: ValidatorIndicesType.toJson(indices)}),
+        parseReqJson: ({params, body}) => ({epoch: params.epoch, indices: ValidatorIndicesType.fromJson(body)}),
+        writeReqSsz: ({epoch, indices}) => ({params: {epoch}, body: ValidatorIndicesType.serialize(indices)}),
+        parseReqSsz: ({params, body}) => ({epoch: params.epoch, indices: ValidatorIndicesType.deserialize(body)}),
+        schema: {
+          params: {epoch: Schema.UintRequired},
+          body: Schema.StringArray,
+        },
+      },
+      resp: {
+        data: InclusionListDutyListType,
+        meta: ExecutionOptimisticAndDependentRootCodec,
+      },
+    },
     produceBlockV2: {
       url: "/eth/v2/validator/blocks/{slot}",
       method: "GET",
@@ -825,6 +906,21 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
         meta: EmptyMetaCodec,
       },
     },
+    produceInclusionList: {
+      url: "/eth/v1/validator/inclusion_list",
+      method: "GET",
+      req: {
+        writeReq: ({slot}) => ({query: {slot}}),
+        parseReq: ({query}) => ({slot: query.slot}),
+        schema: {
+          query: {slot: Schema.UintRequired},
+        },
+      },
+      resp: {
+        data: ssz.bellatrix.Transactions,
+        meta: VersionCodec,
+      },
+    },
     getAggregatedAttestation: {
       url: "/eth/v1/validator/aggregate_attestation",
       method: "GET",
@@ -966,6 +1062,37 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
       },
       resp: EmptyResponseCodec,
     },
+    publishInclusionList: {
+      url: "/eth/v1/validator/inclusion_list",
+      method: "POST",
+      req: {
+        writeReqJson: ({signedInclusionList}) => {
+          const fork = config.getForkName(signedInclusionList.message.slot);
+          return {
+            body: ssz.focil.SignedInclusionList.toJson(signedInclusionList),
+            headers: {
+              [MetaHeader.Version]: fork,
+            },
+          };
+        },
+        parseReqJson: ({body}) => ({signedInclusionList: ssz.focil.SignedInclusionList.fromJson(body)}),
+        writeReqSsz: ({signedInclusionList}) => {
+          const fork = config.getForkName(signedInclusionList.message.slot);
+          return {
+            body: ssz.focil.SignedInclusionList.serialize(signedInclusionList),
+            headers: {
+              [MetaHeader.Version]: fork,
+            },
+          };
+        },
+        parseReqSsz: ({body}) => ({signedInclusionList: ssz.focil.SignedInclusionList.deserialize(body)}),
+        schema: {
+          body: Schema.Object,
+          headers: {[MetaHeader.Version]: Schema.String},
+        },
+      },
+      resp: EmptyResponseCodec,
+    },
     prepareBeaconCommitteeSubnet: {
       url: "/eth/v1/validator/beacon_committee_subscriptions",
       method: "POST",

packages/api/src/utils/metadata.ts

@@ -114,7 +114,7 @@ export const ExecutionOptimisticAndVersionCodec: ResponseMetadataCodec<Execution
   fromJson: (val) => ExecutionOptimisticAndVersionType.fromJson(val),
   toHeadersObject: (val) => ({
     [MetaHeader.ExecutionOptimistic]: val.executionOptimistic.toString(),
-    [MetaHeader.Version]: val.version,
+    [MetaHeader.Version]: val.version === ForkName.focil ? ForkName.electra : val.version,
     [HttpHeader.ExposeHeaders]: [MetaHeader.ExecutionOptimistic, MetaHeader.Version].toString(),
   }),
   fromHeaders: (headers) => ({
@@ -144,7 +144,7 @@ export const ExecutionOptimisticFinalizedAndVersionCodec: ResponseMetadataCodec<
     toHeadersObject: (val) => ({
       [MetaHeader.ExecutionOptimistic]: val.executionOptimistic.toString(),
       [MetaHeader.Finalized]: val.finalized.toString(),
-      [MetaHeader.Version]: val.version,
+      [MetaHeader.Version]: val.version === ForkName.focil ? ForkName.electra : val.version,
       [HttpHeader.ExposeHeaders]: [MetaHeader.ExecutionOptimistic, MetaHeader.Finalized, MetaHeader.Version].toString(),
     }),
     fromHeaders: (headers) => ({

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

@@ -254,4 +254,18 @@ export const eventTestData: EventData = {
     slot: "1",
     versioned_hash: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
   }),
+  // TODO FOCIL: update example value
+  [EventType.inclusionList]: {
+    version: ForkName.focil,
+    data: ssz.focil.SignedInclusionList.fromJson({
+      message: {
+        slot: "0",
+        validator_index: "0",
+        inclusion_list_committee_root: "0x0000000000000000000000000000000000000000000000000000000000000000",
+        transactions: ["0x0000000000000000000000000000000000000000000000000000000000000000"],
+      },
+      signature:
+        "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    }),
+  },
 };

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

@@ -42,6 +42,20 @@ export const testData: GenericServerTestCases<Endpoints> = {
       meta: {executionOptimistic: true},
     },
   },
+  getInclusionListCommitteeDuties: {
+    args: {epoch: 0, indices: [1, 2, 3]},
+    res: {
+      data: [
+        {
+          pubkey: new Uint8Array(48).fill(1),
+          validatorIndex: 2,
+          slot: 3,
+          inclusionListCommitteeRoot: ZERO_HASH,
+        },
+      ],
+      meta: {executionOptimistic: true, dependentRoot: ZERO_HASH_HEX},
+    },
+  },
   produceBlockV2: {
     args: {
       slot: 32000,
@@ -98,6 +112,10 @@ export const testData: GenericServerTestCases<Endpoints> = {
     args: {slot: 32000, subcommitteeIndex: 2, beaconBlockRoot: ZERO_HASH},
     res: {data: ssz.altair.SyncCommitteeContribution.defaultValue()},
   },
+  produceInclusionList: {
+    args: {slot: 32000},
+    res: {data: [ssz.bellatrix.Transaction.defaultValue()], meta: {version: ForkName.focil}},
+  },
   getAggregatedAttestation: {
     args: {attestationDataRoot: ZERO_HASH, slot: 32000},
     res: {data: ssz.phase0.Attestation.defaultValue()},
@@ -118,6 +136,10 @@ export const testData: GenericServerTestCases<Endpoints> = {
     args: {contributionAndProofs: [ssz.altair.SignedContributionAndProof.defaultValue()]},
     res: undefined,
   },
+  publishInclusionList: {
+    args: {signedInclusionList: ssz.focil.SignedInclusionList.defaultValue()},
+    res: undefined,
+  },
   prepareBeaconCommitteeSubnet: {
     args: {subscriptions: [{validatorIndex: 1, committeeIndex: 2, committeesAtSlot: 3, slot: 4, isAggregator: true}]},
     res: undefined,

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

@@ -458,7 +458,7 @@ export function getBeaconBlockApi({
           };
         }
       } else if (blockId === "head") {
-        const head = chain.forkChoice.getHead();
+        const head = chain.forkChoice.getAttesterHead();
         return {
           data: {root: fromHex(head.blockRoot)},
           meta: {executionOptimistic: isOptimisticBlock(head), finalized: false},

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

@@ -239,7 +239,7 @@ export function getBeaconStateApi({
           `No shuffling found to calculate committees for epoch: ${epoch} and decisionRoot: ${decisionRoot}`
         );
       }
-      const committees = shuffling.committees;
+      const committees = shuffling.beaconCommittees;
       const committeesFlat = committees.flatMap((slotCommittees, slotInEpoch) => {
         const slot = startSlot + slotInEpoch;
         if (filters.slot !== undefined && filters.slot !== slot) {