feat: integrate BIP 353 dns payment instructions

Author: sdmg15

Cargo.lock

@@ -36,6 +36,7 @@ shlex = {  version = "1.3.0", optional = true }
 payjoin = { version = "1.0.0-rc.1", features = ["v1", "v2", "io", "_test-utils"], optional = true}
 reqwest = { version = "0.12.23", default-features = false, optional = true }
 url = { version = "2.5.4", optional = true }
+bitcoin-payment-instructions = { version = "0.7.0", optional = true}
 
 [features]
 default = ["repl", "sqlite"]
@@ -51,7 +52,8 @@ redb = ["bdk_redb"]
 cbf = ["bdk_kyoto", "_payjoin-dependencies"]
 electrum = ["bdk_electrum", "_payjoin-dependencies"]
 esplora = ["bdk_esplora", "_payjoin-dependencies"]
-rpc = ["bdk_bitcoind_rpc", "_payjoin-dependencies"] 
+rpc = ["bdk_bitcoind_rpc", "_payjoin-dependencies"]
+dns_payment = ["bitcoin-payment-instructions"] 
 
 # Internal features
 _payjoin-dependencies = ["payjoin", "reqwest", "url"]

Cargo.toml

@@ -19,6 +19,8 @@ use bdk_wallet::bitcoin::{
 };
 use clap::{Args, Parser, Subcommand, ValueEnum, value_parser};
 
+#[cfg(feature = "dns_payment")]
+use crate::utils::parse_dns_recipients;
 #[cfg(any(feature = "electrum", feature = "esplora", feature = "rpc"))]
 use crate::utils::parse_proxy_auth;
 use crate::utils::{parse_address, parse_outpoint, parse_recipient};
@@ -127,6 +129,10 @@ pub enum CliSubCommand {
     },
     /// List all saved wallet configurations.
     Wallets,
+
+    #[cfg(feature = "dns_payment")]
+    /// Resolves the given hrn payment instructions
+    ResolveDnsRecipient { hrn: String },
 }
 /// Wallet operation subcommands.
 #[derive(Debug, Subcommand, Clone, PartialEq)]
@@ -298,6 +304,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", value_parser = parse_dns_recipients)]
+        dns_recipients: Vec<(String, u64)>,
         /// 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/commands.rs

@@ -0,0 +1,194 @@
+use bdk_wallet::bitcoin::{Address, Amount, Network};
+use bitcoin_payment_instructions::{
+    FixedAmountPaymentInstructions, ParseError, PaymentInstructions, PaymentMethod,
+    PaymentMethodType, amount, dns_resolver::DNSHrnResolver,
+};
+use core::{net::SocketAddr, str::FromStr};
+
+use crate::error::BDKCliError;
+
+#[derive(Debug)]
+pub struct Payment {
+    pub payment_methods: Vec<PaymentMethod>,
+    pub min_amount: Option<Amount>,
+    pub max_amount: Option<Amount>,
+    pub description: Option<String>,
+    pub expected_amount: Option<Amount>,
+    pub receiving_addr: Option<Address>,
+    pub notes: String,
+}
+
+pub(crate) async fn parse_dns_instructions(
+    hrn: &str,
+    network: Network,
+) -> Result<PaymentInstructions, ParseError> {
+    let resolver = DNSHrnResolver(SocketAddr::from_str("8.8.8.8:53").expect("Should not fail."));
+    let instructions = PaymentInstructions::parse(hrn, network, &resolver, true).await?;
+    Ok(instructions)
+}
+
+fn get_onchain_info(
+    instructions: &FixedAmountPaymentInstructions,
+) -> Result<(Address, Amount), BDKCliError> {
+    // Look for on chain payment method as it's the only one we can support
+    let PaymentMethod::OnChain(addr) = instructions
+        .methods()
+        .iter()
+        .find(|ix| matches!(ix, PaymentMethod::OnChain(_)))
+        .ok_or(BDKCliError::Generic(
+            "Missing Onchain payment method option.".to_string(),
+        ))?
+    else {
+        return Err(BDKCliError::Generic(
+            "Unsupported payment method".to_string(),
+        ));
+    };
+
+    let Some(onchain_amount) = instructions.onchain_payment_amount() else {
+        return Err(BDKCliError::Generic(
+            "On chain amount should be specified".to_string(),
+        ));
+    };
+
+    // We need this conversion since Amount from instructions is different from Amount from bitcoin
+    Ok((addr.clone(), Amount::from_sat(onchain_amount.milli_sats())))
+}
+
+pub async fn process_instructions(
+    amount_to_send: Amount,
+    payment_instructions: &PaymentInstructions,
+) -> Result<Payment, BDKCliError> {
+    let resolver = DNSHrnResolver(SocketAddr::from_str("8.8.8.8:53").expect("Should not fail."));
+
+    match payment_instructions {
+        PaymentInstructions::ConfigurableAmount(instructions) => {
+            // Look for on chain payment method as it's the only one we can support
+            if instructions
+                .methods()
+                .find(|method| matches!(method.method_type(), PaymentMethodType::OnChain))
+                .is_none()
+            {
+                return Err(BDKCliError::Generic(
+                    "Unsupported payment method".to_string(),
+                ));
+            }
+
+            let min_amount = instructions
+                .min_amt()
+                .map(|amnt| Amount::from_sat(amnt.milli_sats()));
+
+            let max_amount = instructions
+                .max_amt()
+                .map(|amnt| Amount::from_sat(amnt.milli_sats()));
+
+            if min_amount.map_or(false, |min| amount_to_send < min) {
+                return Err(BDKCliError::Generic(
+                    format!(
+                        "Amount to send should be greater than min {}",
+                        min_amount.unwrap()
+                    )
+                    .to_string(),
+                ));
+            }
+
+            if max_amount.map_or(false, |max| amount_to_send > max) {
+                return Err(BDKCliError::Generic(
+                    format!(
+                        "Amount to send should be lower than max {}",
+                        max_amount.unwrap()
+                    )
+                    .to_string(),
+                ));
+            }
+
+            let fixed_instructions = instructions
+                .clone()
+                .set_amount(
+                    amount::Amount::from_sats(amount_to_send.to_sat()).unwrap(),
+                    &resolver,
+                )
+                .await
+                .map_err(|err| {
+                    BDKCliError::Generic(format!("Error occured while parsing instructions {err}"))
+                })?;
+
+            let onchain_details = get_onchain_info(&fixed_instructions)?;
+
+            Ok(Payment {
+                payment_methods: vec![PaymentMethod::OnChain(onchain_details.clone().0)],
+                min_amount,
+                max_amount,
+                description: instructions.recipient_description().map(|s| s.to_string()),
+                expected_amount: Some(onchain_details.1),
+                receiving_addr: Some(onchain_details.0.clone()),
+                notes: "".to_string(),
+            })
+        }
+
+        PaymentInstructions::FixedAmount(instructions) => {
+            let onchain_info = get_onchain_info(&instructions)?;
+
+            Ok(Payment {
+                payment_methods: vec![PaymentMethod::OnChain(onchain_info.clone().0)],
+                min_amount: None,
+                max_amount: instructions
+                    .max_amount()
+                    .map(|amnt| Amount::from_sat(amnt.milli_sats())),
+                description: instructions.recipient_description().map(|s| s.to_string()),
+                expected_amount: Some(onchain_info.1),
+                receiving_addr: Some(onchain_info.0),
+                notes: "".to_string(),
+            })
+        }
+    }
+}
+
+/// Resolves the dns payment instructions found at the specified Human Readable Name
+pub async fn resolve_dns_recipient(hrn: &str, network: Network) -> Result<Payment, ParseError> {
+    let instructions = parse_dns_instructions(hrn, network).await?;
+    let resolver = DNSHrnResolver(SocketAddr::from_str("8.8.8.8:53").expect("Should not fail."));
+
+    match instructions {
+        PaymentInstructions::ConfigurableAmount(ix) => {
+            let description = ix.recipient_description().map(|s| s.to_string());
+            let min_amount = ix.min_amt().map(|amnt| Amount::from_sat(amnt.milli_sats()));
+            let max_amount = ix.max_amt().map(|amnt| Amount::from_sat(amnt.milli_sats()));
+
+            // Let's set a dummy amount to resolve the payment methods accepted.
+            let fixed_instructions = ix
+                .set_amount(amount::Amount::ZERO, &resolver)
+                .await
+                .map_err(ParseError::InvalidInstructions)?;
+
+            let payment = Payment {
+                min_amount,
+                max_amount,
+                payment_methods: fixed_instructions.methods().into(),
+                description,
+                expected_amount: None,
+                receiving_addr: None,
+                notes: "This is configurable payment instructions. You must send an amount between min_amount and max_amount if set.".to_string()
+            };
+
+            Ok(payment)
+        }
+
+        PaymentInstructions::FixedAmount(ix) => {
+            let max_amount = ix
+                .max_amount()
+                .map(|amnt| Amount::from_sat(amnt.milli_sats()));
+
+            let payment = Payment {
+                min_amount: None,
+                max_amount,
+                payment_methods: ix.methods().into(),
+                description: ix.recipient_description().map(|s| s.to_string()),
+                expected_amount: None,
+                receiving_addr: None,
+                notes: "This is a fixed payment instructions. You must send exactly the amount specified in max_amount.".to_string()
+            };
+
+            Ok(payment)
+        }
+    }
+}