refactor

Author: hpmaxi

Cargo.lock

@@ -3,13 +3,15 @@ pub mod helpers;
 
 use crate::cli::{Cli, Commands, WalletAction};
 use clap::Parser as _;
+use core::chain::SupportedChain;
 use core::compiler::compile_contract;
-use core::layer_zero::deploy_on_chains;
-use core::provider::get_providers_with_endpoints;
+use core::layer_zero::{deploy_on_chains, setup_peer_connections};
+use core::provider::build_chain_clients;
 use ethers::providers::Middleware;
 use ethers::signers::Signer;
 use ethers::types::Address;
 use std::process::Command;
+use std::str::FromStr;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
@@ -18,18 +20,6 @@ async fn main() -> anyhow::Result<()> {
     let cli = Cli::parse();
     let chain = cli.chain;
 
-    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)),
-    };
-
-    println!("{:?}", rpc_info);
-
     match cli.command {
         Commands::Wallet { action } => match action {
             WalletAction::New => {
@@ -49,15 +39,14 @@ async fn main() -> anyhow::Result<()> {
                 );
             }
             WalletAction::Balance { path, password } => {
-                let wallet = helpers::get_wallet_from_keystore(
-                    path.as_str(),
-                    Some(rpc_info.clone().provider),
-                    password,
-                )
-                .await?;
+                let wallet =
+                    helpers::get_wallet_from_keystore(path.as_str(), None, password).await?;
 
                 let addr: Address = wallet.address();
-                let balance = rpc_info.provider.get_balance(addr, None).await?;
+                let chain_object = SupportedChain::from_str(&chain).unwrap();
+                let clients = build_chain_clients(&wallet).await?;
+                let provider = clients.get(&chain_object).unwrap().provider();
+                let balance = provider.get_balance(addr, None).await?;
 
                 println!(
                     "Deployer: {:?}\nBalance: {} ETH",
@@ -71,15 +60,47 @@ async fn main() -> anyhow::Result<()> {
             password,
             chainlist,
         } => {
-            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?;
-            deploy_on_chains(&chainlist, &wallet).await?;
-            // println!("Deployed `{}` at {:?}\n", contract, addr);
+            let wallet = helpers::get_wallet_from_keystore(path.as_str(), None, password).await?;
+
+            let supported_chains = chainlist
+                .iter()
+                .map(|chain_str| {
+                    chain_str
+                        .parse::<core::chain::SupportedChain>()
+                        .expect("Invalid chain")
+                })
+                .collect::<Vec<core::chain::SupportedChain>>();
+
+            let deployed = deploy_on_chains(&supported_chains, &wallet).await?;
+            for (chain, addr) in supported_chains.iter().zip(deployed.iter()) {
+                println!("Chain {}: Deployed contract at address: {:?}", chain, addr);
+            }
+
+            // TODO make this optional
+            setup_peer_connections(&wallet, &deployed).await?;
+            // Send cross-chain message from each chain to every other chain
+            println!("Sending cross-chain messages...");
+            for (src_idx, src_chain) in supported_chains.iter().enumerate() {
+                for (dst_idx, dst_chain) in supported_chains.iter().enumerate() {
+                    if src_idx != dst_idx {
+                        let message = format!("Hi {} from {}", dst_chain, src_chain);
+                        match core::layer_zero::send_cross_chain_message(
+                            &wallet, &deployed, src_chain, dst_chain, message,
+                        )
+                        .await
+                        {
+                            Ok(_) => println!(
+                                "Successfully sent message from {} to {}",
+                                src_chain, dst_chain
+                            ),
+                            Err(e) => println!(
+                                "Failed to send message from {} to {}: {}",
+                                src_chain, dst_chain, e
+                            ),
+                        }
+                    }
+                }
+            }
         }
         Commands::Compile => {
             println!("Compiling contract...");

cli/src/main.rs

@@ -12,3 +12,4 @@ tokio = { version = "1", features = ["full"] }
 foundry-compilers = "0.10.1"
 foundry-config = "0.2"
 dotenvy = "0.15"
+futures = "0.3.31"

core/Cargo.toml

@@ -0,0 +1,61 @@
+use ethers::types::Address;
+use std::str::FromStr;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum SupportedChain {
+    BaseSepolia,
+    OptimismSepolia,
+    ArbitrumSepolia,
+    GnosisChiado,
+    LineaSepolia,
+}
+
+impl std::fmt::Display for SupportedChain {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SupportedChain::BaseSepolia => write!(f, "base_sepolia"),
+            SupportedChain::OptimismSepolia => write!(f, "optimism_sepolia"),
+            SupportedChain::ArbitrumSepolia => write!(f, "arbitrum_sepolia"),
+            SupportedChain::GnosisChiado => write!(f, "gnosis_chiado"),
+            SupportedChain::LineaSepolia => write!(f, "linea_sepolia"),
+        }
+    }
+}
+
+impl FromStr for SupportedChain {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "base_sepolia" => Ok(SupportedChain::BaseSepolia),
+            "optimism_sepolia" => Ok(SupportedChain::OptimismSepolia),
+            "arbitrum_sepolia" => Ok(SupportedChain::ArbitrumSepolia),
+            "gnosis_chiado" => Ok(SupportedChain::GnosisChiado),
+            "linea_sepolia" => Ok(SupportedChain::LineaSepolia),
+            _ => Err(format!("Unsupported chain alias: {}", s)),
+        }
+    }
+}
+
+impl SupportedChain {
+    pub fn lz_endpoint_id(&self) -> u32 {
+        match self {
+            SupportedChain::BaseSepolia => 40245,
+            SupportedChain::OptimismSepolia => 40232,
+            SupportedChain::ArbitrumSepolia => 40231,
+            SupportedChain::GnosisChiado => 40145,
+            SupportedChain::LineaSepolia => 40287,
+        }
+    }
+    pub fn endpoint_address(&self) -> Address {
+        match self {
+            SupportedChain::BaseSepolia
+            | SupportedChain::OptimismSepolia
+            | SupportedChain::ArbitrumSepolia
+            | SupportedChain::GnosisChiado
+            | SupportedChain::LineaSepolia => "0x6EDCE65403992e310A62460808c4b910D972f10f"
+                .parse::<Address>()
+                .unwrap(),
+        }
+    }
+}

core/src/chain.rs

@@ -1,18 +1,19 @@
-use crate::provider::RpcInfo;
 use anyhow::Result;
 use ethers::prelude::*;
-use std::sync::Arc;
 
-pub async fn deploy_oapp_contract(rpc_info: RpcInfo, wallet: LocalWallet) -> Result<Address> {
-    let endpoint_address = rpc_info.endpoint;
-    let delegator_address = wallet.address();
+use crate::{chain::SupportedChain, provider::ChainClient};
 
-    // FIXME Hardcoded string
-    abigen!(MyOApp, "core/src/solidity/artifacts/MyOApp.sol/MyOApp.json");
+// FIXME Hardcoded string
+abigen!(MyOApp, "core/src/solidity/artifacts/MyOApp.sol/MyOApp.json");
 
-    let client = Arc::new(SignerMiddleware::new(rpc_info.clone().provider, wallet));
+pub async fn deploy_oapp_contract(
+    chain: &SupportedChain,
+    chain_client: &ChainClient,
+) -> Result<Address> {
+    let endpoint_address = chain.endpoint_address();
+    let delegator_address = chain_client.address();
 
-    let deployed = MyOApp::deploy(client, (endpoint_address, delegator_address))
+    let deployed = MyOApp::deploy(chain_client.clone(), (endpoint_address, delegator_address))
         .map_err(|e| {
             println!("Deployment preparation error: {:?}", e);
             anyhow::Error::from(e)