Add inclusion list production to the validator client

.github/workflows/test-suite.yml

@@ -108,13 +108,12 @@ jobs:
     runs-on: ${{ github.repository == 'sigp/lighthouse' && 'warp-ubuntu-latest-x64-8x;snapshot.key=lighthouse-ubuntu-latest-v1' || 'ubuntu-latest' }}
     steps:
     - uses: actions/checkout@v5
-    # Set Java version to 21. (required since Web3Signer 24.12.0).
-    # On sigp/lighthouse, Java 21 is baked into the snapshot.
-    - if: github.repository != 'sigp/lighthouse'
-      uses: actions/setup-java@v4
+    # Set Java version to 25. (required since Web3Signer 26.7.0).
+    # Always install; do not rely on the WarpBuild snapshot containing Java 25.
+    - uses: actions/setup-java@v4
       with:
         distribution: 'temurin'
-        java-version: '21'
+        java-version: '25'
     - if: github.repository != 'sigp/lighthouse'
       name: Get latest version of stable Rust
       uses: moonrepo/setup-rust@v1
@@ -310,8 +309,30 @@ jobs:
           cache-target: release
     - name: Run state_transition_vectors in release.
       run: make run-state-transition-tests
-  ef-tests-ubuntu:
-    name: ef-tests-ubuntu
+  ef-tests-mainnet-ubuntu:
+    name: ef-tests-mainnet-ubuntu
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
+    runs-on: ${{ github.repository == 'sigp/lighthouse' && 'warp-ubuntu-latest-x64-8x;snapshot.key=lighthouse-ubuntu-latest-v1' || 'ubuntu-latest' }}
+    env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+    - uses: actions/checkout@v5
+    - if: github.repository != 'sigp/lighthouse'
+      name: Get latest version of stable Rust
+      uses: moonrepo/setup-rust@v1
+      with:
+          channel: stable
+          cache-target: release
+          bins: cargo-nextest
+    - if: github.repository == 'sigp/lighthouse'
+      uses: Swatinem/rust-cache@v2
+      with:
+          cache-provider: warpbuild
+    - name: Run mainnet consensus-spec-tests with blst and fake_crypto
+      run: make test-ef-mainnet
+  ef-tests-minimal-ubuntu:
+    name: ef-tests-minimal-ubuntu
     needs: [check-labels]
     if: needs.check-labels.outputs.skip_ci != 'true'
     runs-on: ${{ github.repository == 'sigp/lighthouse' && 'warp-ubuntu-latest-x64-8x;snapshot.key=lighthouse-ubuntu-latest-v1' || 'ubuntu-latest' }}
@@ -330,8 +351,8 @@ jobs:
       uses: Swatinem/rust-cache@v2
       with:
           cache-provider: warpbuild
-    - name: Run consensus-spec-tests with blst and fake_crypto
-      run: make test-ef
+    - name: Run minimal consensus-spec-tests with blst and fake_crypto
+      run: make test-ef-minimal
   basic-simulator-ubuntu:
     name: basic-simulator-ubuntu
     needs: [check-labels]
@@ -549,7 +570,8 @@ jobs:
       'http-api-tests',
       'debug-tests-ubuntu',
       'state-transition-vectors-ubuntu',
-      'ef-tests-ubuntu',
+      'ef-tests-mainnet-ubuntu',
+      'ef-tests-minimal-ubuntu',
       'basic-simulator-ubuntu',
       'fallback-simulator-ubuntu',
       'execution-engine-integration-ubuntu',

.github/workflows/warpbuild-ubuntu-latest-snapshot.yml

@@ -52,11 +52,11 @@ jobs:
           cargo install --locked cargo-sort
           cargo install --locked cargo-hack
 
-      - name: Install Java (Temurin 21)
+      - name: Install Java (Temurin 25)
         uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
-          java-version: '21'
+          java-version: '25'
 
       - name: Save snapshot
         uses: WarpBuilds/snapshot-save@v1

Makefile

@@ -202,10 +202,22 @@ check-benches:
 
 # Runs EF test vectors
 run-ef-tests:
+	$(MAKE) run-ef-tests-mainnet
+	$(MAKE) run-ef-tests-minimal
+
+# Runs the mainnet EF test vectors
+run-ef-tests-mainnet:
 	rm -rf $(EF_TESTS)/.accessed_file_log.txt
 	cargo nextest run --release -p ef_tests --features "ef_tests,$(EF_TEST_FEATURES)"
 	cargo nextest run --release -p ef_tests --features "ef_tests,$(EF_TEST_FEATURES),fake_crypto"
-	./$(EF_TESTS)/check_all_files_accessed.py $(EF_TESTS)/.accessed_file_log.txt $(EF_TESTS)/consensus-spec-tests
+	./$(EF_TESTS)/check_all_files_accessed.py $(EF_TESTS)/.accessed_file_log.txt $(EF_TESTS)/consensus-spec-tests "tests/minimal/"
+
+# Runs the minimal EF test vectors
+run-ef-tests-minimal:
+	rm -rf $(EF_TESTS)/.accessed_file_log.txt
+	cargo nextest run --release -p ef_tests --features "ef_tests,spec-minimal,$(EF_TEST_FEATURES)"
+	cargo nextest run --release -p ef_tests --features "ef_tests,spec-minimal,$(EF_TEST_FEATURES),fake_crypto"
+	./$(EF_TESTS)/check_all_files_accessed.py $(EF_TESTS)/.accessed_file_log.txt $(EF_TESTS)/consensus-spec-tests "tests/mainnet/"
 
 # Run the tests in the `beacon_chain` crate for all known forks.
 test-beacon-chain: $(patsubst %,test-beacon-chain-%,$(RECENT_FORKS))
@@ -259,6 +271,12 @@ run-state-transition-tests:
 # Downloads and runs the EF test vectors.
 test-ef: make-ef-tests run-ef-tests
 
+# Downloads and runs the mainnet EF test vectors.
+test-ef-mainnet: make-ef-tests run-ef-tests-mainnet
+
+# Downloads and runs the minimal EF test vectors.
+test-ef-minimal: make-ef-tests run-ef-tests-minimal
+
 # Downloads and runs the nightly EF test vectors.
 test-ef-nightly: make-ef-tests-nightly run-ef-tests
 

beacon_node/beacon_chain/src/beacon_block_reward.rs

@@ -45,11 +45,11 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             let bid_parent_block_hash = block
                 .body()
                 .signed_execution_payload_bid()?
-                .message
-                .parent_block_hash;
-            if bid_parent_block_hash == parent_bid.block_hash {
+                .message()
+                .parent_block_hash();
+            if bid_parent_block_hash == parent_bid.block_hash() {
                 let availability_index = parent_bid
-                    .slot
+                    .slot()
                     .as_usize()
                     .safe_rem(T::EthSpec::slots_per_historical_root())?;
                 state
@@ -291,7 +291,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         let parent_slot = state
             .latest_execution_payload_bid()
             .ok()
-            .map(|bid| bid.slot);
+            .map(|bid| bid.slot());
 
         for attestation in block.body().attestations() {
             let data = attestation.data();

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -35,7 +35,7 @@ use crate::envelope_times_cache::EnvelopeTimesCache;
 use crate::errors::{BeaconChainError as Error, BlockProductionError};
 use crate::events::ServerSentEventHandler;
 use crate::execution_payload::{NotifyExecutionLayer, PreparePayloadHandle, get_execution_payload};
-use crate::execution_proof_verification::{GossipVerifiedExecutionProof, ObservedExecutionProofs};
+use crate::execution_proof_verification::ObservedExecutionProofs;
 use crate::fork_choice_signal::{ForkChoiceSignalRx, ForkChoiceSignalTx};
 use crate::graffiti_calculator::{GraffitiCalculator, GraffitiSettings};
 use crate::inclusion_list_store::{DependentRoot, InclusionListStore};
@@ -1768,8 +1768,18 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         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 dependent_root = if self.spec.gloas_fork_epoch == Some(epoch) {
+            let decision_slot = epoch
+                .start_slot(T::EthSpec::slots_per_epoch())
+                .saturating_sub(1_u64);
+            if state.slot() == decision_slot {
+                dependent_block_root
+            } else {
+                *state.get_block_root(decision_slot)?
+            }
+        } else {
+            state.attester_shuffling_decision_root(dependent_block_root, relative_epoch)?
+        };
 
         let pubkey_cache = self.validator_pubkey_cache.read();
 
@@ -3925,7 +3935,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                         .message()
                         .body()
                         .signed_execution_payload_bid()?
-                        .clone(),
+                        .clone_as_signed_execution_payload_bid(),
                 );
                 chain.pending_payload_cache.insert_bid(block_root, bid);
             }
@@ -4230,23 +4240,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         }
     }
 
-    /// Caches an execution proof, importing the payload envelope if that was the last piece.
-    pub async fn check_execution_proof_availability_and_import(
-        self: &Arc<Self>,
-        verified_proof: GossipVerifiedExecutionProof,
-    ) -> Result<AvailabilityProcessingStatus, BlockError> {
-        let GossipVerifiedExecutionProof { proof, block_slot } = verified_proof;
-        let bid = self
-            .get_or_load_gloas_payload_bid(proof.beacon_block_root())
-            .await?;
-        let availability = self
-            .pending_payload_cache
-            .put_execution_proof(proof, &bid)
-            .map_err(BlockError::from)?;
-        self.process_payload_envelope_availability(block_slot, availability, || Ok(()))
-            .await
-    }
-
     /// Load a persisted Gloas bid without blocking the async runtime.
     pub(crate) async fn get_or_load_gloas_payload_bid(
         self: &Arc<Self>,

beacon_node/beacon_chain/src/block_production/bid_selection.rs

@@ -153,15 +153,15 @@ impl<E: EthSpec> BidCandidate<E> {
     /// terms are far below `Uint256::MAX`, so it is exact (a u64 gwei sum could saturate under a
     /// hostile `execution_payment` with the cap disabled).
     fn trusted_value(&self) -> Uint256 {
-        let bid = &self.signed_bid.message;
+        let bid = self.signed_bid.message();
         match &self.source {
             BidSource::Local { block_value, .. } => *block_value,
-            BidSource::Gossip => gwei_to_wei(bid.value), // gossip `execution_payment` is zero
+            BidSource::Gossip => gwei_to_wei(bid.value()), // gossip `execution_payment` is zero
             BidSource::Direct {
                 max_execution_payment,
                 ..
-            } => gwei_to_wei(bid.value).saturating_add(gwei_to_wei(
-                bid.execution_payment.min(*max_execution_payment),
+            } => gwei_to_wei(bid.value()).saturating_add(gwei_to_wei(
+                bid.execution_payment().min(*max_execution_payment),
             )),
         }
     }
@@ -197,10 +197,10 @@ impl<E: EthSpec> BidCandidate<E> {
     /// or the **unclamped** `value + execution_payment` (the proposer's real revenue; the clamp is a
     /// ranking-only trust bound).
     pub fn payload_value(&self) -> Uint256 {
-        let bid = &self.signed_bid.message;
+        let bid = self.signed_bid.message();
         match &self.source {
             BidSource::Local { block_value, .. } => *block_value,
-            _ => gwei_to_wei(bid.value.saturating_add(bid.execution_payment)),
+            _ => gwei_to_wei(bid.value().saturating_add(bid.execution_payment())),
         }
     }
 
@@ -252,7 +252,7 @@ mod tests {
     use super::*;
     use bls::Signature;
     use ssz_types::VariableList;
-    use types::{ExecutionPayloadBid, MainnetEthSpec};
+    use types::{ExecutionPayloadBidGloas, MainnetEthSpec, SignedExecutionPayloadBidGloas};
 
     type TestSpec = MainnetEthSpec;
 
@@ -277,15 +277,17 @@ mod tests {
         value_gwei: u64,
         payment_gwei: u64,
     ) -> Arc<SignedExecutionPayloadBid<TestSpec>> {
-        Arc::new(SignedExecutionPayloadBid {
-            message: ExecutionPayloadBid {
-                builder_index,
-                value: value_gwei,
-                execution_payment: payment_gwei,
-                ..Default::default()
+        Arc::new(SignedExecutionPayloadBid::Gloas(
+            SignedExecutionPayloadBidGloas {
+                message: ExecutionPayloadBidGloas {
+                    builder_index,
+                    value: value_gwei,
+                    execution_payment: payment_gwei,
+                    ..Default::default()
+                },
+                signature: Signature::empty(),
             },
-            signature: Signature::empty(),
-        })
+        ))
     }
 
     fn gossip(value_gwei: u64, boost: u64) -> BidCandidate<TestSpec> {
@@ -327,13 +329,13 @@ mod tests {
 
     fn local(block_value_gwei: u64, should_override_builder: bool) -> BidCandidate<TestSpec> {
         BidCandidate::local(
-            SignedExecutionPayloadBid {
-                message: ExecutionPayloadBid {
+            SignedExecutionPayloadBid::Gloas(SignedExecutionPayloadBidGloas {
+                message: ExecutionPayloadBidGloas {
                     builder_index: LOCAL_BUILDER,
                     ..Default::default()
                 },
                 signature: Signature::empty(),
-            },
+            }),
             ExecutionPayloadData {
                 payload: ExecutionPayloadGloas::default(),
                 execution_requests: ExecutionRequestsGloas::default(),
@@ -354,7 +356,7 @@ mod tests {
             BidSource::Direct { .. } => "direct",
         };
         (
-            win.signed_bid.message.builder_index,
+            win.signed_bid.message().builder_index(),
             win.is_local(),
             win.payload_value(),
             source,