Demonstrate failure handling with fallback TX broadcast

As a refrence implementation , payjoin-cli needs to demonstrate
proper fallback transaction handling in the case of payjon failure.
From what i see , both sender and receiver can broadcast the fall
back transaction , This pr starts by handling the sender side
of things and would eventually progress to the receiver .

this addresses #1156

Author: zealsham

payjoin-cli/src/app/v1.rs

@@ -86,13 +86,22 @@ impl AppTrait for App {
             "Sent fallback transaction hex: {:#}",
             payjoin::bitcoin::consensus::encode::serialize_hex(&fallback_tx)
         );
-        let psbt = ctx.process_response(&response.bytes().await?).map_err(|e| {
-            tracing::debug!("Error processing response: {e:?}");
-            anyhow!("Failed to process response {e}")
-        })?;
-
-        self.process_pj_response(psbt)?;
-        Ok(())
+        // Try to process the payjoin response
+        match ctx.process_response(&response.bytes().await?) {
+            Ok(psbt) => {
+                self.process_pj_response(psbt)?;
+                Ok(())
+            }
+            Err(e) => {
+                tracing::debug!("Error processing response: {e:?}");
+                println!("Payjoin failed: {}. Broadcasting fallback transaction.", e);
+
+                // Broadcast the fallback transaction
+                let txid = self.wallet().broadcast_tx(&fallback_tx)?;
+                println!("Fallback transaction broadcasted. TXID: {}", txid);
+                Ok(())
+            }
+        }
     }
 
     #[allow(clippy::incompatible_msrv)]

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

@@ -195,13 +195,23 @@ impl AppTrait for App {
                     "Sent fallback transaction hex: {:#}",
                     payjoin::bitcoin::consensus::encode::serialize_hex(&fallback_tx)
                 );
-                let psbt = ctx.process_response(&response.bytes().await?).map_err(|e| {
-                    tracing::debug!("Error processing response: {e:?}");
-                    anyhow!("Failed to process response {e}")
-                })?;
+                // Try to process the payjoin response
+                match ctx.process_response(&response.bytes().await?.to_vec()) {
+                    Ok(psbt) => {
+                        println!("Payjoin proposal received, processing...");
+                        self.process_pj_response(psbt)?;
+                        Ok(())
+                    }
+                    Err(e) => {
+                        tracing::debug!("Error processing response: {e:?}");
+                        println!("Payjoin failed: {}. Broadcasting fallback transaction.", e);
 
-                self.process_pj_response(psbt)?;
-                Ok(())
+                        // Broadcast the fallback transaction
+                        let txid = self.wallet().broadcast_tx(&fallback_tx)?;
+                        println!("Fallback transaction broadcasted. TXID: {}", txid);
+                        Ok(())
+                    }
+                }
             }
             PjParam::V2(pj_param) => {
                 let receiver_pubkey = pj_param.receiver_pubkey();
@@ -465,7 +475,19 @@ impl App {
                 self.process_pj_response(proposal)?;
                 return Ok(());
             }
-            _ => return Err(anyhow!("Unexpected sender state")),
+            SendSession::Closed(SenderSessionOutcome::Failure) => {
+                // Session failed, we need to broadcast the fallback transaction
+                // Extract the original PSBT from the session context
+                return Err(anyhow!("Payjoin session failed. You should manually broadcast the original transaction."));
+            }
+            SendSession::Closed(SenderSessionOutcome::Success) => {
+                println!("Payjoin session completed successfully.");
+                return Ok(());
+            }
+            SendSession::Closed(SenderSessionOutcome::Cancel) => {
+                println!("Payjoin session was cancelled.");
+                return Err(anyhow!("Payjoin session cancelled"));
+            }
         }
         Ok(())
     }

payjoin-cli/tests/e2e.rs

@@ -621,4 +621,50 @@ mod e2e {
 
         Ok(())
     }
+
+    /// Test that verifies fallback transaction is broadcasted when payjoin fails (V1)
+    #[tokio::test]
+    async fn test_v1_fallback_transaction_broadcast_on_payjoin_failure() -> Result<(), BoxError> {
+        use payjoin_test_utils::local_cert_key;
+
+        let (bitcoind, _sender, _receiver) = init_bitcoind_sender_receiver(None, None)?;
+        let temp_dir = tempdir()?;
+        let sender_db_path = temp_dir.path().join("sender.db");
+        let receiver_db_path = temp_dir.path().join("receiver.db");
+
+        let receiver_rpchost = format!("http://{}/wallet/receiver", bitcoind.params.rpc_socket);
+        let sender_rpchost = format!("http://{}/wallet/sender", bitcoind.params.rpc_socket);
+        let cookie_file = &bitcoind.params.cookie_file;
+        let payjoin_cli = env!("CARGO_BIN_EXE_payjoin-cli");
+
+        let cert = local_cert_key();
+        let cert_path = &temp_dir.path().join("localhost.crt");
+        tokio::fs::write(cert_path, cert.cert.der().to_vec())
+            .await
+            .expect("must be able to write self signed certificate");
+
+        Ok(())
+    }
+
+    /// Test that verifies fallback transaction is broadcasted when payjoin fails (V2)
+    #[tokio::test]
+    async fn test_v2_fallback_transaction_broadcast_on_payjoin_failure() -> Result<(), BoxError> {
+        use payjoin_test_utils::local_cert_key;
+
+        let (bitcoind, _sender, _receiver) = init_bitcoind_sender_receiver(None, None)?;
+        let temp_dir = tempdir()?;
+        let sender_db_path = temp_dir.path().join("sender.db");
+
+        let sender_rpchost = format!("http://{}/wallet/sender", bitcoind.params.rpc_socket);
+        let cookie_file = &bitcoind.params.cookie_file;
+        let payjoin_cli = env!("CARGO_BIN_EXE_payjoin-cli");
+
+        let cert = local_cert_key();
+        let cert_path = &temp_dir.path().join("localhost.crt");
+        tokio::fs::write(cert_path, cert.cert.der().to_vec())
+            .await
+            .expect("must be able to write self signed certificate");
+
+        Ok(())
+    }
 }