Scan for po's handled in a cospend

Mark po's as success if they are handled in the a cospend.

Author: arminsabouri

mppj/results.json

@@ -1,29 +1,19 @@
 {
   "total_payment_obligations": 10,
-  "percentage_payment_obligations_missed": 1.0,
-  "total_block_weight_wu": 16132,
-  "average_fee_cost_sats": 143,
-  "dust_utxo_count": 5,
+  "percentage_payment_obligations_missed": 0.8,
+  "total_block_weight_wu": 12742,
+  "average_fee_cost_sats": 471,
+  "dust_utxo_count": 1,
   "utxo_size_distribution_sats": [
     152,
-    152,
-    152,
-    152,
-    152,
-    821,
-    821,
-    821,
-    821,
-    821,
-    821,
-    821,
     821,
-    8422,
-    4999991468,
-    4999996768,
-    4999997024,
-    4999999027,
-    4999999289,
+    4483,
+    8521,
+    11851,
+    4999988039,
+    4999991369,
+    4999995407,
+    4999998886,
     5000000000,
     5000000000,
     5000000000,
@@ -78,39 +68,40 @@
     5000000000,
     5000000000,
     5000000000,
-    5000000110,
-    5000000141,
-    5000000141,
-    5000000141,
-    5000000141
+    5000000000,
+    5000000000,
+    5000000000,
+    5000000000,
+    5000000000,
+    5000000471
   ],
   "wallet_utxo_stats": [
     {
       "wallet_id": 0,
       "dust_count": 0,
-      "total_count": 47,
+      "total_count": 48,
       "p50_sats": 5000000000,
-      "p90_sats": 5000000110
+      "p90_sats": 5000000000
     },
     {
       "wallet_id": 1,
-      "dust_count": 5,
-      "total_count": 10,
-      "p50_sats": 152,
+      "dust_count": 1,
+      "total_count": 6,
+      "p50_sats": 5000000000,
       "p90_sats": 5000000000
     },
     {
       "wallet_id": 2,
       "dust_count": 0,
-      "total_count": 7,
+      "total_count": 8,
       "p50_sats": 5000000000,
       "p90_sats": 5000000000
     },
     {
       "wallet_id": 3,
       "dust_count": 0,
-      "total_count": 14,
-      "p50_sats": 821,
+      "total_count": 7,
+      "p50_sats": 5000000000,
       "p90_sats": 5000000000
     }
   ]

src/actions.rs

@@ -99,23 +99,23 @@ pub(crate) struct ParticipateMultiPartyPayjoinOutcome {
     base_cost: f64,
 }
 
- #[derive(Debug)]
- pub(crate) struct RespondToPayjoinOutcome {
-     /// Base cost: fee_paid + amount handled. In sats
-     base_cost: f64,
- }
- 
- impl RespondToPayjoinOutcome {
-     fn cost(&self) -> ActionCost {
-         // Responding to a payjoin should always be better than unilaterally spending at this point
-         // As there is no interaction cost. TODO in the future we will want to model the cost of doing
-         // the last round of interaction with the counterparty as a function of rounds remaining.
-         ActionCost(0.0)
-     }
- }
- 
- #[derive(Debug)]
-      // TODO: model the participation utility as a linear function of the progression of the session
+#[derive(Debug)]
+pub(crate) struct RespondToPayjoinOutcome {
+    /// Base cost: fee_paid + amount handled. In sats
+    base_cost: f64,
+}
+
+impl RespondToPayjoinOutcome {
+    fn cost(&self) -> ActionCost {
+        // Responding to a payjoin should always be better than unilaterally spending at this point
+        // As there is no interaction cost. TODO in the future we will want to model the cost of doing
+        // the last round of interaction with the counterparty as a function of rounds remaining.
+        ActionCost(0.0)
+    }
+}
+
+#[derive(Debug)]
+// TODO: model the participation utility as a linear function of the progression of the session
 pub(crate) struct AcceptCospendOutcome;
 
 impl AcceptCospendOutcome {
@@ -449,51 +449,51 @@ impl Strategy for BatchSpender {
 }
 
 #[derive(Debug, Clone)]
- pub(crate) struct MultipartyPayjoinInitiatorStrategy;
- 
- impl Strategy for MultipartyPayjoinInitiatorStrategy {
-     fn enumerate_candidate_actions(&self, state: &WalletView) -> Vec<Action> {
-         if state.payment_obligations.is_empty() {
-             return vec![Action::Wait];
-         }
-         // TODO: if the sesion is on going do not intiate a new one
-         // TODO: this is scaffolding for now, peers in the future will evaluate if they should initiate a multi-party payjoin given the number of payment obligations
-         if state.wallet_id != WalletId(0) {
-             return vec![Action::Wait];
-         }
-         let receivers = state
-             .payment_obligations
-             .iter()
-             .map(|po| po.to)
-             .collect::<HashSet<_>>();
-         if receivers.len() < 2 {
-             return vec![Action::Wait];
-         }
- 
-         // TODO: only one multi-party payjoin session can be active at a time FOR NOW
-         let mut actions = vec![];
+pub(crate) struct MultipartyPayjoinInitiatorStrategy;
+
+impl Strategy for MultipartyPayjoinInitiatorStrategy {
+    fn enumerate_candidate_actions(&self, state: &WalletView) -> Vec<Action> {
+        if state.payment_obligations.is_empty() {
+            return vec![Action::Wait];
+        }
+        // TODO: if the sesion is on going do not intiate a new one
+        // TODO: this is scaffolding for now, peers in the future will evaluate if they should initiate a multi-party payjoin given the number of payment obligations
+        if state.wallet_id != WalletId(0) {
+            return vec![Action::Wait];
+        }
+        let receivers = state
+            .payment_obligations
+            .iter()
+            .map(|po| po.to)
+            .collect::<HashSet<_>>();
+        if receivers.len() < 2 {
+            return vec![Action::Wait];
+        }
+
+        // TODO: only one multi-party payjoin session can be active at a time FOR NOW
+        let mut actions = vec![];
         if !state.active_cospends.is_empty() {
-             // If we have an active session we should actively participate in it
+            // If we have an active session we should actively participate in it
             debug_assert!(state.active_cospends.len() <= 1);
             for bulletin_board_id in state.active_cospends.iter() {
                 actions.push(Action::ContinueParticipateInCospend(*bulletin_board_id));
-             }
-             return actions;
-         }
- 
+            }
+            return actions;
+        }
+
         actions.push(Action::CreateCospendProposal(
-             state.payment_obligations.iter().map(|po| po.id).collect(),
-         ));
- 
-         actions
-     }
- 
-     fn clone_box(&self) -> Box<dyn Strategy> {
-         Box::new(self.clone())
-     }
- }
- 
- #[derive(Debug, Clone)]
+            state.payment_obligations.iter().map(|po| po.id).collect(),
+        ));
+
+        actions
+    }
+
+    fn clone_box(&self) -> Box<dyn Strategy> {
+        Box::new(self.clone())
+    }
+}
+
+#[derive(Debug, Clone)]
 pub(crate) struct MakerStrategy;
 
 impl Strategy for MakerStrategy {

src/blocks.rs

@@ -204,6 +204,20 @@ impl<'a> BroadcastSetHandleMut<'a> {
                             {
                                 info.handled_payment_obligations
                                     .extend(payment_obligation_ids.iter().map(|id| *id));
+
+                                for (_, mppj_session) in info.active_multi_party_payjoins.iter() {
+                                    if mppj_session
+                                        .tx_template
+                                        .inputs
+                                        .iter()
+                                        .any(|i| i.outpoint == input.data().outpoint)
+                                    {
+                                        info.handled_payment_obligations.extend(
+                                            mppj_session.payment_obligation_ids.iter().copied(),
+                                        );
+                                        break;
+                                    }
+                                }
                             }
                         })
                     }

src/tx_contruction.rs

@@ -22,6 +22,8 @@ pub(crate) struct MultiPartyPayjoinSession {
     pub(crate) tx_template: TxData,
     /// The state of the session
     pub(crate) state: TxConstructionState,
+    /// True if this wallet created the session (taker/initiator), false for makers/participants
+    pub(crate) is_initiator: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -30,7 +32,7 @@ pub(crate) enum TxConstructionState {
     SentInputs,
     SentOutputs,
     SentReadyToSign,
-    Success(TxId),
+    Success(Option<TxId>),
 }
 
 #[derive(Debug)]

src/wallet.rs

@@ -54,6 +54,7 @@ define_entity_info!(Wallet, {
         /// Set of multi-party payjoin sessions that this wallet is participating in
         pub(crate) active_multi_party_payjoins: HashMap<BulletinBoardId, MultiPartyPayjoinSession>,
         /// UTXOs registered in the order book by this wallet
+        // TODO: this should be moved to wallet data
         pub(crate) registered_inputs: OrdSet<Outpoint>,
     }
 );
@@ -248,9 +249,6 @@ impl<'a> WalletHandleMut<'a> {
     }
 
     fn create_multi_party_payjoin_session(&mut self, po_ids: &[PaymentObligationId]) {
-        if self.id.0 != 0 {
-            return; // TODO For now the first wallet is the leader
-        }
         // First we create the bulletin board
         let bulletin_board_id = self.sim.create_bulletin_board();
         // Then we invite all members to join
@@ -273,6 +271,7 @@ impl<'a> WalletHandleMut<'a> {
             payment_obligation_ids: po_ids.to_owned(),
             tx_template,
             state: TxConstructionState::SentInputs,
+            is_initiator: true,
         };
         self.info_mut()
             .active_multi_party_payjoins
@@ -343,22 +342,26 @@ impl<'a> WalletHandleMut<'a> {
             TxConstructionState::SentReadyToSign => {
                 let t = SentReadyToSign::new(self.sim, *bulletin_board_id);
                 let res = t.have_enough_ready_to_sign();
-                info!(">>> have enough ready to sign: {:?}, id: {:?}", res, self.id);
                 if let Some(tx) = res {
-                    // TODO: only the leader should broadcast the tx right now
-                    if self.id.0 != 0 {
+                    if !session.is_initiator {
+                        let mut updated_session = session.clone();
+                        updated_session.state = TxConstructionState::Success(None);
+
+                        // TODO: update latest wallet info index in wallet data
+                        self.info_mut()
+                            .active_multi_party_payjoins
+                            .insert(*bulletin_board_id, updated_session);
                         return;
                     }
-                    println!("tx: {:?}", tx);
                     let tx_id = self.spend_tx(tx);
-                    log::info!(
-                        "Multi party payjoin session successful with bulletin board id: {:?}",
-                        bulletin_board_id
-                    );
                     self.broadcast(std::iter::once(tx_id));
-                    // Update session state to success
+                    let po_ids = session.payment_obligation_ids.clone();
+                    self.info_mut()
+                        .txid_to_payment_obligation_ids
+                        .insert(tx_id, po_ids);
+                    // TODO: update latest wallet info index in wallet data
                     let mut updated_session = session.clone();
-                    updated_session.state = TxConstructionState::Success(tx_id);
+                    updated_session.state = TxConstructionState::Success(Some(tx_id));
                     self.info_mut()
                         .active_multi_party_payjoins
                         .insert(*bulletin_board_id, updated_session);
@@ -441,6 +444,8 @@ impl<'a> WalletHandleMut<'a> {
         )
     }
 
+    // TODO: this should take input the list of order book entries
+    // Candidate selection should be done by the cost function
     pub(crate) fn create_cospend_proposal(&'a mut self, po_ids: &[PaymentObligationId]) {
         // TODO: change should be decomposed.
         let change_addr = self.new_address();
@@ -461,10 +466,10 @@ impl<'a> WalletHandleMut<'a> {
         );
 
         // If no candidates, fall back to a plain batch spend
-        let Some(_) = candidates.first() else {
+        if candidates.is_empty() {
             self.handle_payment_obligations(po_ids);
             return;
-        };
+        }
 
         // Collect unique maker wallet IDs from the best candidate
         let maker_ids: Vec<WalletId> = candidates
@@ -496,6 +501,7 @@ impl<'a> WalletHandleMut<'a> {
             payment_obligation_ids: po_ids.to_owned(),
             tx_template,
             state: TxConstructionState::SentInputs,
+            is_initiator: true,
         };
         self.info_mut()
             .active_multi_party_payjoins
@@ -541,6 +547,7 @@ impl<'a> WalletHandleMut<'a> {
                         tx_template,
                         // TODO: better state for someone who has not started the session yet
                         state: TxConstructionState::SentBulletinBoardId,
+                        is_initiator: false,
                     },
                 );
                 // Mark message as processed