feat: read config from yaml file

Author: MarcosNicolau

aggregation-mode/Cargo.lock

@@ -9,9 +9,10 @@ sp1-sdk = "4.1.3"
 sp1_aggregator = { path = "./zkvm/sp1/" }
 serde = { version = "1.0.203", features = ["derive"] }
 serde_json = "1.0.117"
+serde_yaml = "0.9"
 tracing = { version = "0.1", features = ["log"] }
 tracing-subscriber = { version = "0.3.0", features = ["env-filter"] }
-alloy = { version = "0.11", features = [] }
+alloy = { version = "0.11", features = ["default", "signer-keystore"] }
 bincode = "1.3.3"
 tokio = { version = "1", features = ["time"]}
 sha3 = "0.10.8"

aggregation-mode/Cargo.toml

@@ -0,0 +1,28 @@
+use serde::Deserialize;
+use std::{fs::File, io::Read};
+
+#[derive(Debug, Deserialize)]
+pub struct ECDSAConfig {
+    pub private_key_store_path: String,
+    pub private_key_store_password: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Config {
+    pub eth_rpc_url: String,
+    pub private_key: String,
+    pub submit_proofs_every_secs: u64,
+    pub max_proofs_in_queue: u16,
+    pub proof_aggregation_service_address: String,
+    pub ecdsa: ECDSAConfig,
+}
+
+impl Config {
+    pub fn from_file(file_path: &str) -> Result<Config, Box<dyn std::error::Error>> {
+        let mut file = File::open(file_path)?;
+        let mut contents = String::new();
+        file.read_to_string(&mut contents)?;
+        let config: Config = serde_yaml::from_str(&contents)?;
+        Ok(config)
+    }
+}

aggregation-mode/src/backend/config.rs

@@ -1,26 +1,26 @@
-use std::{str::FromStr, time::Duration};
+pub mod config;
+mod merkle_tree;
+mod types;
 
+use crate::zk::{
+    aggregator::{self, AggregatedProof, ProgramInput, ProofAggregationError},
+    backends::sp1::SP1AggregationInput,
+    Proof, VerificationError, ZKVMEngine,
+};
 use alloy::{
     network::EthereumWallet,
     primitives::Address,
     providers::{PendingTransactionError, ProviderBuilder},
     rpc::types::TransactionReceipt,
-    signers::local::PrivateKeySigner,
+    signers::local::LocalSigner,
 };
+use config::Config;
 use merkle_tree::compute_proofs_merkle_root;
 use sp1_sdk::HashableKey;
+use std::{str::FromStr, time::Duration};
 use tracing::{error, info, warn};
 use types::{AlignedProofAggregationService, AlignedProofAggregationServiceContract};
 
-use crate::zk::{
-    aggregator::{self, AggregatedProof, ProgramInput, ProofAggregationError},
-    backends::sp1::SP1AggregationInput,
-    Proof, VerificationError, ZKVMEngine,
-};
-
-mod merkle_tree;
-mod types;
-
 #[derive(Debug)]
 pub enum ProofQueueError {
     QueueMaxCapacity,
@@ -43,18 +43,14 @@ pub struct ProofAggregator {
     proof_aggregation_service: AlignedProofAggregationServiceContract,
 }
 
-pub struct Config {
-    pub rpc_url: String,
-    pub private_key: String,
-    pub submit_proofs_every_secs: u64,
-    pub max_proofs_in_queue: u16,
-    pub proof_aggregation_service_address: String,
-}
-
 impl ProofAggregator {
     pub fn new(config: Config) -> Self {
-        let rpc_url = config.rpc_url.parse().expect("correct url");
-        let signer = PrivateKeySigner::from_str(&config.private_key).expect("valid string");
+        let rpc_url = config.eth_rpc_url.parse().expect("correct url");
+        let signer = LocalSigner::decrypt_keystore(
+            config.ecdsa.private_key_store_path,
+            config.ecdsa.private_key_store_password,
+        )
+        .expect("Correct keystore signer");
         let wallet = EthereumWallet::from(signer);
         let provider = ProviderBuilder::new().wallet(wallet).on_http(rpc_url);
         let proof_aggregation_service = AlignedProofAggregationService::new(

aggregation-mode/src/backend/mod.rs

@@ -1,7 +1,7 @@
-use std::fs;
+use std::{env, fs};
 
 use proof_aggregator::{
-    backend::{Config, ProofAggregator},
+    backend::{config::Config, ProofAggregator},
     zk::{
         backends::sp1::{vk_from_elf, SP1Proof},
         Proof,
@@ -10,29 +10,35 @@ use proof_aggregator::{
 use sp1_sdk::SP1ProofWithPublicValues;
 use tracing_subscriber::FmtSubscriber;
 
+fn read_config_filepath_from_args() -> String {
+    let args: Vec<String> = env::args().collect();
+    if args.len() < 2 {
+        panic!(
+            "You mus provide a config file. Usage: {} <config-file-path>",
+            args[0]
+        );
+    }
+
+    args[1].clone()
+}
+
 #[tokio::main]
 async fn main() {
     let subscriber = FmtSubscriber::builder().finish();
     tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
 
-    let proofs_to_push = 2;
-
-    // TODO read proof aggregator yaml config file
-    let config = Config {
-        proof_aggregation_service_address: "0xcbEAF3BDe82155F56486Fb5a1072cb8baAf547cc".into(),
-        private_key: "0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6".into(),
-        rpc_url: "http://localhost:8545".into(),
-        max_proofs_in_queue: proofs_to_push,
-        submit_proofs_every_secs: 2,
-    };
+    // init proof aggregator
+    let config_file_path = read_config_filepath_from_args();
+    let config = Config::from_file(&config_file_path).expect("Config is valid");
     let mut proof_aggregator = ProofAggregator::new(config);
 
-    for _ in 0..proofs_to_push {
+    // push some proofs from fs
+    for _ in 0..2 {
         let sp1_proof =
-            SP1ProofWithPublicValues::load("../scripts/test_files/sp1/sp1_fibonacci_4_1_3.proof")
+            SP1ProofWithPublicValues::load("scripts/test_files/sp1/sp1_fibonacci_4_1_3.proof")
                 .expect("loading proof failed");
         let proof_elf =
-            fs::read("../scripts/test_files/sp1/sp1_fibonacci_4_1_3.elf").expect("elf bytes");
+            fs::read("scripts/test_files/sp1/sp1_fibonacci_4_1_3.elf").expect("elf bytes");
         let proof = Proof::SP1(SP1Proof {
             proof: sp1_proof,
             vk: vk_from_elf(&proof_elf),
@@ -43,5 +49,6 @@ async fn main() {
             .expect("Proof to be valid");
     }
 
+    // start service
     proof_aggregator.start().await;
 }