Broadcast fallback transaction V2 test case

Author: zealsham

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

@@ -507,6 +507,7 @@ impl App {
                         return Ok(());
                     }
                     Err(e) => {
+                        // Check if it's a PersistedError with an API error
                         if let Some(persisted_error) = e.downcast_ref::<PersistedError<
                             EncapsulationError,
                             db_error::Error,
@@ -521,6 +522,12 @@ impl App {
                                 ));
                             }
                         }
+                        // Also handle HTTP/network errors (e.g., invalid directory URL)
+                        // These indicate the payjoin cannot proceed, so broadcast fallback
+                        println!("Error posting original proposal: {e}");
+                        let txid = self.wallet().broadcast_tx(fallback_tx)?;
+                        println!("Fallback transaction broadcasted. TXID: {txid}");
+                        return Err(anyhow!("Fallback transaction broadcasted due to: {e}"));
                     }
                 }
             }
@@ -531,6 +538,7 @@ impl App {
                         return Ok(());
                     }
                     Err(e) => {
+                        // Check if it's a PersistedError with an API error
                         if let Some(persisted_error) = e.downcast_ref::<PersistedError<
                             EncapsulationError,
                             db_error::Error,
@@ -545,6 +553,11 @@ impl App {
                                 ));
                             }
                         }
+                        // Also handle HTTP/network errors
+                        println!("Error getting proposed payjoin psbt: {e}");
+                        let txid = self.wallet().broadcast_tx(fallback_tx)?;
+                        println!("Fallback transaction broadcasted. TXID: {txid}");
+                        return Err(anyhow!("Fallback transaction broadcasted due to: {e}"));
                     }
                 }
             }
@@ -554,7 +567,6 @@ impl App {
             }
             _ => return Err(anyhow!("Unexpected sender state")),
         }
-        Ok(())
     }
 
     async fn post_original_proposal(

payjoin-cli/tests/e2e.rs

@@ -196,6 +196,123 @@ mod e2e {
         Ok(())
     }
 
+    #[cfg(feature = "v2")]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+    async fn send_receive_payjoin_v2_fallback_transaction_handling(
+    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+        use payjoin_test_utils::{init_tracing, TestServices};
+        use tempfile::TempDir;
+        use tokio::process::Child;
+
+        type Result<T> = std::result::Result<T, BoxError>;
+
+        init_tracing();
+        let mut services = TestServices::initialize().await?;
+        let temp_dir = tempdir()?;
+
+        let result = tokio::select! {
+            res = services.take_ohttp_relay_handle() => Err(format!("Ohttp relay is long running: {res:?}").into()),
+            res = services.take_directory_handle() => Err(format!("Directory server is long running: {res:?}").into()),
+            res = send_receive_fallback_async(&services, &temp_dir) => res,
+        };
+
+        assert!(result.is_ok(), "v2 fallback test failed: {:#?}", result.unwrap_err());
+
+        async fn send_receive_fallback_async(
+            services: &TestServices,
+            temp_dir: &TempDir,
+        ) -> Result<()> {
+            let receiver_db_path = temp_dir.path().join("receiver_db");
+            let sender_db_path = temp_dir.path().join("sender_db");
+            let (bitcoind, _sender, _receiver) = init_bitcoind_sender_receiver(None, None)?;
+            let cert_path = &temp_dir.path().join("localhost.der");
+            tokio::fs::write(cert_path, services.cert()).await?;
+            services.wait_for_services_ready().await?;
+            let ohttp_keys = services.fetch_ohttp_keys().await?;
+            let ohttp_keys_path = temp_dir.path().join("ohttp_keys");
+            tokio::fs::write(&ohttp_keys_path, ohttp_keys.encode()?).await?;
+
+            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");
+
+            // Use an invalid directory URL to trigger fallback behavior
+            let invalid_directory = "https://random-does-not-exist.com";
+            let ohttp_relay = &services.ohttp_relay_url();
+
+            // Start receiver with invalid directory to simulate failure scenario
+            let cli_receive_initiator = Command::new(payjoin_cli)
+                .arg("--root-certificate")
+                .arg(cert_path)
+                .arg("--rpchost")
+                .arg(&receiver_rpchost)
+                .arg("--cookie-file")
+                .arg(cookie_file)
+                .arg("--db-path")
+                .arg(&receiver_db_path)
+                .arg("--ohttp-relays")
+                .arg(ohttp_relay)
+                .arg("receive")
+                .arg(RECEIVE_SATS)
+                .arg("--pj-directory")
+                .arg(invalid_directory)
+                .arg("--ohttp-keys")
+                .arg(&ohttp_keys_path)
+                .stdout(Stdio::piped())
+                .stderr(Stdio::inherit())
+                .spawn()
+                .expect("Failed to execute payjoin-cli");
+
+            let bip21 = get_bip21_from_receiver(cli_receive_initiator).await;
+
+            // Send with the BIP21 URI - should broadcast fallback transaction
+            let cli_send_initiator = Command::new(payjoin_cli)
+                .arg("--root-certificate")
+                .arg(cert_path)
+                .arg("--rpchost")
+                .arg(&sender_rpchost)
+                .arg("--cookie-file")
+                .arg(cookie_file)
+                .arg("--db-path")
+                .arg(&sender_db_path)
+                .arg("--ohttp-relays")
+                .arg(ohttp_relay)
+                .arg("send")
+                .arg(&bip21)
+                .arg("--fee-rate")
+                .arg("1")
+                .stdout(Stdio::piped())
+                .stderr(Stdio::inherit())
+                .spawn()
+                .expect("Failed to execute payjoin-cli");
+
+            check_fallback_broadcasted(cli_send_initiator).await?;
+
+            Ok(())
+        }
+
+        async fn check_fallback_broadcasted(mut cli_sender: Child) -> Result<()> {
+            let mut stdout =
+                cli_sender.stdout.take().expect("failed to take stdout of child process");
+            let timeout = tokio::time::Duration::from_secs(35);
+            let res = tokio::time::timeout(
+                timeout,
+                wait_for_stdout_match(&mut stdout, |line| {
+                    line.contains("Fallback transaction broadcasted")
+                }),
+            )
+            .await?;
+
+            terminate(cli_sender).await.expect("Failed to kill payjoin-cli sender");
+            assert!(res.is_some(), "Fallback transaction broadcast was not detected");
+            Ok(())
+        }
+
+        Ok(())
+    }
+
     #[cfg(feature = "v1")]
     #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
     async fn send_receive_payjoin_v1_fallback_transaction_handling() -> Result<(), BoxError> {