start anvil

Author: musitdev

Cargo.lock

@@ -1,16 +1,15 @@
+use crate::M1DaLightNodeSetupOperations;
+use celestia_types::nmt::Namespace;
 use commander::run_command;
 use dot_movement::DotMovement;
+use rand::Rng;
 use tokio::fs;
 use tracing::info;
-use celestia_types::nmt::Namespace;
-use crate::M1DaLightNodeSetupOperations;
-use rand::Rng;
 
 #[derive(Debug, Clone)]
 pub struct Local;
 
 impl Local {
-    
     pub fn new() -> Self {
         Self
     }

protocol-units/da/m1/setup/src/local.rs

@@ -27,6 +27,7 @@ alloy-transport-ws = { workspace = true }
 anyhow = { workspace = true }
 async-stream = { workspace = true }
 async-trait = { workspace = true }
+serde_json = { workspace = true }
 movement-types = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }
@@ -37,7 +38,6 @@ tracing-subscriber = { workspace = true }
 [dev-dependencies]
 alloy-rpc-types = { workspace = true }
 futures = { workspace = true }
-serde_json = { workspace = true }
 
 [features]
 default = ["eth"]

protocol-units/settlement/mcr/client/Cargo.toml

@@ -1,2 +1,3 @@
 pub mod mcr;
 // pub mod staking;
+pub mod utils;

protocol-units/settlement/mcr/client/src/eth/mod.rs

@@ -3,10 +3,6 @@ use crate::send_eth_tx::SendTxErrorRule;
 use crate::send_eth_tx::UnderPriced;
 use crate::send_eth_tx::VerifyRule;
 use crate::{CommitmentStream, McrSettlementClientOperations};
-use mcr_settlement_config::Config;
-use movement_types::BlockCommitment;
-use movement_types::{Commitment, Id};
-
 use alloy::pubsub::PubSubFrontend;
 use alloy_network::Ethereum;
 use alloy_network::EthereumSigner;
@@ -24,13 +20,17 @@ use alloy_signer_wallet::LocalWallet;
 use alloy_sol_types::sol;
 use alloy_transport::BoxTransport;
 use alloy_transport_ws::WsConnect;
-
 use anyhow::Context;
+use mcr_settlement_config::Config;
+use movement_types::BlockCommitment;
+use movement_types::{Commitment, Id};
+use serde_json::Value as JsonValue;
+use std::array::TryFromSliceError;
+use std::fs;
+use std::path::Path;
 use thiserror::Error;
 use tokio_stream::StreamExt;
 
-use std::array::TryFromSliceError;
-
 #[derive(Error, Debug)]
 pub enum McrEthConnectorError {
 	#[error(
@@ -252,6 +252,45 @@ where
 	}
 }
 
+pub struct AnvilAddressEntry {
+	pub address: String,
+	pub private_key: String,
+}
+
+/// Read the Anvil config file keys and return all address/private key.
+pub fn read_anvil_json_file_addresses<P: AsRef<Path>>(
+	anvil_conf_path: P,
+) -> Result<Vec<AnvilAddressEntry>, anyhow::Error> {
+	let file_content = fs::read_to_string(anvil_conf_path)?;
+
+	let json_value: JsonValue = serde_json::from_str(&file_content)?;
+
+	// Extract the available_accounts and private_keys fields
+	let available_accounts_iter = json_value["available_accounts"]
+		.as_array()
+		.expect("available_accounts should be an array")
+		.iter()
+		.map(|v| {
+			let s = v.as_str().expect("available_accounts elements should be strings");
+			s.to_owned()
+		});
+
+	let private_keys_iter = json_value["private_keys"]
+		.as_array()
+		.expect("private_keys should be an array")
+		.iter()
+		.map(|v| {
+			let s = v.as_str().expect("private_keys elements should be strings");
+			s.to_owned()
+		});
+
+	let res = available_accounts_iter
+		.zip(private_keys_iter)
+		.map(|(address, private_key)| AnvilAddressEntry { address, private_key })
+		.collect::<Vec<_>>();
+	Ok(res)
+}
+
 #[cfg(test)]
 #[cfg(feature = "integration-tests")]
 mod tests {
@@ -265,8 +304,6 @@ mod tests {
 	use movement_types::Commitment;
 
 	use anyhow::Context;
-	use serde_json::Value as JsonValue;
-
 	use std::env;
 	use std::fs;
 
@@ -290,7 +327,10 @@ mod tests {
 		let rpc_url = format!("http://localhost:{rpc_port}");
 		let ws_url = format!("ws://localhost:{rpc_port}");
 
-		let anvil_addresses = read_anvil_json_file_addresses()?;
+		let anvil_conf_file = env::var("ANVIL_JSON_PATH").context(
+			"ANVIL_JSON_PATH env var is not defined. It should point to the anvil json file",
+		)?;
+		let anvil_addresses = crate::eth::utils::read_anvil_json_file_addresses(&anvil_conf_file)?;
 
 		//Do SC ceremony init stake calls.
 		do_genesis_ceremonial(&anvil_addresses, &rpc_url).await?;
@@ -400,45 +440,6 @@ mod tests {
 		Ok(())
 	}
 
-	struct AnvilAddressEntry {
-		address: String,
-		private_key: String,
-	}
-
-	fn read_anvil_json_file_addresses() -> Result<Vec<AnvilAddressEntry>, anyhow::Error> {
-		let anvil_conf_file = env::var("ANVIL_JSON_PATH").context(
-			"ANVIL_JSON_PATH env var is not defined. It should point to the anvil json file",
-		)?;
-		let file_content = fs::read_to_string(anvil_conf_file)?;
-
-		let json_value: JsonValue = serde_json::from_str(&file_content)?;
-
-		// Extract the available_accounts and private_keys fields
-		let available_accounts_iter = json_value["available_accounts"]
-			.as_array()
-			.expect("available_accounts should be an array")
-			.iter()
-			.map(|v| {
-				let s = v.as_str().expect("available_accounts elements should be strings");
-				s.to_owned()
-			});
-
-		let private_keys_iter = json_value["private_keys"]
-			.as_array()
-			.expect("private_keys should be an array")
-			.iter()
-			.map(|v| {
-				let s = v.as_str().expect("private_keys elements should be strings");
-				s.to_owned()
-			});
-
-		let res = available_accounts_iter
-			.zip(private_keys_iter)
-			.map(|(address, private_key)| AnvilAddressEntry { address, private_key })
-			.collect::<Vec<_>>();
-		Ok(res)
-	}
-
 	fn read_mcr_sc_adress() -> Result<Address, anyhow::Error> {
 		let file_path = env::var("MCR_SC_ADDRESS_FILE")?;
 		let addr_str = fs::read_to_string(file_path)?;

protocol-units/settlement/mcr/client/src/eth_client.rs

@@ -11,7 +11,7 @@ publish.workspace = true
 rust-version.workspace = true
 
 [dependencies]
-serde = { workspace = true }
+serde = { workspace = true , features = ["derive"] }
 
 [dev-dependencies]
 anyhow = { workspace = true }

protocol-units/settlement/mcr/config/Cargo.toml

@@ -12,12 +12,16 @@ rust-version.workspace = true
 
 [dependencies]
 mcr-settlement-config = { workspace = true }
+mcr-settlement-client = { workspace = true }
 dot-movement = { workspace = true }
+commander = { workspace = true }
 
 alloy-primitives = { workspace = true }
 
 anyhow = { workspace = true }
 k256 = { workspace = true }
+rand = { workspace = true }
+tokio = { workspace = true }
 tracing = { workspace = true }
 
 [lints]

protocol-units/settlement/mcr/setup/Cargo.toml

@@ -1,14 +1,13 @@
 use super::Setup;
-
-use dot_movement::DotMovement;
-use mcr_settlement_config::Config;
-
 use alloy_primitives::hex;
-
+use commander::run_command;
+use dot_movement::DotMovement;
 use k256::ecdsa::SigningKey;
-use tracing::info;
-
+use mcr_settlement_config::Config;
+use rand::{thread_rng, Rng};
+use std::env;
 use std::future::Future;
+use tracing::info;
 
 const DEFAULT_ETH_RPC_PORT: u16 = 8545;
 const DEFAULT_ETH_WS_PORT: u16 = 8545;
@@ -40,18 +39,103 @@ impl Setup for Local {
 		_dot_movement: &DotMovement,
 		mut config: Config,
 	) -> impl Future<Output = Result<Config, anyhow::Error>> + Send {
-		async move {
-			// Can't use rand 0.7 while k256 is on rand 0.6
-			let mut rng = k256::elliptic_curve::rand_core::OsRng;
+		//define a temporary chain Id for Anvil
+		let mut rng = thread_rng(); // rng is not send.
+		let id: u16 = rng.gen_range(100, 32768);
+		let chain_id = id.to_string();
 
-			info!("setting up MCR Ethereum client");
+		tracing::info!("Init Settlement local conf");
 
+		async move {
 			if config.rpc_url.is_none() {
 				config.rpc_url = Some(format!("http://localhost:{}", self.eth_rpc_port));
 			}
 			if config.ws_url.is_none() {
 				config.ws_url = Some(format!("http://localhost:{}", self.eth_ws_port));
 			}
+
+			tracing::info!("Run Settlement local conf");
+			//start local process and deploy smart contract.
+
+			//define working directory of Anvil
+			let mut path = std::env::current_dir()?;
+			let storage_path = env::var("MOVEMENT_BASE_STORAGE_PATH").unwrap_or_else(|_| {
+				tracing::info!(
+					"MOVEMENT_BASE_STORAGE_PATH not set. Use the default value: .movement",
+				);
+				".movement".to_string()
+			});
+			path.push(storage_path);
+			path.push("anvil/mcr");
+			path.push(chain_id.clone());
+			tokio::fs::create_dir_all(&path).await?;
+			tracing::info!("dir exist:{}", path.exists());
+			path.push("anvil.json");
+
+			let anvil_path = path.to_string_lossy().to_string();
+			tracing::info!("anvil_path: {:?}", anvil_path);
+
+			tokio::spawn({
+				let anvil_path = anvil_path.clone();
+				let chain_id = chain_id.clone();
+				async move {
+					let result = run_command(
+						"anvil",
+						&[
+							"--chain-id",
+							&chain_id,
+							"--config-out",
+							&anvil_path,
+							"--port",
+							&DEFAULT_ETH_RPC_PORT.to_string(),
+						],
+					)
+					.await;
+					tracing::info!("Anvil start result:{result:?}");
+				}
+			});
+
+			//wait Anvil to start
+			let _ = tokio::time::sleep(tokio::time::Duration::from_millis(2000)).await;
+			tracing::info!("after start:{}", path.exists());
+
+			// Deploy MCR smart contract.
+			let anvil_addresses =
+				mcr_settlement_client::eth_client::read_anvil_json_file_addresses(&*anvil_path)?;
+			let settlement_private_key = &anvil_addresses[1].private_key;
+			let settlement_address = &anvil_addresses[1].address;
+
+			let mut solidity_path = std::env::current_dir()?;
+			solidity_path.push("protocol-units/settlement/mcr/contracts");
+			let solidity_path = solidity_path.to_string_lossy();
+			tracing::info!("solidity_path: {:?}", solidity_path);
+			let mcr_address = run_command(
+				"forge",
+				&[
+					"script",
+					"DeployMCRLegacy",
+					"--root",
+					&solidity_path,
+					"--broadcast",
+					"--chain-id",
+					&chain_id,
+					"--sender",
+					&settlement_address,
+					"--rpc-url",
+					&config.rpc_url.clone().unwrap(),
+					"--private-key",
+					&settlement_private_key,
+				],
+			)
+			.await?
+			.trim()
+			.to_string();
+
+			// Can't use rand 0.7 while k256 is on rand 0.6
+			let mut rng = k256::elliptic_curve::rand_core::OsRng;
+
+			info!("setting up MCR Ethereum client mcr_address:{mcr_address}");
+
 			if config.signer_private_key.is_none() {
 				let key = SigningKey::random(&mut rng);
 				let key_bytes = key.to_bytes();