Merge branch 'unstable' into deneb-free-blobs

# Conflicts:
#	.github/workflows/docker.yml
#	.github/workflows/local-testnet.yml
#	.github/workflows/test-suite.yml
#	Cargo.lock
#	Cargo.toml
#	beacon_node/beacon_chain/src/beacon_chain.rs
#	beacon_node/beacon_chain/src/builder.rs
#	beacon_node/beacon_chain/src/test_utils.rs
#	beacon_node/execution_layer/src/engine_api/json_structures.rs
#	beacon_node/network/src/beacon_processor/mod.rs
#	beacon_node/network/src/beacon_processor/worker/gossip_methods.rs
#	beacon_node/network/src/sync/backfill_sync/mod.rs
#	beacon_node/store/src/config.rs
#	beacon_node/store/src/hot_cold_store.rs
#	common/eth2_network_config/Cargo.toml
#	consensus/ssz/src/decode/impls.rs
#	consensus/ssz_derive/src/lib.rs
#	consensus/ssz_derive/tests/tests.rs
#	consensus/ssz_types/src/serde_utils/mod.rs
#	consensus/tree_hash/src/impls.rs
#	consensus/tree_hash/src/lib.rs
#	consensus/types/Cargo.toml
#	consensus/types/src/beacon_state.rs
#	consensus/types/src/chain_spec.rs
#	consensus/types/src/eth_spec.rs
#	consensus/types/src/fork_name.rs
#	lcli/Cargo.toml
#	lcli/src/main.rs
#	lcli/src/new_testnet.rs
#	scripts/local_testnet/el_bootnode.sh
#	scripts/local_testnet/genesis.json
#	scripts/local_testnet/geth.sh
#	scripts/local_testnet/setup.sh
#	scripts/local_testnet/start_local_testnet.sh
#	scripts/local_testnet/vars.env
#	scripts/tests/doppelganger_protection.sh
#	scripts/tests/genesis.json
#	scripts/tests/vars.env
#	testing/ef_tests/Cargo.toml
#	validator_client/src/block_service.rs

consensus/types/Cargo.toml

@@ -16,7 +16,7 @@ compare_fields = { path = "../../common/compare_fields" }
 compare_fields_derive = { path = "../../common/compare_fields_derive" }
 eth2_interop_keypairs = { path = "../../common/eth2_interop_keypairs" }
 ethereum-types = { version = "0.14.1", features = ["arbitrary"] }
-eth2_hashing = "0.3.0"
+ethereum_hashing = "1.0.0-beta.2"
 hex = "0.4.2"
 int_to_bytes = { path = "../int_to_bytes" }
 log = "0.4.11"
@@ -26,13 +26,13 @@ safe_arith = { path = "../safe_arith" }
 serde = {version = "1.0.116" , features = ["rc"] }
 serde_derive = "1.0.116"
 slog = "2.5.2"
-eth2_ssz = { version = "0.4.1", features = ["arbitrary"] }
-eth2_ssz_derive = "0.3.1"
-eth2_ssz_types = { version = "0.2.2", features = ["arbitrary"] }
+ethereum_ssz = { version = "0.5.0", features = ["arbitrary"] }
+ethereum_ssz_derive = "0.5.0"
+ssz_types = { version = "0.5.0", features = ["arbitrary"] }
 swap_or_not_shuffle = { path = "../swap_or_not_shuffle", features = ["arbitrary"] }
 test_random_derive = { path = "../../common/test_random_derive" }
-tree_hash = { version = "0.4.1", features = ["arbitrary"] }
-tree_hash_derive = "0.4.0"
+tree_hash = { version = "0.5.0", features = ["arbitrary"] }
+tree_hash_derive = "0.5.0"
 rand_xorshift = "0.3.0"
 cached_tree_hash = { path = "../cached_tree_hash" }
 serde_yaml = "0.8.13"
@@ -41,8 +41,8 @@ derivative = "2.1.1"
 # The arbitrary dependency is enabled by default since Capella to avoid complexity introduced by
 # `AbstractExecPayload`
 arbitrary = { version = "1.0", features = ["derive"] }
+ethereum_serde_utils = "0.5.0"
 rusqlite = { version = "0.28.0", features = ["bundled"], optional = true }
-eth2_serde_utils = "0.1.1"
 regex = "1.5.5"
 lazy_static = "1.4.0"
 parking_lot = "0.12.0"

consensus/types/presets/gnosis/capella.yaml

@@ -9,9 +9,9 @@ MAX_BLS_TO_EXECUTION_CHANGES: 16
 # Execution
 # ---------------------------------------------------------------
 # 2**4 (= 16) withdrawals
-MAX_WITHDRAWALS_PER_PAYLOAD: 16
+MAX_WITHDRAWALS_PER_PAYLOAD: 8
 
 # Withdrawals processing
 # ---------------------------------------------------------------
 # 2**14 (= 16384) validators
-MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP: 16384
+MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP: 8192

consensus/types/src/aggregate_and_proof.rs

@@ -27,7 +27,7 @@ use tree_hash_derive::TreeHash;
 #[arbitrary(bound = "T: EthSpec")]
 pub struct AggregateAndProof<T: EthSpec> {
     /// The index of the validator that created the attestation.
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub aggregator_index: u64,
     /// The aggregate attestation.
     pub aggregate: Attestation<T>,

consensus/types/src/attestation_data.rs

@@ -27,7 +27,7 @@ use tree_hash_derive::TreeHash;
 )]
 pub struct AttestationData {
     pub slot: Slot,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub index: u64,
 
     // LMD GHOST vote

consensus/types/src/attestation_duty.rs

@@ -12,6 +12,6 @@ pub struct AttestationDuty {
     /// The total number of attesters in the committee.
     pub committee_len: usize,
     /// The committee count at `attestation_slot`.
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub committees_at_slot: u64,
 }

consensus/types/src/beacon_block.rs

@@ -58,7 +58,7 @@ pub struct BeaconBlock<T: EthSpec, Payload: AbstractExecPayload<T> = FullPayload
     #[superstruct(getter(copy))]
     pub slot: Slot,
     #[superstruct(getter(copy))]
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub proposer_index: u64,
     #[superstruct(getter(copy))]
     pub parent_root: Hash256,

consensus/types/src/beacon_block_header.rs

@@ -26,7 +26,7 @@ use tree_hash_derive::TreeHash;
 )]
 pub struct BeaconBlockHeader {
     pub slot: Slot,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub proposer_index: u64,
     pub parent_root: Hash256,
     pub state_root: Hash256,

consensus/types/src/beacon_state.rs

@@ -5,7 +5,7 @@ use crate::*;
 use compare_fields::CompareFields;
 use compare_fields_derive::CompareFields;
 use derivative::Derivative;
-use eth2_hashing::hash;
+use ethereum_hashing::hash;
 use int_to_bytes::{int_to_bytes4, int_to_bytes8};
 use pubkey_cache::PubkeyCache;
 use safe_arith::{ArithError, SafeArith};
@@ -210,7 +210,7 @@ where
 {
     // Versioning
     #[superstruct(getter(copy))]
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub genesis_time: u64,
     #[superstruct(getter(copy))]
     pub genesis_validators_root: Hash256,
@@ -232,7 +232,7 @@ where
     pub eth1_data: Eth1Data,
     pub eth1_data_votes: VariableList<Eth1Data, T::SlotsPerEth1VotingPeriod>,
     #[superstruct(getter(copy))]
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub eth1_deposit_index: u64,
 
     // Registry
@@ -301,10 +301,10 @@ where
 
     // Capella
     #[superstruct(only(Capella, Deneb), partial_getter(copy))]
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub next_withdrawal_index: u64,
     #[superstruct(only(Capella, Deneb), partial_getter(copy))]
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub next_withdrawal_validator_index: u64,
     // Deep history valid from Capella onwards.
     #[superstruct(only(Capella, Deneb))]

consensus/types/src/blob_sidecar.rs

@@ -48,11 +48,11 @@ impl Ord for BlobIdentifier {
 #[derivative(PartialEq, Eq, Hash(bound = "T: EthSpec"))]
 pub struct BlobSidecar<T: EthSpec> {
     pub block_root: Hash256,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub index: u64,
     pub slot: Slot,
     pub block_parent_root: Hash256,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub proposer_index: u64,
     #[serde(with = "ssz_types::serde_utils::hex_fixed_vec")]
     pub blob: Blob<T>,

consensus/types/src/bls_to_execution_change.rs

@@ -21,7 +21,7 @@ use tree_hash_derive::TreeHash;
     TestRandom,
 )]
 pub struct BlsToExecutionChange {
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub validator_index: u64,
     pub from_bls_pubkey: PublicKeyBytes,
     pub to_execution_address: Address,

consensus/types/src/builder_bid.rs

@@ -16,7 +16,7 @@ use tree_hash_derive::TreeHash;
 pub struct BuilderBid<E: EthSpec, Payload: AbstractExecPayload<E>> {
     #[serde_as(as = "BlindedPayloadAsHeader<E>")]
     pub header: Payload,
-    #[serde(with = "eth2_serde_utils::quoted_u256")]
+    #[serde(with = "serde_utils::quoted_u256")]
     pub value: Uint256,
     pub pubkey: PublicKeyBytes,
     #[serde(skip)]
@@ -50,7 +50,7 @@ impl<T: EthSpec, Payload: AbstractExecPayload<T>> ForkVersionDeserialize
         #[derive(Deserialize)]
         struct Helper {
             header: serde_json::Value,
-            #[serde(with = "eth2_serde_utils::quoted_u256")]
+            #[serde(with = "serde_utils::quoted_u256")]
             value: Uint256,
             pubkey: PublicKeyBytes,
         }

consensus/types/src/chain_spec.rs

@@ -1,9 +1,9 @@
 use crate::application_domain::{ApplicationDomain, APPLICATION_DOMAIN_BUILDER};
 use crate::*;
-use eth2_serde_utils::quoted_u64::MaybeQuoted;
 use int_to_bytes::int_to_bytes4;
 use serde::{Deserializer, Serialize, Serializer};
 use serde_derive::Deserialize;
+use serde_utils::quoted_u64::MaybeQuoted;
 use std::fs::File;
 use std::path::Path;
 use tree_hash::TreeHash;
@@ -871,7 +871,7 @@ impl ChainSpec {
              */
             capella_fork_version: [0x03, 0x00, 0x00, 0x64],
             capella_fork_epoch: None,
-            max_validators_per_withdrawals_sweep: 16384,
+            max_validators_per_withdrawals_sweep: 8192,
 
             /*
              * Deneb hard fork params
@@ -929,33 +929,33 @@ pub struct Config {
     pub preset_base: String,
 
     #[serde(default = "default_terminal_total_difficulty")]
-    #[serde(with = "eth2_serde_utils::quoted_u256")]
+    #[serde(with = "serde_utils::quoted_u256")]
     pub terminal_total_difficulty: Uint256,
     #[serde(default = "default_terminal_block_hash")]
     pub terminal_block_hash: ExecutionBlockHash,
     #[serde(default = "default_terminal_block_hash_activation_epoch")]
     pub terminal_block_hash_activation_epoch: Epoch,
     #[serde(default = "default_safe_slots_to_import_optimistically")]
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub safe_slots_to_import_optimistically: u64,
 
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     min_genesis_active_validator_count: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     min_genesis_time: u64,
-    #[serde(with = "eth2_serde_utils::bytes_4_hex")]
+    #[serde(with = "serde_utils::bytes_4_hex")]
     genesis_fork_version: [u8; 4],
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     genesis_delay: u64,
 
-    #[serde(with = "eth2_serde_utils::bytes_4_hex")]
+    #[serde(with = "serde_utils::bytes_4_hex")]
     altair_fork_version: [u8; 4],
     #[serde(serialize_with = "serialize_fork_epoch")]
     #[serde(deserialize_with = "deserialize_fork_epoch")]
     pub altair_fork_epoch: Option<MaybeQuoted<Epoch>>,
 
     #[serde(default = "default_bellatrix_fork_version")]
-    #[serde(with = "eth2_serde_utils::bytes_4_hex")]
+    #[serde(with = "serde_utils::bytes_4_hex")]
     bellatrix_fork_version: [u8; 4],
     #[serde(default)]
     #[serde(serialize_with = "serialize_fork_epoch")]
@@ -963,7 +963,7 @@ pub struct Config {
     pub bellatrix_fork_epoch: Option<MaybeQuoted<Epoch>>,
 
     #[serde(default = "default_capella_fork_version")]
-    #[serde(with = "eth2_serde_utils::bytes_4_hex")]
+    #[serde(with = "serde_utils::bytes_4_hex")]
     capella_fork_version: [u8; 4],
     #[serde(default)]
     #[serde(serialize_with = "serialize_fork_epoch")]
@@ -971,41 +971,41 @@ pub struct Config {
     pub capella_fork_epoch: Option<MaybeQuoted<Epoch>>,
 
     #[serde(default = "default_deneb_fork_version")]
-    #[serde(with = "eth2_serde_utils::bytes_4_hex")]
+    #[serde(with = "serde_utils::bytes_4_hex")]
     deneb_fork_version: [u8; 4],
     #[serde(default)]
     #[serde(serialize_with = "serialize_fork_epoch")]
     #[serde(deserialize_with = "deserialize_fork_epoch")]
     pub deneb_fork_epoch: Option<MaybeQuoted<Epoch>>,
 
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     seconds_per_slot: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     seconds_per_eth1_block: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     min_validator_withdrawability_delay: Epoch,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     shard_committee_period: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     eth1_follow_distance: u64,
 
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     inactivity_score_bias: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     inactivity_score_recovery_rate: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     ejection_balance: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     min_per_epoch_churn_limit: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     churn_limit_quotient: u64,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     proposer_score_boost: Option<MaybeQuoted<u64>>,
 
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     deposit_chain_id: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     deposit_network_id: u64,
     deposit_contract_address: Address,
 }

consensus/types/src/contribution_and_proof.rs

@@ -25,7 +25,7 @@ use tree_hash_derive::TreeHash;
 #[arbitrary(bound = "T: EthSpec")]
 pub struct ContributionAndProof<T: EthSpec> {
     /// The index of the validator that created the sync contribution.
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub aggregator_index: u64,
     /// The aggregate contribution.
     pub contribution: SyncCommitteeContribution<T>,

consensus/types/src/deposit_data.rs

@@ -26,7 +26,7 @@ use tree_hash_derive::TreeHash;
 pub struct DepositData {
     pub pubkey: PublicKeyBytes,
     pub withdrawal_credentials: Hash256,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub amount: u64,
     pub signature: SignatureBytes,
 }

consensus/types/src/deposit_message.rs

@@ -25,7 +25,7 @@ use tree_hash_derive::TreeHash;
 pub struct DepositMessage {
     pub pubkey: PublicKeyBytes,
     pub withdrawal_credentials: Hash256,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub amount: u64,
 }
 

consensus/types/src/deposit_tree_snapshot.rs

@@ -1,5 +1,5 @@
 use crate::*;
-use eth2_hashing::{hash32_concat, ZERO_HASHES};
+use ethereum_hashing::{hash32_concat, ZERO_HASHES};
 use int_to_bytes::int_to_bytes32;
 use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};

consensus/types/src/enr_fork_id.rs

@@ -24,9 +24,9 @@ use tree_hash_derive::TreeHash;
     TestRandom,
 )]
 pub struct EnrForkId {
-    #[serde(with = "eth2_serde_utils::bytes_4_hex")]
+    #[serde(with = "serde_utils::bytes_4_hex")]
     pub fork_digest: [u8; 4],
-    #[serde(with = "eth2_serde_utils::bytes_4_hex")]
+    #[serde(with = "serde_utils::bytes_4_hex")]
     pub next_fork_version: [u8; 4],
     pub next_fork_epoch: Epoch,
 }

consensus/types/src/eth1_data.rs

@@ -26,7 +26,7 @@ use tree_hash_derive::TreeHash;
 )]
 pub struct Eth1Data {
     pub deposit_root: Hash256,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub deposit_count: u64,
     pub block_hash: Hash256,
 }

consensus/types/src/eth_spec.rs

@@ -397,7 +397,7 @@ impl EthSpec for GnosisEthSpec {
     type MaxPendingAttestations = U2048; // 128 max attestations * 16 slots per epoch
     type SlotsPerEth1VotingPeriod = U1024; // 64 epochs * 16 slots per epoch
     type MaxBlsToExecutionChanges = U16;
-    type MaxWithdrawalsPerPayload = U16;
+    type MaxWithdrawalsPerPayload = U8;
     type MaxBlobsPerBlock = U4;
     type FieldElementsPerBlob = U4096;
     type BytesPerFieldElement = U32;

consensus/types/src/execution_payload.rs

@@ -60,21 +60,21 @@ pub struct ExecutionPayload<T: EthSpec> {
     pub logs_bloom: FixedVector<u8, T::BytesPerLogsBloom>,
     #[superstruct(getter(copy))]
     pub prev_randao: Hash256,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     #[superstruct(getter(copy))]
     pub block_number: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     #[superstruct(getter(copy))]
     pub gas_limit: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     #[superstruct(getter(copy))]
     pub gas_used: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     #[superstruct(getter(copy))]
     pub timestamp: u64,
     #[serde(with = "ssz_types::serde_utils::hex_var_list")]
     pub extra_data: VariableList<u8, T::MaxExtraDataBytes>,
-    #[serde(with = "eth2_serde_utils::quoted_u256")]
+    #[serde(with = "serde_utils::quoted_u256")]
     #[superstruct(getter(copy))]
     pub base_fee_per_gas: Uint256,
     #[superstruct(getter(copy))]
@@ -84,7 +84,7 @@ pub struct ExecutionPayload<T: EthSpec> {
     #[superstruct(only(Capella, Deneb))]
     pub withdrawals: Withdrawals<T>,
     #[superstruct(only(Deneb))]
-    #[serde(with = "eth2_serde_utils::quoted_u256")]
+    #[serde(with = "serde_utils::quoted_u256")]
     #[superstruct(getter(copy))]
     pub excess_data_gas: Uint256,
 }

consensus/types/src/execution_payload_header.rs

@@ -53,21 +53,21 @@ pub struct ExecutionPayloadHeader<T: EthSpec> {
     pub logs_bloom: FixedVector<u8, T::BytesPerLogsBloom>,
     #[superstruct(getter(copy))]
     pub prev_randao: Hash256,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     #[superstruct(getter(copy))]
     pub block_number: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     #[superstruct(getter(copy))]
     pub gas_limit: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     #[superstruct(getter(copy))]
     pub gas_used: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     #[superstruct(getter(copy))]
     pub timestamp: u64,
     #[serde(with = "ssz_types::serde_utils::hex_var_list")]
     pub extra_data: VariableList<u8, T::MaxExtraDataBytes>,
-    #[serde(with = "eth2_serde_utils::quoted_u256")]
+    #[serde(with = "serde_utils::quoted_u256")]
     #[superstruct(getter(copy))]
     pub base_fee_per_gas: Uint256,
     #[superstruct(getter(copy))]
@@ -78,7 +78,7 @@ pub struct ExecutionPayloadHeader<T: EthSpec> {
     #[superstruct(getter(copy))]
     pub withdrawals_root: Hash256,
     #[superstruct(only(Deneb))]
-    #[serde(with = "eth2_serde_utils::quoted_u256")]
+    #[serde(with = "serde_utils::quoted_u256")]
     #[superstruct(getter(copy))]
     pub excess_data_gas: Uint256,
 }

consensus/types/src/fork.rs

@@ -24,9 +24,9 @@ use tree_hash_derive::TreeHash;
     TestRandom,
 )]
 pub struct Fork {
-    #[serde(with = "eth2_serde_utils::bytes_4_hex")]
+    #[serde(with = "serde_utils::bytes_4_hex")]
     pub previous_version: [u8; 4],
-    #[serde(with = "eth2_serde_utils::bytes_4_hex")]
+    #[serde(with = "serde_utils::bytes_4_hex")]
     pub current_version: [u8; 4],
     pub epoch: Epoch,
 }

consensus/types/src/fork_data.rs

@@ -23,7 +23,7 @@ use tree_hash_derive::TreeHash;
     TestRandom,
 )]
 pub struct ForkData {
-    #[serde(with = "eth2_serde_utils::bytes_4_hex")]
+    #[serde(with = "serde_utils::bytes_4_hex")]
     pub current_version: [u8; 4],
     pub genesis_validators_root: Hash256,
 }

consensus/types/src/fork_name.rs

@@ -28,6 +28,11 @@ impl ForkName {
         ]
     }
 
+    pub fn latest() -> ForkName {
+        // This unwrap is safe as long as we have 1+ forks. It is tested below.
+        *ForkName::list_all().last().unwrap()
+    }
+
     /// Set the activation slots in the given `ChainSpec` so that the fork named by `self`
     /// is the only fork in effect from genesis.
     pub fn make_genesis_spec(&self, mut spec: ChainSpec) -> ChainSpec {
@@ -201,7 +206,7 @@ mod test {
 
     #[test]
     fn previous_and_next_fork_consistent() {
-        assert_eq!(ForkName::Deneb.next_fork(), None);
+        assert_eq!(ForkName::latest().next_fork(), None);
         assert_eq!(ForkName::Base.previous_fork(), None);
 
         for (prev_fork, fork) in ForkName::list_all().into_iter().tuple_windows() {
@@ -234,4 +239,15 @@ mod test {
         assert_eq!(ForkName::from_str("merge"), Ok(ForkName::Merge));
         assert_eq!(ForkName::Merge.to_string(), "bellatrix");
     }
+
+    #[test]
+    fn fork_name_latest() {
+        assert_eq!(ForkName::latest(), *ForkName::list_all().last().unwrap());
+
+        let mut fork = ForkName::Base;
+        while let Some(next_fork) = fork.next_fork() {
+            fork = next_fork;
+        }
+        assert_eq!(ForkName::latest(), fork);
+    }
 }

consensus/types/src/graffiti.rs

@@ -27,7 +27,7 @@ impl Graffiti {
 
 impl fmt::Display for Graffiti {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", eth2_serde_utils::hex::encode(self.0))
+        write!(f, "{}", serde_utils::hex::encode(self.0))
     }
 }
 
@@ -96,7 +96,7 @@ pub mod serde_graffiti {
     where
         S: Serializer,
     {
-        serializer.serialize_str(&eth2_serde_utils::hex::encode(bytes))
+        serializer.serialize_str(&serde_utils::hex::encode(bytes))
     }
 
     pub fn deserialize<'de, D>(deserializer: D) -> Result<[u8; GRAFFITI_BYTES_LEN], D::Error>
@@ -105,7 +105,7 @@ pub mod serde_graffiti {
     {
         let s: String = Deserialize::deserialize(deserializer)?;
 
-        let bytes = eth2_serde_utils::hex::decode(&s).map_err(D::Error::custom)?;
+        let bytes = serde_utils::hex::decode(&s).map_err(D::Error::custom)?;
 
         if bytes.len() != GRAFFITI_BYTES_LEN {
             return Err(D::Error::custom(format!(

consensus/types/src/indexed_attestation.rs

@@ -72,9 +72,9 @@ impl<T: EthSpec> Hash for IndexedAttestation<T> {
 mod quoted_variable_list_u64 {
     use super::*;
     use crate::Unsigned;
-    use eth2_serde_utils::quoted_u64_vec::{QuotedIntVecVisitor, QuotedIntWrapper};
     use serde::ser::SerializeSeq;
     use serde::{Deserializer, Serializer};
+    use serde_utils::quoted_u64_vec::{QuotedIntVecVisitor, QuotedIntWrapper};
 
     pub fn serialize<S, T>(value: &VariableList<u64, T>, serializer: S) -> Result<S::Ok, S::Error>
     where

consensus/types/src/participation_flags.rs

@@ -9,7 +9,7 @@ use tree_hash::{PackedEncoding, TreeHash, TreeHashType};
 #[serde(transparent)]
 #[derive(arbitrary::Arbitrary)]
 pub struct ParticipationFlags {
-    #[serde(with = "eth2_serde_utils::quoted_u8")]
+    #[serde(with = "serde_utils::quoted_u8")]
     bits: u8,
 }
 

consensus/types/src/pending_attestation.rs

@@ -25,9 +25,9 @@ use tree_hash_derive::TreeHash;
 pub struct PendingAttestation<T: EthSpec> {
     pub aggregation_bits: BitList<T::MaxValidatorsPerCommittee>,
     pub data: AttestationData,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub inclusion_delay: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub proposer_index: u64,
 }
 

consensus/types/src/preset.rs

@@ -12,71 +12,71 @@ use serde_derive::{Deserialize, Serialize};
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "UPPERCASE")]
 pub struct BasePreset {
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub max_committees_per_slot: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub target_committee_size: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub max_validators_per_committee: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u8")]
+    #[serde(with = "serde_utils::quoted_u8")]
     pub shuffle_round_count: u8,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub hysteresis_quotient: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub hysteresis_downward_multiplier: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub hysteresis_upward_multiplier: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub safe_slots_to_update_justified: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub min_deposit_amount: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub max_effective_balance: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub effective_balance_increment: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub min_attestation_inclusion_delay: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub slots_per_epoch: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub min_seed_lookahead: Epoch,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub max_seed_lookahead: Epoch,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub epochs_per_eth1_voting_period: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub slots_per_historical_root: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub min_epochs_to_inactivity_penalty: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub epochs_per_historical_vector: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub epochs_per_slashings_vector: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub historical_roots_limit: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub validator_registry_limit: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub base_reward_factor: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub whistleblower_reward_quotient: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub proposer_reward_quotient: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub inactivity_penalty_quotient: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub min_slashing_penalty_quotient: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub proportional_slashing_multiplier: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub max_proposer_slashings: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub max_attester_slashings: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub max_attestations: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub max_deposits: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub max_voluntary_exits: u64,
 }
 
@@ -123,17 +123,17 @@ impl BasePreset {
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "UPPERCASE")]
 pub struct AltairPreset {
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub inactivity_penalty_quotient_altair: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub min_slashing_penalty_quotient_altair: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub proportional_slashing_multiplier_altair: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub sync_committee_size: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub epochs_per_sync_committee_period: Epoch,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub min_sync_committee_participants: u64,
 }
 
@@ -153,19 +153,19 @@ impl AltairPreset {
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "UPPERCASE")]
 pub struct BellatrixPreset {
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub inactivity_penalty_quotient_bellatrix: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub min_slashing_penalty_quotient_bellatrix: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub proportional_slashing_multiplier_bellatrix: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub max_bytes_per_transaction: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub max_transactions_per_payload: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub bytes_per_logs_bloom: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub max_extra_data_bytes: u64,
 }
 
@@ -187,11 +187,11 @@ impl BellatrixPreset {
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "UPPERCASE")]
 pub struct CapellaPreset {
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub max_bls_to_execution_changes: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub max_withdrawals_per_payload: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub max_validators_per_withdrawals_sweep: u64,
 }
 

consensus/types/src/proposer_preparation_data.rs

@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
 #[derive(PartialEq, Debug, Serialize, Deserialize, Clone)]
 pub struct ProposerPreparationData {
     /// The validators index.
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub validator_index: u64,
     /// The fee-recipient address.
     pub fee_recipient: Address,

consensus/types/src/selection_proof.rs

@@ -1,7 +1,7 @@
 use crate::{
     ChainSpec, Domain, EthSpec, Fork, Hash256, PublicKey, SecretKey, Signature, SignedRoot, Slot,
 };
-use eth2_hashing::hash;
+use ethereum_hashing::hash;
 use safe_arith::{ArithError, SafeArith};
 use ssz::Encode;
 use std::cmp;

consensus/types/src/slot_epoch.rs

@@ -38,7 +38,7 @@ use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Rem, Sub, SubAssi
     Deserialize,
 )]
 #[serde(transparent)]
-pub struct Slot(#[serde(with = "eth2_serde_utils::quoted_u64")] u64);
+pub struct Slot(#[serde(with = "serde_utils::quoted_u64")] u64);
 
 #[derive(
     arbitrary::Arbitrary,
@@ -54,7 +54,7 @@ pub struct Slot(#[serde(with = "eth2_serde_utils::quoted_u64")] u64);
     Deserialize,
 )]
 #[serde(transparent)]
-pub struct Epoch(#[serde(with = "eth2_serde_utils::quoted_u64")] u64);
+pub struct Epoch(#[serde(with = "serde_utils::quoted_u64")] u64);
 
 impl_common!(Slot);
 impl_common!(Epoch);

consensus/types/src/subnet_id.rs

@@ -20,7 +20,7 @@ lazy_static! {
 
 #[derive(arbitrary::Arbitrary, Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(transparent)]
-pub struct SubnetId(#[serde(with = "eth2_serde_utils::quoted_u64")] u64);
+pub struct SubnetId(#[serde(with = "serde_utils::quoted_u64")] u64);
 
 pub fn subnet_id_to_string(i: u64) -> &'static str {
     if i < MAX_SUBNET_ID as u64 {
@@ -85,7 +85,7 @@ impl SubnetId {
 
         let subscription_event_idx = epoch.as_u64() / spec.epochs_per_subnet_subscription;
         let permutation_seed =
-            eth2_hashing::hash(&int_to_bytes::int_to_bytes8(subscription_event_idx));
+            ethereum_hashing::hash(&int_to_bytes::int_to_bytes8(subscription_event_idx));
 
         let num_subnets = 1 << spec.attestation_subnet_prefix_bits();
 

consensus/types/src/sync_aggregator_selection_data.rs

@@ -21,7 +21,7 @@ use tree_hash_derive::TreeHash;
 )]
 pub struct SyncAggregatorSelectionData {
     pub slot: Slot,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub subcommittee_index: u64,
 }
 

consensus/types/src/sync_committee_contribution.rs

@@ -32,7 +32,7 @@ pub enum Error {
 pub struct SyncCommitteeContribution<T: EthSpec> {
     pub slot: Slot,
     pub beacon_block_root: Hash256,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub subcommittee_index: u64,
     pub aggregation_bits: BitVector<T::SyncSubcommitteeSize>,
     pub signature: AggregateSignature,

consensus/types/src/sync_committee_message.rs

@@ -23,7 +23,7 @@ use tree_hash_derive::TreeHash;
 pub struct SyncCommitteeMessage {
     pub slot: Slot,
     pub beacon_block_root: Hash256,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub validator_index: u64,
     // Signature by the validator over `beacon_block_root`.
     pub signature: Signature,

consensus/types/src/sync_committee_subscription.rs

@@ -7,10 +7,10 @@ use ssz_derive::{Decode, Encode};
 #[derive(PartialEq, Debug, Serialize, Deserialize, Clone, Encode, Decode)]
 pub struct SyncCommitteeSubscription {
     /// The validators index.
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub validator_index: u64,
     /// The sync committee indices.
-    #[serde(with = "eth2_serde_utils::quoted_u64_vec")]
+    #[serde(with = "serde_utils::quoted_u64_vec")]
     pub sync_committee_indices: Vec<u64>,
     /// Epoch until which this subscription is required.
     pub until_epoch: Epoch,

consensus/types/src/sync_duty.rs

@@ -7,9 +7,9 @@ use std::collections::HashSet;
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct SyncDuty {
     pub pubkey: PublicKeyBytes,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub validator_index: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64_vec")]
+    #[serde(with = "serde_utils::quoted_u64_vec")]
     pub validator_sync_committee_indices: Vec<u64>,
 }
 

consensus/types/src/sync_selection_proof.rs

@@ -5,7 +5,7 @@ use crate::{
     ChainSpec, Domain, EthSpec, Fork, Hash256, PublicKey, SecretKey, Signature, SignedRoot, Slot,
     SyncAggregatorSelectionData,
 };
-use eth2_hashing::hash;
+use ethereum_hashing::hash;
 use safe_arith::{ArithError, SafeArith};
 use ssz::Encode;
 use ssz_types::typenum::Unsigned;

consensus/types/src/sync_subnet_id.rs

@@ -21,7 +21,7 @@ lazy_static! {
 
 #[derive(arbitrary::Arbitrary, Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(transparent)]
-pub struct SyncSubnetId(#[serde(with = "eth2_serde_utils::quoted_u64")] u64);
+pub struct SyncSubnetId(#[serde(with = "serde_utils::quoted_u64")] u64);
 
 pub fn sync_subnet_id_to_string(i: u64) -> &'static str {
     if i < SYNC_COMMITTEE_SUBNET_COUNT {

consensus/types/src/validator.rs

@@ -25,7 +25,7 @@ use tree_hash_derive::TreeHash;
 pub struct Validator {
     pub pubkey: PublicKeyBytes,
     pub withdrawal_credentials: Hash256,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub effective_balance: u64,
     pub slashed: bool,
     pub activation_eligibility_epoch: Epoch,

consensus/types/src/validator_registration_data.rs

@@ -13,9 +13,9 @@ pub struct SignedValidatorRegistrationData {
 #[derive(PartialEq, Debug, Serialize, Deserialize, Clone, Encode, Decode, TreeHash)]
 pub struct ValidatorRegistrationData {
     pub fee_recipient: Address,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub gas_limit: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub timestamp: u64,
     pub pubkey: PublicKeyBytes,
 }

consensus/types/src/voluntary_exit.rs

@@ -27,7 +27,7 @@ use tree_hash_derive::TreeHash;
 pub struct VoluntaryExit {
     /// Earliest epoch when voluntary exit can be processed.
     pub epoch: Epoch,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub validator_index: u64,
 }
 

consensus/types/src/withdrawal.rs

@@ -20,12 +20,12 @@ use tree_hash_derive::TreeHash;
     TestRandom,
 )]
 pub struct Withdrawal {
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub index: u64,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub validator_index: u64,
     pub address: Address,
-    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    #[serde(with = "serde_utils::quoted_u64")]
     pub amount: u64,
 }