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

Author: sdmg15

src/commands.rs

@@ -291,8 +291,8 @@ pub enum OfflineWalletSubCommand {
     Transactions,
     /// Returns the current wallet balance.
     Balance,
-    /// Resolves the given DNS payment instructions
     #[cfg(feature = "dns_payment")]
+    /// Resolves the given DNS payment instructions
     ResolveDnsRecipient {
         /// Human Readable Name to resolve
         hrn: String,
@@ -306,6 +306,10 @@ 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)>,
+        #[cfg(feature = "dns_payment")]
+        /// 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(),
@@ -92,7 +92,7 @@ pub async fn resolve_dns_recipient(
                     &resolver,
                 )
                 .await
-                .map_err(|s| ParseError::InvalidInstructions(s))?;
+                .map_err(ParseError::InvalidInstructions)?;
 
             let mut instructions = process_fixed_instructions(&fixed_instructions)?;
 

src/handlers.rs

@@ -21,6 +21,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::{
@@ -332,10 +333,10 @@ pub async fn handle_offline_wallet_subcommand(
                 )?)
             }
         }
-        
+
         #[cfg(feature = "dns_payment")]
         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)))?;
 
@@ -349,6 +350,8 @@ pub async fn handle_offline_wallet_subcommand(
 
         CreateTx {
             recipients,
+            #[cfg(feature = "dns_payment")]
+            dns_recipients,
             send_all,
             enable_rbf,
             offline_signer,
@@ -365,10 +368,36 @@ pub async fn handle_offline_wallet_subcommand(
             if send_all {
                 tx_builder.drain_wallet().drain_to(recipients[0].0.clone());
             } else {
-                let recipients = recipients
+                #[allow(unused_mut)]
+                let mut recipients: Vec<(ScriptBuf, Amount)> = recipients
                     .into_iter()
                     .map(|(script, amount)| (script, Amount::from_sat(amount)))
                     .collect();
+
+                #[cfg(feature = "dns_payment")]
+                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);
             }
 
@@ -1329,7 +1358,7 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
                     &wallet_opts,
                     &cli_opts,
                     offline_subcommand.clone(),
-                )?
+                ).await?
             };
             Ok(result)
         }

src/utils.rs

@@ -10,7 +10,12 @@
 //!
 //! This module includes all the utility tools used by the App.
 use crate::config::WalletConfig;
+#[cfg(feature = "dns_payment")]
+use crate::dns_payment_instructions::{Payment, resolve_dns_recipient};
 use crate::error::BDKCliError as Error;
+#[cfg(feature = "dns_payment")]
+use bdk_wallet::bitcoin::Amount;
+
 use std::{
     fmt::Display,
     path::{Path, PathBuf},
@@ -70,6 +75,27 @@ pub(crate) fn parse_recipient(s: &str) -> Result<(ScriptBuf, u64), String> {
     Ok((addr.script_pubkey(), val))
 }
 
+#[cfg(feature = "dns_payment")]
+/// 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> {