feat: add cluster lock v1.10.0 support

Author: varex83

Cargo.lock

@@ -40,6 +40,7 @@ prost-build = "0.14"
 rand = {version = "0.8", features = ["std_rng"]}
 uuid = {version = "1.16", features = ["serde"] }
 serde_with = { version = "3", features = ["hex"] }
+charon-crypto = { path = "crates/charon-crypto" }
 
 [workspace.lints.rust]
 missing_docs = "deny"

Cargo.toml

@@ -15,6 +15,8 @@ serde.workspace = true
 serde_json.workspace = true
 hex.workspace = true
 serde_with.workspace = true
+charon-crypto.workspace = true
+thiserror.workspace = true
 
 [build-dependencies]
 prost-build.workspace = true

crates/charon-cluster/Cargo.toml

@@ -32,10 +32,10 @@ pub struct Definition {
     pub timestamp: DateTime<Utc>,
     /// NumValidators is the number of DVs to be created in the cluster lock
     /// file.
-    pub num_validators: u32,
+    pub num_validators: u64,
     /// Threshold required for signature reconstruction. Defaults to safe value
     /// for number of nodes/peers.
-    pub threshold: u32,
+    pub threshold: u64,
     /// DKGAlgorithm to use for key generation. Max 32 chars.
     pub dkg_algorithm: String,
     /// ForkVersion defines the cluster's 4 byte beacon chain fork version
@@ -59,7 +59,7 @@ pub struct Definition {
     /// cluster, e.g. "abft".
     pub consensus_protocol: String,
     /// TargetGasLimit is the target block gas limit for the cluster.
-    pub target_gas_limit: u32,
+    pub target_gas_limit: u64,
     /// Compounding flag enables compounding rewards for validators by using
     /// 0x02 withdrawal credentials.
     pub compounding: bool,

crates/charon-cluster/src/definition.rs

@@ -1 +1,28 @@
+use crate::helpers::EthHex;
+use serde::{Deserialize, Serialize};
+use serde_with::{DisplayFromStr, serde_as};
 
+/// DepositData defines the deposit data to activate a validator.
+/// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#depositdata
+#[serde_as]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct DepositData {
+    /// PubKey is the validator's public key.
+    #[serde_as(as = "EthHex")]
+    #[serde(rename = "pubkey")]
+    pub pub_key: Vec<u8>,
+
+    /// WithdrawalCredentials included in the deposit.
+    #[serde_as(as = "EthHex")]
+    pub withdrawal_credentials: Vec<u8>,
+
+    /// Amount is the amount in Gwei to be deposited [1ETH..2048ETH].
+    /// We use DisplayFromStr to allow for easy conversion from string to u64.
+    #[serde_as(as = "DisplayFromStr")]
+    pub amount: u64,
+
+    /// Signature is the BLS signature of the deposit message (above three
+    /// fields).
+    #[serde_as(as = "EthHex")]
+    pub signature: Vec<u8>,
+}

crates/charon-cluster/src/deposit.rs

@@ -1 +1,97 @@
+use charon_crypto::types::{PUBLIC_KEY_LENGTH, PublicKey};
+use serde::{Deserialize, Serialize};
 
+use crate::{deposit::DepositData, helpers::EthHex, registration::BuilderRegistration};
+use serde_with::serde_as;
+
+/// DistValidator is a distributed validator managed by the cluster.
+#[serde_as]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct DistValidator {
+    /// PubKey is the distributed validator group public key.
+    #[serde(rename = "distributed_public_key")]
+    #[serde_as(as = "EthHex")]
+    pub pub_key: Vec<u8>,
+
+    /// PubShares are the public keys corresponding to each node's secret key
+    /// share. It can be used to verify a partial signature created by any
+    /// node in the cluster.
+    #[serde(rename = "public_shares")]
+    #[serde_as(as = "Vec<EthHex>")]
+    pub pub_shares: Vec<Vec<u8>>,
+
+    /// PartialDepositData is the list of partial deposit data.
+    pub partial_deposit_data: Vec<DepositData>,
+
+    /// BuilderRegistration is the pre-generated signed validator builder
+    /// registration.
+    pub builder_registration: BuilderRegistration,
+}
+
+/// DistValidatorError is an error type for DistValidator operations.
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+pub enum DistValidatorError {
+    /// Invalid public key length.
+    #[error("invalid public key length: got {0}, want {1}")]
+    InvalidPublicKeyLength(usize, usize),
+    /// Invalid public share index.
+    #[error("invalid public share index: got {0}, want less than {1}")]
+    InvalidPublicShareIndex(usize, usize),
+}
+
+impl DistValidator {
+    /// PublicKey returns the distributed validator group public key.
+    pub fn public_key(&self) -> Result<PublicKey, DistValidatorError> {
+        if self.pub_key.len() != PUBLIC_KEY_LENGTH {
+            return Err(DistValidatorError::InvalidPublicKeyLength(
+                self.pub_key.len(),
+                PUBLIC_KEY_LENGTH,
+            ));
+        }
+        let mut pub_key = [0u8; PUBLIC_KEY_LENGTH];
+        pub_key.copy_from_slice(&self.pub_key);
+        Ok(pub_key)
+    }
+
+    /// PublicKeyHex returns the validator hex group public key.
+    pub fn public_key_hex(&self) -> Result<String, DistValidatorError> {
+        let pub_key = self.public_key()?;
+        Ok(format!("0x{}", hex::encode(pub_key)))
+    }
+
+    /// PublicShare returns a peer's threshold BLS public share.
+    pub fn public_share(&self, index: usize) -> Result<PublicKey, DistValidatorError> {
+        if index >= self.pub_shares.len() {
+            return Err(DistValidatorError::InvalidPublicShareIndex(
+                index,
+                self.pub_shares.len(),
+            ));
+        }
+        if self.pub_shares[index].len() != PUBLIC_KEY_LENGTH {
+            return Err(DistValidatorError::InvalidPublicKeyLength(
+                self.pub_shares[index].len(),
+                PUBLIC_KEY_LENGTH,
+            ));
+        }
+        let mut pub_share = [0u8; PUBLIC_KEY_LENGTH];
+        pub_share.copy_from_slice(&self.pub_shares[index]);
+        Ok(pub_share)
+    }
+
+    /// ZeroRegistration returns a true if the validator has zero valued
+    /// registration.
+    pub fn zero_registration(&self) -> bool {
+        self.builder_registration.signature.is_empty()
+            && self.builder_registration.message.fee_recipient.is_empty()
+            && self.builder_registration.message.gas_limit == 0
+            && self.builder_registration.message.timestamp.timestamp() == 0
+            && self.builder_registration.message.pub_key.is_empty()
+    }
+
+    /// Eth2Registration returns the validator's Eth2 registration.
+    pub fn eth2_registration(&self) -> Result<(), DistValidatorError> {
+        unimplemented!(
+            "Eth2 registration requires to have ethereum types library which is not yet integrated in charon-cluster"
+        )
+    }
+}

crates/charon-cluster/src/distvalidator.rs

@@ -1,3 +1,4 @@
+use chrono::{DateTime, Utc};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde_with::{DeserializeAs, SerializeAs};
 use std::borrow::Cow;
@@ -90,6 +91,28 @@ impl TryFrom<&str> for EthHex {
     }
 }
 
+/// TimestampSeconds represents a timestamp in seconds since the Unix epoch.
+pub struct TimestampSeconds;
+
+impl SerializeAs<DateTime<Utc>> for TimestampSeconds {
+    fn serialize_as<S>(value: &DateTime<Utc>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_i64(value.timestamp())
+    }
+}
+
+impl<'de> DeserializeAs<'de, DateTime<Utc>> for TimestampSeconds {
+    fn deserialize_as<D>(deserializer: D) -> Result<DateTime<Utc>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let timestamp = i64::deserialize(deserializer)?;
+        Ok(DateTime::<Utc>::from_timestamp(timestamp, 0).unwrap())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;