[bitcoin] Cli bitcoin address binding

crates/rooch/Cargo.toml

@@ -39,6 +39,8 @@ parking_lot = { workspace = true }
 bcs-ext = { workspace = true }
 rpassword = { workspace = true }
 fastcrypto = { workspace = true }
+bitcoin = { workspace = true }
+bitcoincore-rpc = { workspace = true }
 
 move-bytecode-utils = { workspace = true }
 move-binary-format = { workspace = true }

crates/rooch/src/commands/account/commands/binding.rs

@@ -0,0 +1,101 @@
+// Copyright (c) RoochNetwork
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::cli_types::{TransactionOptions, WalletContextOptions};
+use bitcoincore_rpc::{Auth, Client, RpcApi};
+use clap::Parser;
+use rooch_types::{
+    address::{BitcoinAddress, MultiChainAddress, RoochAddress},
+    error::{RoochError, RoochResult},
+    multichain_id::RoochMultiChainID,
+};
+
+/// Binding a
+#[derive(Debug, Parser)]
+pub struct BindingCommand {
+    /// L1 chain id    
+    #[clap(long, short = 'c')]
+    pub l1_chain: RoochMultiChainID,
+
+    /// L1 chain address
+    #[clap(long)]
+    pub l1_address: String,
+
+    #[clap(
+        long,
+        env = "BITCOIN_RPC_URL",
+        requires = "btc-rpc-username",
+        requires = "btc-rpc-password"
+    )]
+    pub btc_rpc_url: String,
+
+    #[clap(long, id = "btc-rpc-username", env = "BTC_RPC_USERNAME")]
+    pub btc_rpc_username: String,
+
+    #[clap(long, id = "btc-rpc-password", env = "BTC_RPC_PASSWORD")]
+    pub btc_rpc_password: String,
+
+    #[clap(flatten)]
+    pub tx_options: TransactionOptions,
+
+    #[clap(flatten)]
+    pub context_options: WalletContextOptions,
+}
+
+impl BindingCommand {
+    pub async fn execute(self) -> RoochResult<()> {
+        let multichain_address = MultiChainAddress::try_from_str_with_multichain_id(
+            self.l1_chain,
+            self.l1_address.as_str(),
+        )?;
+        let wallet_context = self.context_options.build()?;
+        let sender = wallet_context.resolve_address(self.tx_options.sender)?;
+        match self.l1_chain {
+            RoochMultiChainID::Bitcoin => {
+                Self::binding_bitcoin_adddress(
+                    self.btc_rpc_url,
+                    self.btc_rpc_username,
+                    self.btc_rpc_password,
+                    sender.into(),
+                    multichain_address.try_into()?,
+                )
+                .await?;
+                Ok(())
+            }
+            RoochMultiChainID::Rooch => Err(RoochError::CommandArgumentError(
+                "Can not binding Rooch address".to_owned(),
+            )),
+            _ => Err(RoochError::CommandArgumentError(
+                "Does not support this chain".to_owned(),
+            )),
+        }
+    }
+
+    async fn binding_bitcoin_adddress(
+        btc_rpc_url: String,
+        btc_rpc_user_name: String,
+        btc_rpc_password: String,
+        _sender: RoochAddress,
+        bitcoin_address: BitcoinAddress,
+    ) -> anyhow::Result<String> {
+        let rpc = Client::new(
+            btc_rpc_url.as_str(),
+            Auth::UserPass(btc_rpc_user_name, btc_rpc_password),
+        )?;
+        let chain_info = rpc.get_blockchain_info()?;
+        let bitcoin_chain_network =
+            rooch_types::bitcoin::network::Network::try_from(chain_info.chain)?;
+        let bitcoin_address_str = bitcoin_address.format(bitcoin_chain_network.to_num())?;
+        let message = "rooch";
+        let result = rpc
+            .call::<String>(
+                "signmessage",
+                &[
+                    serde_json::to_value(bitcoin_address_str)?,
+                    serde_json::to_value(message)?,
+                ],
+            )
+            .map_err(|e| RoochError::UnexpectedError(e.to_string()))?;
+        Ok(result)
+    }
+}

crates/rooch/src/commands/account/commands/mod.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 pub mod balance;
+pub mod binding;
 pub mod create;
 pub mod list;
 pub mod nullify;

crates/rooch/src/commands/account/mod.rs

@@ -5,7 +5,8 @@ use crate::cli_types::CommandAction;
 use crate::commands::account::commands::balance::BalanceCommand;
 use async_trait::async_trait;
 use commands::{
-    create::CreateCommand, list::ListCommand, nullify::NullifyCommand, switch::SwitchCommand,
+    binding::BindingCommand, create::CreateCommand, list::ListCommand, nullify::NullifyCommand,
+    switch::SwitchCommand,
 };
 use rooch_types::error::{RoochError, RoochResult};
 use std::path::PathBuf;
@@ -33,6 +34,7 @@ impl CommandAction<String> for Account {
             AccountCommand::Switch(switch) => switch.execute().await.map(|_| "".to_owned()),
             AccountCommand::Nullify(nullify) => nullify.execute().await.map(|_| "".to_owned()),
             AccountCommand::Balance(balance) => balance.execute().await.map(|_| "".to_owned()),
+            AccountCommand::Binding(binding) => binding.execute().await.map(|_| "".to_owned()),
         }
         .map_err(RoochError::from)
     }
@@ -46,4 +48,5 @@ pub enum AccountCommand {
     Switch(SwitchCommand),
     Nullify(NullifyCommand),
     Balance(BalanceCommand),
+    Binding(BindingCommand),
 }