refactor(light-client): Refactor light-client crate to use ethportal-api consensus types (#907)

* Refactor consensus `ethportal-api` types

* Update `light-client` test files to latest Capella data

* Update `light-client` sync test to recent Capella mainnet data

* Refator `light-client` crate to use `ethportal-api` consensus types

Author: ogenev

Cargo.lock

@@ -21,6 +21,7 @@ eth2_ssz = "0.4.0"
 eth2_ssz_derive = "0.3.0"
 eth2_ssz_types = "0.2.1"
 ethereum-types = "0.12.1"
+ethereum_serde_utils = "0.5.1"
 ethnum = "1.3.2"
 hex = "0.4.3"
 jsonrpsee = {version="0.20.0", features = ["async-client", "client", "macros", "server"]}

ethportal-api/Cargo.toml

@@ -32,6 +32,8 @@ pub use types::content_key::{
     state::StateContentKey,
 };
 
+pub use types::consensus;
+pub use types::consensus::light_client;
 pub use types::content_value::{
     beacon::{BeaconContentValue, PossibleBeaconContentValue},
     error::ContentValueError,

ethportal-api/src/lib.rs

@@ -1,22 +1,27 @@
 use super::serde::{de_hex_to_txs, de_number_to_u256, se_hex_to_number, se_txs_to_hex};
 use crate::types::consensus::body::Transactions;
 use crate::types::consensus::fork::ForkName;
-use crate::types::wrapped::bloom::Bloom;
-use crate::types::wrapped::bytes::Bytes;
 use crate::types::wrapped::h160::H160;
+use crate::utils::serde::{hex_fixed_vec, hex_var_list};
 use ethereum_types::{H256, U256};
 use serde::{Deserialize, Serialize};
 use serde_this_or_that::as_u64;
 use ssz::Decode;
 use ssz_derive::{Decode, Encode};
+use ssz_types::{typenum, FixedVector, VariableList};
 use superstruct::superstruct;
+use tree_hash_derive::TreeHash;
+
+pub type Bloom = FixedVector<u8, typenum::U256>;
+pub type ExtraData = VariableList<u8, typenum::U32>;
 
 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize, Encode, Decode)]
 pub struct ExecutionPayload {
     pub parent_hash: H256,
     pub fee_recipient: H160,
     pub state_root: H256,
     pub receipts_root: H256,
+    #[serde(with = "hex_fixed_vec")]
     pub logs_bloom: Bloom,
     pub prev_randao: H256, // 'difficulty' in the yellow paper
     #[serde(deserialize_with = "as_u64")]
@@ -27,7 +32,8 @@ pub struct ExecutionPayload {
     pub gas_used: u64,
     #[serde(deserialize_with = "as_u64")]
     pub timestamp: u64,
-    pub extra_data: Bytes,
+    #[serde(with = "hex_var_list")]
+    pub extra_data: ExtraData,
     #[serde(deserialize_with = "de_number_to_u256")]
     #[serde(serialize_with = "se_hex_to_number")]
     pub base_fee_per_gas: U256,
@@ -49,10 +55,12 @@ pub struct ExecutionPayload {
         Deserialize,
         Encode,
         Decode,
+        TreeHash
     ),)
 )]
-#[derive(Debug, Clone, Serialize, Deserialize, Encode)]
+#[derive(Debug, Clone, Serialize, Deserialize, Encode, TreeHash)]
 #[ssz(enum_behaviour = "transparent")]
+#[tree_hash(enum_behaviour = "transparent")]
 pub struct ExecutionPayloadHeader {
     #[superstruct(getter(copy))]
     pub parent_hash: H256,
@@ -61,6 +69,7 @@ pub struct ExecutionPayloadHeader {
     pub state_root: H256,
     #[superstruct(getter(copy))]
     pub receipts_root: H256,
+    #[serde(with = "hex_fixed_vec")]
     pub logs_bloom: Bloom,
     #[superstruct(getter(copy))]
     pub prev_randao: H256,
@@ -76,7 +85,8 @@ pub struct ExecutionPayloadHeader {
     #[superstruct(getter(copy))]
     #[serde(deserialize_with = "as_u64")]
     pub timestamp: u64,
-    pub extra_data: Bytes,
+    #[serde(with = "hex_var_list")]
+    pub extra_data: ExtraData,
     #[superstruct(getter(copy))]
     #[serde(deserialize_with = "de_number_to_u256")]
     #[serde(serialize_with = "se_hex_to_number")]

ethportal-api/src/types/consensus/execution_payload.rs

@@ -2,10 +2,13 @@ use ethereum_types::H256;
 use serde::{Deserialize, Serialize};
 use serde_this_or_that::as_u64;
 use ssz_derive::{Decode, Encode};
+use tree_hash_derive::TreeHash;
 
 /// Types based off specs @
 /// https://github.com/ethereum/consensus-specs/blob/5970ae56a1cd50ea06049d8aad6bed74093d49d3/specs/phase0/beacon-chain.md
-#[derive(Debug, PartialEq, Eq, Clone, Default, Serialize, Deserialize, Encode, Decode)]
+#[derive(
+    Debug, PartialEq, Eq, Clone, Default, Serialize, Deserialize, Encode, Decode, TreeHash,
+)]
 pub struct BeaconBlockHeader {
     #[serde(deserialize_with = "as_u64")]
     pub slot: u64,

ethportal-api/src/types/consensus/header.rs

@@ -23,6 +23,7 @@ pub type CurrentSyncCommitteeProofLen = U5;
     )
 )]
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode)]
+#[serde(untagged)]
 #[ssz(enum_behaviour = "transparent")]
 pub struct LightClientBootstrap {
     /// Header matching the requested beacon block root

ethportal-api/src/types/consensus/light_client/bootstrap.rs

@@ -8,18 +8,30 @@ use ssz_derive::{Decode, Encode};
 use ssz_types::typenum::U4;
 use ssz_types::FixedVector;
 use superstruct::superstruct;
+use tree_hash_derive::TreeHash;
 
 pub type ExecutionBranchLen = U4;
 
 #[superstruct(
     variants(Bellatrix, Capella),
     variant_attributes(
-        derive(Debug, Clone, Serialize, PartialEq, Deserialize, Encode, Decode,),
+        derive(
+            Debug,
+            Clone,
+            Serialize,
+            PartialEq,
+            Deserialize,
+            Encode,
+            Decode,
+            Default,
+            TreeHash
+        ),
         serde(deny_unknown_fields),
     )
 )]
-#[derive(Debug, Clone, Serialize, Deserialize, Encode)]
+#[derive(Debug, Clone, Serialize, Deserialize, Encode, TreeHash)]
 #[ssz(enum_behaviour = "transparent")]
+#[tree_hash(enum_behaviour = "transparent")]
 pub struct LightClientHeader {
     pub beacon: BeaconBlockHeader,
     #[superstruct(only(Capella))]
@@ -28,6 +40,12 @@ pub struct LightClientHeader {
     pub execution_branch: FixedVector<H256, ExecutionBranchLen>,
 }
 
+impl Default for LightClientHeader {
+    fn default() -> Self {
+        Self::Capella(LightClientHeaderCapella::default())
+    }
+}
+
 impl LightClientHeader {
     pub fn from_ssz_bytes(bytes: &[u8], fork_name: ForkName) -> Result<Self, ssz::DecodeError> {
         match fork_name {

ethportal-api/src/types/consensus/light_client/header.rs

@@ -1,22 +1,42 @@
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use ssz::{Decode, Encode};
+use ssz_types::{typenum, FixedVector};
+use std::ops::Deref;
+use tree_hash_derive::TreeHash;
 
 use crate::utils::bytes::{hex_decode, hex_encode};
 
 /// Types based off specs @
 /// https://github.com/ethereum/consensus-specs/blob/5970ae56a1/specs/phase0/beacon-chain.md
-#[derive(Debug, PartialEq, Clone)]
-pub struct PubKey([u8; 48]);
+#[derive(Debug, PartialEq, Clone, TreeHash)]
+pub struct PubKey {
+    pub inner: FixedVector<u8, typenum::U48>,
+}
+
+impl Default for PubKey {
+    fn default() -> Self {
+        Self {
+            inner: FixedVector::from_elem(0),
+        }
+    }
+}
+
+impl Deref for PubKey {
+    type Target = FixedVector<u8, typenum::U48>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
 
 impl Decode for PubKey {
     fn is_ssz_fixed_len() -> bool {
         true
     }
 
     fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, ssz::DecodeError> {
-        let mut key = [0u8; 48];
-        key.copy_from_slice(bytes);
-        Ok(Self(key))
+        let key = FixedVector::from(Vec::from(bytes));
+        Ok(Self { inner: key })
     }
     fn ssz_fixed_len() -> usize {
         48
@@ -29,10 +49,10 @@ impl Encode for PubKey {
     }
 
     fn ssz_append(&self, buf: &mut Vec<u8>) {
-        buf.extend_from_slice(&self.0);
+        buf.extend_from_slice(&self.inner.as_ssz_bytes());
     }
     fn ssz_bytes_len(&self) -> usize {
-        self.0.len()
+        self.inner.len()
     }
     fn ssz_fixed_len() -> usize {
         48
@@ -46,9 +66,8 @@ impl<'de> Deserialize<'de> for PubKey {
     {
         let result: String = Deserialize::deserialize(deserializer)?;
         let result = hex_decode(&result).map_err(serde::de::Error::custom)?;
-        let mut key = [0u8; 48];
-        key.copy_from_slice(&result);
-        Ok(Self(key))
+        let key = FixedVector::from(result);
+        Ok(Self { inner: key })
     }
 }
 
@@ -57,7 +76,7 @@ impl Serialize for PubKey {
     where
         S: Serializer,
     {
-        let val = hex_encode(self.0);
+        let val = hex_encode(self.inner.as_ssz_bytes());
         serializer.serialize_str(&val)
     }
 }

ethportal-api/src/types/consensus/pubkey.rs

@@ -10,6 +10,14 @@ pub struct BlsSignature {
     pub signature: [u8; 96],
 }
 
+impl Default for BlsSignature {
+    fn default() -> Self {
+        Self {
+            signature: [0u8; 96],
+        }
+    }
+}
+
 impl Decode for BlsSignature {
     fn is_ssz_fixed_len() -> bool {
         true

ethportal-api/src/types/consensus/signature.rs

@@ -3,12 +3,22 @@ use serde::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use ssz_types::typenum::U512;
 use ssz_types::FixedVector;
+use tree_hash_derive::TreeHash;
 
 type SyncCommitteeSize = U512;
 
 /// https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/beacon-chain.md#synccommittee
-#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Encode, Decode)]
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Encode, Decode, TreeHash)]
 pub struct SyncCommittee {
     pub pubkeys: FixedVector<PubKey, SyncCommitteeSize>,
     pub aggregate_pubkey: PubKey,
 }
+
+impl Default for SyncCommittee {
+    fn default() -> Self {
+        Self {
+            pubkeys: FixedVector::from_elem(PubKey::default()),
+            aggregate_pubkey: PubKey::default(),
+        }
+    }
+}