feat: add legacy locks support (#24)

* feat: setup initial project structure

* feat: update CI to use nightly toolchain for rustfmt

* feat: update CI to use nightly toolchain for rustfmt

* fix: fmt

* refactor: reorganize workspace members and remove charon-types crate

* feat: add core types and dependencies for Charon

* feat: add is_valid method and tests for DutyType

* feat: enhance Charon core types with new methods and error handling for PubKey

* chore: remove unused proptest dependency from workspace

* feat: implement Default trait for UnsignedDataSet, ParSignedDataSet, and SignedDataSet

* refactor: update PubKey methods for improved error handling and add try_from implementation

* docs: clarify slot duration comment and add debug prints for PubKey serialization/deserialization tests

* fix: remove unnecessary println

* feat: add tbls crypto boilerplate

* feat: add initial implementation of tbls

* feat: add tests for the bls implementation

* feat: init structure of charon-cluster

* feat: integrate blsful implementation and refactor tbls module

- Added `thiserror` dependency for improved error handling.
- Introduced `blsful` module for TBLS implementation.
- Refactored `tbls` module to utilize new types and error handling.
- Created `tblsconv` module for type conversions between byte slices and cryptographic types.
- Removed the old `herumi` implementation and replaced it with the new `blsful` based implementation.
- Added utility functions for key and signature conversions.
- Updated types and error definitions for better clarity and consistency.

* style: improve code formatting and documentation in tblsconv module

- Reformatted comments for better readability.
- Adjusted spacing and alignment in error messages for consistency.
- Ensured clarity in documentation regarding expected byte lengths for key and signature conversions.

* chore: clean up Cargo.toml by removing duplicate dependencies and organizing workspace lints

* chore: update Cargo.lock with new dependencies and versions

* chore: fix clippy warnings

* chore: apply fmt

* refactor: replace blsful implementation with blst for threshold BLS signatures

- Updated dependencies in Cargo.toml and Cargo.lock to use the blst library.
- Removed blsful module and its associated code, including type conversions and utility functions.
- Introduced a new blst_impl module for the BLST implementation of threshold BLS signatures.
- Refactored tbls module to utilize the new blst implementation.
- Cleaned up error handling and types to align with the new library.
- Added workspace lints and improved documentation throughout the codebase.

* fix: add protoc to workflow files

* fix: add ignore files to typos config

* feat: add support for cluster definition v1.10.0

* feat: add cluster lock v1.10.0 support

* feat: add support for legacy cluster definitions

* fix: linter errors

* feat: add legacy locks support

* fix: linter warnings

Author: varex83

crates/charon-cluster/src/definition.rs

@@ -5,18 +5,18 @@ 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)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
 pub struct DepositData {
-    /// PubKey is the validator's public key.
+    /// Validator's public key.
     #[serde_as(as = "EthHex")]
     #[serde(rename = "pubkey")]
     pub pub_key: Vec<u8>,
 
-    /// WithdrawalCredentials included in the deposit.
+    /// Withdrawal credentials included in the deposit.
     #[serde_as(as = "EthHex")]
     pub withdrawal_credentials: Vec<u8>,
 
-    /// Amount is the amount in Gwei to be deposited [1ETH..2048ETH].
+    /// 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,

crates/charon-cluster/src/deposit.rs

@@ -2,28 +2,31 @@ 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;
+use serde_with::{
+    base64::{Base64, Standard},
+    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.
+    /// 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.
+    /// Public shares 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.
+    /// Partial deposit data is the list of partial deposit data.
     pub partial_deposit_data: Vec<DepositData>,
 
-    /// BuilderRegistration is the pre-generated signed validator builder
+    /// Builder registration is the pre-generated signed validator builder
     /// registration.
     pub builder_registration: BuilderRegistration,
 }
@@ -40,7 +43,7 @@ pub enum DistValidatorError {
 }
 
 impl DistValidator {
-    /// PublicKey returns the distributed validator group public key.
+    /// 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(
@@ -53,13 +56,13 @@ impl DistValidator {
         Ok(pub_key)
     }
 
-    /// PublicKeyHex returns the validator hex group public key.
+    /// 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.
+    /// 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(
@@ -78,7 +81,7 @@ impl DistValidator {
         Ok(pub_share)
     }
 
-    /// ZeroRegistration returns a true if the validator has zero valued
+    /// True if the validator has zero valued registration.
     /// registration.
     pub fn zero_registration(&self) -> bool {
         self.builder_registration.signature.is_empty()
@@ -88,10 +91,239 @@ impl DistValidator {
             && self.builder_registration.message.pub_key.is_empty()
     }
 
-    /// Eth2Registration returns the validator's Eth2 registration.
+    /// 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"
         )
     }
 }
+
+/// DistValidatorV1x1 is a distributed validator managed by the cluster for
+/// version v1.0.0 or v1.1.0.
+#[serde_as]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct DistValidatorV1x0or1 {
+    /// Distributed validator group public key.
+    #[serde(rename = "distributed_public_key")]
+    #[serde_as(as = "EthHex")]
+    pub pub_key: Vec<u8>,
+
+    /// Public shares 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<Base64<Standard>>")]
+    pub pub_shares: Vec<Vec<u8>>,
+
+    /// Fee recipient address for the validator.
+    #[serde(default)]
+    #[serde_as(as = "EthHex")]
+    pub fee_recipient_address: Vec<u8>,
+}
+
+impl From<DistValidator> for DistValidatorV1x0or1 {
+    fn from(dist_validator: DistValidator) -> Self {
+        Self {
+            pub_key: dist_validator.pub_key,
+            pub_shares: dist_validator.pub_shares,
+            fee_recipient_address: Default::default(),
+        }
+    }
+}
+
+impl From<DistValidatorV1x0or1> for DistValidator {
+    fn from(dist_validator: DistValidatorV1x0or1) -> Self {
+        Self {
+            pub_key: dist_validator.pub_key,
+            pub_shares: dist_validator.pub_shares,
+            partial_deposit_data: Vec::new(),
+            builder_registration: BuilderRegistration::default(),
+        }
+    }
+}
+/// DistValidatorV1x2to5 is a distributed validator managed by the cluster for
+/// version v1.2.0 to v1.5.0.
+#[serde_as]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct DistValidatorV1x2to5 {
+    /// Distributed validator group public key.
+    #[serde(rename = "distributed_public_key")]
+    #[serde_as(as = "EthHex")]
+    pub pub_key: Vec<u8>,
+
+    /// Public shares 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>>,
+
+    /// Fee recipient address for the validator.
+    #[serde(default)]
+    #[serde_as(as = "EthHex")]
+    pub fee_recipient_address: Vec<u8>,
+}
+
+impl From<DistValidator> for DistValidatorV1x2to5 {
+    fn from(dist_validator: DistValidator) -> Self {
+        Self {
+            pub_key: dist_validator.pub_key,
+            pub_shares: dist_validator.pub_shares,
+            fee_recipient_address: Default::default(),
+        }
+    }
+}
+
+impl From<DistValidatorV1x2to5> for DistValidator {
+    fn from(dist_validator: DistValidatorV1x2to5) -> Self {
+        Self {
+            pub_key: dist_validator.pub_key,
+            pub_shares: dist_validator.pub_shares,
+            partial_deposit_data: Vec::new(),
+            builder_registration: BuilderRegistration::default(),
+        }
+    }
+}
+/// DistValidatorV1x6 is a distributed validator managed by the cluster for
+/// version v1.6.0.
+#[serde_as]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct DistValidatorV1x6 {
+    /// Distributed validator group public key.
+    #[serde(rename = "distributed_public_key")]
+    #[serde_as(as = "EthHex")]
+    pub pub_key: Vec<u8>,
+
+    /// Public shares 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>>,
+
+    /// Deposit data defines the deposit data to activate a validator.
+    pub deposit_data: DepositData,
+}
+
+impl From<DistValidator> for DistValidatorV1x6 {
+    fn from(dist_validator: DistValidator) -> Self {
+        Self {
+            pub_key: dist_validator.pub_key,
+            pub_shares: dist_validator.pub_shares,
+            deposit_data: dist_validator
+                .partial_deposit_data
+                .into_iter()
+                .next()
+                .unwrap_or_default(),
+        }
+    }
+}
+
+impl From<DistValidatorV1x6> for DistValidator {
+    fn from(dist_validator: DistValidatorV1x6) -> Self {
+        Self {
+            pub_key: dist_validator.pub_key,
+            pub_shares: dist_validator.pub_shares,
+            partial_deposit_data: vec![dist_validator.deposit_data],
+            builder_registration: BuilderRegistration::default(),
+        }
+    }
+}
+
+/// DistValidatorV1x7 is a distributed validator managed by the cluster for
+/// version v1.7.0.
+#[serde_as]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct DistValidatorV1x7 {
+    /// Distributed validator group public key.
+    #[serde(rename = "distributed_public_key")]
+    #[serde_as(as = "EthHex")]
+    pub pub_key: Vec<u8>,
+
+    /// Public shares 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>>,
+
+    /// Deposit data defines the deposit data to activate a validator.
+    pub deposit_data: DepositData,
+
+    /// Builder registration is the pre-generated signed validator builder
+    /// registration.
+    pub builder_registration: BuilderRegistration,
+}
+
+impl From<DistValidator> for DistValidatorV1x7 {
+    fn from(dist_validator: DistValidator) -> Self {
+        Self {
+            pub_key: dist_validator.pub_key,
+            pub_shares: dist_validator.pub_shares,
+            deposit_data: dist_validator
+                .partial_deposit_data
+                .into_iter()
+                .next()
+                .unwrap_or_default(),
+            builder_registration: dist_validator.builder_registration,
+        }
+    }
+}
+
+impl From<DistValidatorV1x7> for DistValidator {
+    fn from(dist_validator: DistValidatorV1x7) -> Self {
+        Self {
+            pub_key: dist_validator.pub_key,
+            pub_shares: dist_validator.pub_shares,
+            partial_deposit_data: vec![dist_validator.deposit_data],
+            builder_registration: dist_validator.builder_registration,
+        }
+    }
+}
+/// DistValidatorV1x8orLater is a distributed validator managed by the cluster
+/// for version v1.8.0 or later.
+#[serde_as]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct DistValidatorV1x8orLater {
+    /// Distributed validator group public key.
+    #[serde(rename = "distributed_public_key")]
+    #[serde_as(as = "EthHex")]
+    pub pub_key: Vec<u8>,
+
+    /// Public shares 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>>,
+
+    /// Deposit data defines the deposit data to activate a validator.
+    pub partial_deposit_data: Vec<DepositData>,
+
+    /// Builder registration is the pre-generated signed validator builder
+    /// registration.
+    pub builder_registration: BuilderRegistration,
+}
+
+impl From<DistValidator> for DistValidatorV1x8orLater {
+    fn from(dist_validator: DistValidator) -> Self {
+        Self {
+            pub_key: dist_validator.pub_key,
+            pub_shares: dist_validator.pub_shares,
+            partial_deposit_data: dist_validator.partial_deposit_data,
+            builder_registration: dist_validator.builder_registration,
+        }
+    }
+}
+
+impl From<DistValidatorV1x8orLater> for DistValidator {
+    fn from(dist_validator: DistValidatorV1x8orLater) -> Self {
+        Self {
+            pub_key: dist_validator.pub_key,
+            pub_shares: dist_validator.pub_shares,
+            partial_deposit_data: dist_validator.partial_deposit_data,
+            builder_registration: dist_validator.builder_registration,
+        }
+    }
+}

crates/charon-cluster/src/distvalidator.rs

@@ -32,11 +32,7 @@
   ],
   "uuid": "B6AE17B3-78F5-147B-2C37-2572B93437DF",
   "version": "v1.8.0",
-<<<<<<< HEAD
-  "timestamp": "2023-05-18T15: 12: 46+02: 00",
-=======
   "timestamp": "2023-05-18T15:12:46+02:00",
->>>>>>> origin/main
   "num_validators": 2,
   "threshold": 3,
   "validators": [

crates/charon-cluster/src/examples/cluster-definition-005.json

@@ -10,8 +10,6 @@ pub mod definition;
 pub mod deposit;
 /// Cluster distributed validator management and coordination.
 pub mod distvalidator;
-/// Cluster documentation management and coordination.
-pub mod doc;
 /// Cluster EIP-712 signatures management and coordination.
 pub mod eip712sigs;
 /// Cluster helpers management and coordination.