Devnet6 (#4404)

* some blob reprocessing work

* remove ForceBlockLookup

* reorder enum match arms in sync manager

* a lot more reprocessing work

* impl logic for triggerng blob lookups along with block lookups

* deal with rpc blobs in groups per block in the da checker. don't cache missing blob ids in the da checker.

* make single block lookup generic

* more work

* add delayed processing logic and combine some requests

* start fixing some compile errors

* fix compilation in main block lookup mod

* much work

* get things compiling

* parent blob lookups

* fix compile

* revert red/stevie changes

* fix up sync manager delay message logic

* add peer usefulness enum

* should remove lookup refactor

* consolidate retry error handling

* improve peer scoring during certain failures in parent lookups

* improve retry code

* drop parent lookup if either req has a peer disconnect during download

* refactor single block processed method

* processing peer refactor

* smol bugfix

* fix some todos

* fix lints

* fix lints

* fix compile in lookup tests

* fix lints

* fix lints

* fix existing block lookup tests

* renamings

* fix after merge

* cargo fmt

* compilation fix in beacon chain tests

* fix

* refactor lookup tests to work with multiple forks and response types

* make tests into macros

* wrap availability check error

* fix compile after merge

* add random blobs

* start fixing up lookup verify error handling

* some bug fixes and the start of deneb only tests

* make tests work for all forks

* track information about peer source

* error refactoring

* improve peer scoring

* fix test compilation

* make sure blobs are sent for processing after stream termination, delete copied tests

* add some tests and fix a bug

* smol bugfixes and moar tests

* add tests and fix some things

* compile after merge

* lots of refactoring

* retry on invalid block/blob

* merge unknown parent messages before current slot lookup

* get tests compiling

* penalize blob peer on invalid blobs

* Check disk on in-memory cache miss

* Update beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs

* Update beacon_node/network/src/sync/network_context.rs

Co-authored-by: Divma <26765164+divagant-martian@users.noreply.github.com>

* fix bug in matching blocks and blobs in range sync

* pr feedback

* fix conflicts

* upgrade logs from warn to crit when we receive incorrect response in range

* synced_and_connected_within_tolerance -> should_search_for_block

* remove todo

* add data gas used and update excess data gas to u64

* Fix Broken Overflow Tests

* payload verification with commitments

* fix merge conflicts

* restore payload file

* Restore payload file

* remove todo

* add max blob commitments per block

* c-kzg lib update

* Fix ef tests

* Abstract over minimal/mainnet spec in kzg crate

* Start integrating new KZG

* checkpoint sync without alignment

* checkpoint sync without alignment

* add import

* add import

* query for checkpoint state by slot rather than state root (teku doesn't serve by state root)

* query for checkpoint state by slot rather than state root (teku doesn't serve by state root)

* loosen check

* get state first and query by most recent block root

* Revert "loosen check"

This reverts commit 069d13dd63.

* get state first and query by most recent block root

* merge max blobs change

* simplify delay logic

* rename unknown parent sync message variants

* rename parameter, block_slot -> slot

* add some docs to the lookup module

* use interval instead of sleep

* drop request if blocks and blobs requests both return `None` for `Id`

* clean up `find_single_lookup` logic

* add lookup source enum

* clean up `find_single_lookup` logic

* add docs to find_single_lookup_request

* move LookupSource our of param where unnecessary

* remove unnecessary todo

* query for block by `state.latest_block_header.slot`

* fix lint

* fix merge transition ef tests

* fix test

* fix test

* fix observed  blob sidecars test

* Add some metrics (#33)

* fix protocol limits for blobs by root

* Update Engine API for 1:1 Structure Method

* make beacon chain tests to fix devnet 6 changes

* get ckzg working and fix some tests

* fix remaining tests

* fix lints

* Fix KZG linking issues

* remove unused dep

* lockfile

* test fixes

* remove dbgs

* remove unwrap

* cleanup tx generator

* small fixes

* fixing fixes

* more self reivew

* more self review

* refactor genesis header initialization

* refactor mock el instantiations

* fix compile

* fix network test, make sure they run for each fork

* pr feedback

* fix last test (hopefully)

---------

Co-authored-by: Pawan Dhananjay <pawandhananjay@gmail.com>
Co-authored-by: Mark Mackey <mark@sigmaprime.io>
Co-authored-by: Divma <26765164+divagant-martian@users.noreply.github.com>
Co-authored-by: Michael Sproul <michael@sigmaprime.io>

beacon_node/lighthouse_network/src/rpc/handler.rs

@@ -47,6 +47,12 @@ const MAX_INBOUND_SUBSTREAMS: usize = 32;
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 pub struct SubstreamId(usize);
 
+impl SubstreamId {
+    pub fn new(id: usize) -> Self {
+        Self(id)
+    }
+}
+
 type InboundSubstream<TSpec> = InboundFramed<NegotiatedSubstream, TSpec>;
 
 /// Events the handler emits to the behaviour.
@@ -753,6 +759,9 @@ where
                                 if matches!(info.protocol, Protocol::BlocksByRange) {
                                     debug!(self.log, "BlocksByRange Response sent"; "duration" => Instant::now().duration_since(info.request_start_time).as_secs());
                                 }
+                                if matches!(info.protocol, Protocol::BlobsByRange) {
+                                    debug!(self.log, "BlobsByRange Response sent"; "duration" => Instant::now().duration_since(info.request_start_time).as_secs());
+                                }
 
                                 // There is nothing more to process on this substream as it has
                                 // been closed. Move on to the next one.
@@ -776,6 +785,9 @@ where
                                 if matches!(info.protocol, Protocol::BlocksByRange) {
                                     debug!(self.log, "BlocksByRange Response failed"; "duration" => info.request_start_time.elapsed().as_secs());
                                 }
+                                if matches!(info.protocol, Protocol::BlobsByRange) {
+                                    debug!(self.log, "BlobsByRange Response failed"; "duration" => info.request_start_time.elapsed().as_secs());
+                                }
                                 break;
                             }
                             // The sending future has not completed. Leave the state as busy and

beacon_node/lighthouse_network/src/rpc/methods.rs

@@ -6,7 +6,7 @@ use serde::Serialize;
 use ssz::Encode;
 use ssz_derive::{Decode, Encode};
 use ssz_types::{
-    typenum::{U1024, U256, U768},
+    typenum::{U1024, U128, U256, U768},
     VariableList,
 };
 use std::marker::PhantomData;
@@ -28,6 +28,7 @@ pub const MAX_REQUEST_BLOCKS: u64 = 1024;
 pub type MaxErrorLen = U256;
 pub const MAX_ERROR_LEN: u64 = 256;
 
+pub type MaxRequestBlocksDeneb = U128;
 pub const MAX_REQUEST_BLOCKS_DENEB: u64 = 128;
 
 // TODO: this is calculated as MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK and
@@ -295,7 +296,7 @@ pub struct BlobsByRangeRequest {
     /// The starting slot to request blobs.
     pub start_slot: u64,
 
-    /// The number of blobs from the start slot.
+    /// The number of slots from the start slot.
     pub count: u64,
 }
 

beacon_node/lighthouse_network/src/rpc/mod.rs

@@ -248,8 +248,10 @@ where
                     Err(RateLimitedErr::TooLarge) => {
                         // we set the batch sizes, so this is a coding/config err for most protocols
                         let protocol = req.versioned_protocol().protocol();
-                        if matches!(protocol, Protocol::BlocksByRange) {
-                            debug!(self.log, "Blocks by range request will never be processed"; "request" => %req);
+                        if matches!(protocol, Protocol::BlocksByRange)
+                            || matches!(protocol, Protocol::BlobsByRange)
+                        {
+                            debug!(self.log, "By range request will never be processed"; "request" => %req, "protocol" => %protocol);
                         } else {
                             crit!(self.log, "Request size too large to ever be processed"; "protocol" => %protocol);
                         }

beacon_node/lighthouse_network/src/rpc/protocol.rs

@@ -101,6 +101,20 @@ lazy_static! {
         ])
     .as_ssz_bytes()
     .len();
+
+    pub static ref BLOBS_BY_ROOT_REQUEST_MIN: usize =
+        VariableList::<Hash256, MaxRequestBlobSidecars>::from(Vec::<Hash256>::new())
+    .as_ssz_bytes()
+    .len();
+    pub static ref BLOBS_BY_ROOT_REQUEST_MAX: usize =
+        VariableList::<Hash256, MaxRequestBlobSidecars>::from(vec![
+            Hash256::zero();
+            MAX_REQUEST_BLOB_SIDECARS
+                as usize
+        ])
+    .as_ssz_bytes()
+    .len();
+
     pub static ref ERROR_TYPE_MIN: usize =
         VariableList::<u8, MaxErrorLen>::from(Vec::<u8>::new())
     .as_ssz_bytes()
@@ -113,13 +127,6 @@ lazy_static! {
         ])
     .as_ssz_bytes()
     .len();
-
-    pub static ref BLOB_SIDECAR_MIN: usize = BlobSidecar::<MainnetEthSpec>::empty().as_ssz_bytes().len();
-    pub static ref BLOB_SIDECAR_MAX: usize = BlobSidecar::<MainnetEthSpec>::max_size();
-
-    //FIXME(sean) these are underestimates
-    pub static ref SIGNED_BLOCK_AND_BLOBS_MIN: usize = *BLOB_SIDECAR_MIN + *SIGNED_BEACON_BLOCK_BASE_MIN;
-    pub static ref SIGNED_BLOCK_AND_BLOBS_MAX: usize =*BLOB_SIDECAR_MAX + *SIGNED_BEACON_BLOCK_DENEB_MAX;
 }
 
 /// The maximum bytes that can be sent across the RPC pre-merge.
@@ -395,8 +402,7 @@ impl ProtocolId {
                 <BlobsByRangeRequest as Encode>::ssz_fixed_len(),
             ),
             Protocol::BlobsByRoot => {
-                // TODO: This looks wrong to me
-                RpcLimits::new(*BLOCKS_BY_ROOT_REQUEST_MIN, *BLOCKS_BY_ROOT_REQUEST_MAX)
+                RpcLimits::new(*BLOBS_BY_ROOT_REQUEST_MIN, *BLOBS_BY_ROOT_REQUEST_MAX)
             }
             Protocol::Ping => RpcLimits::new(
                 <Ping as Encode>::ssz_fixed_len(),
@@ -420,8 +426,8 @@ impl ProtocolId {
             Protocol::Goodbye => RpcLimits::new(0, 0), // Goodbye request has no response
             Protocol::BlocksByRange => rpc_block_limits_by_fork(fork_context.current_fork()),
             Protocol::BlocksByRoot => rpc_block_limits_by_fork(fork_context.current_fork()),
-            Protocol::BlobsByRange => RpcLimits::new(*BLOB_SIDECAR_MIN, *BLOB_SIDECAR_MAX),
-            Protocol::BlobsByRoot => RpcLimits::new(*BLOB_SIDECAR_MIN, *BLOB_SIDECAR_MAX),
+            Protocol::BlobsByRange => rpc_blob_limits::<T>(),
+            Protocol::BlobsByRoot => rpc_blob_limits::<T>(),
             Protocol::Ping => RpcLimits::new(
                 <Ping as Encode>::ssz_fixed_len(),
                 <Ping as Encode>::ssz_fixed_len(),
@@ -476,6 +482,13 @@ impl ProtocolId {
     }
 }
 
+pub fn rpc_blob_limits<T: EthSpec>() -> RpcLimits {
+    RpcLimits::new(
+        BlobSidecar::<T>::empty().as_ssz_bytes().len(),
+        BlobSidecar::<T>::max_size(),
+    )
+}
+
 impl ProtocolName for ProtocolId {
     fn protocol_name(&self) -> &[u8] {
         self.protocol_id.as_bytes()

beacon_node/lighthouse_network/tests/rpc_tests.rs

@@ -9,8 +9,9 @@ use std::time::Duration;
 use tokio::runtime::Runtime;
 use tokio::time::sleep;
 use types::{
-    BeaconBlock, BeaconBlockAltair, BeaconBlockBase, BeaconBlockMerge, EmptyBlock, Epoch, EthSpec,
-    ForkContext, ForkName, Hash256, MinimalEthSpec, Signature, SignedBeaconBlock, Slot,
+    BeaconBlock, BeaconBlockAltair, BeaconBlockBase, BeaconBlockMerge, BlobSidecar, EmptyBlock,
+    Epoch, EthSpec, ForkContext, ForkName, Hash256, MinimalEthSpec, Signature, SignedBeaconBlock,
+    Slot,
 };
 
 mod common;
@@ -259,6 +260,111 @@ fn test_blocks_by_range_chunked_rpc() {
     })
 }
 
+// Tests a streamed BlobsByRange RPC Message
+#[test]
+#[allow(clippy::single_match)]
+fn test_blobs_by_range_chunked_rpc() {
+    // set up the logging. The level and enabled logging or not
+    let log_level = Level::Debug;
+    let enable_logging = false;
+
+    let slot_count = 32;
+    let messages_to_send = 34;
+
+    let log = common::build_log(log_level, enable_logging);
+
+    let rt = Arc::new(Runtime::new().unwrap());
+
+    rt.block_on(async {
+        // get sender/receiver
+        let (mut sender, mut receiver) =
+            common::build_node_pair(Arc::downgrade(&rt), &log, ForkName::Deneb).await;
+
+        // BlobsByRange Request
+        let rpc_request = Request::BlobsByRange(BlobsByRangeRequest {
+            start_slot: 0,
+            count: slot_count,
+        });
+
+        // BlocksByRange Response
+        let blob = BlobSidecar::<E>::default();
+
+        let rpc_response = Response::BlobsByRange(Some(Arc::new(blob)));
+
+        // keep count of the number of messages received
+        let mut messages_received = 0;
+        let request_id = messages_to_send as usize;
+        // build the sender future
+        let sender_future = async {
+            loop {
+                match sender.next_event().await {
+                    NetworkEvent::PeerConnectedOutgoing(peer_id) => {
+                        // Send a STATUS message
+                        debug!(log, "Sending RPC");
+                        sender.send_request(peer_id, request_id, rpc_request.clone());
+                    }
+                    NetworkEvent::ResponseReceived {
+                        peer_id: _,
+                        id: _,
+                        response,
+                    } => {
+                        warn!(log, "Sender received a response");
+                        match response {
+                            Response::BlobsByRange(Some(_)) => {
+                                assert_eq!(response, rpc_response.clone());
+                                messages_received += 1;
+                                warn!(log, "Chunk received");
+                            }
+                            Response::BlobsByRange(None) => {
+                                // should be exactly `messages_to_send` messages before terminating
+                                assert_eq!(messages_received, messages_to_send);
+                                // end the test
+                                return;
+                            }
+                            _ => panic!("Invalid RPC received"),
+                        }
+                    }
+                    _ => {} // Ignore other behaviour events
+                }
+            }
+        };
+
+        // build the receiver future
+        let receiver_future = async {
+            loop {
+                match receiver.next_event().await {
+                    NetworkEvent::RequestReceived {
+                        peer_id,
+                        id,
+                        request,
+                    } => {
+                        if request == rpc_request {
+                            // send the response
+                            warn!(log, "Receiver got request");
+                            for _ in 0..messages_to_send {
+                                // Send first third of responses as base blocks,
+                                // second as altair and third as merge.
+                                receiver.send_response(peer_id, id, rpc_response.clone());
+                            }
+                            // send the stream termination
+                            receiver.send_response(peer_id, id, Response::BlobsByRange(None));
+                        }
+                    }
+                    _ => {} // Ignore other events
+                }
+            }
+        };
+
+        tokio::select! {
+            _ = sender_future => {}
+            _ = receiver_future => {}
+            _ = sleep(Duration::from_secs(30)) => {
+                    panic!("Future timed out");
+            }
+        }
+    })
+}
+
 // Tests rejection of blocks over `MAX_RPC_SIZE`.
 #[test]
 #[allow(clippy::single_match)]