feat: add cmd to init default config (#1382)

Author: karlem

Cargo.lock

@@ -28,6 +28,7 @@ prometheus_exporter = { workspace = true }
 prost = { workspace = true }
 rand_chacha = { workspace = true }
 serde = { workspace = true }
+toml = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { workspace = true }
 tendermint = { workspace = true }
@@ -68,8 +69,8 @@ fendermint_vm_snapshot = { path = "../vm/snapshot" }
 fendermint_vm_topdown = { path = "../vm/topdown" }
 
 # .car file wrapped in a crate
-actors-builtin-car =  { path = "../actors-builtin-car"}
-actors-custom-car = { path = "../actors-custom-car"}
+actors-builtin-car = { path = "../actors-builtin-car" }
+actors-custom-car = { path = "../actors-custom-car" }
 
 
 fvm = { workspace = true }

fendermint/app/Cargo.toml

@@ -15,6 +15,8 @@ builtin_actors_bundle = "bundle.car"
 custom_actors_bundle = "custom_actors_bundle.car"
 # Where to reach CometBFT for queries or broadcasting transactions.
 tendermint_rpc_url = "http://127.0.0.1:26657"
+# Where to reach CometBFT for subscriptions.
+tendermint_websocket_url = "ws://127.0.0.1:26657/websocket"
 # Block height where we should gracefully stop the node to perform maintenance or
 # with planning for an upcoming coordinated upgrade. Set to 0 to never halt.
 halt_height = 0

fendermint/app/config/default.toml

@@ -1,7 +1,24 @@
 // Copyright 2022-2024 Protocol Labs
 // SPDX-License-Identifier: Apache-2.0, MIT
 
-use clap::Args;
+use clap::{Args, Subcommand};
 
 #[derive(Args, Debug)]
-pub struct ConfigArgs;
+pub struct DisplayConfigArgs;
+
+#[derive(Args, Debug)]
+pub struct InitConfigArgs;
+
+#[derive(Subcommand, Debug)]
+pub enum ConfigCommands {
+    /// Create a new default config file
+    Init(InitConfigArgs),
+    /// Display the current config
+    Display(DisplayConfigArgs),
+}
+
+#[derive(Args, Debug)]
+pub struct ConfigArgs {
+    #[command(subcommand)]
+    pub command: ConfigCommands,
+}

fendermint/app/options/src/config.rs

@@ -2,10 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 
 use fvm_shared::econ::TokenAmount;
-use ipc_provider::config::deserialize::{
-    deserialize_cors_headers, deserialize_cors_methods, deserialize_cors_origins,
+use ipc_provider::config::serialize::{
+    vec_to_allow_headers, vec_to_allow_methods, vec_to_allow_origin,
 };
-use serde::Deserialize;
+use serde::de::Error as DeError;
+use serde::{Deserialize, Deserializer, Serialize};
 use serde_with::{serde_as, DurationSeconds};
 use std::time::Duration;
 use tower_http::cors::{AllowHeaders, AllowMethods, AllowOrigin};
@@ -16,7 +17,7 @@ use crate::{IsHumanReadable, MetricsSettings, SocketAddress};
 
 /// Ethereum API facade settings.
 #[serde_as]
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct EthSettings {
     pub listen: SocketAddress,
     #[serde_as(as = "DurationSeconds<u64>")]
@@ -29,8 +30,36 @@ pub struct EthSettings {
     pub tracing: TracingSettings,
 }
 
+impl Default for EthSettings {
+    fn default() -> Self {
+        EthSettings {
+            filter_timeout: Duration::from_secs(300),
+            cache_capacity: 1000000,
+            max_nonce_gap: 10,
+            gas: GasOpt {
+                min_gas_premium: TokenAmount::from_atto(100000),
+                num_blocks_max_prio_fee: 10,
+                max_fee_hist_size: 1024,
+            },
+            listen: SocketAddress {
+                host: "127.0.0.1".into(),
+                port: 8545,
+            },
+            metrics: MetricsSettings {
+                enabled: true,
+                listen: SocketAddress {
+                    host: "127.0.0.1".into(),
+                    port: 9185,
+                },
+            },
+            cors: CorsOpt::default(),
+            tracing: TracingSettings::default(),
+        }
+    }
+}
+
 #[serde_as]
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct GasOpt {
     /// Minimum gas fee in atto.
     #[serde_as(as = "IsHumanReadable")]
@@ -40,12 +69,55 @@ pub struct GasOpt {
 }
 
 #[serde_as]
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Serialize, Default)]
 pub struct CorsOpt {
-    #[serde(deserialize_with = "deserialize_cors_origins")]
+    #[serde(default, rename = "allowed_origins")]
+    pub temp_origins: Vec<String>,
+    #[serde(default, rename = "allowed_methods")]
+    pub temp_methods: Vec<String>,
+    #[serde(default, rename = "allowed_headers")]
+    pub temp_headers: Vec<String>,
+
+    // Runtime representations, skipped during (de)serialization.
+    #[serde(skip)]
     pub allowed_origins: AllowOrigin,
-    #[serde(deserialize_with = "deserialize_cors_methods")]
+    #[serde(skip)]
     pub allowed_methods: AllowMethods,
-    #[serde(deserialize_with = "deserialize_cors_headers")]
+    #[serde(skip)]
     pub allowed_headers: AllowHeaders,
 }
+
+impl<'de> Deserialize<'de> for CorsOpt {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct Temp {
+            #[serde(default, rename = "allowed_origins")]
+            allowed_origins: Vec<String>,
+            #[serde(default, rename = "allowed_methods")]
+            allowed_methods: Vec<String>,
+            #[serde(default, rename = "allowed_headers")]
+            allowed_headers: Vec<String>,
+        }
+
+        let temp = Temp::deserialize(deserializer)?;
+
+        let allowed_origins =
+            vec_to_allow_origin(temp.allowed_origins.clone()).map_err(D::Error::custom)?;
+        let allowed_methods =
+            vec_to_allow_methods(temp.allowed_methods.clone()).map_err(D::Error::custom)?;
+        let allowed_headers =
+            vec_to_allow_headers(temp.allowed_headers.clone()).map_err(D::Error::custom)?;
+
+        Ok(CorsOpt {
+            temp_origins: temp.allowed_origins,
+            temp_methods: temp.allowed_methods,
+            temp_headers: temp.allowed_headers,
+            allowed_origins,
+            allowed_methods,
+            allowed_headers,
+        })
+    }
+}

fendermint/app/settings/src/eth.rs

@@ -2,26 +2,20 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 
 use fvm_shared::econ::TokenAmount;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use serde_with::serde_as;
 
 use crate::IsHumanReadable;
 
 #[serde_as]
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct FvmSettings {
     /// Overestimation rate applied to gas estimations to ensure that the
     /// message goes through
     pub gas_overestimation_rate: f64,
     /// Gas search step increase used to find the optimal gas limit.
     /// It determines how fine-grained we want the gas estimation to be.
     pub gas_search_step: f64,
-    /// Indicate whether transactions should be fully executed during the checks performed
-    /// when they are added to the mempool, or just the most basic ones are performed.
-    ///
-    /// Enabling this option is required to fully support "pending" queries in the Ethereum API,
-    /// otherwise only the nonces and balances are projected into a partial state.
-    pub exec_in_check: bool,
 
     /// Gas fee used when broadcasting transactions.
     #[serde_as(as = "IsHumanReadable")]
@@ -30,3 +24,14 @@ pub struct FvmSettings {
     #[serde_as(as = "IsHumanReadable")]
     pub gas_premium: TokenAmount,
 }
+
+impl Default for FvmSettings {
+    fn default() -> Self {
+        FvmSettings {
+            gas_overestimation_rate: 1.25,
+            gas_search_step: 1.25,
+            gas_fee_cap: TokenAmount::from_atto(0),
+            gas_premium: TokenAmount::from_atto(0),
+        }
+    }
+}