test multiple coinbase outputs round-trip

xyephy · xyephy · commit d0fb1970bfa2 · 2026-03-09T07:24:45.000+03:00
Closes #58
diff --git a/integration-tests/lib/mod.rs b/integration-tests/lib/mod.rs
@@ -167,10 +167,23 @@ pub async fn start_pool(
 pub fn start_template_provider(
     sv2_interval: Option<u32>,
     difficulty_level: DifficultyLevel,
+) -> (TemplateProvider, SocketAddr) {
+    start_template_provider_with_args(sv2_interval, difficulty_level, vec![])
+}
+
+pub fn start_template_provider_with_args(
+    sv2_interval: Option<u32>,
+    difficulty_level: DifficultyLevel,
+    extra_bitcoin_args: Vec<&str>,
 ) -> (TemplateProvider, SocketAddr) {
     let address = get_available_address();
     let sv2_interval = sv2_interval.unwrap_or(20);
-    let template_provider = TemplateProvider::start(address.port(), sv2_interval, difficulty_level);
+    let template_provider = TemplateProvider::start_with_args(
+        address.port(),
+        sv2_interval,
+        difficulty_level,
+        extra_bitcoin_args,
+    );
     template_provider.generate_blocks(1);
     (template_provider, address)
 }
diff --git a/integration-tests/lib/template_provider.rs b/integration-tests/lib/template_provider.rs
@@ -69,6 +69,18 @@ pub struct BitcoinCore {
 impl BitcoinCore {
     /// Start a new [`BitcoinCore`] instance with IPC enabled.
     pub fn start(port: u16, difficulty_level: DifficultyLevel) -> Self {
+        Self::start_with_args(port, difficulty_level, vec![])
+    }
+
+    /// Start a new [`BitcoinCore`] instance with IPC enabled and extra arguments.
+    ///
+    /// Set `BITCOIN_NODE_BIN` to override the bitcoin-node binary path
+    /// (e.g. a custom build with `-testmulticoinbase` support).
+    pub fn start_with_args(
+        port: u16,
+        difficulty_level: DifficultyLevel,
+        extra_args: Vec<&str>,
+    ) -> Self {
         let current_dir: PathBuf = std::env::current_dir().expect("failed to read current dir");
         let bin_dir = current_dir.join("template-provider");
         // Use temp dir for Bitcoin datadir to avoid long Unix socket paths in CI
@@ -110,46 +122,53 @@ impl BitcoinCore {
             }
         }
 
-        // Download and setup Bitcoin Core v30.2 with IPC support
-        let os = env::consts::OS;
-        let arch = env::consts::ARCH;
-        let bitcoin_filename = get_bitcoin_core_filename(os, arch);
-        let bitcoin_home = bin_dir.join(format!("bitcoin-{VERSION_BITCOIN_CORE}"));
-        let bitcoin_node_bin = bitcoin_home.join("libexec").join("bitcoin-node");
-        let bitcoin_cli_bin = bitcoin_home.join("bin").join("bitcoin-cli");
+        // Use custom bitcoin-node binary if BITCOIN_NODE_BIN is set,
+        // otherwise download Bitcoin Core v30.2.
+        let bitcoin_node_bin = if let Ok(custom_bin) = env::var("BITCOIN_NODE_BIN") {
+            PathBuf::from(custom_bin)
+        } else {
+            let os = env::consts::OS;
+            let arch = env::consts::ARCH;
+            let bitcoin_filename = get_bitcoin_core_filename(os, arch);
+            let bitcoin_home = bin_dir.join(format!("bitcoin-{VERSION_BITCOIN_CORE}"));
+            let bitcoin_node_bin = bitcoin_home.join("libexec").join("bitcoin-node");
+            let bitcoin_cli_bin = bitcoin_home.join("bin").join("bitcoin-cli");
+
+            if !bitcoin_node_bin.exists() {
+                let tarball_bytes = match env::var("BITCOIN_CORE_TARBALL_FILE") {
+                    Ok(path) => tarball::read_from_file(&path),
+                    Err(_) => {
+                        warn!("Downloading Bitcoin Core {} for the testing session. This could take a while...", VERSION_BITCOIN_CORE);
+                        let download_endpoint = env::var("BITCOIN_CORE_DOWNLOAD_ENDPOINT")
+                            .unwrap_or_else(|_| {
+                                "https://bitcoincore.org/bin/bitcoin-core-30.2".to_owned()
+                            });
+                        let url = format!("{download_endpoint}/{bitcoin_filename}");
+                        http::make_get_request(&url, 5)
+                    }
+                };
 
-        if !bitcoin_node_bin.exists() {
-            let tarball_bytes = match env::var("BITCOIN_CORE_TARBALL_FILE") {
-                Ok(path) => tarball::read_from_file(&path),
-                Err(_) => {
-                    warn!("Downloading Bitcoin Core {} for the testing session. This could take a while...", VERSION_BITCOIN_CORE);
-                    let download_endpoint = env::var("BITCOIN_CORE_DOWNLOAD_ENDPOINT")
-                        .unwrap_or_else(|_| {
-                            "https://bitcoincore.org/bin/bitcoin-core-30.2".to_owned()
-                        });
-                    let url = format!("{download_endpoint}/{bitcoin_filename}");
-                    http::make_get_request(&url, 5)
+                if let Some(parent) = bitcoin_home.parent() {
+                    create_dir_all(parent).unwrap();
                 }
-            };
 
-            if let Some(parent) = bitcoin_home.parent() {
-                create_dir_all(parent).unwrap();
-            }
-
-            tarball::unpack(&tarball_bytes, &bin_dir);
-
-            // Sign the binaries on macOS
-            if os == "macos" {
-                for bin in &[&bitcoin_node_bin, &bitcoin_cli_bin] {
-                    std::process::Command::new("codesign")
-                        .arg("--sign")
-                        .arg("-")
-                        .arg(bin)
-                        .output()
-                        .expect("Failed to sign Bitcoin Core binary");
+                tarball::unpack(&tarball_bytes, &bin_dir);
+
+                // Sign the binaries on macOS
+                if os == "macos" {
+                    for bin in &[&bitcoin_node_bin, &bitcoin_cli_bin] {
+                        std::process::Command::new("codesign")
+                            .arg("--sign")
+                            .arg("-")
+                            .arg(bin)
+                            .output()
+                            .expect("Failed to sign Bitcoin Core binary");
+                    }
                 }
             }
-        }
+
+            bitcoin_node_bin
+        };
 
         // Add IPC and basic args
         conf.args.extend(vec![
@@ -158,6 +177,7 @@ impl BitcoinCore {
             "-debug=rpc",
             "-logtimemicros=1",
         ]);
+        conf.args.extend(extra_args);
 
         // Launch bitcoin-node using corepc-node (which will manage the process for us)
         let timeout = std::time::Duration::from_secs(10);
@@ -278,7 +298,17 @@ pub struct TemplateProvider {
 impl TemplateProvider {
     /// Start a new [`TemplateProvider`] instance with Bitcoin Core v30.2+ and standalone sv2-tp.
     pub fn start(port: u16, sv2_interval: u32, difficulty_level: DifficultyLevel) -> Self {
-        let bitcoin_core = BitcoinCore::start(port, difficulty_level);
+        Self::start_with_args(port, sv2_interval, difficulty_level, vec![])
+    }
+
+    /// Start with extra arguments passed to bitcoin-node.
+    pub fn start_with_args(
+        port: u16,
+        sv2_interval: u32,
+        difficulty_level: DifficultyLevel,
+        extra_bitcoin_args: Vec<&str>,
+    ) -> Self {
+        let bitcoin_core = BitcoinCore::start_with_args(port, difficulty_level, extra_bitcoin_args);
 
         let current_dir: PathBuf = std::env::current_dir().expect("failed to read current dir");
         let bin_dir = current_dir.join("template-provider");
diff --git a/integration-tests/tests/template_provider_integration.rs b/integration-tests/tests/template_provider_integration.rs
@@ -23,3 +23,108 @@ async fn tp_high_diff() {
     assert_eq!(blockchain_info.difficulty, 77761.1123986095);
     assert_eq!(blockchain_info.chain, "signet");
 }
+
+// Verifies coinbase outputs survive the full round-trip: TP -> Pool -> Translator -> Minerd.
+// A SegWit mempool transaction triggers Bitcoin Core to add a witness commitment (OP_RETURN)
+// to the coinbase. sv2-tp serializes this as coinbase_tx_outputs in NewTemplate. The pool
+// incorporates it into the coinbase, and the miner submits a solution back to Bitcoin Core.
+// If any output was dropped during serialization, Bitcoin Core rejects the block.
+//
+// This catches the sv2-tp < v1.0.4 bug where only .at(0) was serialized (sv2-tp PR #55).
+#[tokio::test]
+async fn tp_coinbase_outputs_round_trip() {
+    start_tracing();
+    let sv2_interval = Some(5);
+    let (tp, tp_addr) = start_template_provider(sv2_interval, DifficultyLevel::Low);
+    tp.fund_wallet().unwrap();
+    let current_block_hash = tp.get_best_block_hash().unwrap();
+
+    let (pool, pool_addr) = start_pool(sv2_tp_config(tp_addr), vec![], vec![]).await;
+
+    // Create a SegWit mempool transaction to trigger witness commitment output
+    tp.create_mempool_transaction().unwrap();
+
+    let (translator, tproxy_addr) =
+        start_sv2_translator(&[pool_addr], false, vec![], vec![], None).await;
+    let (_minerd, _) = start_minerd(tproxy_addr, None, None, false).await;
+
+    // Poll until a block is mined and accepted by Bitcoin Core.
+    // If coinbase outputs were serialized incorrectly, the block is rejected.
+    let timeout = tokio::time::Duration::from_secs(60);
+    let poll_interval = tokio::time::Duration::from_secs(2);
+    let start_time = tokio::time::Instant::now();
+    loop {
+        tokio::time::sleep(poll_interval).await;
+        let new_block_hash = tp.get_best_block_hash().unwrap();
+        if new_block_hash != current_block_hash {
+            shutdown_all!(pool, translator);
+            return;
+        }
+        if start_time.elapsed() > timeout {
+            panic!(
+                "Block should have been mined and accepted within {} seconds, \
+                 confirming coinbase outputs survived the round-trip",
+                timeout.as_secs()
+            );
+        }
+    }
+}
+
+// Verifies multiple coinbase outputs survive the full round-trip.
+// Requires a custom Bitcoin Core build with -testmulticoinbase support.
+// Set BITCOIN_NODE_BIN to the custom bitcoin-node binary path.
+//
+// With -testmulticoinbase, Bitcoin Core adds 2 extra OP_RETURN outputs to the coinbase.
+// Combined with the witness commitment, we get 3 OP_RETURN outputs total. The old .at(0)
+// bug would drop all but the first, causing Bitcoin Core to reject the block.
+#[tokio::test]
+async fn tp_multiple_coinbase_outputs_round_trip() {
+    start_tracing();
+
+    if std::env::var("BITCOIN_NODE_BIN").is_err() {
+        eprintln!(
+            "Skipping tp_multiple_coinbase_outputs_round_trip: \
+             BITCOIN_NODE_BIN not set (requires custom Bitcoin Core with -testmulticoinbase)"
+        );
+        return;
+    }
+
+    let sv2_interval = Some(5);
+    let (tp, tp_addr) = start_template_provider_with_args(
+        sv2_interval,
+        DifficultyLevel::Low,
+        vec!["-testmulticoinbase"],
+    );
+    tp.fund_wallet().unwrap();
+    let current_block_hash = tp.get_best_block_hash().unwrap();
+
+    let (pool, pool_addr) = start_pool(sv2_tp_config(tp_addr), vec![], vec![]).await;
+
+    // Create a SegWit mempool transaction (adds witness commitment as another OP_RETURN)
+    tp.create_mempool_transaction().unwrap();
+
+    let (translator, tproxy_addr) =
+        start_sv2_translator(&[pool_addr], false, vec![], vec![], None).await;
+    let (_minerd, _) = start_minerd(tproxy_addr, None, None, false).await;
+
+    // Poll until a block is mined and accepted by Bitcoin Core.
+    // With 3 OP_RETURN outputs, the old .at(0) bug would cause block rejection.
+    let timeout = tokio::time::Duration::from_secs(60);
+    let poll_interval = tokio::time::Duration::from_secs(2);
+    let start_time = tokio::time::Instant::now();
+    loop {
+        tokio::time::sleep(poll_interval).await;
+        let new_block_hash = tp.get_best_block_hash().unwrap();
+        if new_block_hash != current_block_hash {
+            shutdown_all!(pool, translator);
+            return;
+        }
+        if start_time.elapsed() > timeout {
+            panic!(
+                "Block should have been mined and accepted within {} seconds, \
+                 confirming all coinbase outputs survived the round-trip",
+                timeout.as_secs()
+            );
+        }
+    }
+}
