Rename "claim_address" to "destination_address" (#119)

* Rename claim_address to destination_address for clarity in deposit and withdrawal commands

* fmt

* change all "claim"s to "destination" for clarity

* typo

---------

Co-authored-by: Ceyhun Şen <ceyhuusen@gmail.com>

Author: aoengin

docs/deposit.md

@@ -27,7 +27,7 @@ The deposit process consists of several stages:
 4. **Recovery (if needed)** - Recover funds if bridging fails
 
 > [!IMPORTANT]
-> The `RECOVERY_TAPROOT_ADDRESS` and the `DEPOSIT_ADDRESS` are different. The `RECOVERY_TAPROOT_ADDRESS` will belong to your Clementine wallet to be able to perform deposit specific signing operations in case the deposit fails, whereas the `DEPOSIT_ADDRESS` is the address you send Bitcoin to in order to perform the deposit operation. Your `RECOVERY_TAPROOT_ADDRESS` is used alongside the `N_of_N_ADDRESS` when creating the `DEPOSIT_ADDRESS` to make sure if the deposit fails, you can recover your funds back to your `CLAIM_ADDRESS`.
+> The `RECOVERY_TAPROOT_ADDRESS` and the `DEPOSIT_ADDRESS` are different. The `RECOVERY_TAPROOT_ADDRESS` will belong to your Clementine wallet to be able to perform deposit specific signing operations in case the deposit fails, whereas the `DEPOSIT_ADDRESS` is the address you send Bitcoin to in order to perform the deposit operation. Your `RECOVERY_TAPROOT_ADDRESS` is used alongside the `N_of_N_ADDRESS` when creating the `DEPOSIT_ADDRESS` to make sure if the deposit fails, you can recover your funds back to your `DESTINATION_ADDRESS`.
 
 ## Step 1: Generate Deposit Address
 
@@ -101,14 +101,14 @@ Gather all necessary information on your online device:
 - `RECOVERY_TAPROOT_ADDRESS`: Your wallet's recovery address (from airgapped device)
 - `EVM_ADDRESS`: Your Citrea address used for the deposit
 - `DEPOSIT_UTXO_OUTPOINT`: Your deposit Outpoint (`txid:vout`)
-- `CLAIM_ADDRESS`: Bitcoin address where recovered funds will be sent
+- `DESTINATION_ADDRESS`: Bitcoin address where recovered funds will be sent
 
 ### Create Recovery Transaction (Airgapped Device)
 
 **AIRGAPPED DEVICE ONLY:** Transfer recovery data to airgapped device and generate signed recovery transaction:
 
 ```sh
-clementine-cli deposit create-signed-recovery-tx --network <BITCOIN_NETWORK> <RECOVERY_TAPROOT_ADDRESS> <CITREA_ADDRESS> <DEPOSIT_OUTPOINT> <CLAIM_ADDRESS> <FEE_RATE> <AMOUNT>
+clementine-cli deposit create-signed-recovery-tx --network <BITCOIN_NETWORK> <RECOVERY_TAPROOT_ADDRESS> <CITREA_ADDRESS> <DEPOSIT_OUTPOINT> <DESTINATION_ADDRESS> <FEE_RATE> <AMOUNT>
 ```
 
 **Example:**

docs/withdraw.md

@@ -9,7 +9,7 @@ All available withdrawal commands can be viewed using `clementine-cli withdraw -
 Before starting a withdrawal, ensure you have:
 
 - A Clementine wallet with `withdrawal` purpose ("wit" prefix address)
-- A Bitcoin address where funds will be sent (claim address)
+- A Bitcoin address where funds will be sent (destination address)
 - Access to both airgapped and online devices
 - Sufficient balance on Citrea to withdraw
 
@@ -27,20 +27,20 @@ The withdrawal process follows these sequential steps:
 8. **Check Status** - Monitor withdrawal progress for operator-paid withdrawal
 
 > [!IMPORTANT]
-> The `SIGNER_ADDRESS` and the `CLAIM_ADDRESS` are different. The `SIGNER_ADDRESS` will belong to your Clementine wallet to be able to perform withdrawal specific signing operations, whereas `CLAIM_ADDRESS` is the address that the withdrawn BTC funds will be sent to.
+> The `SIGNER_ADDRESS` and the `DESTINATION_ADDRESS` are different. The `SIGNER_ADDRESS` will belong to your Clementine wallet to be able to perform withdrawal specific signing operations, whereas `DESTINATION_ADDRESS` is the address that the withdrawn BTC funds will be sent to.
 
 ## Step 1: Start Withdrawal
 
 **ONLINE DEVICE OPERATION:** Start the withdrawal process:
 
 ```sh
-clementine-cli withdraw start --network <BITCOIN_NETWORK> <SIGNER_ADDRESS> <CLAIM_ADDRESS>
+clementine-cli withdraw start --network <BITCOIN_NETWORK> <SIGNER_ADDRESS> <DESTINATION_ADDRESS>
 ```
 
 **Parameters:**
 
 - `SIGNER_ADDRESS`: Withdrawal wallet address with "wit" prefix (from airgapped device)
-- `CLAIM_ADDRESS`: Bitcoin address where funds will be sent
+- `DESTINATION_ADDRESS`: Bitcoin address where funds will be sent
 
 **Example:**
 
@@ -76,7 +76,7 @@ This creates the 0-value UTXO needed for the withdrawal operation.
 **ONLINE DEVICE OPERATION:** Scan for available withdrawal UTXOs that can be used for the withdrawal operation:
 
 ```sh
-clementine-cli withdraw scan --network <BITCOIN_NETWORK> <SIGNER_ADDRESS> <CLAIM_ADDRESS>
+clementine-cli withdraw scan --network <BITCOIN_NETWORK> <SIGNER_ADDRESS> <DESTINATION_ADDRESS>
 ```
 
 **Example:**
@@ -96,7 +96,7 @@ This command will scan Bitcoin network and return possible withdrawal scenarios
 **Transfer from online device to airgapped device:**
 
 - Signer address (with "wit" prefix)
-- Withdrawal address (claim address)
+- Withdrawal address (destination address)
 - Withdrawal UTXO details (from scan command)
 
 ### Generate Signature
@@ -191,7 +191,7 @@ clementine-cli withdraw send-withdrawal-signature-to-operators  --network testne
 **Critical Security Requirements:**
 
 - **Airgapped Signing**: ALL signature generation must occur on airgapped device
-- **Address Verification**: Always verify withdrawal and claim addresses before signing
+- **Address Verification**: Always verify withdrawal and destination addresses before signing
 - **Signature Protection**: Never share or expose withdrawal signatures
 - **Data Verification**: Cross-check all parameters between devices
 - **Status Monitoring**: Regularly monitor withdrawal progress

src/bitcoin_utils.rs

@@ -79,14 +79,14 @@ fn sign_with_tweak(
 }
 
 #[allow(clippy::too_many_arguments)]
-/// Sign a recovery transaction with a given keypair, Citrea 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, destination address, fee rate, and network
 pub(crate) fn sign_recovery_tx(
     keypair: &SecureKeypair,
     citrea_address: &CitreaAddress,
     recovery_taproot_address: &BitcoinAddress,
     deposit_outpoint: &OutPoint,
     deposit_amount: Amount,
-    claim_address: &BitcoinAddress,
+    destination_address: &BitcoinAddress,
     fee_rate: FeeRate,
     config: &BridgeCliConfig,
 ) -> Result<Transaction, BridgeCliError> {
@@ -110,7 +110,7 @@ pub(crate) fn sign_recovery_tx(
 
     let txout = TxOut {
         value: deposit_amount,
-        script_pubkey: claim_address.script_pubkey(),
+        script_pubkey: destination_address.script_pubkey(),
     };
 
     let mut recovery_tx = Transaction {
@@ -122,8 +122,8 @@ pub(crate) fn sign_recovery_tx(
 
     // This is the weight of the transaction without script_pubkey.
     let mut weight = Weight::from_wu(414);
-    let claim_address_script_len = claim_address.script_pubkey().to_bytes().len();
-    weight += Weight::from_wu(claim_address_script_len as u64 * 4);
+    let destination_address_script_len = destination_address.script_pubkey().to_bytes().len();
+    weight += Weight::from_wu(destination_address_script_len as u64 * 4);
     let fee = fee_rate.fee_wu(weight).expect("fee is valid");
     let output_amount: Amount = match deposit_amount.checked_sub(fee) {
         Some(amt) => amt,
@@ -315,10 +315,10 @@ pub(crate) fn sign_withdrawal_signature(
     keypair: &SecureKeypair,
     signer_address: &BitcoinAddress,
     withdrawal_utxo: &OutPoint,
-    claim_address: &BitcoinAddress,
+    destination_address: &BitcoinAddress,
     amount: Amount,
 ) -> Result<bitcoin::taproot::Signature, BridgeCliError> {
-    let withdrawal_tx = create_withdrawal_transaction(withdrawal_utxo, claim_address, amount);
+    let withdrawal_tx = create_withdrawal_transaction(withdrawal_utxo, destination_address, amount);
     let prevout = create_withdrawal_prevout(signer_address);
 
     let sighash = create_withdrawal_sighash(&withdrawal_tx, &prevout)?;
@@ -332,7 +332,7 @@ pub(crate) fn sign_withdrawal_signature(
 
 fn create_withdrawal_transaction(
     withdrawal_utxo: &OutPoint,
-    claim_address: &BitcoinAddress,
+    destination_address: &BitcoinAddress,
     amount: Amount,
 ) -> Transaction {
     let txin = TxIn {
@@ -344,7 +344,7 @@ fn create_withdrawal_transaction(
 
     let txout = TxOut {
         value: amount,
-        script_pubkey: claim_address.script_pubkey(),
+        script_pubkey: destination_address.script_pubkey(),
     };
 
     Transaction {
@@ -359,10 +359,10 @@ pub(crate) fn verify_withdrawal_signature(
     sig: &bitcoin::taproot::Signature,
     signer_address: &BitcoinAddress,
     withdrawal_utxo: &OutPoint,
-    claim_address: &BitcoinAddress,
+    destination_address: &BitcoinAddress,
     amount: Amount,
 ) -> Result<(), BridgeCliError> {
-    let withdrawal_tx = create_withdrawal_transaction(withdrawal_utxo, claim_address, amount);
+    let withdrawal_tx = create_withdrawal_transaction(withdrawal_utxo, destination_address, amount);
     let prevout = create_withdrawal_prevout(signer_address);
 
     let sighash = create_withdrawal_sighash(&withdrawal_tx, &prevout)?;
@@ -512,36 +512,37 @@ mod tests {
         }
     }
 
-    fn create_claim_address(
+    fn create_destination_address(
         address_type: AddressType,
         network: Network,
         key_offset: u8,
     ) -> BitcoinAddress {
         use bitcoin::key::{CompressedPublicKey, PublicKey};
         use bitcoin::script::Builder;
 
-        let claim_secret = SecretKey::from_slice(&[key_offset; 32]).unwrap();
-        let claim_keypair = Keypair::from_secret_key(&SECP, &claim_secret);
-        let claim_pubkey = PublicKey::from(claim_keypair.public_key());
-        let claim_compressed_pubkey = CompressedPublicKey::try_from(claim_pubkey).unwrap();
+        let destination_secret = SecretKey::from_slice(&[key_offset; 32]).unwrap();
+        let destination_keypair = Keypair::from_secret_key(&SECP, &destination_secret);
+        let destination_pubkey = PublicKey::from(destination_keypair.public_key());
+        let destination_compressed_pubkey =
+            CompressedPublicKey::try_from(destination_pubkey).unwrap();
 
         match address_type {
             AddressType::P2tr => {
-                let secure_keypair = SecureKeypair::new(claim_keypair);
+                let secure_keypair = SecureKeypair::new(destination_keypair);
                 calculate_taproot_address(&secure_keypair, network)
             }
-            AddressType::P2wpkh => BitcoinAddress::p2wpkh(&claim_compressed_pubkey, network),
-            AddressType::P2pkh => BitcoinAddress::p2pkh(claim_compressed_pubkey, network),
+            AddressType::P2wpkh => BitcoinAddress::p2wpkh(&destination_compressed_pubkey, network),
+            AddressType::P2pkh => BitcoinAddress::p2pkh(destination_compressed_pubkey, network),
             AddressType::P2sh => {
-                let claim_redeem_script = Builder::new()
+                let destination_redeem_script = Builder::new()
                     .push_int(0)
-                    .push_slice(claim_compressed_pubkey.pubkey_hash())
+                    .push_slice(destination_compressed_pubkey.pubkey_hash())
                     .into_script();
-                BitcoinAddress::p2sh(&claim_redeem_script, network).unwrap()
+                BitcoinAddress::p2sh(&destination_redeem_script, network).unwrap()
             }
             AddressType::P2wsh => {
                 let witness_script = Builder::new()
-                    .push_slice(claim_compressed_pubkey.to_bytes())
+                    .push_slice(destination_compressed_pubkey.to_bytes())
                     .push_opcode(bitcoin::opcodes::all::OP_CHECKSIG)
                     .into_script();
                 BitcoinAddress::p2wsh(&witness_script, network)
@@ -598,7 +599,8 @@ mod tests {
 
     fn test_fee_rate_correctness_for_address_type(address_type: AddressType, key_offset: u8) {
         let setup = TestSetup::new();
-        let claim_address = create_claim_address(address_type, setup.config.network, key_offset);
+        let destination_address =
+            create_destination_address(address_type, setup.config.network, key_offset);
 
         for fee_rate in get_test_fee_rates() {
             let result = sign_recovery_tx(
@@ -607,7 +609,7 @@ mod tests {
                 &setup.recovery_address,
                 &setup.deposit_outpoint,
                 setup.deposit_amount,
-                &claim_address,
+                &destination_address,
                 fee_rate,
                 &setup.config,
             );

src/cli.rs

@@ -285,7 +285,7 @@ pub async fn deposit_create_signed_recovery_tx(
     citrea_addr: &CitreaAddress,
     recovery_taproot_address: &TaprootAddressWithPrefix<bitcoin::address::NetworkChecked>,
     outpoint: &OutPoint,
-    claim_addr: &BitcoinAddress,
+    destination_addr: &BitcoinAddress,
     fee_rate: u64,
     amount: f64,
     config: &BridgeCliConfig,
@@ -298,7 +298,7 @@ pub async fn deposit_create_signed_recovery_tx(
         citrea_addr: *citrea_addr,
         recovery_taproot_address: recovery_taproot_address.clone(),
         outpoint: *outpoint,
-        claim_addr: claim_addr.clone(),
+        destination_addr: destination_addr.clone(),
         fee_rate: Some(fee_rate),
         amount: Some(amount),
     };
@@ -401,19 +401,19 @@ pub async fn cli_get_deposit_address(
 
 pub async fn cli_start_withdrawal(
     signer_address: &TaprootAddressWithPrefix<bitcoin::address::NetworkChecked>,
-    claim_address: &BitcoinAddress,
+    destination_address: &BitcoinAddress,
     config: &BridgeCliConfig,
 ) -> Result<(), BridgeCliError> {
-    start_withdrawal(signer_address, claim_address, config)?;
+    start_withdrawal(signer_address, destination_address, config)?;
     Ok(())
 }
 
 pub async fn cli_scan_withdrawals(
     signer_address: &TaprootAddressWithPrefix<bitcoin::address::NetworkChecked>,
-    claim_address: &BitcoinAddress,
+    destination_address: &BitcoinAddress,
     config: &BridgeCliConfig,
 ) -> Result<(), BridgeCliError> {
-    let utxos = withdraw::scan_withdrawal(signer_address, claim_address, config).await;
+    let utxos = withdraw::scan_withdrawal(signer_address, destination_address, config).await;
 
     let mut utxos =
         utxos.inspect_err(|e| eprintln!("{} Failed to scan withdrawals: {}", "ERROR".bold(), e))?;
@@ -455,7 +455,7 @@ pub async fn cli_scan_withdrawals(
                 "clementine-cli withdraw generate-withdrawal-signatures --network {} {} {} {}",
                 config.network,
                 &signer_address.address_with_prefix(),
-                claim_address,
+                destination_address,
                 outpoint,
             );
         };
@@ -494,7 +494,7 @@ pub async fn cli_scan_withdrawals(
 
 pub fn cli_generate_withdrawal_signatures(
     signer_address: &TaprootAddressWithPrefix<bitcoin::address::NetworkChecked>,
-    claim_address: &BitcoinAddress,
+    destination_address: &BitcoinAddress,
     withdrawal_utxo: &OutPoint,
     optimistic_withdrawal_amount: &Amount,
     operator_withdrawal_amount: &Amount,
@@ -508,7 +508,7 @@ pub fn cli_generate_withdrawal_signatures(
     generate_withdrawal_signatures(
         keypair,
         signer_address,
-        claim_address,
+        destination_address,
         withdrawal_utxo,
         optimistic_withdrawal_amount,
         operator_withdrawal_amount,

src/deposit.rs

@@ -19,7 +19,7 @@ pub struct RecoveryTxParams {
     pub citrea_addr: CitreaAddress,
     pub recovery_taproot_address: TaprootAddressWithPrefix<bitcoin::address::NetworkChecked>,
     pub outpoint: OutPoint,
-    pub claim_addr: BitcoinAddress,
+    pub destination_addr: BitcoinAddress,
     pub fee_rate: Option<u64>,
     pub amount: Option<f64>,
 }
@@ -148,7 +148,7 @@ pub fn create_signed_recovery_tx(
         &params.recovery_taproot_address.address,
         &params.outpoint,
         deposit_amount.unwrap_or(config.bridge_amount),
-        &params.claim_addr,
+        &params.destination_addr,
         fee_rate,
         config,
     )?;

src/errors.rs

@@ -147,9 +147,9 @@ pub enum BridgeCliError {
     #[error("Address mismatch! The decrypted key doesn't correspond to this wallet address.")]
     AddressMismatch,
     #[error(
-        "Claim address cannot be a wallet address. The claim address belongs to one of your wallets."
+        "Destination address cannot be a wallet address. The destination address belongs to one of your wallets."
     )]
-    ClaimAddressIsWalletAddress,
+    DestinationAddressIsWalletAddress,
     #[error("Address '{0}' should not have a prefix.")]
     AddressShouldNotHavePrefix(String),