add resolve_dns_recipient command

Author: sdmg15

Cargo.lock

@@ -34,6 +34,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.5.0", optional = true}
 
 [features]
 default = ["repl", "sqlite"]
@@ -49,7 +50,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

@@ -277,6 +277,13 @@ pub enum OfflineWalletSubCommand {
     Transactions,
     /// Returns the current wallet balance.
     Balance,
+    /// Resolves the given DNS payment instructions
+    ResolveDnsRecipient {
+        /// Human Readable Name to resolve
+        hrn: String,
+        /// The amount you're willing to send to the HRN
+        amount: u64,
+    },
     /// Creates a new unsigned transaction.
     CreateTx {
         /// Adds a recipient to the transaction.

src/commands.rs

@@ -0,0 +1,107 @@
+use bdk_wallet::bitcoin::{Address, Amount, Network};
+use bitcoin_payment_instructions::{
+    FixedAmountPaymentInstructions, ParseError, PaymentInstructions, PaymentMethod,
+    PaymentMethodType, amount, dns_resolver::DNSHrnResolver, hrn_resolution::HrnResolver,
+};
+use core::{net::SocketAddr, str::FromStr};
+
+async fn parse_dns_instructions(
+    hrn: &str,
+    resolver: &impl HrnResolver,
+    network: Network,
+) -> Result<PaymentInstructions, ParseError> {
+    let instructions = PaymentInstructions::parse(hrn, network, resolver, true).await?;
+    Ok(instructions)
+}
+
+#[derive(Debug)]
+#[allow(dead_code)]
+pub struct Payment {
+    pub address: Address,
+    pub amount: Amount,
+    pub min_amount: Option<Amount>,
+    pub max_amount: Option<Amount>,
+    pub dnssec_proof: Option<Vec<u8>>,
+}
+
+fn process_fixed_instructions(
+    instructions: &FixedAmountPaymentInstructions,
+) -> Result<Payment, ParseError> {
+    // 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(_)))
+        .map(|pm| pm)
+        .unwrap()
+    else {
+        return Err(ParseError::InvalidInstructions(
+            "Unsupported payment method",
+        ));
+    };
+
+    let Some(onchain_amount) = instructions.onchain_payment_amount() else {
+        return Err(ParseError::InvalidInstructions(
+            "On chain amount should be specified",
+        ));
+    };
+
+    // 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());
+
+    Ok(Payment {
+        address: addr.clone(),
+        amount: onchain_amount,
+        min_amount: None,
+        max_amount: None,
+        dnssec_proof: instructions.bip_353_dnssec_proof().clone(),
+    })
+}
+
+pub async fn resolve_dns_recipient(
+    hrn: &str,
+    amount: Amount,
+    network: Network,
+) -> Result<Payment, ParseError> {
+    let resolver = DNSHrnResolver(SocketAddr::from_str("8.8.8.8:53").expect("Should not fail."));
+    let payment_instructions = parse_dns_instructions(hrn, &resolver, network).await?;
+
+    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(ParseError::InvalidInstructions(
+                    "Unsupported payment method",
+                ));
+            }
+
+            let min_amount = instructions
+                .min_amt()
+                .map(|amnt| Amount::from_sat(amnt.sats_rounding_up()));
+            let max_amount = instructions
+                .max_amt()
+                .map(|amnt| Amount::from_sat(amnt.sats_rounding_up()));
+
+            let fixed_instructions = instructions
+                .set_amount(
+                    amount::Amount::from_sats(amount.to_sat()).unwrap(),
+                    &resolver,
+                )
+                .await
+                .map_err(|s| ParseError::InvalidInstructions(s))?;
+
+            let mut instructions = process_fixed_instructions(&fixed_instructions)?;
+
+            instructions.min_amount = min_amount;
+            instructions.max_amount = max_amount;
+
+            Ok(instructions)
+        }
+
+        PaymentInstructions::FixedAmount(instructions) => process_fixed_instructions(&instructions),
+    }
+}

src/dns_payment_instructions.rs

@@ -11,6 +11,7 @@
 //! This module describes all the command handling logic used by bdk-cli.
 use crate::commands::OfflineWalletSubCommand::*;
 use crate::commands::*;
+use crate::dns_payment_instructions::resolve_dns_recipient;
 use crate::error::BDKCliError as Error;
 #[cfg(any(feature = "sqlite", feature = "redb"))]
 use crate::persister::Persister;
@@ -94,7 +95,7 @@ const NUMS_UNSPENDABLE_KEY_HEX: &str =
 /// Execute an offline wallet sub-command
 ///
 /// Offline wallet sub-commands are described in [`OfflineWalletSubCommand`].
-pub fn handle_offline_wallet_subcommand(
+pub async fn handle_offline_wallet_subcommand(
     wallet: &mut Wallet,
     wallet_opts: &WalletOpts,
     cli_opts: &CliOpts,
@@ -328,6 +329,19 @@ pub fn handle_offline_wallet_subcommand(
             }
         }
 
+        ResolveDnsRecipient { hrn, amount } => {
+            let resolved = resolve_dns_recipient(&hrn, Amount::from_sat(amount), Network::Bitcoin)
+                .await
+                .map_err(|e| Error::Generic(format!("{:?}", e)))?;
+
+            Ok(serde_json::to_string_pretty(&json!({
+                    "hrn": hrn,
+                    "recipient": resolved.address,
+                    "min_amount": resolved.min_amount.unwrap_or_default(),
+                    "max_amount": resolved.max_amount.unwrap_or_default(),
+            }))?)
+        }
+
         CreateTx {
             recipients,
             send_all,
@@ -1046,7 +1060,8 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
                     wallet_opts,
                     &cli_opts,
                     offline_subcommand.clone(),
-                )?;
+                )
+                .await?;
                 wallet.persist(&mut persister)?;
                 result
             };
@@ -1194,6 +1209,7 @@ async fn respond(
         } => {
             let value =
                 handle_offline_wallet_subcommand(wallet, wallet_opts, cli_opts, offline_subcommand)
+                    .await
                     .map_err(|e| e.to_string())?;
             Some(value)
         }

src/handlers.rs

@@ -24,6 +24,9 @@ mod payjoin;
 mod persister;
 mod utils;
 
+#[cfg(feature = "dns_payment")]
+mod dns_payment_instructions;
+
 use bdk_wallet::bitcoin::Network;
 use log::{debug, error, warn};