Remove ineffectual block RPC limits post merge (#6798)

dapplion · web-flow · commit b1a19a8b20b2 · 2025-01-15T12:43:00.000Z
* Remove ineffectual block RPC limits post merge

* Remove more things
diff --git a/beacon_node/lighthouse_network/src/rpc/protocol.rs b/beacon_node/lighthouse_network/src/rpc/protocol.rs
@@ -17,12 +17,11 @@ use tokio_util::{
     compat::{Compat, FuturesAsyncReadCompatExt},
 };
 use types::{
-    BeaconBlock, BeaconBlockAltair, BeaconBlockBase, BeaconBlockCapella, BeaconBlockElectra,
-    BeaconBlockFulu, BlobSidecar, ChainSpec, DataColumnSidecar, EmptyBlock, EthSpec, EthSpecId,
-    ForkContext, ForkName, LightClientBootstrap, LightClientBootstrapAltair,
-    LightClientFinalityUpdate, LightClientFinalityUpdateAltair, LightClientOptimisticUpdate,
-    LightClientOptimisticUpdateAltair, LightClientUpdate, MainnetEthSpec, MinimalEthSpec,
-    Signature, SignedBeaconBlock,
+    BeaconBlock, BeaconBlockAltair, BeaconBlockBase, BlobSidecar, ChainSpec, DataColumnSidecar,
+    EmptyBlock, EthSpec, EthSpecId, ForkContext, ForkName, LightClientBootstrap,
+    LightClientBootstrapAltair, LightClientFinalityUpdate, LightClientFinalityUpdateAltair,
+    LightClientOptimisticUpdate, LightClientOptimisticUpdateAltair, LightClientUpdate,
+    MainnetEthSpec, MinimalEthSpec, Signature, SignedBeaconBlock,
 };
 
 // Note: Hardcoding the `EthSpec` type for `SignedBeaconBlock` as min/max values is
@@ -55,74 +54,16 @@ pub static SIGNED_BEACON_BLOCK_ALTAIR_MAX: LazyLock<usize> = LazyLock::new(|| {
     .len()
 });
 
-pub static SIGNED_BEACON_BLOCK_CAPELLA_MAX_WITHOUT_PAYLOAD: LazyLock<usize> = LazyLock::new(|| {
-    SignedBeaconBlock::<MainnetEthSpec>::from_block(
-        BeaconBlock::Capella(BeaconBlockCapella::full(&MainnetEthSpec::default_spec())),
-        Signature::empty(),
-    )
-    .as_ssz_bytes()
-    .len()
-});
-
-pub static SIGNED_BEACON_BLOCK_ELECTRA_MAX_WITHOUT_PAYLOAD: LazyLock<usize> = LazyLock::new(|| {
-    SignedBeaconBlock::<MainnetEthSpec>::from_block(
-        BeaconBlock::Electra(BeaconBlockElectra::full(&MainnetEthSpec::default_spec())),
-        Signature::empty(),
-    )
-    .as_ssz_bytes()
-    .len()
-});
-
-pub static SIGNED_BEACON_BLOCK_FULU_MAX_WITHOUT_PAYLOAD: LazyLock<usize> = LazyLock::new(|| {
-    SignedBeaconBlock::<MainnetEthSpec>::from_block(
-        BeaconBlock::Fulu(BeaconBlockFulu::full(&MainnetEthSpec::default_spec())),
-        Signature::empty(),
-    )
-    .as_ssz_bytes()
-    .len()
-});
-
 /// The `BeaconBlockBellatrix` block has an `ExecutionPayload` field which has a max size ~16 GiB for future proofing.
 /// We calculate the value from its fields instead of constructing the block and checking the length.
 /// Note: This is only the theoretical upper bound. We further bound the max size we receive over the network
 /// with `max_chunk_size`.
-///
-/// FIXME: Given that these limits are useless we should probably delete them. See:
-///
-/// https://github.com/sigp/lighthouse/issues/6790
 pub static SIGNED_BEACON_BLOCK_BELLATRIX_MAX: LazyLock<usize> =
     LazyLock::new(||     // Size of a full altair block
     *SIGNED_BEACON_BLOCK_ALTAIR_MAX
     + types::ExecutionPayload::<MainnetEthSpec>::max_execution_payload_bellatrix_size() // adding max size of execution payload (~16gb)
     + ssz::BYTES_PER_LENGTH_OFFSET); // Adding the additional ssz offset for the `ExecutionPayload` field
 
-pub static SIGNED_BEACON_BLOCK_CAPELLA_MAX: LazyLock<usize> = LazyLock::new(|| {
-    *SIGNED_BEACON_BLOCK_CAPELLA_MAX_WITHOUT_PAYLOAD
-    + types::ExecutionPayload::<MainnetEthSpec>::max_execution_payload_capella_size() // adding max size of execution payload (~16gb)
-    + ssz::BYTES_PER_LENGTH_OFFSET
-}); // Adding the additional ssz offset for the `ExecutionPayload` field
-
-pub static SIGNED_BEACON_BLOCK_DENEB_MAX: LazyLock<usize> = LazyLock::new(|| {
-    *SIGNED_BEACON_BLOCK_CAPELLA_MAX_WITHOUT_PAYLOAD
-    + types::ExecutionPayload::<MainnetEthSpec>::max_execution_payload_deneb_size() // adding max size of execution payload (~16gb)
-    + ssz::BYTES_PER_LENGTH_OFFSET // Adding the additional offsets for the `ExecutionPayload`
-    + ssz::BYTES_PER_LENGTH_OFFSET
-}); // Length offset for the blob commitments field.
-    //
-pub static SIGNED_BEACON_BLOCK_ELECTRA_MAX: LazyLock<usize> = LazyLock::new(|| {
-    *SIGNED_BEACON_BLOCK_ELECTRA_MAX_WITHOUT_PAYLOAD
-    + types::ExecutionPayload::<MainnetEthSpec>::max_execution_payload_electra_size() // adding max size of execution payload (~16gb)
-    + ssz::BYTES_PER_LENGTH_OFFSET // Adding the additional ssz offset for the `ExecutionPayload` field
-    + ssz::BYTES_PER_LENGTH_OFFSET
-}); // Length offset for the blob commitments field.
-
-pub static SIGNED_BEACON_BLOCK_FULU_MAX: LazyLock<usize> = LazyLock::new(|| {
-    *SIGNED_BEACON_BLOCK_FULU_MAX_WITHOUT_PAYLOAD
-        + types::ExecutionPayload::<MainnetEthSpec>::max_execution_payload_fulu_size()
-        + ssz::BYTES_PER_LENGTH_OFFSET
-        + ssz::BYTES_PER_LENGTH_OFFSET
-});
-
 pub static BLOB_SIDECAR_SIZE: LazyLock<usize> =
     LazyLock::new(BlobSidecar::<MainnetEthSpec>::max_size);
 
@@ -203,26 +144,12 @@ pub fn rpc_block_limits_by_fork(current_fork: ForkName) -> RpcLimits {
             *SIGNED_BEACON_BLOCK_BASE_MIN, // Base block is smaller than altair blocks
             *SIGNED_BEACON_BLOCK_ALTAIR_MAX, // Altair block is larger than base blocks
         ),
-        ForkName::Bellatrix => RpcLimits::new(
+        // After the merge the max SSZ size of a block is absurdly big. The size is actually
+        // bound by other constants, so here we default to the bellatrix's max value
+        _ => RpcLimits::new(
             *SIGNED_BEACON_BLOCK_BASE_MIN, // Base block is smaller than altair and bellatrix blocks
             *SIGNED_BEACON_BLOCK_BELLATRIX_MAX, // Bellatrix block is larger than base and altair blocks
         ),
-        ForkName::Capella => RpcLimits::new(
-            *SIGNED_BEACON_BLOCK_BASE_MIN, // Base block is smaller than altair and bellatrix blocks
-            *SIGNED_BEACON_BLOCK_CAPELLA_MAX, // Capella block is larger than base, altair and merge blocks
-        ),
-        ForkName::Deneb => RpcLimits::new(
-            *SIGNED_BEACON_BLOCK_BASE_MIN, // Base block is smaller than altair and bellatrix blocks
-            *SIGNED_BEACON_BLOCK_DENEB_MAX, // Deneb block is larger than all prior fork blocks
-        ),
-        ForkName::Electra => RpcLimits::new(
-            *SIGNED_BEACON_BLOCK_BASE_MIN, // Base block is smaller than altair and bellatrix blocks
-            *SIGNED_BEACON_BLOCK_ELECTRA_MAX, // Electra block is larger than Deneb block
-        ),
-        ForkName::Fulu => RpcLimits::new(
-            *SIGNED_BEACON_BLOCK_BASE_MIN, // Base block is smaller than all other blocks
-            *SIGNED_BEACON_BLOCK_FULU_MAX, // Fulu block is largest
-        ),
     }
 }
 
diff --git a/consensus/types/src/beacon_block.rs b/consensus/types/src/beacon_block.rs
@@ -12,7 +12,7 @@ use test_random_derive::TestRandom;
 use tree_hash::TreeHash;
 use tree_hash_derive::TreeHash;
 
-use self::indexed_attestation::{IndexedAttestationBase, IndexedAttestationElectra};
+use self::indexed_attestation::IndexedAttestationBase;
 
 /// A block of the `BeaconChain`.
 #[superstruct(
@@ -499,52 +499,6 @@ impl<E: EthSpec, Payload: AbstractExecPayload<E>> EmptyBlock for BeaconBlockBell
     }
 }
 
-impl<E: EthSpec, Payload: AbstractExecPayload<E>> BeaconBlockCapella<E, Payload> {
-    /// Return a Capella block where the block has maximum size.
-    pub fn full(spec: &ChainSpec) -> Self {
-        let base_block: BeaconBlockBase<_, Payload> = BeaconBlockBase::full(spec);
-        let bls_to_execution_changes = vec![
-            SignedBlsToExecutionChange {
-                message: BlsToExecutionChange {
-                    validator_index: 0,
-                    from_bls_pubkey: PublicKeyBytes::empty(),
-                    to_execution_address: Address::ZERO,
-                },
-                signature: Signature::empty()
-            };
-            E::max_bls_to_execution_changes()
-        ]
-        .into();
-        let sync_aggregate = SyncAggregate {
-            sync_committee_signature: AggregateSignature::empty(),
-            sync_committee_bits: BitVector::default(),
-        };
-        BeaconBlockCapella {
-            slot: spec.genesis_slot,
-            proposer_index: 0,
-            parent_root: Hash256::zero(),
-            state_root: Hash256::zero(),
-            body: BeaconBlockBodyCapella {
-                proposer_slashings: base_block.body.proposer_slashings,
-                attester_slashings: base_block.body.attester_slashings,
-                attestations: base_block.body.attestations,
-                deposits: base_block.body.deposits,
-                voluntary_exits: base_block.body.voluntary_exits,
-                bls_to_execution_changes,
-                sync_aggregate,
-                randao_reveal: Signature::empty(),
-                eth1_data: Eth1Data {
-                    deposit_root: Hash256::zero(),
-                    block_hash: Hash256::zero(),
-                    deposit_count: 0,
-                },
-                graffiti: Graffiti::default(),
-                execution_payload: Payload::Capella::default(),
-            },
-        }
-    }
-}
-
 impl<E: EthSpec, Payload: AbstractExecPayload<E>> EmptyBlock for BeaconBlockCapella<E, Payload> {
     /// Returns an empty Capella block to be used during genesis.
     fn empty(spec: &ChainSpec) -> Self {
@@ -604,79 +558,6 @@ impl<E: EthSpec, Payload: AbstractExecPayload<E>> EmptyBlock for BeaconBlockDene
     }
 }
 
-impl<E: EthSpec, Payload: AbstractExecPayload<E>> BeaconBlockElectra<E, Payload> {
-    /// Return a Electra block where the block has maximum size.
-    pub fn full(spec: &ChainSpec) -> Self {
-        let base_block: BeaconBlockBase<_, Payload> = BeaconBlockBase::full(spec);
-        let indexed_attestation: IndexedAttestationElectra<E> = IndexedAttestationElectra {
-            attesting_indices: VariableList::new(vec![0_u64; E::MaxValidatorsPerSlot::to_usize()])
-                .unwrap(),
-            data: AttestationData::default(),
-            signature: AggregateSignature::empty(),
-        };
-        let attester_slashings = vec![
-            AttesterSlashingElectra {
-                attestation_1: indexed_attestation.clone(),
-                attestation_2: indexed_attestation,
-            };
-            E::max_attester_slashings_electra()
-        ]
-        .into();
-        let attestation = AttestationElectra {
-            aggregation_bits: BitList::with_capacity(E::MaxValidatorsPerSlot::to_usize()).unwrap(),
-            data: AttestationData::default(),
-            signature: AggregateSignature::empty(),
-            committee_bits: BitVector::new(),
-        };
-        let mut attestations_electra = vec![];
-        for _ in 0..E::MaxAttestationsElectra::to_usize() {
-            attestations_electra.push(attestation.clone());
-        }
-
-        let bls_to_execution_changes = vec![
-            SignedBlsToExecutionChange {
-                message: BlsToExecutionChange {
-                    validator_index: 0,
-                    from_bls_pubkey: PublicKeyBytes::empty(),
-                    to_execution_address: Address::ZERO,
-                },
-                signature: Signature::empty()
-            };
-            E::max_bls_to_execution_changes()
-        ]
-        .into();
-        let sync_aggregate = SyncAggregate {
-            sync_committee_signature: AggregateSignature::empty(),
-            sync_committee_bits: BitVector::default(),
-        };
-        BeaconBlockElectra {
-            slot: spec.genesis_slot,
-            proposer_index: 0,
-            parent_root: Hash256::zero(),
-            state_root: Hash256::zero(),
-            body: BeaconBlockBodyElectra {
-                proposer_slashings: base_block.body.proposer_slashings,
-                attester_slashings,
-                attestations: attestations_electra.into(),
-                deposits: base_block.body.deposits,
-                voluntary_exits: base_block.body.voluntary_exits,
-                bls_to_execution_changes,
-                sync_aggregate,
-                randao_reveal: Signature::empty(),
-                eth1_data: Eth1Data {
-                    deposit_root: Hash256::zero(),
-                    block_hash: Hash256::zero(),
-                    deposit_count: 0,
-                },
-                graffiti: Graffiti::default(),
-                execution_payload: Payload::Electra::default(),
-                blob_kzg_commitments: VariableList::empty(),
-                execution_requests: ExecutionRequests::default(),
-            },
-        }
-    }
-}
-
 impl<E: EthSpec, Payload: AbstractExecPayload<E>> EmptyBlock for BeaconBlockElectra<E, Payload> {
     /// Returns an empty Electra block to be used during genesis.
     fn empty(spec: &ChainSpec) -> Self {
@@ -708,79 +589,6 @@ impl<E: EthSpec, Payload: AbstractExecPayload<E>> EmptyBlock for BeaconBlockElec
     }
 }
 
-impl<E: EthSpec, Payload: AbstractExecPayload<E>> BeaconBlockFulu<E, Payload> {
-    /// Return a Fulu block where the block has maximum size.
-    pub fn full(spec: &ChainSpec) -> Self {
-        let base_block: BeaconBlockBase<_, Payload> = BeaconBlockBase::full(spec);
-        let indexed_attestation: IndexedAttestationElectra<E> = IndexedAttestationElectra {
-            attesting_indices: VariableList::new(vec![0_u64; E::MaxValidatorsPerSlot::to_usize()])
-                .unwrap(),
-            data: AttestationData::default(),
-            signature: AggregateSignature::empty(),
-        };
-        let attester_slashings = vec![
-            AttesterSlashingElectra {
-                attestation_1: indexed_attestation.clone(),
-                attestation_2: indexed_attestation,
-            };
-            E::max_attester_slashings_electra()
-        ]
-        .into();
-        let attestation = AttestationElectra {
-            aggregation_bits: BitList::with_capacity(E::MaxValidatorsPerSlot::to_usize()).unwrap(),
-            data: AttestationData::default(),
-            signature: AggregateSignature::empty(),
-            committee_bits: BitVector::new(),
-        };
-        let mut attestations_electra = vec![];
-        for _ in 0..E::MaxAttestationsElectra::to_usize() {
-            attestations_electra.push(attestation.clone());
-        }
-
-        let bls_to_execution_changes = vec![
-            SignedBlsToExecutionChange {
-                message: BlsToExecutionChange {
-                    validator_index: 0,
-                    from_bls_pubkey: PublicKeyBytes::empty(),
-                    to_execution_address: Address::ZERO,
-                },
-                signature: Signature::empty()
-            };
-            E::max_bls_to_execution_changes()
-        ]
-        .into();
-        let sync_aggregate = SyncAggregate {
-            sync_committee_signature: AggregateSignature::empty(),
-            sync_committee_bits: BitVector::default(),
-        };
-        BeaconBlockFulu {
-            slot: spec.genesis_slot,
-            proposer_index: 0,
-            parent_root: Hash256::zero(),
-            state_root: Hash256::zero(),
-            body: BeaconBlockBodyFulu {
-                proposer_slashings: base_block.body.proposer_slashings,
-                attester_slashings,
-                attestations: attestations_electra.into(),
-                deposits: base_block.body.deposits,
-                voluntary_exits: base_block.body.voluntary_exits,
-                bls_to_execution_changes,
-                sync_aggregate,
-                randao_reveal: Signature::empty(),
-                eth1_data: Eth1Data {
-                    deposit_root: Hash256::zero(),
-                    block_hash: Hash256::zero(),
-                    deposit_count: 0,
-                },
-                graffiti: Graffiti::default(),
-                execution_payload: Payload::Fulu::default(),
-                blob_kzg_commitments: VariableList::empty(),
-                execution_requests: ExecutionRequests::default(),
-            },
-        }
-    }
-}
-
 impl<E: EthSpec, Payload: AbstractExecPayload<E>> EmptyBlock for BeaconBlockFulu<E, Payload> {
     /// Returns an empty Fulu block to be used during genesis.
     fn empty(spec: &ChainSpec) -> Self {
diff --git a/consensus/types/src/execution_payload.rs b/consensus/types/src/execution_payload.rs
