Remove terminal_error method for sender and receiver

The public `terminal_error` method does not really serve a purpose as we
now deal with errors directly in the state machine and don't really have
an opportunity to call the `terminal_error` method where looking for an
error wouldn't be sufficient.

Author: benalleng

payjoin-cli/src/app/v2/mod.rs

@@ -350,36 +350,57 @@ impl AppTrait for App {
         self.db.get_inactive_send_session_ids()?.into_iter().try_for_each(
             |(session_id, completed_at)| {
                 let persister = SenderPersister::from_id(self.db.clone(), session_id.clone());
-                if let Ok((sender_state, session_history)) = replay_sender_event_log(&persister) {
-                    let row = SessionHistoryRow {
-                        session_id,
-                        role: Role::Sender,
-                        status: sender_state,
-                        completed_at: Some(completed_at),
-                        error_message: session_history.terminal_error(),
-                    };
-                    send_rows.push(row);
-                }
+                match replay_sender_event_log(&persister) {
+                    Ok((sender_state, _)) => {
+                        let row = SessionHistoryRow {
+                            session_id,
+                            role: Role::Receiver,
+                            status: sender_state.clone(),
+                            completed_at: Some(completed_at),
+                            error_message: None,
+                        };
+                        send_rows.push(row);
+                    }
+                    Err(e) => {
+                        let row = SessionHistoryRow {
+                            session_id,
+                            role: Role::Receiver,
+                            status: SendSession::TerminalFailure,
+                            completed_at: Some(completed_at),
+                            error_message: Some(e.to_string()),
+                        };
+                        send_rows.push(row);
+                    }
+                };
                 Ok::<_, anyhow::Error>(())
             },
         )?;
 
         self.db.get_inactive_recv_session_ids()?.into_iter().try_for_each(
             |(session_id, completed_at)| {
                 let persister = ReceiverPersister::from_id(self.db.clone(), session_id.clone());
-                if let Ok((receiver_state, session_history)) = replay_receiver_event_log(&persister)
-                {
-                    let row = SessionHistoryRow {
-                        session_id,
-                        role: Role::Receiver,
-                        status: receiver_state,
-                        completed_at: Some(completed_at),
-                        error_message: session_history
-                            .terminal_error()
-                            .map(|e| e.to_json().to_string()),
-                    };
-                    recv_rows.push(row);
-                }
+                match replay_receiver_event_log(&persister) {
+                    Ok((receiver_state, _)) => {
+                        let row = SessionHistoryRow {
+                            session_id,
+                            role: Role::Receiver,
+                            status: receiver_state.clone(),
+                            completed_at: Some(completed_at),
+                            error_message: None,
+                        };
+                        recv_rows.push(row);
+                    }
+                    Err(e) => {
+                        let row = SessionHistoryRow {
+                            session_id,
+                            role: Role::Receiver,
+                            status: ReceiveSession::TerminalFailure,
+                            completed_at: Some(completed_at),
+                            error_message: Some(e.to_string()),
+                        };
+                        recv_rows.push(row);
+                    }
+                };
                 Ok::<_, anyhow::Error>(())
             },
         )?;

payjoin-ffi/src/receive/mod.rs

@@ -145,9 +145,9 @@ impl SessionHistory {
     /// Receiver session Payjoin URI
     pub fn pj_uri(&self) -> Arc<crate::PjUri> { Arc::new(self.0.pj_uri().into()) }
 
-    /// Terminal error from the session if present
-    pub fn terminal_error(&self) -> Option<Arc<JsonReply>> {
-        self.0.terminal_error().map(|reply| Arc::new(reply.into()))
+    /// Psbt With fee contributions applied
+    pub fn psbt_ready_for_signing(&self) -> Option<Arc<crate::Psbt>> {
+        self.0.psbt_ready_for_signing().map(|psbt| Arc::new(psbt.into()))
     }
 
     /// Fallback transaction from the session if present

payjoin/src/core/receive/v2/session.rs

@@ -94,11 +94,10 @@ impl SessionHistory {
         })
     }
 
-    /// Terminal error from the session if present
-    /// TODO: This should replay the event log and return the actual error, not a JSON reply
-    pub fn terminal_error(&self) -> Option<JsonReply> {
+    /// Psbt with fee contributions applied
+    pub fn psbt_ready_for_signing(&self) -> Option<bitcoin::Psbt> {
         self.events.iter().find_map(|event| match event {
-            SessionEvent::GotReplyableError(reply) => Some(reply.clone()),
+            SessionEvent::AppliedFeeRange(psbt_context) => Some(psbt_context.payjoin_psbt.clone()),
             _ => None,
         })
     }

payjoin/src/core/send/v2/session.rs

@@ -91,13 +91,6 @@ impl SessionHistory {
             _ => SessionStatus::Active,
         }
     }
-
-    pub fn terminal_error(&self) -> Option<String> {
-        self.events.iter().find_map(|event| match event {
-            SessionEvent::Closed(SessionOutcome::Failure) => None,
-            _ => None,
-        })
-    }
 }
 
 /// Represents the status of a session that can be inferred from the information in the session
@@ -215,13 +208,53 @@ mod tests {
             persister.save_event(event).expect("In memory persister shouldn't fail");
         }
 
+<<<<<<< HEAD
         let (sender, session_history) =
             replay_event_log(&persister).expect("In memory persister shouldn't fail");
         assert_eq!(sender, test.expected_sender_state);
         assert_eq!(session_history.fallback_tx(), test.expected_session_history.fallback_tx);
         assert_eq!(*session_history.pj_param(), test.expected_session_history.pj_param);
         assert_eq!(session_history.status(), test.expected_session_history.expected_status);
         assert_eq!(session_history.terminal_error(), test.expected_error);
+=======
+        let session = match replay_event_log(&persister) {
+            Ok((sender_state, session_history)) => SessionHistoryTest {
+                events: session_history.events.clone(),
+                expected_session_history: SessionHistoryExpectedOutcome {
+                    fallback_tx: session_history.fallback_tx(),
+                    pj_param: session_history.pj_param().to_owned(),
+                },
+                expected_sender_state: sender_state.clone(),
+                expected_error: None,
+            },
+            Err(e) => SessionHistoryTest {
+                events: vec![],
+                expected_session_history: SessionHistoryExpectedOutcome {
+                    fallback_tx: test.expected_session_history.fallback_tx.clone(),
+                    pj_param: test.expected_session_history.pj_param.clone(),
+                },
+                expected_sender_state: SendSession::TerminalFailure,
+                expected_error: Some(e.to_string()),
+            },
+        };
+
+        assert_eq!(session.expected_sender_state, test.expected_sender_state);
+        assert_eq!(
+            session.expected_session_history.fallback_tx,
+            test.expected_session_history.fallback_tx
+        );
+        assert_eq!(
+            session.expected_session_history.pj_param,
+            test.expected_session_history.pj_param
+        );
+        assert_eq!(
+            session.events.iter().find_map(|event| match event {
+                SessionEvent::SessionInvalid(error) => Some(error.clone()),
+                _ => None,
+            }),
+            test.expected_error
+        );
+>>>>>>> 70daf91a (Remove terminal_error method for sender and receiver)
     }
 
     #[test]