feat: add readme for setting up the mvp

Author: varex83

Makefile

@@ -0,0 +1,46 @@
+.PHONY: peerinfo init-peerinfo node1 node2
+
+# Profile configurations
+ifneq ($(filter node1,$(MAKECMDGOALS)),)
+PORT := 4001
+NICKNAME := node1
+DATA_DIR := .charon-example-peerinfo-1
+METRICS_PORT := 9465
+else ifneq ($(filter node2,$(MAKECMDGOALS)),)
+PORT := 4002
+NICKNAME := node2
+DATA_DIR := .charon-example-peerinfo-2
+METRICS_PORT := 9466
+endif
+
+# Extract dial addresses from command line (multiaddresses starting with /)
+DIAL_ADDRS := $(filter /%,$(MAKECMDGOALS))
+
+# Build the dial arguments
+ifneq ($(DIAL_ADDRS),)
+DIAL_ARGS := $(foreach addr,$(DIAL_ADDRS),--dial $(addr))
+endif
+
+# Run peerinfo with the selected profile
+peerinfo:
+	cargo run -p charon-peerinfo --example peerinfo -- \
+		--port $(PORT) \
+		--nickname $(NICKNAME) \
+		--data-dir $(DATA_DIR) \
+		--metrics-port $(METRICS_PORT) \
+		$(DIAL_ARGS)
+
+# Initialize peerinfo with a private key
+# Usage: make init node1 KEY=<private_key>
+init-peerinfo:
+	cargo run -p charon-peerinfo --example peerinfo -- init \
+		--data-dir $(DATA_DIR) \
+		--private-key $(KEY)
+
+# No-op targets for profile selection
+node1 node2:
+	@:
+
+# Catch-all for multiaddresses (prevents "No rule to make target" errors)
+/%:
+	@:

crates/peerinfo/examples/README.md

@@ -0,0 +1,115 @@
+# Peerinfo Example
+
+Demonstrates the peerinfo protocol with mDNS auto-discovery.
+
+## Setup
+
+### Using Nix (recommended)
+
+```bash
+nix develop
+```
+
+### Manual
+
+Ensure you have:
+
+- Rust (stable + nightly for fmt)
+- protobuf compiler (`protoc`)
+
+## Creating a cluster
+
+For now we use simple approach by creating cluster in charon and taking private keys from the generated nodes.
+
+### Building charon
+
+So to do this you need to clone [charon repository](https://github.com/ObolNetwork/charon.git)
+
+Then, in the cloned repository build charon:
+
+```bash
+make charon
+```
+
+Output binary (`charon`) will be put in the project's root directory and will be accessible via `./charon <args>`.
+Now, you have everything needed to create test cluster.
+
+### Creating cluster configuration
+
+Creating a cluster could be done by simply running:
+
+```bash
+./charon create cluster --nodes 3 --network mainnet --num-validators 1 --cluster-dir ./test-cluster --insecure-keys --fee-recipient-addresses 0x0000000000000000000000000000000000000000 --withdrawal-addresses 0x0000000000000000000000000000000000000000
+```
+
+This command will initialize testing cluster with 3 nodes and 1 validator and put output artifacts in the `./test-cluster` folder. Each node configuration will have separate subfolder in the format of node<NODE_NUMBER> (i.e. node1, node2, node3 etc.).
+
+Next, thing we will do is to actually run first node:
+
+```bash
+./charon run --simnet-beacon-mock --no-verify --nickname=charon-1 --lock-file=test-cluster/node0/cluster-lock.json --private-key-file=test-cluster/node0/charon-enr-private-key --p2p-tcp-address=0.0.0.0:3610 --validator-api-address=0.0.0.0:3680 --monitoring-address=0.0.0.0:9464 --log-level=debug
+```
+
+### Initializing the peerinfo example
+
+In order to connect to the `node0` we need to initialize our example with 2 node profiles (node1, node2).
+
+```bash
+make init-peerinfo node1 KEY=<PRIVATE_KEY_NODE_1>
+make init-peerinfo node1 KEY=<PRIVATE_KEY_NODE_2>
+```
+
+This will initialize data-dirs for two pluto nodes.
+
+### Running pluto's nodes
+
+To run the node you will need the following commands in different terminals:
+
+```bash
+make peerinfo node1 /ip4/127.0.0.1/tcp/3610
+```
+
+```bash
+make peerinfo node2 /ip4/127.0.0.1/tcp/3610
+```
+
+`/ip4/127.0.0.1/tcp/3610` is tcp address of charon's node in [multiaddr format](https://multiformats.io/multiaddr/).
+
+### Working with results
+
+Charon node is configured to send `peerinfo` every one minute and you will be able to see corresponding logs in the terminal.
+
+On charon's side you can track the by accessing metrics endpoint:
+
+```bash
+curl 0.0.0.0:9464/metrics | grep app_peerinfo
+```
+
+For pluto:
+
+`node1`:
+
+```bash
+curl 0.0.0.0:9465/metrics | grep app_peerinfo
+```
+
+`node2`:
+
+```bash
+curl 0.0.0.0:9466/metrics | grep app_peerinfo
+```
+
+### Running grafana locally
+
+To run grafana we use `docker-compose`. All infra files located at `test-infra` folder.
+
+To run it use this command:
+
+```bash
+cd test-infra
+docker-compose up
+```
+
+And grafana will be accessible via `http://localhost:3000`.
+
+> Note, that you may need to add prometheus as a data source

crates/peerinfo/examples/peerinfo.rs

@@ -21,11 +21,12 @@ use std::{
 
 use charon_p2p::{
     config::P2PConfig,
-    k1,
+    k1::{self, key_path},
     p2p::{Node, NodeType},
 };
 use charon_peerinfo::{Behaviour, Config, Event, LocalPeerInfo};
 use clap::Parser;
+use k256::SecretKey;
 use libp2p::{
     Multiaddr, Swarm,
     futures::StreamExt,
@@ -41,13 +42,16 @@ use vise_exporter::MetricsExporter;
 #[command(name = "peerinfo-example")]
 #[command(about = "Demonstrates the peerinfo protocol with mDNS discovery")]
 pub struct Args {
+    #[command(subcommand)]
+    pub command: Option<Command>,
+
     /// The port to listen on
     #[arg(short, long, default_value = "4001")]
     pub port: u16,
 
-    /// Optional address to dial
+    /// Optional addresses to dial
     #[arg(short, long)]
-    pub dial: Option<Multiaddr>,
+    pub dial: Vec<Multiaddr>,
 
     /// Nickname for this node
     #[arg(short, long, default_value = "example-node")]
@@ -66,6 +70,20 @@ pub struct Args {
     pub metrics_port: u16,
 }
 
+#[derive(Debug, Parser)]
+pub enum Command {
+    /// Initialize the node with a private key
+    Init {
+        /// Data directory for storing the private key
+        #[arg(long, default_value = ".charon-example")]
+        data_dir: PathBuf,
+
+        /// Private key as a hex string
+        #[arg(long)]
+        private_key: String,
+    },
+}
+
 /// Combined behaviour with peerinfo, identify, ping, and mdns
 #[derive(NetworkBehaviour)]
 pub struct CombinedBehaviour {
@@ -149,6 +167,28 @@ fn handle_event(event: SwarmEvent<CombinedEvent>, swarm: &mut Swarm<CombinedBeha
     }
 }
 
+fn init_node(data_dir: &PathBuf, private_key: &str) -> anyhow::Result<()> {
+    // Decode the hex string
+    let key_bytes = hex::decode(private_key.trim().trim_start_matches("0x"))?;
+
+    // Parse the secret key
+    let key = SecretKey::from_slice(&key_bytes)?;
+
+    // Create the data directory
+    std::fs::create_dir_all(data_dir)?;
+
+    // Save the key
+    let key_file = key_path(data_dir);
+    std::fs::write(&key_file, hex::encode(key.to_bytes()))?;
+
+    tracing::info!(
+        "Initialized node with private key in {}",
+        key_file.display()
+    );
+
+    Ok(())
+}
+
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     // Initialize logging
@@ -158,6 +198,15 @@ async fn main() -> anyhow::Result<()> {
 
     let args = Args::parse();
 
+    // Handle init subcommand
+    if let Some(Command::Init {
+        data_dir,
+        private_key,
+    }) = args.command
+    {
+        return init_node(&data_dir, &private_key);
+    }
+
     // Run the metrics exporter
     let bind_address = SocketAddr::from(([0, 0, 0, 0], args.metrics_port));
 
@@ -238,8 +287,8 @@ async fn main() -> anyhow::Result<()> {
     let listen_addr: Multiaddr = format!("/ip4/0.0.0.0/tcp/{}", args.port).parse()?;
     swarm.listen_on(listen_addr)?;
 
-    // Dial the specified address if provided
-    if let Some(dial_addr) = &args.dial {
+    // Dial the specified addresses if provided
+    for dial_addr in &args.dial {
         tracing::info!("Dialing {dial_addr}");
         swarm.dial(dial_addr.clone())?;
     }

test-infra/prometheus.yml

@@ -5,7 +5,7 @@ global:
 scrape_configs:
   - job_name: 'local-exporter'
     static_configs:
-      - targets: ['host.docker.internal:9464']
+      - targets: ['host.docker.internal:9464', 'host.docker.internal:9465', 'host.docker.internal:9466']
         labels:
           instance: 'local-exporter'
           environment: 'dev'