feat: load config from env

Author: MarcosNicolau

examples/circom/.env.devnet

@@ -0,0 +1,5 @@
+ETH_RPC_URL=http://localhost:8545
+PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
+# Deploy the contract with make deploy_contract_devnet
+FIBONACCI_CONTRACT_ADDRESS=<FIBONACCI_CONTRACT_ADDRESS>
+NETWORK=devnet

examples/circom/Cargo.toml

@@ -9,3 +9,12 @@ serde_json = "1.0.117"
 aligned-sdk = { path = "../../crates/sdk" }
 tokio = "1.44"
 alloy = { version = "0.14", features = ["full", "signer-keystore", "providers"] }
+dotenv = "0.15.0"
+
+[[bin]]
+name = "main"
+path = "./src/main.rs"
+
+[[bin]]
+name = "get_vk_commitment"
+path = "./src/get_vk_commitment.rs"

examples/circom/src/aligned.rs

@@ -1,3 +1,5 @@
+use std::str::FromStr;
+
 use aligned_sdk::{
     common::types::{AlignedVerificationData, Signer, VerificationData, Wallet},
     verification_layer::{estimate_fee, get_chain_id},
@@ -14,12 +16,9 @@ pub async fn submit_proof_to_aligned(
     let chain_id = get_chain_id(&config.eth_rpc_url)
         .await
         .expect("To query chain id from rpc");
-    let wallet = Wallet::decrypt_keystore(
-        &config.private_key_store_path,
-        &config.private_key_store_password,
-    )
-    .expect("Keystore to be `cast wallet` compliant")
-    .with_chain_id(chain_id);
+    let wallet = Wallet::from_str(&config.private_key)
+        .expect("Keystore to be `cast wallet` compliant")
+        .with_chain_id(chain_id);
 
     let verification_data = VerificationData {
         proof_generator_addr: wallet.address(),

examples/circom/src/config.rs

@@ -1,10 +1,45 @@
+use std::env;
+
 use aligned_sdk::common::types::Network;
 
 #[derive(Clone)]
 pub struct EnvConfig {
     pub eth_rpc_url: String,
-    pub private_key_store_path: String,
-    pub private_key_store_password: String,
+    pub private_key: String,
     pub fibonacci_contract_address: String,
     pub network: Network,
 }
+
+impl EnvConfig {
+    pub fn new(env_file: Option<String>) -> Self {
+        if let Some(env_file) = env_file {
+            dotenv::from_filename(env_file).expect("env file to exist");
+        } else {
+            dotenv::dotenv().ok();
+        }
+
+        let eth_rpc_url = env::var("ETH_RPC_URL").expect("ETH_RPC_URL not set");
+        let private_key = env::var("PRIVATE_KEY").expect("PRIVATE_KEY not set");
+        let fibonacci_contract_address =
+            env::var("FIBONACCI_CONTRACT_ADDRESS").expect("FIBONACCI_CONTRACT_ADDRESS not set");
+
+        let network = match env::var("NETWORK")
+            .expect("NETWORK not set")
+            .to_lowercase()
+            .as_str()
+        {
+            "devnet" => Network::Devnet,
+            "holesky-stage" => Network::HoleskyStage,
+            "holesky" => Network::Holesky,
+            "mainnet" => Network::Mainnet,
+            _ => panic!("Unsupported NETWORK value"),
+        };
+
+        EnvConfig {
+            eth_rpc_url,
+            private_key,
+            fibonacci_contract_address,
+            network,
+        }
+    }
+}

examples/circom/src/eth.rs

@@ -23,11 +23,8 @@ pub async fn update_number_on_contract(
     aligned_verification_data: AlignedVerificationData,
 ) -> String {
     let rpc_url = config.eth_rpc_url.parse().expect("RPC URL should be valid");
-    let signer = LocalSigner::decrypt_keystore(
-        &config.private_key_store_path,
-        &config.private_key_store_password,
-    )
-    .expect("Keystore signer should be `cast wallet` compliant");
+    let signer = LocalSigner::from_str(&config.private_key)
+        .expect("Keystore signer should be `cast wallet` compliant");
     let wallet = EthereumWallet::from(signer);
 
     let rpc_provider = ProviderBuilder::new()

examples/circom/src/main.rs

@@ -1,43 +1,61 @@
-use std::process::Command;
+use std::{env, process::Command};
 
 use circom_example::{aligned, config::EnvConfig, eth};
 
 #[tokio::main]
 async fn main() {
-    // Adjust the path to your script if it's not in the same directory
+    println!("===============================");
+    println!("Starting proof generation...");
+    println!("===============================");
+
+    // Run proof generation script
     let status = Command::new("bash")
         .arg("./circuits/generate_proof.sh")
         .status()
         .expect("failed to execute process");
 
     if status.success() {
-        println!("Script executed successfully!");
+        println!("Proof generation script executed successfully");
     } else {
         println!("Script failed with status: {:?}", status.code());
+        return;
     }
 
-    let config: EnvConfig = EnvConfig {
-        eth_rpc_url: "http://localhost:8545".to_string(),
-        private_key_store_path: "devnet_keystore.json".to_string(),
-        private_key_store_password: "".to_string(),
-        fibonacci_contract_address: "".to_string(),
-        network: aligned_sdk::common::types::Network::Devnet,
+    // Handle custom .env file
+    let args: Vec<String> = env::args().collect();
+    let custom_env = if args.len() > 1 {
+        let env_file = args[1].to_string();
+        println!("Using custom .env file: {env_file}");
+        Some(env_file)
+    } else {
+        println!("Using default .env file (if present)");
+        None
     };
-    let proof = std::fs::read("circuits/proof.json").expect("proof to be created");
-    let vk =
-        std::fs::read("circuits/verification_key.json").expect("verification key to be created");
+
+    let config: EnvConfig = EnvConfig::new(custom_env);
+
+    // Load circuit artifacts
+    println!("-------------------------------");
+    println!("Loading circuit artifacts...");
+    println!("-------------------------------");
+
+    let proof = std::fs::read("circuits/proof.json").expect("proof.json should exist");
+    let vk = std::fs::read("circuits/verification_key.json")
+        .expect("verification_key.json should exist");
     let public_inputs_file =
-        std::fs::read("circuits/public.json").expect("public inputs to be created");
+        std::fs::read("circuits/public.json").expect("public.json should exist");
     let pub_inputs: Vec<String> =
-        serde_json::from_slice(&public_inputs_file).expect("parse inputs json");
+        serde_json::from_slice(&public_inputs_file).expect("could not parse inputs json");
     let decoded_inputs = aligned_sdk::common::utils::encode_circom_pub_inputs(&pub_inputs)
-        .expect("Inputs to be decoded");
+        .expect("inputs should be decoded");
 
+    println!("Submitting proof to Aligned...");
     let aligned_verification_data =
         aligned::submit_proof_to_aligned(config.clone(), proof, vk, decoded_inputs.clone()).await;
 
+    println!("Updating on-chain contract with proof result...");
     let receipt =
         eth::update_number_on_contract(config, decoded_inputs, aligned_verification_data).await;
 
-    println!("RECEIPT HASH {}", receipt);
+    println!("Done. Transaction receipt hash: {}", receipt);
 }