feat: implement some of the cluster config function, ENR functionality, k1util, RLP, p2p.name etc.

Author: varex83

Cargo.lock

@@ -38,9 +38,20 @@ prost = "0.14"
 prost-types = "0.14"
 prost-build = "0.14"
 rand = {version = "0.8", features = ["std_rng"]}
-uuid = {version = "1.16", features = ["serde"] }
+uuid = {version = "1.16", features = ["serde", "v4"] }
 serde_with = { version = "3", features = ["hex", "base64"] }
+libp2p = { version = "0.56", features = ["full", "secp256k1"] }
+base64 = { version = "0.22.1" }
+sha3 = { version = "0.10.8" }
+k256 = { version = "0.13.4", features = ["ecdsa", "sha256"] }
+criterion = "0.7.0"
+
+# Crates in the workspace
+charon = { path = "crates/charon" }
 charon-crypto = { path = "crates/charon-crypto" }
+charon-eth2 = { path = "crates/charon-eth2" }
+charon-p2p = { path = "crates/charon-p2p" }
+charon-testutil = { path = "crates/charon-testutil" }
 
 [workspace.lints.rust]
 missing_docs = "deny"

Cargo.toml

@@ -17,6 +17,10 @@ hex.workspace = true
 serde_with.workspace = true
 charon-crypto.workspace = true
 thiserror.workspace = true
+rand_core.workspace = true
+libp2p.workspace = true
+charon-p2p.workspace = true
+charon-eth2.workspace = true
 
 [build-dependencies]
 prost-build.workspace = true

crates/charon-cluster/Cargo.toml

@@ -1,9 +1,14 @@
+use std::collections::HashSet;
+
 use crate::{
-    helpers::EthHex,
+    helpers::{EthHex, from_0x_hex_str},
     operator::{Operator, OperatorV1X1, OperatorV1X2OrLater},
-    version::versions::*,
+    version::{CURRENT_VERSION, DKG_ALGO, versions::*},
 };
+use charon_eth2::enr::{Record, RecordError};
+use charon_p2p::peer::{Peer, PeerError};
 use chrono::{DateTime, Utc};
+use libp2p::PeerId;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde_with::{
     DisplayFromStr, PickFirst,
@@ -12,6 +17,22 @@ use serde_with::{
 };
 use uuid::Uuid;
 
+/// Length of the fork version in bytes.
+pub const FORK_VERSION_LEN: usize = 4;
+
+/// Length of the address in bytes.
+pub const ADDRESS_LEN: usize = 20;
+
+/// NodeIdx represents the index of a node/peer/share in the cluster as operator
+/// order in cluster definition.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct NodeIdx {
+    /// Index of a peer in the peer list (it's 0-indexed).
+    pub peer_idx: usize,
+    /// tbls share identifier (it is 1-indexed).
+    pub share_idx: usize,
+}
+
 /// Definition defines an intended charon cluster configuration excluding
 /// validators.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -159,9 +180,198 @@ pub enum DefinitionError {
     /// are found.
     #[error("Multiple withdrawal or fee recipient addresses found")]
     InvalidValidatorAddresses,
+
+    /// Insufficient fee-recipient addresses
+    #[error("Insufficient fee-recipient addresses")]
+    InsufficientFeeRecipientAddresses,
+
+    /// Insufficient withdrawal addresses
+    #[error("Insufficient withdrawal addresses")]
+    InsufficientWithdrawalAddresses,
+
+    /// Failed to convert length
+    #[error("Failed to convert length")]
+    FailedToConvertLength,
+
+    /// Failed to convert hex string
+    #[error("Failed to convert hex string")]
+    FailedToConvertHexString(#[from] hex::FromHexError),
+
+    /// Invalid target gas limit
+    #[error("Invalid target gas limit: {0}")]
+    InvalidTargetGasLimit(&'static str),
+
+    /// Invalid deposit amounts
+    #[error("Invalid deposit amounts: {0}")]
+    InvalidDepositAmounts(&'static str),
+
+    /// Invalid compounding
+    #[error("Invalid deposit amounts: {0}")]
+    InvalidCompounding(&'static str),
+
+    /// Invalid gas limit
+    #[error("Invalid gas limit: {0}")]
+    InvalidGasLimit(&'static str),
+
+    /// Peer not found
+    #[error("Peer not in definition: {0}")]
+    PeerNotFound(String),
+
+    /// Duplicate peer ENRs
+    #[error("Duplicate peer ENRs: {0}")]
+    DuplicatePeerENRs(String),
+
+    /// Failed to parse ENR
+    #[error("Failed to parse ENR: {0}")]
+    FailedToParseENR(#[from] RecordError),
+
+    /// Failed to create peer
+    #[error("Failed to create peer: {0}")]
+    FailedToCreatePeer(#[from] PeerError),
 }
 
 impl Definition {
+    /// Create a new cluster definition.
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        name: String,
+        num_validators: u64,
+        threshold: u64,
+        fee_recipient_addresses: Vec<String>,
+        withdrawal_addresses: Vec<String>,
+        fork_version_hex: String,
+        creator: Creator,
+        operators: Vec<Operator>,
+        deposit_amounts: Vec<u64>,
+        consensus_protocol: String,
+        target_gas_limit: u64,
+        compounding: bool,
+        opts: Vec<fn(&mut Self) -> Self>,
+    ) -> Result<Self, DefinitionError> {
+        if u64::try_from(fee_recipient_addresses.len())
+            .map_err(|_| DefinitionError::FailedToConvertLength)?
+            != num_validators
+        {
+            return Err(DefinitionError::InsufficientFeeRecipientAddresses);
+        }
+
+        if u64::try_from(withdrawal_addresses.len())
+            .map_err(|_| DefinitionError::FailedToConvertLength)?
+            != num_validators
+        {
+            return Err(DefinitionError::InsufficientWithdrawalAddresses);
+        }
+
+        let uuid = Uuid::new_v4();
+
+        let mut def = Definition {
+            uuid,
+            name,
+            version: CURRENT_VERSION.to_string(),
+            timestamp: Utc::now(),
+            num_validators,
+            threshold,
+            dkg_algorithm: DKG_ALGO.to_string(),
+            fork_version: Default::default(),
+            operators,
+            creator,
+            validator_addresses: Vec::new(),
+            deposit_amounts,
+            consensus_protocol,
+            target_gas_limit,
+            compounding,
+            config_hash: Default::default(),
+            definition_hash: Default::default(),
+        };
+
+        def.validator_addresses = fee_recipient_addresses
+            .into_iter()
+            .enumerate()
+            .map(|(i, address)| ValidatorAddresses {
+                fee_recipient_address: address,
+                withdrawal_address: withdrawal_addresses[i].clone(),
+            })
+            .collect();
+
+        def.fork_version = from_0x_hex_str(&fork_version_hex, FORK_VERSION_LEN)?;
+
+        for opt in opts {
+            opt(&mut def);
+        }
+
+        if def.deposit_amounts.len() > 1 && !Self::support_partial_deposits(&def.version) {
+            return Err(DefinitionError::InvalidDepositAmounts(
+                "the version does not support partial deposits",
+            ));
+        }
+
+        if def.target_gas_limit != 0 && !Self::support_target_gas_limit(&def.version) {
+            return Err(DefinitionError::InvalidTargetGasLimit(
+                "the version does not support custom target gas limit",
+            ));
+        }
+
+        if def.compounding && !Self::support_compounding(&def.version) {
+            return Err(DefinitionError::InvalidCompounding(
+                "the version does not support compounding",
+            ));
+        }
+
+        if def.target_gas_limit == 0 && Self::support_target_gas_limit(&def.version) {
+            return Err(DefinitionError::InvalidTargetGasLimit(
+                "target gas limit should be set",
+            ));
+        }
+
+        // TODO: Construct and return a Definition. Placeholder for now.
+        def.set_definition_hashes()
+    }
+
+    /// Sets the definition hashes.
+    pub fn set_definition_hashes(self) -> Result<Self, DefinitionError> {
+        // todo
+        Ok(self)
+    }
+
+    /// Returns the node index for a given peer ID.
+    pub fn node_idx(&self, pid: &PeerId) -> Result<NodeIdx, DefinitionError> {
+        let peers = self.peers()?;
+
+        for (i, peer) in peers.iter().enumerate() {
+            if peer.id == *pid {
+                return Ok(NodeIdx {
+                    peer_idx: i,
+                    share_idx: peer.share_idx(),
+                });
+            }
+        }
+
+        Err(DefinitionError::PeerNotFound(pid.to_string()))
+    }
+
+    /// Returns the peers in the cluster.
+    pub fn peers(&self) -> Result<Vec<Peer>, DefinitionError> {
+        let mut peers = Vec::new();
+
+        let mut dedup: HashSet<String> = HashSet::new();
+
+        for (i, operator) in self.operators.iter().enumerate() {
+            if dedup.contains(&operator.enr) {
+                return Err(DefinitionError::DuplicatePeerENRs(operator.enr.clone()));
+            }
+
+            dedup.insert(operator.enr.clone());
+
+            let enr = Record::try_from(operator.enr.as_str())?;
+
+            let peer = Peer::from_enr(&enr, i)?;
+
+            peers.push(peer);
+        }
+
+        Ok(peers)
+    }
+
     /// Legacy single withdrawal and single
     /// fee recipient addresses or an error if multiple addresses are found.
     pub fn legacy_validator_addresses(&self) -> Result<ValidatorAddresses, DefinitionError> {
@@ -177,6 +387,39 @@ impl Definition {
 
         Ok(result_validator_addresses)
     }
+
+    /// Returns true if the provided definition version supports EIP712
+    /// signatures. Note that Definition versions prior to v1.3.0 don't
+    /// support EIP712 signatures.
+    pub fn support_eip712_sigs(version: &str) -> bool {
+        !matches!(version, V1_0 | V1_1 | V1_2)
+    }
+
+    /// Returns true if the provided definition version supports partial
+    /// deposits.
+    pub fn support_partial_deposits(version: &str) -> bool {
+        !matches!(
+            version,
+            V1_0 | V1_1 | V1_2 | V1_3 | V1_4 | V1_5 | V1_6 | V1_7
+        )
+    }
+
+    /// Returns true if the provided definition version supports custom target
+    /// gas limit.
+    pub fn support_target_gas_limit(version: &str) -> bool {
+        !matches!(
+            version,
+            V1_0 | V1_1 | V1_2 | V1_3 | V1_4 | V1_5 | V1_6 | V1_7 | V1_8 | V1_9
+        )
+    }
+
+    /// Returns true if the provided definition version supports compounding.
+    pub fn support_compounding(version: &str) -> bool {
+        !matches!(
+            version,
+            V1_0 | V1_1 | V1_2 | V1_3 | V1_4 | V1_5 | V1_6 | V1_7 | V1_8 | V1_9
+        )
+    }
 }
 
 /// Creator identifies the creator of a cluster definition. They may also be an

crates/charon-cluster/src/definition.rs

@@ -114,6 +114,16 @@ impl<'de> DeserializeAs<'de, DateTime<Utc>> for TimestampSeconds {
     }
 }
 
+/// Converts a 0x prefixed hex string to a byte slice.
+pub fn from_0x_hex_str(s: &str, len: usize) -> Result<Vec<u8>, hex::FromHexError> {
+    let s = s.strip_prefix("0x").unwrap_or(s);
+    let bytes = hex::decode(s)?;
+    if bytes.len() != len {
+        return Err(hex::FromHexError::InvalidStringLength);
+    }
+    Ok(bytes)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/charon-cluster/src/helpers.rs

@@ -7,6 +7,13 @@ license.workspace = true
 publish.workspace = true
 
 [dependencies]
+k256.workspace = true
+thiserror.workspace = true
+base64.workspace = true
+sha3.workspace = true
+charon.workspace = true
+hex.workspace = true
+charon-testutil.workspace = true
 
 [lints]
 workspace = true