support rune offer creation and acceptance across multiple utxos, updated documentation

Author: joshdoman

docs/src/guides/wallet.md

@@ -465,13 +465,13 @@ ord wallet offer create --rune <DECIMAL:RUNE> --fee-rate <FEE_RATE> --amount <AM
 Accepting an Inscription or Runes Buy Offer
 -------------------------------------------
 
-Accept the offer to buy the inscription `INSCRIPTION_ID` for `AMOUNT` via `PSBT` using:
+Accept the offer to buy the inscription `INSCRIPTION_ID` for `AMOUNT` in `PSBT` using:
 
 ```
 ord wallet offer accept --inscription <INSCRIPTION_ID> --amount <AMOUNT> --psbt <PSBT>
 ```
 
-Accept the offer to buy the rune balance `DECIMAL:RUNE` sold in `PSBT` using:
+Accept the offer to buy the rune balance `DECIMAL:RUNE` in `PSBT` using:
 
 ```
 ord wallet offer accept --rune <DECIMAL:RUNE> --amount <AMOUNT> --psbt <PSBT>

src/subcommand/wallet/offer/accept.rs

@@ -39,21 +39,12 @@ impl Accept {
       }
     }
 
-    ensure! {
-      outgoing.len() <= 1,
-      "PSBT contains {} inputs owned by wallet", outgoing.len(),
-    }
-
-    let Some((index, outgoing)) = outgoing.into_iter().next() else {
-      bail!("PSBT contains no inputs owned by wallet");
-    };
-
     match (self.inscription, self.rune.clone()) {
       (Some(inscription), None) => {
-        self.check_inscription_buy_offer(&wallet, outgoing, inscription)?
+        self.check_inscription_buy_offer(&wallet, outgoing.clone(), inscription)?
       }
       (None, Some(rune)) => {
-        self.check_rune_buy_offer(&wallet, psbt.unsigned_tx.clone(), outgoing, rune)?
+        self.check_rune_buy_offer(&wallet, psbt.unsigned_tx.clone(), outgoing.clone(), rune)?
       }
       (None, None) => bail!("must include either --inscription or --rune"),
       (Some(_), Some(_)) => bail!("cannot include both --inscription and --rune"),
@@ -71,7 +62,7 @@ impl Accept {
     for (i, signature) in signatures.iter().enumerate() {
       let outpoint = psbt.unsigned_tx.input[i].previous_output;
 
-      if i == index {
+      if outgoing.contains_key(&i) {
         ensure! {
           signature.is_none(),
           "seller input `{outpoint}` is signed: seller input must not be signed",
@@ -115,7 +106,7 @@ impl Accept {
         {
           let outpoint = signed_tx.input[i].previous_output;
 
-          if i == index {
+          if outgoing.contains_key(&i) {
             ensure! {
               new.is_some(),
               "seller input `{outpoint}` was not signed by wallet",
@@ -138,9 +129,18 @@ impl Accept {
   fn check_inscription_buy_offer(
     &self,
     wallet: &Wallet,
-    outgoing: OutPoint,
+    outgoing: BTreeMap<usize, OutPoint>,
     inscription_id: InscriptionId,
   ) -> Result {
+    ensure! {
+      outgoing.len() <= 1,
+      "PSBT contains {} inputs owned by wallet", outgoing.len(),
+    }
+
+    let Some((_, outgoing)) = outgoing.into_iter().next() else {
+      bail!("PSBT contains no inputs owned by wallet");
+    };
+
     if let Some(runes) = wallet.get_runes_balances_in_output(&outgoing)? {
       ensure! {
         runes.is_empty(),
@@ -175,9 +175,14 @@ impl Accept {
     &self,
     wallet: &Wallet,
     unsigned_tx: Transaction,
-    outgoing: OutPoint,
+    outgoing: BTreeMap<usize, OutPoint>,
     rune: Outgoing,
   ) -> Result {
+    ensure! {
+      !outgoing.is_empty(),
+      "PSBT contains no inputs owned by wallet"
+    }
+
     let (decimal, spaced_rune) = match rune {
       Outgoing::Rune { decimal, rune } => (decimal, rune),
       _ => bail!("invalid format for --rune (must be `DECIMAL:RUNE`)"),
@@ -192,36 +197,46 @@ impl Accept {
       .get_rune(spaced_rune.rune)?
       .with_context(|| format!("rune `{}` has not been etched", spaced_rune.rune))?;
 
-    let Some(runes) = wallet.get_runes_balances_in_output(&outgoing)? else {
-      bail!("outgoing input contains no runes");
-    };
+    let mut contains_multiple_runes = false;
+    let mut amount = 0;
 
-    if let Some(inscriptions) = wallet.get_inscriptions_in_output(&outgoing)? {
-      ensure! {
-        inscriptions.is_empty(),
-        "outgoing input {} contains {} inscription(s)",
-        outgoing,
-        inscriptions.len()
-      }
-    };
+    for utxo in outgoing.values() {
+      let Some(runes) = wallet.get_runes_balances_in_output(utxo)? else {
+        bail! {
+          "outgoing input {} contains no runes",
+          utxo
+        }
+      };
 
-    let Some(pile) = runes.get(&spaced_rune) else {
-      bail!(format!(
-        "outgoing input {} does not contain rune {}",
-        outgoing, spaced_rune
-      ));
-    };
+      if let Some(inscriptions) = wallet.get_inscriptions_in_output(utxo)? {
+        ensure! {
+          inscriptions.is_empty(),
+          "outgoing input {} contains {} inscription(s)",
+          utxo,
+          inscriptions.len()
+        }
+      };
+
+      let Some(pile) = runes.get(&spaced_rune) else {
+        bail!(format!(
+          "outgoing input {} does not contain rune {}",
+          utxo, spaced_rune
+        ));
+      };
+
+      contains_multiple_runes = contains_multiple_runes || runes.len() > 1;
+      amount += pile.amount;
+    }
 
     ensure! {
-      pile.amount == decimal.value,
-      "unexpected rune {} balance at outgoing input {} ({} vs. {})",
+      amount == decimal.value,
+      "unexpected rune {} balance at outgoing input(s) ({} vs. {})",
       spaced_rune,
-      outgoing,
-      pile.amount,
+      amount,
       decimal.value
     }
 
-    if runes.len() > 1 {
+    if contains_multiple_runes {
       let Some(runestone) = Runestone::decipher(&unsigned_tx) else {
         bail!("missing runestone in PSBT");
       };
@@ -242,7 +257,9 @@ impl Accept {
 
       ensure! {
         !unsigned_tx.output.is_empty() &&
-        unsigned_tx.output[0].script_pubkey == wallet.utxos().get(&outgoing).unwrap().script_pubkey,
+        outgoing.values().any(|outgoing| {
+          unsigned_tx.output[0].script_pubkey == wallet.utxos().get(outgoing).unwrap().script_pubkey
+        }),
         "unexpected seller address in PSBT"
       }
     } else {

src/subcommand/wallet/offer/create.rs

@@ -19,7 +19,7 @@ pub(crate) struct Create {
   #[arg(long, help = "<FEE_RATE> for finalized transaction.")]
   fee_rate: FeeRate,
   #[arg(long, help = "UTXO to make an offer for. (format: <TXID:VOUT>)")]
-  utxo: Option<OutPoint>,
+  utxo: Vec<OutPoint>,
   #[arg(
     long,
     help = "Include at least <AMOUNT> postage with receive output. [default: 10000sat]"
@@ -70,9 +70,9 @@ impl Create {
       );
     };
 
-    if let Some(utxo) = self.utxo {
+    for utxo in &self.utxo {
       ensure! {
-        inscription.satpoint.outpoint == utxo,
+        inscription.satpoint.outpoint == *utxo,
         "inscription utxo {} does not match provided utxo {}",
         inscription.satpoint.outpoint,
         utxo
@@ -137,65 +137,83 @@ impl Create {
       .get_rune(spaced_rune.rune)?
       .with_context(|| format!("rune `{}` has not been etched", spaced_rune.rune))?;
 
-    let Some(utxo) = self.utxo else {
-      bail!("--utxo must be set");
-    };
-
-    ensure!(
-      !wallet.utxos().contains_key(&utxo),
-      "utxo {} already in wallet",
-      utxo
-    );
-
     ensure! {
-      wallet.output_exists(utxo)?,
-      "utxo {} does not exist",
-      utxo
+      !self.utxo.is_empty(),
+      "--utxo must be set"
     }
 
-    let Some(output_info) = wallet.get_output_info(utxo)? else {
-      bail!("utxo {} does not exist", utxo);
-    };
+    let mut contains_multiple_runes = false;
+    let mut amount = 0;
+    let mut seller_address = None;
+    let mut seller_postage = Amount::ZERO;
 
-    let Some(seller_address) = output_info.address else {
-      bail!("utxo {} script pubkey not valid address", utxo);
-    };
+    for utxo in &self.utxo {
+      ensure!(
+        !wallet.utxos().contains_key(utxo),
+        "utxo {} already in wallet",
+        *utxo
+      );
 
-    let Some(runes) = output_info.runes else {
-      bail!("utxo {} does not hold any runes", utxo);
-    };
+      ensure! {
+        wallet.output_exists(*utxo)?,
+        "utxo {} does not exist",
+        *utxo
+      }
 
-    let Some(pile) = runes.get(&spaced_rune) else {
-      bail!("utxo {} does not hold any {} runes", utxo, spaced_rune);
-    };
+      let Some(output_info) = wallet.get_output_info(*utxo)? else {
+        bail!("utxo {} does not exist", *utxo);
+      };
+
+      let Some(utxo_seller_address) = output_info.address else {
+        bail!("utxo {} script pubkey not valid address", *utxo);
+      };
+
+      let Some(runes) = output_info.runes else {
+        bail!("utxo {} does not hold any runes", *utxo);
+      };
 
-    if pile.amount < decimal.value {
+      let Some(pile) = runes.get(&spaced_rune) else {
+        bail!("utxo {} does not hold any {} runes", *utxo, spaced_rune);
+      };
+
+      if runes.len() > 1 {
+        contains_multiple_runes = true;
+      }
+
+      amount += pile.amount;
+
+      if seller_address.is_none() {
+        seller_address = Some(utxo_seller_address);
+      }
+
+      seller_postage += Amount::from_sat(output_info.value);
+    }
+
+    if amount < decimal.value {
       bail!(
-        "utxo {} holds less {} than required ({} < {})",
-        utxo,
+        "utxo(s) hold less {} than required ({} < {})",
         spaced_rune,
-        pile.amount,
+        amount,
         decimal.value,
       );
     }
 
-    if pile.amount > decimal.value {
+    if amount > decimal.value {
       bail!(
-        "utxo {} holds more {} than expected ({} > {})",
-        utxo,
+        "utxo(s) hold more {} than expected ({} > {})",
         spaced_rune,
-        pile.amount,
+        amount,
         decimal.value,
       );
     }
 
     let buyer_postage = self.postage.unwrap_or(TARGET_POSTAGE);
 
-    let seller_postage = Amount::from_sat(output_info.value);
-
-    let seller_address = seller_address.require_network(wallet.chain().network())?;
+    let seller_address = seller_address
+      .unwrap()
+      .require_network(wallet.chain().network())?;
 
-    let output = if runes.len() > 1 {
+    let output = if contains_multiple_runes {
       let runestone = Runestone {
         edicts: vec![Edict {
           amount: 0,
@@ -239,12 +257,17 @@ impl Create {
     let tx = Transaction {
       version: Version(2),
       lock_time: LockTime::ZERO,
-      input: vec![TxIn {
-        previous_output: utxo,
-        script_sig: ScriptBuf::new(),
-        sequence: Sequence::ENABLE_RBF_NO_LOCKTIME,
-        witness: Witness::new(),
-      }],
+      input: self
+        .utxo
+        .clone()
+        .into_iter()
+        .map(|utxo| TxIn {
+          previous_output: utxo,
+          script_sig: ScriptBuf::new(),
+          sequence: Sequence::ENABLE_RBF_NO_LOCKTIME,
+          witness: Witness::new(),
+        })
+        .collect(),
       output,
     };