Refactor CLI and core modules with layer-zero support

Author: hpmaxi

Cargo.lock

@@ -0,0 +1,38 @@
+use clap::{Parser, Subcommand};
+
+#[derive(Parser)]
+#[command(name = "deploy-cli")]
+#[command(about = "Deploy contracts and manage deployer", long_about = None)]
+pub struct Cli {
+    #[arg(long)]
+    pub chain: String,
+
+    #[command(subcommand)]
+    pub command: Commands,
+}
+#[derive(Subcommand)]
+pub enum Commands {
+    Wallet {
+        #[command(subcommand)]
+        action: WalletAction,
+    },
+    Deploy {
+        #[arg(long)]
+        path: String,
+        #[arg(long, hide = true)]
+        password: Option<String>,
+        contract: String,
+    },
+    Compile,
+}
+
+#[derive(Subcommand)]
+pub enum WalletAction {
+    New,
+    Balance {
+        #[arg(long)]
+        path: String,
+        #[arg(long, hide = true)]
+        password: Option<String>,
+    },
+}

cli/src/cli.rs

@@ -0,0 +1,27 @@
+use ethers::providers::{Http, Provider};
+use rpassword::prompt_password;
+
+/// Retrieves a wallet from a keystore file.
+///
+/// This function provides user prompting for password input when needed,
+/// but delegates the actual keystore loading and wallet creation to the
+/// `client::wallet_from_keystore` function which contains the core logic.
+///
+/// # Arguments
+/// * `path` - Path to the keystore file
+/// * `provider` - Optional Ethereum provider
+/// * `password` - Optional password (will prompt user if None)
+///
+/// # Returns
+/// A Result containing the loaded LocalWallet or an error
+pub async fn get_wallet_from_keystore(
+    path: &str,
+    provider: Option<Provider<Http>>,
+    password: Option<String>,
+) -> anyhow::Result<ethers::signers::LocalWallet> {
+    let password = match password {
+        Some(pass) => pass,
+        None => prompt_password("Enter password: ")?,
+    };
+    core::client::wallet_from_keystore(path, provider, &password).await
+}

cli/src/helpers.rs

@@ -1,81 +1,32 @@
-use clap::{Parser, Subcommand};
+pub mod cli;
+pub mod helpers;
+
+use crate::cli::{Cli, Commands, WalletAction};
+use clap::Parser as _;
 use core::compiler::compile_contract;
-use core::{client, deployer};
-use ethers::providers::{Http, Middleware, Provider};
+use core::deployer;
+use core::provider::get_providers_with_endpoints;
+use ethers::providers::Middleware;
 use ethers::signers::Signer;
 use ethers::types::Address;
-use foundry_config::Config;
-use rpassword::prompt_password;
 use std::process::Command;
 
-#[derive(Parser)]
-#[command(name = "deploy-cli")]
-#[command(about = "Deploy contracts and manage deployer", long_about = None)]
-struct Cli {
-    #[arg(long)]
-    chain: String,
-
-    #[command(subcommand)]
-    command: Commands,
-}
-#[derive(Subcommand)]
-enum Commands {
-    Wallet {
-        #[command(subcommand)]
-        action: WalletAction,
-    },
-    Deploy {
-        #[arg(long)]
-        path: String,
-        #[arg(long, hide = true)]
-        password: Option<String>,
-        contract: String,
-    },
-    Compile,
-}
-
-#[derive(Subcommand)]
-enum WalletAction {
-    New,
-    Balance {
-        #[arg(long)]
-        path: String,
-        #[arg(long, hide = true)]
-        password: Option<String>,
-    },
-}
-
-async fn get_wallet_from_keystore(
-    path: &str,
-    password: Option<String>,
-) -> anyhow::Result<ethers::signers::LocalWallet> {
-    let password = match password {
-        Some(pass) => pass,
-        None => prompt_password("Enter password: ")?,
-    };
-    client::wallet_from_keystore(path, &password).await
-}
-
-fn get_provider(chain_alias: &str) -> anyhow::Result<Provider<Http>> {
-    let config = Config::load();
-
-    let rpc_url: String = config
-        .get_rpc_url_with_alias(chain_alias)
-        .ok_or_else(|| anyhow::anyhow!("Error trying to get RPC URL from config"))?
-        .map_err(|e| anyhow::anyhow!("Error getting RPC URL: {}", e))?
-        .into_owned();
-
-    Provider::<Http>::try_from(rpc_url)
-        .map_err(|e| anyhow::anyhow!("Error instantiating provider: {}", e))
-}
-
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     dotenvy::dotenv().ok();
 
     let cli = Cli::parse();
     let chain = cli.chain;
-    let provider = get_provider(chain.as_str()).expect("Provider setup failed");
+
+    let providers = match get_providers_with_endpoints() {
+        Ok(providers) => providers,
+        Err(e) => return Err(e),
+    };
+
+    let rpc_info = match providers.get(chain.as_str()) {
+        Some(rpc_info) => rpc_info.clone(),
+        None => return Err(anyhow::anyhow!("Chain '{}' not found", chain)),
+    };
 
     match cli.command {
         Commands::Wallet { action } => match action {
@@ -96,9 +47,16 @@ async fn main() -> anyhow::Result<()> {
                 );
             }
             WalletAction::Balance { path, password } => {
-                let wallet = get_wallet_from_keystore(path.as_str(), password).await?;
+                let wallet = helpers::get_wallet_from_keystore(
+                    path.as_str(),
+                    Some(rpc_info.clone().provider),
+                    password,
+                )
+                .await?;
+
                 let addr: Address = wallet.address();
-                let balance = provider.get_balance(addr, None).await?;
+                let balance = rpc_info.provider.get_balance(addr, None).await?;
+
                 println!(
                     "Deployer: {:?}\nBalance: {} ETH",
                     addr,
@@ -111,8 +69,13 @@ async fn main() -> anyhow::Result<()> {
             password,
             contract,
         } => {
-            let wallet = get_wallet_from_keystore(path.as_str(), password).await?;
-            let addr = deployer::deploy_contract(&contract, provider, wallet).await?;
+            let wallet = helpers::get_wallet_from_keystore(
+                path.as_str(),
+                Some(rpc_info.provider.clone()),
+                password,
+            )
+            .await?;
+            let addr = deployer::deploy_oapp_contract(rpc_info, wallet).await?;
             println!("Deployed `{}` at {:?}\n", contract, addr);
         }
         Commands::Compile => {

cli/src/main.rs

@@ -10,3 +10,4 @@ serde_json = "1"
 anyhow = "1"
 tokio = { version = "1", features = ["full"] }
 foundry-compilers = "0.10.1"
+foundry-config = "0.2"

core/Cargo.toml

@@ -1,16 +1,27 @@
 use anyhow::Result;
-use ethers::signers::{LocalWallet, Signer, Wallet};
+use ethers::{
+    providers::{Http, Middleware, Provider},
+    signers::{LocalWallet, Signer, Wallet},
+};
 use std::path::Path;
 
 /// Load a wallet from a keystore file.
-/// `cast wallet new .`
-pub async fn wallet_from_keystore(path: &str, password: &str) -> Result<LocalWallet> {
+/// `cast wallet new .` is needed to call from CLI first.
+pub async fn wallet_from_keystore(
+    path: &str,
+    provider: Option<Provider<Http>>,
+    password: &str,
+) -> Result<LocalWallet> {
     let path = Path::new(path);
     let mut wallet = Wallet::decrypt_keystore(&path, password)?;
 
-    // TODO Replace with chain id from provider
-    let chain_id: u64 = 84532;
-    wallet = wallet.with_chain_id(chain_id);
+    match provider {
+        Some(provider) => {
+            let chain_id = provider.get_chainid().await?.as_u64();
+            wallet = wallet.with_chain_id(chain_id);
+        }
+        None => (),
+    }
 
     println!("Wallet loaded successfully.");
     Ok(wallet)

core/src/artifacts.rs

@@ -1,27 +1,17 @@
-use crate::artifacts;
+use crate::provider::RpcInfo;
 use anyhow::Result;
 use ethers::prelude::*;
 use std::sync::Arc;
 
-pub async fn deploy_contract(
-    contract_name: &str,
-    provider: Provider<Http>,
-    wallet: LocalWallet,
-) -> Result<Address> {
-    // TODO Extract
-    let endpoint_address = "0x6EDCE65403992e310A62460808c4b910D972f10f".parse::<Address>()?;
-    let delegator_address = "0x6EDCE65403992e310A62460808c4b910D972f10f".parse::<Address>()?;
+pub async fn deploy_oapp_contract(rpc_info: RpcInfo, wallet: LocalWallet) -> Result<Address> {
+    let endpoint_address = rpc_info.endpoint;
+    let delegator_address = wallet.address();
 
-    // FIXME abi is not used, is replaced by abigen! macro. Remove from artifacts module
-    // let abi = artifacts::load_abi(contract_name)?;
-    // TODO Move closer to artifact reading
+    // FIXME Hardcoded string
     abigen!(MyOApp, "core/src/solidity/artifacts/MyOApp.sol/MyOApp.json");
 
-    // FIXME bytecode is not used, is replaced by abigen! macro. Remove from artifacts module
-    // let bytecode = artifacts::load_bytecode(contract_name)?;
-    let client = Arc::new(SignerMiddleware::new(provider, wallet));
+    let client = Arc::new(SignerMiddleware::new(rpc_info.clone().provider, wallet));
 
-    // Tuples are used.
     let deployed = MyOApp::deploy(client, (endpoint_address, delegator_address))
         .map_err(|e| {
             println!("Deployment preparation error: {:?}", e);

core/src/client.rs

@@ -0,0 +1,78 @@
+use std::sync::Arc;
+
+use ethers::prelude::*;
+use ethers::types::H256;
+
+use crate::deployer::deploy_oapp_contract;
+use crate::provider::get_providers_with_endpoints;
+
+// TODO Make strings an enum of possible chains
+pub async fn deploy_on_chains(
+    chains: &[String],
+    deployer: &LocalWallet,
+) -> Result<(), anyhow::Error> {
+    let mut addresses = Vec::new();
+
+    let providers = get_providers_with_endpoints()?;
+
+    // Deploy the oapp on each chain
+    for chain in chains {
+        println!("Deploying provider on chain {}", chain);
+
+        let rpc_info_for_current_chain = if let Some(rpc_info) = providers.get(chain) {
+            rpc_info.clone()
+        } else {
+            println!("Chain {} not found in providers, skipping", chain);
+            continue;
+        };
+
+        let chain_id = rpc_info_for_current_chain
+            .provider
+            .get_chainid()
+            .await?
+            .as_u64();
+        let wallet = deployer.clone().with_chain_id(chain_id);
+
+        let oapp_addr =
+            deploy_oapp_contract(rpc_info_for_current_chain.clone(), wallet.clone()).await?;
+        addresses.push((chain.clone(), oapp_addr));
+    }
+
+    abigen!(MyOApp, "core/src/solidity/artifacts/MyOApp.sol/MyOApp.json");
+
+    // Set up peer connections (each with n-1 others)
+    for (i, (chain_i, addr_i)) in addresses.iter().enumerate() {
+        for (j, (chain_j, addr_j)) in addresses.iter().enumerate() {
+            if i != j {
+                println!("Connecting {} to {}", chain_i, chain_j);
+                // Instantiate OApp contract using its address
+
+                let rpc_info_for_current_chain = if let Some(rpc_info) = providers.get(chain_i) {
+                    rpc_info.clone()
+                } else {
+                    println!("Chain {} not found in providers, skipping", chain_i);
+                    continue;
+                };
+
+                let client = Arc::new(SignerMiddleware::new(
+                    rpc_info_for_current_chain.clone().provider,
+                    deployer.clone(),
+                ));
+                let oapp_contract = MyOApp::new(*addr_i, client);
+
+                // Convert the address to the 20-byte format required by LayerZero
+                let peer_addr = H256::from(*addr_j).to_fixed_bytes();
+                let eid = match chain_i.as_str() {
+                    "base_sepolia" => 40245,
+                    "optimism_sepolia" => 40232,
+                    _ => 1,
+                };
+                // oapp_contract
+                oapp_contract.set_peer(eid, peer_addr).await?;
+            }
+        }
+    }
+
+    println!("Layer Zero network successfully deployed and connected!");
+    Ok(())
+}