Remove config source

crates/cli/src/commands/chart/mod.rs

@@ -1,7 +1,7 @@
 use crate::execute::Execute;
 use anyhow::{anyhow, Result};
 use clap::Args;
-use rain_orderbook_app_settings::{config_source::ConfigSource, Config};
+use rain_orderbook_app_settings::Config;
 use rain_orderbook_common::dotrain::RainDocument;
 use rain_orderbook_common::fuzz::FuzzRunner;
 use std::fs::read_to_string;
@@ -22,10 +22,7 @@ impl Execute for Chart {
     async fn execute(&self) -> Result<()> {
         let dotrain = read_to_string(self.dotrain_file.clone()).map_err(|e| anyhow!(e))?;
         let frontmatter = RainDocument::get_front_matter(&dotrain).unwrap();
-        let config_string = ConfigSource::try_from_string(frontmatter.to_string(), None)
-            .await?
-            .0;
-        let config: Config = config_string.try_into()?;
+        let config = Config::try_from_yaml(vec![frontmatter.to_string()], false)?;
         let fuzzer = FuzzRunner::new(&dotrain, config, None).await;
         let chart_data = fuzzer.make_chart_data().await?;
 

crates/cli/src/commands/order/add.rs

@@ -3,7 +3,6 @@ use crate::{
 };
 use anyhow::{anyhow, Result};
 use clap::{ArgAction, Args};
-use rain_orderbook_app_settings::Config;
 use rain_orderbook_common::add_order::AddOrderArgs;
 use rain_orderbook_common::frontmatter::parse_frontmatter;
 use rain_orderbook_common::transaction::TransactionArgs;
@@ -40,10 +39,10 @@ pub struct CliOrderAddArgs {
 impl CliOrderAddArgs {
     async fn to_add_order_args(&self) -> Result<AddOrderArgs> {
         let text = read_to_string(&self.dotrain_file).map_err(|e| anyhow!(e))?;
-        let config: Config = parse_frontmatter(text.clone()).await?.try_into()?;
+        let config = parse_frontmatter(text.clone(), true)?;
 
         if !self.skip_version_check {
-            if let Some(ver) = config.raindex_version {
+            if let Some(ver) = config.get_raindex_version() {
                 if ver.to_ascii_lowercase() != GH_COMMIT_SHA.to_ascii_lowercase() {
                     return Err(anyhow!(format!(
                         "mismatch raindex version: expected: {}, got: {}",
@@ -58,7 +57,7 @@ impl CliOrderAddArgs {
         }
 
         let config_deployment = config
-            .deployments
+            .get_deployments()
             .get(&self.deployment)
             .ok_or(anyhow!("specified deployment is undefined!"))?;
 
@@ -193,6 +192,9 @@ networks:
 subgraphs:
     some-sg: https://www.some-sg.com
 
+metaboards:
+    some-metaboard: https://www.some-metaboard.com
+
 deployers:
     some-deployer:
         network: some-network

crates/common/src/dotrain_order/mod.rs

@@ -15,7 +15,7 @@ use rain_orderbook_app_settings::yaml::cache::Cache;
 use rain_orderbook_app_settings::yaml::{
     default_document, dotrain::DotrainYaml, orderbook::OrderbookYaml, YamlError, YamlParsable,
 };
-use rain_orderbook_app_settings::ParseConfigSourceError;
+use rain_orderbook_app_settings::ParseConfigError;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 #[cfg(target_family = "wasm")]
@@ -37,7 +37,7 @@ impl PartialEq for DotrainOrder {
 #[derive(Error, Debug)]
 pub enum DotrainOrderError {
     #[error(transparent)]
-    ParseConfigSourceError(#[from] ParseConfigSourceError),
+    ParseConfigError(#[from] ParseConfigError),
 
     #[error("Scenario {0} not found")]
     ScenarioNotFound(String),

crates/common/src/frontmatter.rs

@@ -1,11 +1,9 @@
 use dotrain::RainDocument;
 pub use rain_metadata::types::authoring::v2::*;
-use rain_orderbook_app_settings::{config::ParseConfigSourceError, config_source::ConfigSource};
+use rain_orderbook_app_settings::{Config, ParseConfigError};
 
 /// Parse dotrain frontmatter and merges it with top Config if given
-pub async fn parse_frontmatter(dotrain: String) -> Result<ConfigSource, ParseConfigSourceError> {
+pub fn parse_frontmatter(dotrain: String, validate: bool) -> Result<Config, ParseConfigError> {
     let frontmatter = RainDocument::get_front_matter(dotrain.as_str()).unwrap_or("");
-    Ok(ConfigSource::try_from_string(frontmatter.to_string(), None)
-        .await?
-        .0)
+    Config::try_from_yaml(vec![frontmatter.to_string()], validate)
 }

crates/common/src/fuzz/impls.rs

@@ -91,7 +91,7 @@ impl FuzzRunner {
         // find the scenario by name in the settings
         let scenario = self
             .settings
-            .scenarios
+            .get_scenarios()
             .get(name)
             .ok_or(FuzzRunnerError::ScenarioNotFound(name.into()))
             .cloned()?;
@@ -229,7 +229,7 @@ impl FuzzRunner {
     }
 
     pub async fn make_chart_data(&self) -> Result<ChartData, FuzzRunnerError> {
-        let charts = self.settings.charts.clone();
+        let charts = self.settings.get_charts();
         let mut scenarios_data: HashMap<String, FuzzResultFlat> = HashMap::new();
 
         for (_, chart) in charts.clone() {
@@ -262,9 +262,38 @@ mod tests {
         primitives::utils::parse_ether,
         providers::{ext::AnvilApi, Provider},
     };
-    use rain_orderbook_app_settings::config_source::ConfigSource;
     use rain_orderbook_test_fixtures::LocalEvm;
 
+    const SETTINGS: &str = r#"
+subgraphs:
+    some-subgraph: https://www.some-subgraph.com
+metaboards:
+    some-metaboard: https://www.some-metaboard.com
+orderbooks:
+    some-orderbook:
+        address: 0x0000000000000000000000000000000000000000
+        network: some-key
+        subgraph: some-subgraph
+tokens:
+    token1:
+        network: some-key
+        address: 0x0000000000000000000000000000000000000001
+    token2:
+        network: some-key
+        address: 0x0000000000000000000000000000000000000002
+orders:
+    some-order:
+        deployer: some-key
+        inputs:
+            - token: token1
+        outputs:
+            - token: token2
+deployments:
+    some-deployment:
+        scenario: some-key
+        order: some-order
+"#;
+
     #[tokio::test(flavor = "multi_thread", worker_threads = 10)]
     async fn test_fuzz_runner() {
         let local_evm = LocalEvm::new().await;
@@ -295,11 +324,9 @@ b: fuzzed;
             deployer = local_evm.deployer.address()
         );
         let frontmatter = RainDocument::get_front_matter(&dotrain).unwrap();
-        let settings = serde_yaml::from_str::<ConfigSource>(frontmatter).unwrap();
-        let config = settings
-            .try_into()
-            .map_err(|e| println!("{:?}", e))
-            .unwrap();
+        let config =
+            Config::try_from_yaml(vec![frontmatter.to_string(), SETTINGS.to_string()], false)
+                .unwrap();
 
         let mut runner = FuzzRunner::new(&dotrain, config, None).await;
 
@@ -350,11 +377,9 @@ _: block-number();
             end_block = last_block_number
         );
         let frontmatter = RainDocument::get_front_matter(&dotrain).unwrap();
-        let settings = serde_yaml::from_str::<ConfigSource>(frontmatter).unwrap();
-        let config = settings
-            .try_into()
-            .map_err(|e| println!("{:?}", e))
-            .unwrap();
+        let config =
+            Config::try_from_yaml(vec![frontmatter.to_string(), SETTINGS.to_string()], false)
+                .unwrap();
 
         let mut runner = FuzzRunner::new(&dotrain, config, None).await;
 
@@ -413,11 +438,9 @@ d: 4;
             deployer = local_evm.deployer.address()
         );
         let frontmatter = RainDocument::get_front_matter(&dotrain).unwrap();
-        let settings = serde_yaml::from_str::<ConfigSource>(frontmatter).unwrap();
-        let config = settings
-            .try_into()
-            .map_err(|e| println!("{:?}", e))
-            .unwrap();
+        let config =
+            Config::try_from_yaml(vec![frontmatter.to_string(), SETTINGS.to_string()], false)
+                .unwrap();
 
         let mut runner = FuzzRunner::new(&dotrain, config, None).await;
 
@@ -472,12 +495,9 @@ _: context<4 4>();
             deployer = local_evm.deployer.address()
         );
         let frontmatter = RainDocument::get_front_matter(&dotrain).unwrap();
-        let settings = serde_yaml::from_str::<ConfigSource>(frontmatter).unwrap();
-        let config = settings
-            .try_into()
-            .map_err(|e| println!("{:?}", e))
-            .unwrap();
-
+        let config =
+            Config::try_from_yaml(vec![frontmatter.to_string(), SETTINGS.to_string()], false)
+                .unwrap();
         let mut runner = FuzzRunner::new(&dotrain, config, None).await;
 
         let res = runner
@@ -521,11 +541,9 @@ _: context<50 50>();
             deployer = local_evm.deployer.address()
         );
         let frontmatter = RainDocument::get_front_matter(&dotrain).unwrap();
-        let settings = serde_yaml::from_str::<ConfigSource>(frontmatter).unwrap();
-        let config = settings
-            .try_into()
-            .map_err(|e| println!("{:?}", e))
-            .unwrap();
+        let config =
+            Config::try_from_yaml(vec![frontmatter.to_string(), SETTINGS.to_string()], false)
+                .unwrap();
 
         let mut runner = FuzzRunner::new(&dotrain, config, None).await;
 
@@ -564,11 +582,9 @@ _: context<1 0>();
             deployer = local_evm.deployer.address()
         );
         let frontmatter = RainDocument::get_front_matter(&dotrain).unwrap();
-        let settings = serde_yaml::from_str::<ConfigSource>(frontmatter).unwrap();
-        let config = settings
-            .try_into()
-            .map_err(|e| println!("{:?}", e))
-            .unwrap();
+        let config =
+            Config::try_from_yaml(vec![frontmatter.to_string(), SETTINGS.to_string()], false)
+                .unwrap();
 
         let mut runner = FuzzRunner::new(&dotrain, config, None).await;
 

crates/common/src/js_api/mod.rs

@@ -6,7 +6,7 @@ use crate::{
 };
 use alloy::primitives::Bytes;
 use js_sys::Uint8Array;
-use rain_orderbook_app_settings::{Config, ParseConfigSourceError};
+use rain_orderbook_app_settings::ParseConfigError;
 use rain_orderbook_subgraph_client::types::common::SgOrder;
 use serde::{Deserialize, Serialize};
 use std::ops::Deref;
@@ -23,7 +23,7 @@ pub enum Error {
     #[error("undefined deployment")]
     UndefinedDeployment,
     #[error(transparent)]
-    ParseConfigSourceError(#[from] ParseConfigSourceError),
+    ParseConfigError(#[from] ParseConfigError),
     #[error(transparent)]
     AddOrderArgsError(#[from] AddOrderArgsError),
     #[error(transparent)]
@@ -39,11 +39,8 @@ impl From<Error> for JsValue {
 /// Get addOrder() calldata from a given dotrain text and deployment key from its frontmatter
 #[wasm_bindgen(js_name = "getAddOrderCalldata")]
 pub async fn get_add_order_calldata(dotrain: &str, deployment: &str) -> Result<Uint8Array, Error> {
-    let config: Config = parse_frontmatter(dotrain.to_string()).await?.try_into()?;
-    let deployment_ref = config
-        .deployments
-        .get(deployment)
-        .ok_or(Error::UndefinedDeployment)?;
+    let config = parse_frontmatter(dotrain.to_string(), true)?;
+    let deployment_ref = config.get_deployment(deployment)?;
     let add_order_args =
         AddOrderArgs::new_from_deployment(dotrain.to_string(), deployment_ref.deref().clone())
             .await?;

crates/common/src/unit_tests/mod.rs

@@ -322,7 +322,7 @@ impl TestRunner {
         self.test_setup.deployer = self
             .settings
             .main_config
-            .deployers
+            .get_deployers()
             .get(&self.settings.test_config.scenario_name)
             .ok_or(TestRunnerError::ScenarioNotFound(
                 self.settings.test_config.scenario_name.clone(),
@@ -369,28 +369,48 @@ impl TestRunner {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use rain_orderbook_app_settings::{
-        config_source::ConfigSource, unit_test::UnitTestConfigSource,
-    };
+    use rain_orderbook_app_settings::unit_test::UnitTestConfigSource;
     use rain_orderbook_test_fixtures::LocalEvm;
 
+    const SETTINGS: &str = r#"
+subgraphs:
+    some-subgraph: https://www.some-subgraph.com
+metaboards:
+    some-metaboard: https://www.some-metaboard.com
+orderbooks:
+    some-orderbook:
+        address: 0x0000000000000000000000000000000000000000
+        network: some-key
+        subgraph: some-subgraph
+tokens:
+    token1:
+        network: some-key
+        address: 0x0000000000000000000000000000000000000001
+    token2:
+        network: some-key
+        address: 0x0000000000000000000000000000000000000002
+orders:
+    some-order:
+        deployer: some-key
+        inputs:
+            - token: token1
+        outputs:
+            - token: token2
+deployments:
+    some-deployment:
+        scenario: some-key
+        order: some-order
+"#;
+
     fn get_main_config(dotrain: &str) -> Config {
         let frontmatter = RainDocument::get_front_matter(dotrain).unwrap();
-        let settings = serde_yaml::from_str::<ConfigSource>(frontmatter).unwrap();
-        settings
-            .try_into()
-            .map_err(|e| println!("{:?}", e))
-            .unwrap()
+        Config::try_from_yaml(vec![frontmatter.to_string(), SETTINGS.to_string()], false).unwrap()
     }
 
     fn get_test_config(test_dotrain: &str) -> TestConfig {
         let frontmatter = RainDocument::get_front_matter(test_dotrain).unwrap();
         let source = serde_yaml::from_str::<UnitTestConfigSource>(frontmatter).unwrap();
-        source
-            .test
-            .try_into_test_config()
-            .map_err(|e| println!("{:?}", e))
-            .unwrap()
+        source.test.try_into_test_config()
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 10)]