Merge pull request #77 from inicio-labs/issue-38/bor-node-wiring

feat(bor-node): wire BorNode with all components and CLI binary

Author: VAIBHAVJINDAL3012

Cargo.lock

@@ -6,3 +6,7 @@ edition.workspace = true
 [[bin]]
 name = "boreth"
 path = "src/main.rs"
+
+[dependencies]
+bor-node = { workspace = true }
+eyre = { workspace = true }

bin/boreth/Cargo.toml

@@ -1,3 +1,27 @@
-fn main() {
-    println!("boreth");
+use bor_node::{BorNode, BorNodeConfig};
+
+fn main() -> eyre::Result<()> {
+    let args: Vec<String> = std::env::args().collect();
+
+    let network = if args.iter().any(|a| a == "--amoy") {
+        "amoy"
+    } else {
+        "mainnet"
+    };
+
+    let config = match network {
+        "amoy" => BorNodeConfig::amoy(),
+        _ => BorNodeConfig::mainnet(),
+    };
+
+    println!("boreth v{}", env!("CARGO_PKG_VERSION"));
+    println!("Network: {:?}", config.network);
+    println!("Chain ID: {}", config.chain_id());
+    println!("Heimdall: {}", config.heimdall_url);
+    println!("Data dir: {}", config.data_dir);
+
+    let node = BorNode::new(config)?;
+    println!("Node initialized (chain_id={})", node.chain_id());
+
+    Ok(())
 }

bin/boreth/src/main.rs

@@ -4,3 +4,16 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
+bor-chainspec = { workspace = true }
+bor-consensus = { workspace = true }
+bor-evm = { workspace = true }
+bor-payload = { workspace = true }
+bor-primitives = { workspace = true }
+bor-rpc = { workspace = true }
+bor-storage = { workspace = true }
+heimdall-client = { workspace = true }
+alloy-primitives = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+eyre = { workspace = true }
+url = { workspace = true }

crates/bor-node/Cargo.toml

@@ -0,0 +1,82 @@
+//! Bor node configuration.
+
+use url::Url;
+
+/// Configuration for the Bor node.
+#[derive(Debug, Clone)]
+pub struct BorNodeConfig {
+    /// The network to run on (mainnet or amoy).
+    pub network: BorNetwork,
+    /// Heimdall API endpoint URL.
+    pub heimdall_url: Url,
+    /// Data directory path.
+    pub data_dir: String,
+    /// RPC listen address.
+    pub rpc_addr: String,
+    /// RPC listen port.
+    pub rpc_port: u16,
+    /// P2P listen port.
+    pub p2p_port: u16,
+}
+
+/// Which Bor network to connect to.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BorNetwork {
+    /// Polygon PoS mainnet (chain ID 137).
+    Mainnet,
+    /// Polygon Amoy testnet (chain ID 80002).
+    Amoy,
+}
+
+impl BorNodeConfig {
+    /// Create a default config for mainnet.
+    pub fn mainnet() -> Self {
+        Self {
+            network: BorNetwork::Mainnet,
+            heimdall_url: Url::parse("https://heimdall-api.polygon.technology").unwrap(),
+            data_dir: "~/.boreth".to_string(),
+            rpc_addr: "127.0.0.1".to_string(),
+            rpc_port: 8545,
+            p2p_port: 30303,
+        }
+    }
+
+    /// Create a default config for Amoy testnet.
+    pub fn amoy() -> Self {
+        Self {
+            network: BorNetwork::Amoy,
+            heimdall_url: Url::parse("https://heimdall-api-amoy.polygon.technology").unwrap(),
+            data_dir: "~/.boreth-amoy".to_string(),
+            rpc_addr: "127.0.0.1".to_string(),
+            rpc_port: 8545,
+            p2p_port: 30303,
+        }
+    }
+
+    /// Get the chain ID for this network.
+    pub fn chain_id(&self) -> u64 {
+        match self.network {
+            BorNetwork::Mainnet => bor_chainspec::constants::MAINNET_CHAIN_ID,
+            BorNetwork::Amoy => bor_chainspec::constants::AMOY_CHAIN_ID,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_mainnet_config() {
+        let config = BorNodeConfig::mainnet();
+        assert_eq!(config.chain_id(), 137);
+        assert_eq!(config.network, BorNetwork::Mainnet);
+    }
+
+    #[test]
+    fn test_amoy_config() {
+        let config = BorNodeConfig::amoy();
+        assert_eq!(config.chain_id(), 80002);
+        assert_eq!(config.network, BorNetwork::Amoy);
+    }
+}

crates/bor-node/src/config.rs

@@ -1 +1,10 @@
 //! Bor node builder and configuration.
+//!
+//! Wires together all Bor components: consensus, EVM, payload builder,
+//! RPC, storage, and Heimdall client into a complete node.
+
+pub mod node;
+pub mod config;
+
+pub use node::BorNode;
+pub use config::BorNodeConfig;

crates/bor-node/src/lib.rs

@@ -0,0 +1,121 @@
+//! BorNode: wires all components together.
+
+use alloy_primitives::{Address, B256};
+use bor_chainspec::BorChainSpec;
+use bor_consensus::BorSnapshot;
+use bor_storage::persistence::{InMemorySpanStore, InMemorySnapshotStore, SpanStore, SnapshotStore};
+use crate::config::{BorNodeConfig, BorNetwork};
+use std::sync::{Arc, RwLock};
+
+/// The assembled Bor node with all components wired together.
+pub struct BorNode {
+    /// Node configuration.
+    pub config: BorNodeConfig,
+    /// Chain specification.
+    pub chain_spec: Arc<BorChainSpec>,
+    /// Span store.
+    pub span_store: Arc<RwLock<InMemorySpanStore>>,
+    /// Snapshot store.
+    pub snapshot_store: Arc<RwLock<InMemorySnapshotStore>>,
+}
+
+impl BorNode {
+    /// Create a new BorNode from configuration.
+    pub fn new(config: BorNodeConfig) -> eyre::Result<Self> {
+        let chain_spec = match config.network {
+            BorNetwork::Mainnet => Arc::new(bor_chainspec::bor_mainnet_genesis()),
+            BorNetwork::Amoy => Arc::new(bor_chainspec::bor_amoy_genesis()),
+        };
+
+        let span_store = Arc::new(RwLock::new(InMemorySpanStore::new()));
+        let snapshot_store = Arc::new(RwLock::new(InMemorySnapshotStore::new()));
+
+        Ok(Self {
+            config,
+            chain_spec,
+            span_store,
+            snapshot_store,
+        })
+    }
+
+    /// Get the chain ID.
+    pub fn chain_id(&self) -> u64 {
+        self.config.chain_id()
+    }
+
+    /// Store a snapshot.
+    pub fn put_snapshot(&self, block_hash: B256, snapshot: &BorSnapshot) -> eyre::Result<()> {
+        let data = snapshot.encode();
+        let mut store = self.snapshot_store.write().map_err(|e| eyre::eyre!("{e}"))?;
+        store.put_snapshot(block_hash.0, data);
+        Ok(())
+    }
+
+    /// Get a snapshot by block hash.
+    pub fn get_snapshot(&self, block_hash: &B256) -> eyre::Result<Option<BorSnapshot>> {
+        let store = self.snapshot_store.read().map_err(|e| eyre::eyre!("{e}"))?;
+        match store.get_snapshot(&block_hash.0) {
+            Some(data) => {
+                let snap = BorSnapshot::decode(&data)?;
+                Ok(Some(snap))
+            }
+            None => Ok(None),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bor_primitives::{Validator, ValidatorSet};
+
+    fn test_validator_set() -> ValidatorSet {
+        ValidatorSet {
+            validators: vec![Validator {
+                id: 1,
+                address: Address::new([0xaa; 20]),
+                voting_power: 100,
+                signer: Address::new([0xaa; 20]),
+                proposer_priority: 0,
+            }],
+            proposer: None,
+        }
+    }
+
+    #[test]
+    fn test_node_builder_compiles() {
+        let config = BorNodeConfig::amoy();
+        let node = BorNode::new(config).unwrap();
+        assert_eq!(node.chain_id(), 80002);
+    }
+
+    #[test]
+    fn test_node_mainnet() {
+        let config = BorNodeConfig::mainnet();
+        let node = BorNode::new(config).unwrap();
+        assert_eq!(node.chain_id(), 137);
+    }
+
+    #[test]
+    fn test_snapshot_roundtrip() {
+        let config = BorNodeConfig::amoy();
+        let node = BorNode::new(config).unwrap();
+
+        let hash = B256::from([0xab; 32]);
+        let snapshot = BorSnapshot::new(100, hash, test_validator_set());
+
+        node.put_snapshot(hash, &snapshot).unwrap();
+
+        let retrieved = node.get_snapshot(&hash).unwrap().unwrap();
+        assert_eq!(retrieved.number, 100);
+        assert_eq!(retrieved.validator_set.validators.len(), 1);
+    }
+
+    #[test]
+    fn test_snapshot_not_found() {
+        let config = BorNodeConfig::amoy();
+        let node = BorNode::new(config).unwrap();
+        let result = node.get_snapshot(&B256::ZERO).unwrap();
+        assert!(result.is_none());
+    }
+}