Consolidate utxo types

Orderbook utxos are utxos that capture some metadata including:
amount and owner.

Author: arminsabouri

src/actions.rs

@@ -4,7 +4,7 @@ use log::debug;
 
 use crate::{
     bulletin_board::BulletinBoardId,
-    cospend::UtxoWithAmount,
+    cospend::UtxoWithMetadata,
     message::MessageId,
     transaction::Outpoint,
     tx_contruction::TxConstructionState,
@@ -119,7 +119,7 @@ pub(crate) struct WalletView {
     payment_obligations: Vec<PaymentObligationData>,
     active_cospends: Vec<BulletinBoardId>,
     cospend_proposals: Vec<(BulletinBoardId, MessageId)>,
-    utxos: Vec<UtxoWithAmount>,
+    utxos: Vec<UtxoWithMetadata>,
     registered_inputs: Vec<Outpoint>,
 }
 
@@ -128,7 +128,7 @@ impl WalletView {
         payment_obligations: Vec<PaymentObligationData>,
         cospend_proposals: Vec<(BulletinBoardId, MessageId)>,
         active_cospends: Vec<BulletinBoardId>,
-        utxos: Vec<UtxoWithAmount>,
+        utxos: Vec<UtxoWithMetadata>,
         registered_inputs: Vec<Outpoint>,
     ) -> Self {
         Self {

src/cospend.rs

@@ -3,15 +3,9 @@ use crate::wallet::WalletId;
 use bitcoin::Amount;
 
 #[derive(Debug, Clone)]
-pub(crate) struct UtxoWithAmount {
+pub(crate) struct UtxoWithMetadata {
     pub(crate) outpoint: Outpoint,
     pub(crate) amount: Amount,
-}
-
-/// A UTXO from the order book
-#[derive(Debug, Clone)]
-pub(crate) struct OrderBookEntry {
-    pub(crate) utxo: UtxoWithAmount,
     pub(crate) owner: WalletId,
 }
 
@@ -23,15 +17,15 @@ fn amount_distance(a: Amount, b: Amount) -> u64 {
 /// Each entry is scored by the minimum amount distance to any taker UTXO,
 /// so the best-matched makers appear first.
 pub(crate) fn generate_candidates(
-    order_book: &[OrderBookEntry],
-    taker_utxos: &[UtxoWithAmount],
-) -> Vec<OrderBookEntry> {
-    let mut scored: Vec<(u64, &OrderBookEntry)> = order_book
+    order_book: &[UtxoWithMetadata],
+    taker_utxos: &[UtxoWithMetadata],
+) -> Vec<UtxoWithMetadata> {
+    let mut scored: Vec<(u64, &UtxoWithMetadata)> = order_book
         .iter()
         .map(|entry| {
             let min_dist = taker_utxos
                 .iter()
-                .map(|t| amount_distance(entry.utxo.amount, t.amount))
+                .map(|t| amount_distance(entry.amount, t.amount))
                 .min()
                 .unwrap_or(u64::MAX);
             (min_dist, entry)
@@ -41,8 +35,8 @@ pub(crate) fn generate_candidates(
     scored.sort_unstable_by(|(dist_a, a), (dist_b, b)| {
         dist_a
             .cmp(dist_b)
-            .then_with(|| a.utxo.outpoint.txid.0.cmp(&b.utxo.outpoint.txid.0))
-            .then_with(|| a.utxo.outpoint.index.cmp(&b.utxo.outpoint.index))
+            .then_with(|| a.outpoint.txid.0.cmp(&b.outpoint.txid.0))
+            .then_with(|| a.outpoint.index.cmp(&b.outpoint.index))
     });
 
     scored.into_iter().map(|(_, entry)| entry.clone()).collect()

src/lib.rs

@@ -15,8 +15,7 @@ use serde::Serialize;
 use crate::bulletin_board::BroadcastMessageType;
 use crate::bulletin_board::BulletinBoardData;
 use crate::bulletin_board::BulletinBoardId;
-use crate::cospend::OrderBookEntry;
-use crate::cospend::UtxoWithAmount;
+use crate::cospend::UtxoWithMetadata;
 use crate::message::MessageType;
 use crate::tx_contruction::MultiPartyPayjoinSession;
 use crate::{
@@ -598,19 +597,17 @@ impl<'a> Simulation {
         bx_id.with_mut(self).broadcast(txs)
     }
 
-    fn get_orderbook_utxos(&'a self) -> Vec<OrderBookEntry> {
+    fn get_orderbook_utxos(&'a self) -> Vec<UtxoWithMetadata> {
         self.wallet_data
             .iter()
             .flat_map(|wallet| {
                 let info = &self.wallet_info[wallet.last_wallet_info_id.0];
                 info.registered_inputs
                     .iter()
                     .filter(|outpoint| info.confirmed_utxos.contains(outpoint))
-                    .map(|outpoint| OrderBookEntry {
-                        utxo: UtxoWithAmount {
-                            outpoint: *outpoint,
-                            amount: outpoint.with(self).data().amount,
-                        },
+                    .map(|outpoint| UtxoWithMetadata {
+                        outpoint: *outpoint,
+                        amount: outpoint.with(self).data().amount,
                         owner: wallet.id,
                     })
                     .collect::<Vec<_>>()

src/wallet.rs

@@ -2,7 +2,7 @@ use crate::{
     actions::{Action, CompositeScorer, CompositeStrategy, WalletView},
     blocks::BroadcastSetId,
     bulletin_board::BulletinBoardId,
-    cospend::{generate_candidates, UtxoWithAmount},
+    cospend::{generate_candidates, UtxoWithMetadata},
     message::{MessageId, MessageType},
     script_type::ScriptType,
     tx_contruction::{
@@ -444,9 +444,10 @@ impl<'a> WalletHandleMut<'a> {
         let utxos = self
             .handle()
             .unspent_coins()
-            .map(|o| UtxoWithAmount {
+            .map(|o| UtxoWithMetadata {
                 outpoint: o.outpoint(),
                 amount: o.data().amount,
+                owner: self.id,
             })
             .collect::<Vec<_>>();
         let registered_inputs = self
@@ -466,22 +467,25 @@ impl<'a> WalletHandleMut<'a> {
     }
 
     // TODO: this should take input the list of order book entries
-    // Candidate selection should be done by the cost function
+    // TODO: at this point we are not concerned with what po's are handled just what inputs are being spent and which order book utxos we prefer.
+    // That should be the input to this method
     pub(crate) fn create_cospend_proposal(&'a mut self, po_ids: &[PaymentObligationId]) {
         // TODO: change should be decomposed.
         let change_addr = self.new_address();
         // TODO: should you try to construct with other utxos than the ones bnb picks out?
         let tx_template = self.construct_transaction_template(po_ids, &change_addr, false, None);
         let orderbook_utxos = self.sim.get_orderbook_utxos();
+        // TODO: currently we pick all order book utxos,
         let candidates = generate_candidates(
             &orderbook_utxos,
             &tx_template
                 .inputs
                 .iter()
                 .map(|input| input.outpoint.with(self.sim))
-                .map(|input| UtxoWithAmount {
+                .map(|input| UtxoWithMetadata {
                     outpoint: input.outpoint,
                     amount: input.data().amount,
+                    owner: self.id,
                 })
                 .collect::<Vec<_>>(),
         );
@@ -493,6 +497,7 @@ impl<'a> WalletHandleMut<'a> {
         }
 
         // Collect unique maker wallet IDs from the best candidate
+        // TODO: Why must this be unique?
         let maker_ids: Vec<WalletId> = candidates
             .iter()
             .map(|e| e.owner)