Add IL committee duties endpoint to BN

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -91,7 +91,7 @@ use crate::{
 use bls::{PublicKey, PublicKeyBytes, Signature};
 use eth2::beacon_response::ForkVersionedResponse;
 use eth2::types::{
-    EventKind, PtcDuty, SseBlobSidecar, SseBlock, SseDataColumnSidecar,
+    EventKind, InclusionListDuty, PtcDuty, SseBlobSidecar, SseBlock, SseDataColumnSidecar,
     SseExtendedPayloadAttributes, SseHead, SseHeadV2,
 };
 use execution_layer::{
@@ -1759,6 +1759,49 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         Ok((duties, dependent_root))
     }
 
+    /// Get inclusion list committee duties for validators at a given epoch ([New in Heze:EIP7805]).
+    pub fn compute_inclusion_list_duties(
+        &self,
+        state: &BeaconState<T::EthSpec>,
+        epoch: Epoch,
+        validator_indices: &[u64],
+        dependent_block_root: Hash256,
+    ) -> Result<(Vec<Option<InclusionListDuty>>, Hash256), Error> {
+        let relative_epoch = RelativeEpoch::from_epoch(state.current_epoch(), epoch)
+            .map_err(Error::IncorrectStateForAttestation)?;
+
+        let dependent_root =
+            state.attester_shuffling_decision_root(dependent_block_root, relative_epoch)?;
+
+        let mut assignments: HashMap<u64, Slot> = HashMap::new();
+        for slot in epoch.slot_iter(T::EthSpec::slots_per_epoch()) {
+            let committee = state.get_inclusion_list_committee(slot)?;
+            for validator_index in &committee {
+                assignments.entry(*validator_index).or_insert(slot);
+            }
+        }
+
+        let pubkey_cache = self.validator_pubkey_cache.read();
+
+        let duties = validator_indices
+            .iter()
+            .map(|&validator_index| {
+                let Some(&pubkey) = pubkey_cache.get_pubkey_bytes(validator_index as usize) else {
+                    return None;
+                };
+                assignments
+                    .get(&validator_index)
+                    .map(|&slot| InclusionListDuty {
+                        pubkey,
+                        validator_index,
+                        slot,
+                    })
+            })
+            .collect::<Vec<_>>();
+
+        Ok((duties, dependent_root))
+    }
+
     pub fn get_aggregated_attestation(
         &self,
         attestation: AttestationRef<T::EthSpec>,

beacon_node/beacon_chain/src/block_production/gloas.rs

@@ -30,13 +30,13 @@ use tree_hash::TreeHash;
 use types::consts::gloas::BUILDER_INDEX_SELF_BUILD;
 use types::{
     Address, Attestation, AttestationGloas, AttesterSlashing, AttesterSlashingGloas, BeaconBlock,
-    BeaconBlockBodyGloas, BeaconBlockGloas, BeaconState, BeaconStateError, BlobsList, BuilderIndex,
-    ChainSpec, Deposit, Eth1Data, EthSpec, ExecutionBlockHash, ExecutionPayloadBid,
-    ExecutionPayloadEnvelope, ExecutionPayloadGloas, ExecutionRequestsGloas, FullPayload, Graffiti,
-    Hash256, IndexedAttestation, KzgProofs, PayloadAttestation, ProposerSlashing, RelativeEpoch,
-    SignedBeaconBlock, SignedBlsToExecutionChange, SignedExecutionPayloadBid,
-    SignedExecutionPayloadEnvelope, SignedVoluntaryExit, Slot, SyncAggregate, Uint256, Withdrawal,
-    Withdrawals,
+    BeaconBlockBodyGloas, BeaconBlockBodyHeze, BeaconBlockGloas, BeaconBlockHeze, BeaconState,
+    BeaconStateError, BlobsList, BuilderIndex, ChainSpec, Deposit, Eth1Data, EthSpec,
+    ExecutionBlockHash, ExecutionPayloadBid, ExecutionPayloadEnvelope, ExecutionPayloadGloas,
+    ExecutionRequestsGloas, FullPayload, Graffiti, Hash256, IndexedAttestation, KzgProofs,
+    PayloadAttestation, ProposerSlashing, RelativeEpoch, SignedBeaconBlock,
+    SignedBlsToExecutionChange, SignedExecutionPayloadBid, SignedExecutionPayloadEnvelope,
+    SignedVoluntaryExit, Slot, SyncAggregate, Uint256, Withdrawal, Withdrawals,
 };
 
 use crate::payload_bid_verification::payload_bid_cache::BidParent;
@@ -650,13 +650,31 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                     _phantom: PhantomData::<FullPayload<T::EthSpec>>,
                 },
             }),
-            // TODO(heze): construct a `BeaconBlockHeze` here once Heze block production is
-            // wired up end-to-end (get_payload, envelope handling, etc).
-            BeaconState::Heze(_) => {
-                return Err(BlockProductionError::InvalidBlockVariant(
-                    "Block production disabled for Heze".to_owned(),
-                ));
-            }
+            BeaconState::Heze(_) => BeaconBlock::Heze(BeaconBlockHeze {
+                slot,
+                proposer_index,
+                parent_root,
+                state_root: Hash256::ZERO,
+                body: BeaconBlockBodyHeze {
+                    randao_reveal,
+                    eth1_data,
+                    graffiti,
+                    // The operation list lengths are bounded by the op pool packing limits above.
+                    proposer_slashings: ProgressiveVariableList::from_iter(proposer_slashings),
+                    attester_slashings: ProgressiveVariableList::from_iter(attester_slashings),
+                    attestations: ProgressiveVariableList::from_iter(attestations),
+                    deposits: ProgressiveVariableList::from_iter(deposits),
+                    voluntary_exits: ProgressiveVariableList::from_iter(voluntary_exits),
+                    sync_aggregate,
+                    bls_to_execution_changes: ProgressiveVariableList::from_iter(
+                        bls_to_execution_changes,
+                    ),
+                    parent_execution_requests,
+                    signed_execution_payload_bid,
+                    payload_attestations: ProgressiveVariableList::from_iter(payload_attestations),
+                    _phantom: PhantomData::<FullPayload<T::EthSpec>>,
+                },
+            }),
         };
 
         let signed_beacon_block = SignedBeaconBlock::from_block(

beacon_node/beacon_chain/tests/store_tests.rs

@@ -1933,6 +1933,58 @@ async fn proposer_lookahead_excludes_slashed_proposer_only_after_first_two_gloas
     );
 }
 
+/// Ensure the harness can produce and import a chain across the Heze fork boundary
+#[tokio::test]
+async fn heze_block_production_across_boundary() {
+    let gloas_fork_epoch = Epoch::new(1);
+    let heze_fork_epoch = Epoch::new(2);
+    let mut spec = ForkName::Fulu.make_genesis_spec(E::default_spec());
+    spec.gloas_fork_epoch = Some(gloas_fork_epoch);
+    spec.heze_fork_epoch = Some(heze_fork_epoch);
+
+    let db_path = tempdir().unwrap();
+    let store = get_store_generic(&db_path, Default::default(), spec.clone());
+    let validators_keypairs =
+        types::test_utils::generate_deterministic_keypairs(LOW_VALIDATOR_COUNT);
+    let harness = TestHarness::builder(E::default())
+        .spec(spec.into())
+        .keypairs(validators_keypairs)
+        .fresh_disk_store(store)
+        .mock_execution_layer()
+        .build();
+    let all_validators = harness.get_all_validators();
+
+    // Build through the first Heze epoch, ending at the first slot of the next epoch
+    let last_slot = (heze_fork_epoch + 1).start_slot(E::slots_per_epoch());
+    let slots: Vec<Slot> = (1..=last_slot.as_u64()).map(Into::into).collect();
+    let state = harness.get_current_state();
+    let (_, _, head_block_root, head_state) = harness
+        .add_attested_blocks_at_slots(state, &slots, &all_validators)
+        .await;
+
+    assert_eq!(head_state.current_epoch(), heze_fork_epoch + 1);
+
+    let head_block_root: Hash256 = head_block_root.into();
+    let head_block = harness
+        .chain
+        .store
+        .get_blinded_block(&head_block_root)
+        .unwrap()
+        .expect("head block should be stored");
+    assert!(
+        matches!(head_block, SignedBeaconBlock::Heze(_)),
+        "the head block should be a Heze block"
+    );
+    assert!(
+        harness
+            .chain
+            .get_payload_envelope(&head_block_root)
+            .unwrap()
+            .is_some(),
+        "the Heze block's execution payload envelope should be stored"
+    );
+}
+
 // Ensure blocks from abandoned forks are pruned from the Hot DB
 #[tokio::test]
 async fn prunes_abandoned_fork_between_two_finalized_checkpoints() {

beacon_node/execution_layer/src/engine_api/http.rs

@@ -1061,7 +1061,9 @@ impl HttpJsonRpc {
         let params = json!([JsonPayloadIdRequest::from(payload_id)]);
 
         match fork_name {
-            ForkName::Gloas => {
+            // TODO(heze): deliberately reusing the Gloas response containers while the Heze
+            // payload is identical to the Gloas one. Switch to the Heze types if it diverges
+            ForkName::Gloas | ForkName::Heze => {
                 let response: JsonGetPayloadResponseGloas<E> = self
                     .rpc_request(
                         ENGINE_GET_PAYLOAD_V6,
@@ -1073,7 +1075,6 @@ impl HttpJsonRpc {
                     .try_into()
                     .map_err(Error::BadResponse)
             }
-            // TODO(heze): add a Heze arm once Heze payload retrieval is implemented.
             _ => Err(Error::UnsupportedForkVariant(format!(
                 "called get_payload_v6 with {}",
                 fork_name
@@ -1444,18 +1445,13 @@ impl HttpJsonRpc {
                     Err(Error::RequiredMethodUnsupported("engine_getPayloadv5"))
                 }
             }
-            ForkName::Gloas => {
+            ForkName::Gloas | ForkName::Heze => {
                 if engine_capabilities.get_payload_v6 {
                     self.get_payload_v6(fork_name, payload_id).await
                 } else {
                     Err(Error::RequiredMethodUnsupported("engine_getPayloadV6"))
                 }
             }
-            // TODO(heze): implement the Heze getPayload path once the engine API for Heze
-            // is specified.
-            ForkName::Heze => Err(Error::UnsupportedForkVariant(
-                "getPayload not implemented for Heze".to_string(),
-            )),
             ForkName::Base | ForkName::Altair => Err(Error::UnsupportedForkVariant(format!(
                 "called get_payload with {}",
                 fork_name

beacon_node/execution_layer/src/lib.rs

@@ -225,8 +225,6 @@ impl<E: EthSpec> From<GetPayloadResponseGloas<E>> for BlockProposalContentsGloas
     }
 }
 
-// TODO(heze): add a `BlockProposalContentsHeze` here once Heze block production is wired up.
-
 pub enum BlockProposalContents<E: EthSpec, Payload: AbstractExecPayload<E>> {
     Payload {
         payload: Payload,
@@ -952,8 +950,6 @@ impl<E: EthSpec> ExecutionLayer<E> {
         Ok(payload_response.into())
     }
 
-    // TODO(heze): add a `get_payload_heze` here once Heze block production is wired up.
-
     /// Maps to the `engine_getPayload` JSON-RPC call.
     ///
     /// However, it will attempt to call `self.prepare_payload` if it cannot find an existing

beacon_node/execution_layer/src/test_utils/execution_block_generator.rs

@@ -850,6 +850,13 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
                                 .push(ProgressiveVariableList::<u8>::new(tx.into()));
                         }
                     }
+                    ExecutionPayload::Heze(payload) => {
+                        for tx in Vec::from(transactions) {
+                            payload
+                                .transactions
+                                .push(ProgressiveVariableList::<u8>::new(tx.into()));
+                        }
+                    }
                     _ => {
                         for tx in Vec::from(transactions) {
                             execution_payload