Merge pull request #25 from chainwayxyz/ozan/use-alloy-addr

Use alloy::primitives::Address instead of manual implementation

Author: ozankaymak

src/backend.rs

@@ -1,24 +1,24 @@
 // Backend communication logic for Clementine CLI
 
-use crate::EVMAddress;
 use crate::config::get_backend_endpoint;
 use crate::deposit::parse_taproot_address;
-use bitcoin::{Address, Network};
+use crate::{BitcoinAddress, CitreaAddress};
+use bitcoin::Network;
 use colored::*;
 use serde_json::json;
 
 /// Make a POST request to create a deposit account
 pub fn create_deposit_account(
-    evm_address: &EVMAddress,
-    recovery_taproot_address: &Address,
+    citrea_address: &CitreaAddress,
+    recovery_taproot_address: &BitcoinAddress,
     network: Network,
-) -> Result<Address, Box<dyn std::error::Error>> {
+) -> Result<BitcoinAddress, Box<dyn std::error::Error>> {
     let backend_endpoint = get_backend_endpoint(network);
     let url = format!("{}deposit-accounts", backend_endpoint);
 
     // Prepare request body
     let request_body = json!({
-        "evm_addr": evm_address.to_string(),
+        "citrea_addr": citrea_address.to_string(),
         "recovery_taproot_addr": recovery_taproot_address.to_string()
     });
 

src/bitcoin_utils.rs

@@ -3,32 +3,32 @@
 use bitcoin::secp256k1::{Keypair, Secp256k1, SecretKey, schnorr};
 use bitcoin::taproot::{LeafVersion, TaprootBuilder, TaprootSpendInfo};
 use bitcoin::{
-    Address, Amount, FeeRate, Network, OutPoint, ScriptBuf, Sequence, TapLeafHash, TapNodeHash,
-    TapSighash, TapTweakHash, Transaction, TxIn, TxOut, Txid, Weight, Witness, XOnlyPublicKey,
+    Amount, FeeRate, Network, OutPoint, ScriptBuf, Sequence, TapLeafHash, TapNodeHash, TapSighash,
+    TapTweakHash, Transaction, TxIn, TxOut, Txid, Weight, Witness, XOnlyPublicKey,
 };
 use colored::*;
 use std::io::{self, Write};
 use std::str::FromStr;
 use std::sync::LazyLock;
 
-use crate::EVMAddress;
 use crate::config::{BRIDGE_AMOUNT, UNSPENDABLE_XONLY_PUBKEY, USER_TAKES_AFTER, get_verifier_pks};
 use crate::musig2::AggregateFromPublicKeys;
 use crate::script::{deposit_script, recover_script};
+use crate::{BitcoinAddress, CitreaAddress};
 use bitcoin::hashes::Hash;
 
 pub static SECP: LazyLock<Secp256k1<bitcoin::secp256k1::All>> = LazyLock::new(Secp256k1::new);
 
 /// Calculate taproot address from a keypair
-pub fn calculate_taproot_address(keypair: &Keypair, network: Network) -> Address {
+pub fn calculate_taproot_address(keypair: &Keypair, network: Network) -> BitcoinAddress {
     let (xonly_public_key, _parity) = keypair.public_key().x_only_public_key();
-    Address::p2tr(&SECP, xonly_public_key, None, network)
+    BitcoinAddress::p2tr(&SECP, xonly_public_key, None, network)
 }
 
 /// Generate a new random secret key and calculate its corresponding taproot address
 pub fn generate_key_and_taproot_address(
     network: Network,
-) -> Result<(Keypair, Address), Box<dyn std::error::Error>> {
+) -> Result<(Keypair, BitcoinAddress), Box<dyn std::error::Error>> {
     let keypair = Keypair::new(&SECP, &mut bitcoin::secp256k1::rand::thread_rng());
     let address = calculate_taproot_address(&keypair, network);
     Ok((keypair, address))
@@ -37,7 +37,7 @@ pub fn generate_key_and_taproot_address(
 pub fn generate_keypair_and_taproot_address_from_private_key(
     private_key: &str,
     network: Network,
-) -> Result<(Keypair, Address), Box<dyn std::error::Error>> {
+) -> Result<(Keypair, BitcoinAddress), Box<dyn std::error::Error>> {
     let sk = SecretKey::from_str(private_key)?;
     let keypair = Keypair::from_secret_key(&SECP, &sk);
     let address = calculate_taproot_address(&keypair, network);
@@ -66,17 +66,17 @@ pub fn confirm_private_key_storage(auto_yes: bool) -> Result<bool, Box<dyn std::
     Ok(input.trim().to_lowercase() == "y" || input.trim().to_lowercase() == "yes")
 }
 
-/// Calculate the deposit address and taproot spend info for a given EVM address and recovery taproot address
+/// Calculate the deposit address and taproot spend info for a given Citrea address and recovery taproot address
 pub fn calculate_deposit_address(
-    evm_address: &EVMAddress,
-    recovery_taproot_address: &Address,
+    citrea_address: &CitreaAddress,
+    recovery_taproot_address: &BitcoinAddress,
     network: Network,
-) -> Result<(Address, TaprootSpendInfo), Box<dyn std::error::Error>> {
+) -> Result<(BitcoinAddress, TaprootSpendInfo), Box<dyn std::error::Error>> {
     let verifiers_public_keys = get_verifier_pks(network);
     let agg_pk = XOnlyPublicKey::from_musig2_pks(&verifiers_public_keys)?;
     debug!("agg_pk: {:?}", agg_pk.to_string());
     debug!("verifiers_public_keys: {:?}", verifiers_public_keys);
-    let deposit_script = deposit_script(*evm_address, agg_pk);
+    let deposit_script = deposit_script(*citrea_address, agg_pk);
     let recovery_key =
         XOnlyPublicKey::from_slice(&recovery_taproot_address.script_pubkey().to_bytes()[2..34])?;
     let recover_script = recover_script(recovery_key, USER_TAKES_AFTER);
@@ -89,7 +89,7 @@ pub fn calculate_deposit_address(
         .finalize(&SECP, *UNSPENDABLE_XONLY_PUBKEY)
         .expect("finalized script is valid");
 
-    let deposit_address = Address::p2tr(
+    let deposit_address = BitcoinAddress::p2tr(
         &SECP,
         *UNSPENDABLE_XONLY_PUBKEY,
         taproot_spend_info.merkle_root(),
@@ -126,19 +126,19 @@ pub fn sign_with_tweak(
 }
 
 #[allow(clippy::too_many_arguments)]
-/// Sign a recovery transaction with a given keypair, EVM address, recovery taproot address, deposit outpoint, deposit amount, claim address, fee rate, and network
+/// Sign a recovery transaction with a given keypair, Citrea address, recovery taproot address, deposit outpoint, deposit amount, claim address, fee rate, and network
 pub fn sign_recovery_tx(
     keypair: &Keypair,
-    evm_address: &EVMAddress,
-    recovery_taproot_address: &Address,
+    citrea_address: &CitreaAddress,
+    recovery_taproot_address: &BitcoinAddress,
     deposit_outpoint: &OutPoint,
     deposit_amount: Option<Amount>,
-    claim_address: &Address,
+    claim_address: &BitcoinAddress,
     fee_rate: Option<FeeRate>,
     network: Network,
 ) -> Result<Transaction, Box<dyn std::error::Error>> {
     let (deposit_address, taproot_spend_info) =
-        calculate_deposit_address(evm_address, recovery_taproot_address, network)?;
+        calculate_deposit_address(citrea_address, recovery_taproot_address, network)?;
 
     let recovery_script = recover_script(
         XOnlyPublicKey::from_slice(&recovery_taproot_address.script_pubkey().to_bytes()[2..34])?,
@@ -249,11 +249,11 @@ pub fn sign_recovery_tx(
 
 pub fn verify_recovery_tx(
     recovery_tx: &Transaction,
-    evm_address: &EVMAddress,
-    recovery_taproot_address: &Address,
+    citrea_address: &CitreaAddress,
+    recovery_taproot_address: &BitcoinAddress,
     input_amount: Option<Amount>,
     network: Network,
-) -> Result<(Txid, Address, Amount), Box<dyn std::error::Error>> {
+) -> Result<(Txid, BitcoinAddress, Amount), Box<dyn std::error::Error>> {
     // sanity check input count
     if recovery_tx.input.len() != 1 {
         return Err("Recovery transaction must have exactly one input".into());
@@ -275,7 +275,7 @@ pub fn verify_recovery_tx(
     }
 
     let (deposit_address, taproot_spend_info) =
-        calculate_deposit_address(evm_address, recovery_taproot_address, network)?;
+        calculate_deposit_address(citrea_address, recovery_taproot_address, network)?;
 
     let recovery_key =
         XOnlyPublicKey::from_slice(&recovery_taproot_address.script_pubkey().to_bytes()[2..34])?;
@@ -359,7 +359,7 @@ pub fn verify_recovery_tx(
         "Signature verification failed. Possible causes include an incorrect input amount, an invalid signature, or a mismatched public key.".into()
     })?;
 
-    let output_address = Address::from_script(
+    let output_address = BitcoinAddress::from_script(
         &recovery_tx.output[0].script_pubkey,
         network,
     )
@@ -376,9 +376,9 @@ pub fn verify_recovery_tx(
 
 pub fn sign_withdrawal_signature(
     keypair: &Keypair,
-    signer_address: &Address,
+    signer_address: &BitcoinAddress,
     withdrawal_utxo: &OutPoint,
-    claim_address: &Address,
+    claim_address: &BitcoinAddress,
     amount: Amount,
 ) -> Result<bitcoin::taproot::Signature, Box<dyn std::error::Error>> {
     let txin = TxIn {
@@ -427,9 +427,9 @@ pub fn sign_withdrawal_signature(
 
 pub fn verify_withdrawal_signature(
     sig: &bitcoin::taproot::Signature,
-    signer_address: &Address,
+    signer_address: &BitcoinAddress,
     withdrawal_utxo: &OutPoint,
-    claim_address: &Address,
+    claim_address: &BitcoinAddress,
     amount: Amount,
 ) -> Result<(), Box<dyn std::error::Error>> {
     let txin = TxIn {

src/deposit.rs

@@ -1,6 +1,5 @@
 // Deposit-related commands and logic for Clementine CLI
 
-use crate::EVMAddress;
 use crate::backend::create_deposit_account;
 use crate::bitcoin_utils::{
     calculate_deposit_address, confirm_private_key_storage, generate_key_and_taproot_address,
@@ -9,22 +8,24 @@ use crate::bitcoin_utils::{
     generate_keypair_and_taproot_address_from_private_key,
     sign_recovery_tx as utils_sign_recovery_tx,
 };
+
 use crate::parameters::get_citrea_deposit_params;
 use crate::storage::load_key;
 use crate::storage::store_key;
 use crate::withdrawal::{get_tx_details, get_txout_details_from_rpc};
+use crate::{BitcoinAddress, CitreaAddress, parse_citrea_address};
 use bitcoin::AddressType;
 use bitcoin::consensus::deserialize;
-use bitcoin::{Address, Network, address::NetworkUnchecked};
 use bitcoin::{Amount, FeeRate, OutPoint, Transaction, Txid};
+use bitcoin::{Network, address::NetworkUnchecked};
 use colored::*;
 use std::str::FromStr;
 
 pub fn parse_address(
     address: &str,
     network: Network,
-) -> Result<Address, Box<dyn std::error::Error>> {
-    let unchecked_address: Address<NetworkUnchecked> = address
+) -> Result<BitcoinAddress, Box<dyn std::error::Error>> {
+    let unchecked_address: BitcoinAddress<NetworkUnchecked> = address
         .parse()
         .map_err(|_| "Invalid Bitcoin address format")?;
     let address = unchecked_address.require_network(network)?;
@@ -35,7 +36,7 @@ pub fn parse_address(
 pub fn parse_taproot_address(
     address: &str,
     network: Network,
-) -> Result<Address, Box<dyn std::error::Error>> {
+) -> Result<BitcoinAddress, Box<dyn std::error::Error>> {
     let address = parse_address(address, network)?;
 
     // Verify it's a taproot (P2TR) address
@@ -84,7 +85,12 @@ pub fn get_deposit_address(
     recovery_taproot_address: &str,
     network: Network,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    let citrea_address = EVMAddress::try_from(citrea_address)?;
+    let citrea_address: CitreaAddress = parse_citrea_address(citrea_address)?;
+    println!(
+        "{} {}",
+        "CITREA_ADDRESS (checksummed)".green().bold(),
+        citrea_address,
+    );
     let recovery_taproot_address = parse_taproot_address(recovery_taproot_address, network)?;
 
     // Call backend to create deposit account
@@ -148,7 +154,7 @@ pub async fn get_deposit_params(
 
 #[allow(clippy::too_many_arguments)]
 pub fn sign_recovery_tx(
-    evm_address: &str,
+    citrea_address: &str,
     recovery_taproot_address: &str,
     deposit_txid: &str,
     deposit_vout: u32,
@@ -157,9 +163,9 @@ pub fn sign_recovery_tx(
     amount: Option<f64>,
     network: Network,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    let evm_addr = EVMAddress::try_from(evm_address)?;
+    let citrea_addr: CitreaAddress = parse_citrea_address(citrea_address)?;
     let recovery_addr = parse_taproot_address(recovery_taproot_address, network)?;
-    let claim_addr = Address::from_str(claim_address)?.require_network(network)?;
+    let claim_addr = BitcoinAddress::from_str(claim_address)?.require_network(network)?;
     let txid = Txid::from_str(deposit_txid)?;
     let outpoint = OutPoint {
         txid,
@@ -176,7 +182,7 @@ pub fn sign_recovery_tx(
     let fee_rate_opt = fee_rate.map(FeeRate::from_sat_per_vb_unchecked);
     let signed_tx = utils_sign_recovery_tx(
         &keypair,
-        &evm_addr,
+        &citrea_addr,
         &recovery_addr,
         &outpoint,
         deposit_amount,
@@ -194,16 +200,16 @@ pub fn sign_recovery_tx(
 #[allow(clippy::too_many_arguments)]
 pub fn verify_recovery_tx(
     recovery_tx: &str,
-    evm_address: &str,
+    citrea_address: &str,
     recovery_taproot_address: &str,
     amount: Option<f64>,
     network: Network,
-) -> Result<(Txid, Address, Amount), Box<dyn std::error::Error>> {
+) -> Result<(Txid, BitcoinAddress, Amount), Box<dyn std::error::Error>> {
     let recovery_tx: Transaction = deserialize(&hex::decode(recovery_tx)?)?;
 
     let (txid, address, amount) = crate::bitcoin_utils::verify_recovery_tx(
         &recovery_tx,
-        &EVMAddress::try_from(evm_address)?,
+        &parse_citrea_address(citrea_address)?,
         &parse_taproot_address(recovery_taproot_address, network)?,
         amount.map(|amount| Amount::from_btc(amount).unwrap()),
         network,

src/lib.rs

@@ -1,4 +1,10 @@
 use std::env;
+use std::str::FromStr;
+
+pub type BitcoinAddress<V = bitcoin::address::NetworkChecked> = bitcoin::Address<V>;
+pub use bitcoin::address::{NetworkChecked, NetworkUnchecked};
+
+pub type CitreaAddress = alloy::primitives::Address;
 
 /// Check if debug mode is enabled via CLEMENTINE_DEBUG environment variable
 pub fn is_debug_enabled() -> bool {
@@ -43,79 +49,10 @@ pub mod storage;
 pub mod types;
 pub mod withdrawal;
 
-/// EVM Address type - 20 bytes
-#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub struct EVMAddress(pub [u8; 20]);
-
-impl TryFrom<Vec<u8>> for EVMAddress {
-    type Error = &'static str;
-
-    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
-        if value.len() == 20 {
-            Ok(EVMAddress(value.try_into().unwrap()))
-        } else {
-            Err("Expected a Vec<u8> of length 20")
-        }
-    }
-}
-
-impl TryFrom<&str> for EVMAddress {
-    type Error = &'static str;
-
-    fn try_from(value: &str) -> Result<Self, Self::Error> {
-        let clean_address = value.strip_prefix("0x").unwrap_or(value);
-        let bytes = hex::decode(clean_address).map_err(|_| "Invalid hex format for EVM address")?;
-        Self::try_from(bytes)
-    }
-}
-
-impl std::fmt::Display for EVMAddress {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "0x{}", hex::encode(self.0))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_evm_address_from_vec() {
-        let bytes = vec![0u8; 20];
-        let addr = EVMAddress::try_from(bytes).unwrap();
-        assert_eq!(addr.0, [0u8; 20]);
-
-        let too_short = vec![0u8; 19];
-        assert!(EVMAddress::try_from(too_short).is_err());
-
-        let too_long = vec![0u8; 21];
-        assert!(EVMAddress::try_from(too_long).is_err());
-    }
-
-    #[test]
-    fn test_evm_address_from_str() {
-        let addr_str = "0x0000000000000000000000000000000000000000";
-        let addr = EVMAddress::try_from(addr_str).unwrap();
-        assert_eq!(addr.0, [0u8; 20]);
-
-        let without_prefix = "0000000000000000000000000000000000000000";
-        let addr = EVMAddress::try_from(without_prefix).unwrap();
-        assert_eq!(addr.0, [0u8; 20]);
-
-        let invalid_hex = "0xgggggggggggggggggggggggggggggggggggggggg";
-        assert!(EVMAddress::try_from(invalid_hex).is_err());
-
-        let wrong_length = "0x00000000000000000000000000000000000000";
-        assert!(EVMAddress::try_from(wrong_length).is_err());
-    }
-
-    #[test]
-    fn test_evm_address_display() {
-        let bytes = vec![0u8; 20];
-        let addr = EVMAddress::try_from(bytes).unwrap();
-        assert_eq!(
-            addr.to_string(),
-            "0x0000000000000000000000000000000000000000"
-        );
-    }
+pub fn parse_citrea_address(
+    citrea_address: &str,
+) -> Result<CitreaAddress, Box<dyn std::error::Error>> {
+    let citrea_address: CitreaAddress =
+        CitreaAddress::from_str(citrea_address).map_err(|_| "Invalid Citrea address format")?;
+    Ok(citrea_address)
 }