feat: add option --to_dns to allow specifying dns recipients when creating a transaction

Author: sdmg15

src/commands.rs

@@ -291,6 +291,9 @@ pub enum OfflineWalletSubCommand {
         // Address and amount parsing is done at run time in handler function.
         #[arg(env = "ADDRESS:SAT", long = "to", required = true, value_parser = parse_recipient)]
         recipients: Vec<(ScriptBuf, u64)>,
+        /// Adds DNS recipients to the transaction
+        #[arg(long = "to_dns")]
+        dns_recipients: Option<String>,
         /// Sends all the funds (or all the selected utxos). Requires only one recipient with value 0.
         #[arg(long = "send_all", short = 'a')]
         send_all: bool,

src/dns_payment_instructions.rs

@@ -47,7 +47,7 @@ fn process_fixed_instructions(
     };
 
     // We need this conversion since Amount from instructions is different from Amount from bitcoin
-    let onchain_amount = Amount::from_sat(onchain_amount.sats_rounding_up());
+    let onchain_amount = Amount::from_sat(onchain_amount.milli_sats());
 
     Ok(Payment {
         address: addr.clone(),

src/handlers.rs

@@ -19,6 +19,7 @@ use crate::utils::*;
 #[cfg(feature = "redb")]
 use bdk_redb::Store as RedbStore;
 use bdk_wallet::bip39::{Language, Mnemonic};
+use bdk_wallet::bitcoin::ScriptBuf;
 use bdk_wallet::bitcoin::base64::Engine;
 use bdk_wallet::bitcoin::base64::prelude::BASE64_STANDARD;
 use bdk_wallet::bitcoin::{
@@ -330,7 +331,7 @@ pub async fn handle_offline_wallet_subcommand(
         }
 
         ResolveDnsRecipient { hrn, amount } => {
-            let resolved = resolve_dns_recipient(&hrn, Amount::from_sat(amount), Network::Bitcoin)
+            let resolved = resolve_dns_recipient(&hrn, Amount::from_sat(amount), wallet.network())
                 .await
                 .map_err(|e| Error::Generic(format!("{:?}", e)))?;
 
@@ -344,6 +345,7 @@ pub async fn handle_offline_wallet_subcommand(
 
         CreateTx {
             recipients,
+            dns_recipients,
             send_all,
             enable_rbf,
             offline_signer,
@@ -360,10 +362,34 @@ pub async fn handle_offline_wallet_subcommand(
             if send_all {
                 tx_builder.drain_wallet().drain_to(recipients[0].0.clone());
             } else {
-                let recipients = recipients
+                let mut recipients: Vec<(ScriptBuf, Amount)> = recipients
                     .into_iter()
                     .map(|(script, amount)| (script, Amount::from_sat(amount)))
                     .collect();
+
+                if let Some(recip) = dns_recipients {
+                    let parsed_recip = parse_dns_recipients(&recip)
+                        .await
+                        .map_err(|pe| Error::Generic(format!("Resolution failed: {pe}")))?;
+
+                    // Validates if the amount the user wants to send is in the range of what the payment instructions returned
+                    parsed_recip.iter().try_for_each(|(_, r)| {
+                        let amount = r.amount.to_sat();
+                        if r.min_amount.map_or(false, |min| amount < min.to_sat()) {
+                            return Err(Error::Generic("Amount lesser than min".to_string()));
+                        }
+                        if r.max_amount.map_or(false, |max| amount > max.to_sat()) {
+                            return Err(Error::Generic("Amount greater than max".to_string()));
+                        }
+                        Ok(())
+                    })?;
+
+                    let mut vec_recip = parsed_recip
+                        .iter()
+                        .map(|recip| (recip.1.address.script_pubkey(), recip.1.amount))
+                        .collect::<Vec<_>>();
+                    recipients.append(&mut vec_recip);
+                }
                 tx_builder.set_recipients(recipients);
             }
 

src/utils.rs

@@ -9,7 +9,10 @@
 //! Utility Tools
 //!
 //! This module includes all the utility tools used by the App.
-use crate::error::BDKCliError as Error;
+use crate::{
+    dns_payment_instructions::{Payment, resolve_dns_recipient},
+    error::BDKCliError as Error,
+};
 use std::{
     fmt::Display,
     path::{Path, PathBuf},
@@ -25,7 +28,10 @@ use bdk_kyoto::{
 };
 use bdk_wallet::{
     KeychainKind,
-    bitcoin::bip32::{DerivationPath, Xpub},
+    bitcoin::{
+        Amount,
+        bip32::{DerivationPath, Xpub},
+    },
     keys::DescriptorPublicKey,
     miniscript::{
         Descriptor, Miniscript, Terminal,
@@ -69,6 +75,26 @@ pub(crate) fn parse_recipient(s: &str) -> Result<(ScriptBuf, u64), String> {
     Ok((addr.script_pubkey(), val))
 }
 
+/// Parse dns recipients in the form "test@me.com:10000,test2@from.com:40000" from cli input
+pub(crate) async fn parse_dns_recipients(s: &str) -> Result<Vec<(Amount, Payment)>, String> {
+    let parts: Vec<_> = s.split(',').collect();
+    let mut res = vec![];
+
+    for addr_amount in parts {
+        let split: Vec<_> = addr_amount.split(':').collect();
+        if split.len() != 2 {
+            return Err("Invalid format".to_string());
+        }
+        let sending_amount = Amount::from_sat(u64::from_str(split[1]).map_err(|e| e.to_string())?);
+
+        let resolved = resolve_dns_recipient(split[0], sending_amount, Network::Bitcoin)
+            .await
+            .map_err(|p| format!("Parse Error occured: {:?}", p).to_string())?;
+        res.push((sending_amount, resolved));
+    }
+    Ok(res)
+}
+
 #[cfg(any(feature = "electrum", feature = "esplora", feature = "rpc"))]
 /// Parse the proxy (Socket:Port) argument from the cli input.
 pub(crate) fn parse_proxy_auth(s: &str) -> Result<(String, String), Error> {