chore: resolve conflicts

Author: dvdplm

Cargo.lock

@@ -1,6 +1,6 @@
 [workspace]
 resolver = "2"
-default-members = ["crates/topos"]
+default-members = ["crates/topos", "crates/topos-node"]
 members = [
     "crates/*"
 ]

Cargo.toml

@@ -36,11 +36,7 @@ pub type Hash = String;
 /// Event collected from the sending subnet
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum SubnetEvent {
-    CrossSubnetMessageSent {
-        target_subnet_id: SubnetId,
-        source_subnet_id: SubnetId,
-        nonce: u64,
-    },
+    CrossSubnetMessageSent { target_subnet_id: SubnetId },
 }
 
 #[derive(Default, Debug, Clone, Serialize, Deserialize)]

crates/topos-certificate-producer-subnet-client/src/lib.rs

@@ -12,7 +12,7 @@ use tracing::info;
 
 abigen!(
     IToposCore,
-    "npm:@topos-protocol/topos-smart-contracts@latest/artifacts/contracts/interfaces/IToposCore.\
+    "npm:@topos-protocol/topos-smart-contracts@3.2.0/artifacts/contracts/interfaces/IToposCore.\
      sol/IToposCore.json"
 );
 
@@ -60,11 +60,9 @@ pub(crate) async fn get_block_events(
             );
             result.push(SubnetEvent::CrossSubnetMessageSent {
                 target_subnet_id: f.target_subnet_id.into(),
-                source_subnet_id: f.source_subnet_id.into(),
-                nonce: f.nonce.as_u64(),
             })
         } else {
-            // Ignored other events until we need them
+            // Ignored for now other events Upgraded, CertStored
         }
     }
 

crates/topos-certificate-producer-subnet-client/src/subnet_contract.rs

@@ -70,9 +70,9 @@ impl AppContext {
                                 "Unrecoverable failure in Certificate Producer <-> TCE interaction. Shutting down Certificate Producer."
                             );
                             if let Err(e) = self.shutdown().await {
-                                warn!("Error happened during shutdown: {e:?}");
+                                warn!("Failed to shutdown: {e:?}");
                             }
-                            warn!("Shutdown finished, restarting Certificate Producer...");
+                            info!("Shutdown finished, restarting Certificate Producer...");
                             return AppContextStatus::Restarting;
                         },
                         _ => self.on_tce_proxy_event(tce_evt).await,

crates/topos-certificate-producer/src/app_context.rs

@@ -80,7 +80,7 @@ async fn open_target_node_connection(
             Ok(value) => value,
             Err(e) => {
                 error!(
-                    "Unable to create TCE client for node {}, error details: {}",
+                    "Unable to create TCE client for node {}: {}",
                     &tce_address, e
                 );
                 return Err(Error::TCENodeConnection(e));
@@ -90,10 +90,7 @@ async fn open_target_node_connection(
         match tce_client.open_stream(Vec::new()).await {
             Ok(_) => {}
             Err(e) => {
-                error!(
-                    "Unable to connect to node {}, error details: {}",
-                    &tce_address, e
-                );
+                error!("Unable to connect to node {}: {}", &tce_address, e);
                 return Err(Error::TCENodeConnection(e));
             }
         }
@@ -150,7 +147,7 @@ async fn close_target_node_connections(
     {
         info!("Closing connection to target node {}", target_node.address);
         if let Err(e) = target_node.shutdown().await {
-            error!("Error shutting down connection {e}");
+            error!("Failed to close stream with {}: {e}", target_node.address);
         }
     }
 }
@@ -176,10 +173,7 @@ async fn send_new_certificate(tce_client: &mut TceClient, cert: Certificate) {
         .instrument(Span::current())
         .await
     {
-        error!(
-            "failed to pass certificate to tce client, error details: {}",
-            e
-        );
+        error!("Failed to send the Certificate to the TCE client: {}", e);
     }
 }
 

crates/topos-certificate-spammer/src/lib.rs

@@ -70,8 +70,8 @@ impl CommandConfig {
 
         let mut child = command
             .stderr(Stdio::piped())
-            .stdout(Stdio::inherit())
-            .stdin(Stdio::inherit())
+            .stdout(Stdio::piped())
+            .stdin(Stdio::piped())
             .spawn()?;
 
         if let Some(pid) = child.id() {

crates/topos-config/src/edge/command.rs

@@ -8,32 +8,34 @@ use topos_core::types::ValidatorId;
 use topos_p2p::{Multiaddr, PeerId};
 use tracing::info;
 
+use crate::node::NodeConfig;
+
 #[cfg(test)]
 pub(crate) mod tests;
 
 /// From the Edge format
 pub struct Genesis {
-    pub path: PathBuf,
     pub json: Value,
 }
 
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
     #[error("Failed to parse validators")]
     ParseValidators,
+
     #[error("Invalid genesis file on path {0}: {1}")]
     InvalidGenesisFile(String, String),
 }
 
 impl Genesis {
-    pub fn new(path: PathBuf) -> Result<Self, Error> {
+    pub fn new(path: &PathBuf) -> Result<Self, Error> {
         info!("Reading subnet genesis file {}", path.display());
-        let genesis_file = fs::File::open(&path)
+        let genesis_file = fs::File::open(path)
             .map_err(|e| Error::InvalidGenesisFile(path.display().to_string(), e.to_string()))?;
 
         let json: Value = serde_json::from_reader(genesis_file).expect("genesis json parsed");
 
-        Ok(Self { path, json })
+        Ok(Self { json })
     }
 
     // TODO: parse directly with serde
@@ -103,3 +105,11 @@ impl Genesis {
         )
     }
 }
+
+impl TryFrom<&NodeConfig> for Genesis {
+    type Error = Error;
+
+    fn try_from(config: &NodeConfig) -> Result<Self, Self::Error> {
+        Genesis::new(&config.edge_path)
+    }
+}

crates/topos-config/src/genesis/mod.rs

@@ -14,7 +14,7 @@ macro_rules! test_case {
 #[fixture]
 #[once]
 pub fn genesis() -> Genesis {
-    Genesis::new(test_case!("genesis-example.json").into())
+    Genesis::new(&test_case!("genesis-example.json").into())
         .expect("Expected valid test genesis file")
 }
 

crates/topos-config/src/genesis/tests.rs

@@ -1,11 +1,13 @@
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 use figment::{
     providers::{Format, Toml},
     Figment,
 };
 
 use serde::{Deserialize, Serialize};
+use topos_wallet::SecretManager;
+use tracing::{debug, error};
 
 use crate::{
     base::BaseConfig, certificate_producer::CertificateProducerConfig, edge::EdgeConfig,
@@ -26,28 +28,86 @@ pub struct NodeConfig {
     pub tce: Option<TceConfig>,
     pub certificate_producer: Option<CertificateProducerConfig>,
     pub edge: Option<EdgeConfig>,
+
+    #[serde(skip)]
+    pub home_path: PathBuf,
+
+    #[serde(skip)]
+    pub node_path: PathBuf,
+
+    #[serde(skip)]
+    pub edge_path: PathBuf,
 }
 
 impl NodeConfig {
-    pub fn new<S: Serialize>(home: &Path, config: Option<S>) -> Self {
-        let base = load_config::<BaseConfig, _>(home, config);
+    /// Try to create a new node config struct from the given home path and node name.
+    /// It expects a config file to be present in the node's folder.
+    ///
+    /// This `config.toml` can be generated using: `topos node init` command
+    pub fn try_from<S: Serialize>(
+        home_path: &Path,
+        node_name: &str,
+        config: Option<S>,
+    ) -> Result<Self, std::io::Error> {
+        let node_path = home_path.join("node").join(node_name);
+        let config_path = node_path.join("config.toml");
+
+        // TODO: Move this to `topos-node` when migrated
+        if !Path::new(&config_path).exists() {
+            error!(
+                "Please run 'topos node init --name {node_name}' to create a config file first \
+                 for {node_name}."
+            );
+            std::process::exit(1);
+        }
+
+        Ok(Self::build_config(node_path, home_path, config))
+    }
+
+    /// Create a new node config struct from the given home path and node name.
+    ///
+    /// It doesn't check the existence of the config file.
+    /// It's useful for creating a config file for a new node, relying on the default values.
+    pub fn create<S: Serialize>(home_path: &Path, node_name: &str, config: Option<S>) -> Self {
+        let node_path = home_path.join("node").join(node_name);
+
+        Self::build_config(node_path, home_path, config)
+    }
+
+    /// Common function to build a node config struct from the given home path and node name.
+    fn build_config<S: Serialize>(node_path: PathBuf, home_path: &Path, config: Option<S>) -> Self {
+        let node_folder = node_path.as_path();
+        let base = load_config::<BaseConfig, _>(node_folder, config);
+
+        // Load genesis pointed by the local config
+        let edge_path = home_path
+            .join("subnet")
+            .join(base.subnet.clone())
+            .join("genesis.json");
 
         let mut config = NodeConfig {
+            node_path: node_path.to_path_buf(),
+            edge_path,
+            home_path: home_path.to_path_buf(),
             base: base.clone(),
             certificate_producer: base
                 .need_certificate_producer()
-                .then(|| load_config::<CertificateProducerConfig, ()>(home, None)),
+                .then(|| load_config::<CertificateProducerConfig, ()>(node_folder, None)),
             tce: base
                 .need_tce()
-                .then(|| load_config::<TceConfig, ()>(home, None)),
+                .then(|| load_config::<TceConfig, ()>(node_folder, None)),
             edge: base
                 .need_edge()
-                .then(|| load_config::<EdgeConfig, ()>(home, None)),
+                .then(|| load_config::<EdgeConfig, ()>(node_folder, None)),
         };
 
         // Make the TCE DB path relative to the folder
         if let Some(config) = config.tce.as_mut() {
-            config.db_path = home.join(&config.db_path);
+            config.db_path = node_folder.join(&config.db_path);
+            debug!(
+                "Maked TCE DB path relative to the node folder -> {:?}",
+                config.db_path
+            );
         }
 
         config
@@ -71,3 +131,12 @@ impl Config for NodeConfig {
         "default".to_string()
     }
 }
+
+impl From<&NodeConfig> for SecretManager {
+    fn from(val: &NodeConfig) -> Self {
+        match val.base.secrets_config.as_ref() {
+            Some(secrets_config) => SecretManager::from_aws(secrets_config),
+            None => SecretManager::from_fs(val.node_path.clone()),
+        }
+    }
+}