BitVM · lucidLuckylee · Nov 27, 2024 · Jun 3, 2024 · Jun 3, 2024 · Jun 4, 2024
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -41,12 +41,16 @@ suppaftp = { version = "6.0.1", features = ["async", "async-native-tls"] }
 openssh-sftp-client = { version = "0.14.6", features = ["openssh"] }
 openssh = { version = "0.10.4", features = ["native-mux"] }
 alloy = { version = "0.2.1", features = ["full"] }
+clap = { version = "4.5.16", features = ["derive", "cargo", "env"] }
+toml = "0.5.11"
+colored = "2.0.0"
 
 [dev-dependencies]
 num-bigint = { version = "0.4.4", features = ["rand"] }
 ark-std = { version = "0.4.0", default-features = false, features = ["print-trace"] }
 ark-crypto-primitives = { git = "https://github.com/arkworks-rs/crypto-primitives", features = ["snark", "sponge"] }
 ark-relations = { git = "https://github.com/arkworks-rs/snark/" }
+serial_test = "*"
 tqdm = "0.7"
 
 [profile.dev]
@@ -75,3 +79,10 @@ ark-crypto-primitives = { git = "https://github.com/arkworks-rs/crypto-primitive
 ark-relations = { git = "https://github.com/arkworks-rs/snark/" }
 ark-snark = { git = "https://github.com/arkworks-rs/snark/" }
 ark-groth16 = { git = "https://github.com/arkworks-rs/groth16" }
+
+[[bin]]
+name = "cli"
+
+[[bin]]
+name = "cli-query"
+path = "src/bin/cli_query/main.rs"
diff --git a/src/bin/cli/main.rs b/src/bin/cli/main.rs
@@ -0,0 +1,76 @@
+use bitcoin::PublicKey;
+use bitvm::bridge::client::cli::client_command::{ClientCommand, CommonArgs};
+use bitvm::bridge::client::cli::key_command::KeysCommand;
+use clap::{arg, command};
+use std::error::Error;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    let command = command!() // requires `cargo` feature
+        .propagate_version(true)
+        .subcommand_required(true)
+        .arg_required_else_help(true)
+        .arg(
+            arg!(--"key-dir" <DIRECTORY> "The directory containing the private keys").required(false).env("KEY_DIR"),
+        )
+        .arg(
+            arg!(-r --verifiers [VERIFIER_PUBKEYS] "Pubkeys of the verifiers")
+                .required(false)
+                .num_args(0..1000)
+                .value_delimiter(',')
+                .value_parser(clap::value_parser!(PublicKey))
+                .env("VERIFIERS"),
+        )
+        .arg(arg!(-e --environment <ENVIRONMENT> "Specify the Bitcoin network environment (mainnet, testnet). Defaults to mainnet.").required(false).default_value("mainnet").env("ENVIRONMENT"))
+        .subcommand(KeysCommand::get_command())
+        .subcommand(ClientCommand::get_depositor_address_command())
+        .subcommand(ClientCommand::get_depositor_utxos_command())
+        .subcommand(ClientCommand::get_initiate_peg_in_command())
+        .subcommand(ClientCommand::get_status_command())
+        .subcommand(ClientCommand::get_broadcast_command())
+        .subcommand(ClientCommand::get_automatic_command())
+        .subcommand(ClientCommand::get_interactive_command());
+
+    let matches = command.clone().get_matches();
+
+    let global_args = CommonArgs {
+        key_dir: matches.get_one::<String>("key-dir").cloned(),
+        verifiers: matches
+            .get_many::<PublicKey>("verifiers")
+            .map(|x| x.cloned().collect::<Vec<PublicKey>>()),
+        environment: matches.get_one::<String>("environment").cloned(),
+    };
+
+    if let Some(sub_matches) = matches.subcommand_matches("keys") {
+        let keys_command = KeysCommand::new(global_args.key_dir);
+        keys_command.handle_command(sub_matches)?;
+    } else if matches
+        .subcommand_matches("get-depositor-address")
+        .is_some()
+    {
+        let mut client_command = ClientCommand::new(global_args).await;
+        let _ = client_command.handle_get_depositor_address().await;
+    } else if matches.subcommand_matches("get-depositor-utxos").is_some() {
+        let mut client_command = ClientCommand::new(global_args).await;
+        let _ = client_command.handle_get_depositor_utxos().await;
+    } else if let Some(sub_matches) = matches.subcommand_matches("initiate-peg-in") {
+        let mut client_command = ClientCommand::new(global_args).await;
+        let _ = client_command
+            .handle_initiate_peg_in_command(sub_matches)
+            .await;
+    } else if matches.subcommand_matches("status").is_some() {
+        let mut client_command = ClientCommand::new(global_args).await;
+        let _ = client_command.handle_status_command().await;
+    } else if let Some(sub_matches) = matches.subcommand_matches("broadcast") {
+        let mut client_command = ClientCommand::new(global_args).await;
+        let _ = client_command.handle_broadcast_command(sub_matches).await;
+    } else if matches.subcommand_matches("automatic").is_some() {
+        let mut client_command = ClientCommand::new(global_args).await;
+        let _ = client_command.handle_automatic_command().await;
+    } else if matches.subcommand_matches("interactive").is_some() {
+        let mut client_command = ClientCommand::new(global_args).await;
+        let _ = client_command.handle_interactive_command(&command).await;
+    }
+
+    Ok(())
+}
diff --git a/src/bin/cli_query/main.rs b/src/bin/cli_query/main.rs
@@ -0,0 +1,49 @@
+use bitcoin::Network;
+use bitvm::bridge::{client::cli::query_command::QueryCommand, constants::DestinationNetwork};
+use clap::{arg, command};
+use std::error::Error;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    let command = command!() // requires `cargo` feature
+        .propagate_version(true)
+        .subcommand_required(true)
+        .arg_required_else_help(true)
+        .subcommand(QueryCommand::depositor_command())
+        .subcommand(QueryCommand::withdrawer_command())
+        .subcommand(QueryCommand::history_command())
+        .subcommand(QueryCommand::transactions_command())
+        .subcommand(QueryCommand::signatures_command())
+        .subcommand(QueryCommand::broadcast_command())
+        .subcommand(QueryCommand::peg_in_graphs_command())
+        .arg(arg!(-e --environment <ENVIRONMENT> "Specify the Bitcoin and L2 network environment (mainnet, testnet)").required(false)
+        .default_value("mainnet"))
+        .arg(arg!(-p --prefix <PREFIX> "Prefix for local file cache path").required(false));
+
+    let matches = command.clone().get_matches();
+    let (source_network, destination_network) =
+        match matches.get_one::<String>("environment").unwrap().as_str() {
+            "mainnet" => (Network::Bitcoin, DestinationNetwork::Ethereum),
+            "testnet" => (Network::Testnet, DestinationNetwork::EthereumSepolia),
+            _ => {
+                eprintln!("Invalid environment. Use mainnet, testnet.");
+                std::process::exit(1);
+            }
+        };
+    let prefix = matches.get_one::<String>("prefix").map(|s| s.as_str());
+
+    let mut query = QueryCommand::new(source_network, destination_network, prefix).await;
+    let resp = match matches.subcommand() {
+        Some(("depositor", sub)) => query.handle_depositor(sub).await,
+        Some(("withdrawer", sub)) => query.handle_withdrawer(sub, destination_network).await,
+        Some(("history", sub)) => query.handle_history(sub, destination_network).await,
+        Some(("transactions", sub)) => query.handle_transactions(sub, destination_network).await,
+        Some(("signatures", sub)) => query.handle_signatures(sub, destination_network).await,
+        Some(("broadcast", sub)) => query.handle_broadcast(sub).await,
+        Some(("pegins", _)) => query.handle_peg_in_graphs().await,
+        _ => unreachable!(),
+    };
+
+    resp.flush();
+    Ok(())
+}
diff --git a/src/bridge/client/chain/chain.rs b/src/bridge/client/chain/chain.rs
@@ -1,21 +1,25 @@
+use std::borrow::Borrow;
+
 use bitcoin::{Amount, OutPoint, PubkeyHash, PublicKey};
+use serde::{Deserialize, Serialize};
 
 use super::{
     base::ChainAdaptor,
     ethereum::{EthereumAdaptor, EthereumInitConfig},
 };
 
-#[derive(Debug)]
+#[derive(Serialize, Deserialize, Eq, PartialEq, Clone, Debug)]
 pub struct PegOutEvent {
     pub withdrawer_chain_address: String,
     pub withdrawer_public_key_hash: PubkeyHash,
     pub source_outpoint: OutPoint,
     pub amount: Amount,
     pub operator_public_key: PublicKey,
     pub timestamp: u32,
+    pub tx_hash: Vec<u8>,
 }
 
-#[derive(Debug)]
+#[derive(Serialize, Deserialize, Eq, PartialEq, Clone, Debug)]
 pub struct PegOutBurntEvent {
     pub withdrawer_chain_address: String,
     pub source_outpoint: OutPoint,
@@ -24,26 +28,30 @@ pub struct PegOutBurntEvent {
     pub timestamp: u32,
 }
 
-#[derive(Debug)]
+#[derive(Serialize, Deserialize, Eq, PartialEq, Clone, Debug)]
 pub struct PegInEvent {
     pub depositor: String,
     pub amount: Amount,
     pub depositor_pubkey: PublicKey,
 }
 
-static CLIENT_MISSING_ORACLE_DRIVER_ERROR: &str = "Bridge client is missing chain adaptor";
+static CLIENT_MISSING_CHAIN_DRIVER_ERROR: &str = "Bridge client is missing chain adaptor";
 
 pub struct Chain {
     ethereum: Option<EthereumAdaptor>,
+    default: Option<Box<dyn ChainAdaptor>>,
 }
 
 impl Chain {
     pub fn new() -> Self {
         Self {
             ethereum: EthereumAdaptor::new(),
+            default: None,
         }
     }
 
+    pub fn init_default(&mut self, adaptor: Box<dyn ChainAdaptor>) { self.default = Some(adaptor); }
+
     pub fn init_ethereum(&mut self, conf: EthereumInitConfig) {
         self.ethereum = Some(EthereumAdaptor::from_config(conf));
     }
@@ -66,10 +74,12 @@ impl Chain {
     }
 
     fn get_driver(&self) -> Result<&dyn ChainAdaptor, &str> {
-        if self.ethereum.is_some() {
+        if self.default.is_some() {
+            return Ok((*self.default.as_ref().unwrap()).borrow());
+        } else if self.ethereum.is_some() {
             return Ok(self.ethereum.as_ref().unwrap());
         } else {
-            Err(CLIENT_MISSING_ORACLE_DRIVER_ERROR)
+            Err(CLIENT_MISSING_CHAIN_DRIVER_ERROR)
         }
     }
 }
diff --git a/src/bridge/client/chain/ethereum.rs b/src/bridge/client/chain/ethereum.rs
@@ -51,23 +51,29 @@ pub struct EthereumAdaptor {
     bridge_address: EvmAddress,
     bridge_creation_block: u64,
     provider: RootProvider<Http<Client>>,
+    to_block: Option<BlockNumberOrTag>,
 }
 
 pub struct EthereumInitConfig {
     pub rpc_url: Url,
     pub bridge_address: EvmAddress,
     pub bridge_creation_block: u64,
+    pub to_block: Option<BlockNumberOrTag>,
 }
 
 impl EthereumAdaptor {
     async fn get_sol_events<T>(&self) -> Result<Vec<Log<T>>, String>
     where
         T: SolEvent,
     {
-        let filter = Filter::new()
+        let mut filter = Filter::new()
             .from_block(BlockNumberOrTag::Number(self.bridge_creation_block))
             .address(self.bridge_address)
             .event(T::SIGNATURE);
+        filter = match self.to_block.is_none() {
+            true => filter.to_block(BlockNumberOrTag::Finalized),
+            false => filter.to_block(self.to_block.unwrap()),
+        };
 
         let results = self.provider.get_logs(&filter).await;
         if results.is_err() {
@@ -119,6 +125,7 @@ impl ChainAdaptor for EthereumAdaptor {
                     .unwrap(),
                     operator_public_key,
                     timestamp: u32::try_from(e.block_timestamp.unwrap()).unwrap(),
+                    tx_hash: e.transaction_hash.unwrap().to_vec(),
                 }
             })
             .collect();
@@ -190,6 +197,7 @@ impl EthereumAdaptor {
         let rpc_url_str = dotenv::var("BRIDGE_CHAIN_ADAPTOR_ETHEREUM_RPC_URL");
         let bridge_address_str = dotenv::var("BRIDGE_CHAIN_ADAPTOR_ETHEREUM_BRIDGE_ADDRESS");
         let bridge_creation = dotenv::var("BRIDGE_CHAIN_ADAPTOR_ETHEREUM_BRIDGE_CREATION");
+        let to_block = dotenv::var("BRIDGE_CHAIN_ADAPTOR_ETHEREUM_TO_BLOCK");
         if bridge_address_str.is_err() || bridge_creation.is_err() {
             return None;
         }
@@ -203,6 +211,10 @@ impl EthereumAdaptor {
             rpc_url: rpc_url.unwrap(),
             bridge_address: bridge_address.unwrap(),
             bridge_creation_block: bridge_creation.unwrap().parse::<u64>().unwrap(),
+            to_block: match to_block {
+                Ok(block) => Some(BlockNumberOrTag::from_str(block.as_str()).unwrap()),
+                Err(_) => Some(BlockNumberOrTag::Finalized),
+            },
         }))
     }
 
@@ -211,6 +223,7 @@ impl EthereumAdaptor {
             bridge_address: conf.bridge_address,
             bridge_creation_block: conf.bridge_creation_block,
             provider: ProviderBuilder::new().on_http(conf.rpc_url),
+            to_block: conf.to_block,
         }
     }
 }