[Merged by Bors] - Shift networking configuration

beacon_node/beacon_chain/src/attestation_verification.rs

@@ -51,7 +51,7 @@ use state_processing::{
  signed_aggregate_selection_proof_signature_set, signed_aggregate_signature_set,
  },
 };
-use std::{borrow::Cow, time::Duration};
+use std::borrow::Cow;
 use strum::AsRefStr;
 use tree_hash::TreeHash;
 use types::{
@@ -1034,10 +1034,8 @@ pub fn verify_propagation_slot_range<S: SlotClock, E: EthSpec>(
  spec: &ChainSpec,
 ) -> Result<(), Error> {
  let attestation_slot = attestation.data.slot;
- let maximum_gossip_clock_disparity =
- Duration::from_millis(spec.maximum_gossip_clock_disparity_millis);
  let latest_permissible_slot = slot_clock
- .now_with_future_tolerance(maximum_gossip_clock_disparity)
+ .now_with_future_tolerance(spec.clone().maximum_gossip_clock_disparity())
  .ok_or(BeaconChainError::UnableToReadSlot)?;
  if attestation_slot > latest_permissible_slot {
  return Err(Error::FutureSlot {
@@ -1048,7 +1046,7 @@ pub fn verify_propagation_slot_range<S: SlotClock, E: EthSpec>(
 
  // Taking advantage of saturating subtraction on `Slot`.
  let earliest_permissible_slot = slot_clock
- .now_with_past_tolerance(maximum_gossip_clock_disparity)
+ .now_with_past_tolerance(spec.clone().maximum_gossip_clock_disparity())
  .ok_or(BeaconChainError::UnableToReadSlot)?
  - E::slots_per_epoch();
  if attestation_slot < earliest_permissible_slot {

beacon_node/beacon_chain/src/sync_committee_verification.rs

@@ -41,16 +41,17 @@ use state_processing::signature_sets::{
  sync_committee_contribution_signature_set_from_pubkeys,
  sync_committee_message_set_from_pubkeys,
 };
+use types::ChainSpec;
 use std::collections::HashMap;
-use std::{borrow::Cow, time::Duration};
+use std::borrow::Cow;
 use strum::AsRefStr;
 use tree_hash::TreeHash;
 use types::consts::altair::SYNC_COMMITTEE_SUBNET_COUNT;
 use types::slot_data::SlotData;
 use types::sync_committee::Error as SyncCommitteeError;
 use types::{
  sync_committee_contribution::Error as ContributionError, AggregateSignature, BeaconStateError,
- EthSpec, Hash256, MainnetEthSpec, SignedContributionAndProof, Slot, SyncCommitteeContribution,
+ EthSpec, Hash256, SignedContributionAndProof, Slot, SyncCommitteeContribution,
  SyncCommitteeMessage, SyncSelectionProof, SyncSubnetId,
 };
 
@@ -285,7 +286,7 @@ impl<T: BeaconChainTypes> VerifiedSyncContribution<T> {
  let subcommittee_index = contribution.subcommittee_index as usize;
 
  // Ensure sync committee contribution is within the MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance.
- verify_propagation_slot_range(&chain.slot_clock, contribution)?;
+ verify_propagation_slot_range(&chain.slot_clock, contribution, &chain.spec)?;
 
  // Validate subcommittee index.
  if contribution.subcommittee_index >= SYNC_COMMITTEE_SUBNET_COUNT {
@@ -440,7 +441,7 @@ impl VerifiedSyncCommitteeMessage {
  // MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance).
  //
  // We do not queue future sync committee messages for later processing.
- verify_propagation_slot_range(&chain.slot_clock, &sync_message)?;
+ verify_propagation_slot_range(&chain.slot_clock, &sync_message, &chain.spec)?;
 
  // Ensure the `subnet_id` is valid for the given validator.
  let pubkey = chain
@@ -556,12 +557,11 @@ impl VerifiedSyncCommitteeMessage {
 pub fn verify_propagation_slot_range<S: SlotClock, U: SlotData>(
  slot_clock: &S,
  sync_contribution: &U,
+ spec: &ChainSpec,
 ) -> Result<(), Error> {
  let message_slot = sync_contribution.get_slot();
- let maximum_gossip_clock_disparity =
- Duration::from_millis(MainnetEthSpec::default_spec().maximum_gossip_clock_disparity_millis);
  let latest_permissible_slot = slot_clock
- .now_with_future_tolerance(maximum_gossip_clock_disparity)
+ .now_with_future_tolerance(spec.clone().maximum_gossip_clock_disparity())
  .ok_or(BeaconChainError::UnableToReadSlot)?;
  if message_slot > latest_permissible_slot {
  return Err(Error::FutureSlot {
@@ -571,7 +571,7 @@ pub fn verify_propagation_slot_range<S: SlotClock, U: SlotData>(
  }
 
  let earliest_permissible_slot = slot_clock
- .now_with_past_tolerance(maximum_gossip_clock_disparity)
+ .now_with_past_tolerance(spec.clone().maximum_gossip_clock_disparity())
  .ok_or(BeaconChainError::UnableToReadSlot)?;
 
  if message_slot < earliest_permissible_slot {

beacon_node/lighthouse_network/src/config.rs

@@ -444,13 +444,13 @@ pub fn gossipsub_config<TSpec: EthSpec>(
  }
  }
  }
-
+ let cloned_spec = spec.clone();
  let is_merge_enabled = fork_context.fork_exists(ForkName::Merge);
  let gossip_message_id = move |message: &GossipsubMessage| {
  MessageId::from(
  &Sha256::digest(
  prefix(
- TSpec::default_spec().message_domain_valid_snappy,
+ cloned_spec.message_domain_valid_snappy,
  message,
  fork_context.clone(),
  )

beacon_node/lighthouse_network/src/rpc/codec/base.rs

@@ -222,7 +222,7 @@ mod tests {
 
  let mut snappy_outbound_codec = SSZSnappyOutboundCodec::<Spec>::new(
  snappy_protocol_id,
- max_rpc_size(&fork_context, &chain_spec),
+ max_rpc_size(&fork_context, chain_spec.max_chunk_size as usize),
  fork_context,
  );
 
@@ -259,7 +259,7 @@ mod tests {
 
  let mut snappy_outbound_codec = SSZSnappyOutboundCodec::<Spec>::new(
  snappy_protocol_id,
- max_rpc_size(&fork_context, &chain_spec),
+ max_rpc_size(&fork_context, chain_spec.max_chunk_size as usize),
  fork_context,
  );
 
@@ -288,7 +288,7 @@ mod tests {
 
  let chain_spec = Spec::default_spec();
 
- let max_rpc_size = max_rpc_size(&fork_context, &chain_spec);
+ let max_rpc_size = max_rpc_size(&fork_context, chain_spec.max_chunk_size as usize);
  let limit = protocol_id.rpc_response_limits::<Spec>(&fork_context);
  let mut max = encode_len(limit.max + 1);
  let mut codec = SSZSnappyOutboundCodec::<Spec>::new(

beacon_node/lighthouse_network/src/rpc/codec/ssz_snappy.rs

@@ -667,7 +667,7 @@ mod tests {
  block.body.execution_payload.execution_payload.transactions = txs;
 
  let block = BeaconBlock::Merge(block);
- assert!(block.ssz_bytes_len() <= max_rpc_size(fork_context, spec));
+ assert!(block.ssz_bytes_len() <= max_rpc_size(fork_context, spec.max_chunk_size as usize));
  SignedBeaconBlock::from_block(block, Signature::empty())
  }
 
@@ -683,7 +683,7 @@ mod tests {
  block.body.execution_payload.execution_payload.transactions = txs;
 
  let block = BeaconBlock::Merge(block);
- assert!(block.ssz_bytes_len() > max_rpc_size(fork_context, spec));
+ assert!(block.ssz_bytes_len() > max_rpc_size(fork_context, spec.max_chunk_size as usize));
  SignedBeaconBlock::from_block(block, Signature::empty())
  }
 
@@ -741,7 +741,7 @@ mod tests {
  ) -> Result<BytesMut, RPCError> {
  let snappy_protocol_id = ProtocolId::new(protocol, Encoding::SSZSnappy);
  let fork_context = Arc::new(fork_context(fork_name));
- let max_packet_size = max_rpc_size(&fork_context, spec);
+ let max_packet_size = max_rpc_size(&fork_context, spec.max_chunk_size as usize);
 
  let mut buf = BytesMut::new();
  let mut snappy_inbound_codec =
@@ -788,7 +788,7 @@ mod tests {
  ) -> Result<Option<RPCResponse<Spec>>, RPCError> {
  let snappy_protocol_id = ProtocolId::new(protocol, Encoding::SSZSnappy);
  let fork_context = Arc::new(fork_context(fork_name));
- let max_packet_size = max_rpc_size(&fork_context, spec);
+ let max_packet_size = max_rpc_size(&fork_context, spec.max_chunk_size as usize);
  let mut snappy_outbound_codec =
  SSZSnappyOutboundCodec::<Spec>::new(snappy_protocol_id, max_packet_size, fork_context);
  // decode message just as snappy message
@@ -813,7 +813,7 @@ mod tests {
  spec: &ChainSpec,
  ) {
  let fork_context = Arc::new(fork_context(fork_name));
- let max_packet_size = max_rpc_size(&fork_context, spec);
+ let max_packet_size = max_rpc_size(&fork_context, spec.max_chunk_size as usize);
  let protocol = ProtocolId::new(req.versioned_protocol(), Encoding::SSZSnappy);
  // Encode a request we send
  let mut buf = BytesMut::new();

beacon_node/lighthouse_network/src/rpc/handler.rs

@@ -129,8 +129,8 @@ where
  /// Logger for handling RPC streams
  log: slog::Logger,
 
- /// ChainSpec for networking constants
- chain_spec: ChainSpec,
+ /// resp_timeout for networking constants
+ resp_timeout: Duration,
 }
 
 enum HandlerState {
@@ -232,7 +232,7 @@ where
  fork_context,
  waker: None,
  log: log.clone(),
- chain_spec: spec.clone(),
+ resp_timeout: spec.clone().resp_timeout(),
  }
  }
 
@@ -353,7 +353,7 @@ where
  // new outbound request. Store the stream and tag the output.
  let delay_key = self.outbound_substreams_delay.insert(
  self.current_outbound_substream_id,
- Duration::from_secs(self.chain_spec.resp_timeout),
+ self.resp_timeout,
  );
  let awaiting_stream = OutboundSubstreamState::RequestPendingResponse {
  substream: Box::new(out),
@@ -404,7 +404,7 @@ where
  // Store the stream and tag the output.
  let delay_key = self.inbound_substreams_delay.insert(
  self.current_inbound_substream_id,
- Duration::from_secs(self.chain_spec.resp_timeout),
+ self.resp_timeout,
  );
  let awaiting_stream = InboundState::Idle(substream);
  self.inbound_substreams.insert(
@@ -717,7 +717,7 @@ where
  if let Some(ref delay_key) = info.delay_key {
  self.inbound_substreams_delay.reset(
  delay_key,
- Duration::from_secs(self.chain_spec.resp_timeout),
+ self.resp_timeout,
  );
  }
 
@@ -853,7 +853,7 @@ where
  substream_entry.remaining_chunks = Some(remaining_chunks);
  self.outbound_substreams_delay.reset(
  delay_key,
- Duration::from_secs(self.chain_spec.resp_timeout),
+ self.resp_timeout,
  );
  }
  } else {
@@ -973,7 +973,7 @@ where
  OutboundRequestContainer {
  req: req.clone(),
  fork_context: self.fork_context.clone(),
- max_rpc_size: max_rpc_size(&self.fork_context, &self.chain_spec),
+ max_rpc_size: max_rpc_size(&self.fork_context, self.listen_protocol.upgrade().max_rpc_size),
  },
  (),
  )

beacon_node/lighthouse_network/src/rpc/mod.rs

@@ -219,9 +219,10 @@ where
  SubstreamProtocol::new(
  RPCProtocol {
  fork_context: self.fork_context.clone(),
- max_rpc_size: max_rpc_size(&self.fork_context, &self.chain_spec),
+ max_rpc_size: max_rpc_size(&self.fork_context, self.chain_spec.max_chunk_size as usize),
  enable_light_client_server: self.enable_light_client_server,
  phantom: PhantomData,
+ ttfb_timeout: self.chain_spec.clone().ttfb_timeout(),
  },
  (),
  ),

beacon_node/lighthouse_network/src/rpc/protocol.rs

@@ -22,7 +22,7 @@ use tokio_util::{
 };
 use types::{
  BeaconBlock, BeaconBlockAltair, BeaconBlockBase, BeaconBlockCapella, BeaconBlockMerge,
- ChainSpec, EmptyBlock, EthSpec, ForkContext, ForkName, Hash256, MainnetEthSpec, Signature,
+ EmptyBlock, EthSpec, ForkContext, ForkName, Hash256, MainnetEthSpec, Signature,
  SignedBeaconBlock,
 };
 
@@ -119,9 +119,9 @@ const PROTOCOL_PREFIX: &str = "/eth2/beacon_chain/req";
 const REQUEST_TIMEOUT: u64 = 15;
 
 /// Returns the maximum bytes that can be sent across the RPC.
-pub fn max_rpc_size(fork_context: &ForkContext, spec: &ChainSpec) -> usize {
+pub fn max_rpc_size(fork_context: &ForkContext, max_chunk_size: usize) -> usize {
  match fork_context.current_fork() {
- ForkName::Altair | ForkName::Base => spec.max_chunk_size as usize,
+ ForkName::Altair | ForkName::Base => max_chunk_size,
  ForkName::Merge => MAX_RPC_SIZE_POST_MERGE,
  ForkName::Capella => MAX_RPC_SIZE_POST_CAPELLA,
  }
@@ -258,6 +258,7 @@ pub struct RPCProtocol<TSpec: EthSpec> {
  pub max_rpc_size: usize,
  pub enable_light_client_server: bool,
  pub phantom: PhantomData<TSpec>,
+ pub ttfb_timeout: Duration,
 }
 
 impl<TSpec: EthSpec> UpgradeInfo for RPCProtocol<TSpec> {
@@ -443,9 +444,7 @@ where
  }
  };
  let mut timed_socket = TimeoutStream::new(socket);
- timed_socket.set_read_timeout(Some(Duration::from_secs(
- TSpec::default_spec().ttfb_timeout,
- )));
+ timed_socket.set_read_timeout(Some(self.ttfb_timeout));
 
  let socket = Framed::new(Box::pin(timed_socket), codec);
 

beacon_node/lighthouse_network/tests/rpc_tests.rs

@@ -27,7 +27,7 @@ fn merge_block_small(fork_context: &ForkContext, spec: &ChainSpec) -> BeaconBloc
  block.body.execution_payload.execution_payload.transactions = txs;
 
  let block = BeaconBlock::Merge(block);
- assert!(block.ssz_bytes_len() <= max_rpc_size(fork_context, spec));
+ assert!(block.ssz_bytes_len() <= max_rpc_size(fork_context, spec.max_chunk_size as usize));
  block
 }
 
@@ -42,7 +42,7 @@ fn merge_block_large(fork_context: &ForkContext, spec: &ChainSpec) -> BeaconBloc
  block.body.execution_payload.execution_payload.transactions = txs;
 
  let block = BeaconBlock::Merge(block);
- assert!(block.ssz_bytes_len() > max_rpc_size(fork_context, spec));
+ assert!(block.ssz_bytes_len() > max_rpc_size(fork_context, spec.max_chunk_size as usize));
  block
 }
 

beacon_node/network/src/beacon_processor/worker/gossip_methods.rs

@@ -2187,6 +2187,7 @@ impl<T: BeaconChainTypes> Worker<T> {
  sync_committee_verification::verify_propagation_slot_range(
  seen_clock,
  &sync_committee_message_slot,
+ &self.chain.spec,
  );
  hindsight_verification.is_err()
  };

consensus/types/src/chain_spec.rs

@@ -6,6 +6,7 @@ use serde_derive::Deserialize;
 use serde_utils::quoted_u64::MaybeQuoted;
 use std::fs::File;
 use std::path::Path;
+use std::time::Duration;
 use tree_hash::TreeHash;
 
 /// Each of the BLS signature domains.
@@ -461,6 +462,18 @@ impl ChainSpec {
  Hash256::from(domain)
  }
 
+ pub fn maximum_gossip_clock_disparity(self) -> Duration {
+ Duration::from_millis(self.maximum_gossip_clock_disparity_millis)
+ }
+
+ pub fn ttfb_timeout(self) -> Duration {
+ Duration::from_secs(self.ttfb_timeout)
+ }
+
+ pub fn resp_timeout(self) -> Duration {
+ Duration::from_secs(self.resp_timeout)
+ }
+
  /// Returns a `ChainSpec` compatible with the Ethereum Foundation specification.
  pub fn mainnet() -> Self {
  Self {