feat: add cli option for root private key in bridge

ethportal-api/src/types/cli.rs

@@ -245,9 +245,9 @@ impl TrinConfig {
     }
 }
 
-fn check_private_key_length(private_key: &str) -> Result<H256, String> {
+pub fn check_private_key_length(private_key: &str) -> Result<H256, String> {
     if private_key.len() == 66 {
-        return H256::from_str(private_key).map_err(|err| format!("HexError: {}", err));
+        return H256::from_str(private_key).map_err(|err| format!("HexError: {err}"));
     }
     Err(format!(
         "Invalid private key length: {}, expected 66 (0x-prefixed 32 byte hexstring)",

portal-bridge/src/cli.rs

@@ -1,12 +1,16 @@
-use crate::client_handles::{fluffy_handle, trin_handle};
-use crate::mode::BridgeMode;
-use crate::types::NetworkKind;
-use clap::{Parser, Subcommand};
 use std::path::PathBuf;
 use std::str::FromStr;
+
+use clap::{Parser, Subcommand};
+use ethereum_types::H256;
 use tokio::process::Child;
 use url::Url;
 
+use crate::client_handles::{fluffy_handle, trin_handle};
+use crate::mode::BridgeMode;
+use crate::types::NetworkKind;
+use ethportal_api::types::cli::check_private_key_length;
+
 // max value of 16 b/c...
 // - reliably calculate spaced private keys in a reasonable time
 // - for values b/w 16 - 256, calculated spaced private keys are
@@ -68,6 +72,13 @@ pub struct BridgeConfig {
 
     #[command(subcommand)]
     pub client_type: ClientType,
+
+    #[arg(
+        long = "root-private-key",
+        value_parser = check_private_key_length,
+        help = "Hex encoded 32 byte private key (with 0x prefix) (used as the root key for generating spaced private keys, if multiple nodes are selected)"
+    )]
+    pub root_private_key: Option<H256>,
 }
 
 fn check_node_count(val: &str) -> Result<u8, String> {

portal-bridge/src/main.rs

@@ -20,7 +20,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     init_tracing_logger();
 
     let bridge_config = BridgeConfig::parse();
-    let private_keys = generate_spaced_private_keys(bridge_config.node_count);
+    let private_keys =
+        generate_spaced_private_keys(bridge_config.node_count, bridge_config.root_private_key);
     let mut handles = vec![];
     let mut http_addresses = vec![];
     for (i, key) in private_keys.into_iter().enumerate() {

portal-bridge/src/utils.rs

@@ -1,6 +1,7 @@
 use anyhow::bail;
 use chrono::Duration;
 use discv5::enr::{CombinedKey, EnrBuilder, NodeId};
+use ethereum_types::H256;
 use ethportal_api::utils::bytes::hex_encode;
 use ethportal_api::HistoryContentKey;
 use ethportal_api::{BeaconContentKey, BeaconContentValue, HistoryContentValue};
@@ -16,9 +17,20 @@ use std::time::{SystemTime, UNIX_EPOCH};
 // stops getting evenly spread, because of how the code spreads the data by
 // inspecting the first byte from the node ID. Also, values between 16 to
 // 256 would be spread, but less and less evenly.
-pub fn generate_spaced_private_keys(count: u8) -> Vec<String> {
+pub fn generate_spaced_private_keys(count: u8, root_private_key: Option<H256>) -> Vec<String> {
     let mut private_keys = vec![];
-    let (root_node_id, root_private_key) = random_node_id();
+    let (root_node_id, root_private_key) = match root_private_key {
+        Some(key) => {
+            let private_key =
+                CombinedKey::secp256k1_from_bytes(key.to_fixed_bytes().as_mut_slice())
+                    .expect("to be able to decode key");
+            let enr = EnrBuilder::new("v4")
+                .build(&private_key)
+                .expect("to be able to build ENR from private key");
+            (enr.node_id(), private_key)
+        }
+        None => random_node_id(),
+    };
     private_keys.push(hex_encode(root_private_key.encode()));
     let mut root_prefix = root_node_id.raw()[0];
 
@@ -169,7 +181,7 @@ mod tests {
     #[case(4)]
     #[case(16)]
     fn test_generate_spaced_private_keys(#[case] count: u8) {
-        let private_keys = generate_spaced_private_keys(count);
+        let private_keys = generate_spaced_private_keys(count, None);
         assert_eq!(private_keys.len() as u8, count);
         let one = EnrBuilder::new("v4")
             .build(