Merge faf298b6da865e57a4fb3992938e3f0f25e3b767 into 5f4422d68dc3530c353af1f87499de1c864b60ad

3301d2cbe8c3b76c97285d75fa59637cb6952d0b qa: Wait for txindex to avoid race condition (Hodlinator)
9bfb0d75ba10591cc6c9620f9fd1ecc0e55e7a48 qa: Remove unnecessary -txindex args (Hodlinator)
7ac281c19cd3d11f316dbbb3308eabf1ad4f26d6 qa: Add missing coverage of corrupt indexes (Hodlinator)

Pull request description:

  - Add synchronization in 3 places where if the Transaction Index happens to be slow, we get rare test failures when querying it for transactions (one such case experienced on Windows, prompting investigation).
  - Remove unnecessary TxIndex initialization in some tests.
  - Add some test coverage where TxIndex aspect could be tested in feature_init.py.

ACKs for top commit:
  fjahr:
    re-ACK 3301d2cbe8c3b76c97285d75fa59637cb6952d0b
  mzumsande:
    Code Review ACK 3301d2cbe8c3b76c97285d75fa59637cb6952d0b
  furszy:
    Code review ACK 3301d2cbe8c3b76c97285d75fa59637cb6952d0b
  Prabhat1308:
    Concept ACK [`3301d2c`](3301d2cbe8)

Tree-SHA512: 7c2019e38455f344856aaf6b381faafbd88d53dc88d13309deb718c1dcfbee4ccca7c7f1b66917395503a6f94c3b216a007ad432cc8b93d0309db9805f38d602

contrib/devtools/README.md

@@ -8,7 +8,7 @@ deterministic-fuzz-coverage
 A tool to check for non-determinism in fuzz coverage. To get the help, run:
 
 ```
-RUST_BACKTRACE=1 cargo run --manifest-path ./contrib/devtools/deterministic-fuzz-coverage/Cargo.toml -- --help
+cargo run --manifest-path ./contrib/devtools/deterministic-fuzz-coverage/Cargo.toml -- --help
 ```
 
 To execute the tool, compilation has to be done with the build options:
@@ -22,7 +22,7 @@ repository must have been cloned. Finally, a fuzz target has to be picked
 before running the tool:
 
 ```
-RUST_BACKTRACE=1 cargo run --manifest-path ./contrib/devtools/deterministic-fuzz-coverage/Cargo.toml -- $PWD/build_dir $PWD/qa-assets/fuzz_corpora fuzz_target_name
+cargo run --manifest-path ./contrib/devtools/deterministic-fuzz-coverage/Cargo.toml -- $PWD/build_dir $PWD/qa-assets/fuzz_corpora fuzz_target_name
 ```
 
 deterministic-unittest-coverage
@@ -31,7 +31,7 @@ deterministic-unittest-coverage
 A tool to check for non-determinism in unit-test coverage. To get the help, run:
 
 ```
-RUST_BACKTRACE=1 cargo run --manifest-path ./contrib/devtools/deterministic-unittest-coverage/Cargo.toml -- --help
+cargo run --manifest-path ./contrib/devtools/deterministic-unittest-coverage/Cargo.toml -- --help
 ```
 
 To execute the tool, compilation has to be done with the build options:
@@ -43,7 +43,7 @@ To execute the tool, compilation has to be done with the build options:
 Both llvm-profdata and llvm-cov must be installed.
 
 ```
-RUST_BACKTRACE=1 cargo run --manifest-path ./contrib/devtools/deterministic-unittest-coverage/Cargo.toml -- $PWD/build_dir <boost unittest filter>
+cargo run --manifest-path ./contrib/devtools/deterministic-unittest-coverage/Cargo.toml -- $PWD/build_dir <boost unittest filter>
 ```
 
 clang-format-diff.py

contrib/devtools/deterministic-fuzz-coverage/src/main.rs

@@ -4,87 +4,99 @@
 
 use std::env;
 use std::fs::{read_dir, File};
-use std::path::Path;
+use std::path::{Path, PathBuf};
-use std::process::{exit, Command};
+use std::process::{Command, ExitCode};
 use std::str;
 
+/// A type for a complete and readable error message.
+type AppError = String;
+type AppResult = Result<(), AppError>;
+
+fn main() -> ExitCode {
+    match app() {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(err) => {
+            eprintln!("{}", err);
+            ExitCode::FAILURE
+        }
+    }
+}
+
 const LLVM_PROFDATA: &str = "llvm-profdata";
 const LLVM_COV: &str = "llvm-cov";
 const GIT: &str = "git";
 
-fn exit_help(err: &str) -> ! {
+fn exit_help(err: &str) -> AppError {
-    eprintln!("Error: {}", err);
+    format!(
-    eprintln!();
+        r#"
-    eprintln!("Usage: program ./build_dir ./qa-assets/fuzz_corpora fuzz_target_name");
+Error: {err}
-    eprintln!();
+
-    eprintln!("Refer to the devtools/README.md for more details.");
+Usage: program ./build_dir ./qa-assets/fuzz_corpora fuzz_target_name
-    exit(1)
+
+Refer to the devtools/README.md for more details."#
+    )
 }
 
-fn sanity_check(corpora_dir: &Path, fuzz_exe: &Path) {
+fn sanity_check(corpora_dir: &Path, fuzz_exe: &Path) -> AppResult {
     for tool in [LLVM_PROFDATA, LLVM_COV, GIT] {
         let output = Command::new(tool).arg("--help").output();
         match output {
             Ok(output) if output.status.success() => {}
-            _ => {
+            _ => Err(exit_help(&format!("The tool {} is not installed", tool)))?,
-                exit_help(&format!("The tool {} is not installed", tool));
-            }
         }
     }
     if !corpora_dir.is_dir() {
-        exit_help(&format!(
+        Err(exit_help(&format!(
             "Fuzz corpora path ({}) must be a directory",
             corpora_dir.display()
-        ));
+        )))?;
     }
     if !fuzz_exe.exists() {
-        exit_help(&format!(
+        Err(exit_help(&format!(
             "Fuzz executable ({}) not found",
             fuzz_exe.display()
-        ));
+        )))?;
     }
+    Ok(())
 }
 
-fn main() {
+fn app() -> AppResult {
     // Parse args
     let args = env::args().collect::<Vec<_>>();
-    let build_dir = args
+    let build_dir = args.get(1).ok_or(exit_help("Must set build dir"))?;
-        .get(1)
-        .unwrap_or_else(|| exit_help("Must set build dir"));
     if build_dir == "--help" {
-        exit_help("--help requested")
+        Err(exit_help("--help requested"))?;
     }
-    let corpora_dir = args
+    let corpora_dir = args.get(2).ok_or(exit_help("Must set fuzz corpora dir"))?;
-        .get(2)
-        .unwrap_or_else(|| exit_help("Must set fuzz corpora dir"));
     let fuzz_target = args
         .get(3)
         // Require fuzz target for now. In the future it could be optional and the tool could
         // iterate over all compiled fuzz targets
-        .unwrap_or_else(|| exit_help("Must set fuzz target"));
+        .ok_or(exit_help("Must set fuzz target"))?;
     if args.get(4).is_some() {
-        exit_help("Too many args")
+        Err(exit_help("Too many args"))?;
     }
 
     let build_dir = Path::new(build_dir);
     let corpora_dir = Path::new(corpora_dir);
     let fuzz_exe = build_dir.join("bin/fuzz");
 
-    sanity_check(corpora_dir, &fuzz_exe);
+    sanity_check(corpora_dir, &fuzz_exe)?;
 
-    deterministic_coverage(build_dir, corpora_dir, &fuzz_exe, fuzz_target);
+    deterministic_coverage(build_dir, corpora_dir, &fuzz_exe, fuzz_target)
 }
 
-fn using_libfuzzer(fuzz_exe: &Path) -> bool {
+fn using_libfuzzer(fuzz_exe: &Path) -> Result<bool, AppError> {
     println!("Check if using libFuzzer ...");
     let stderr = Command::new(fuzz_exe)
         .arg("-help=1") // Will be interpreted as option (libfuzzer) or as input file
         .env("FUZZ", "addition_overflow") // Any valid target
         .output()
-        .expect("fuzz failed")
+        .map_err(|e| format!("fuzz failed with {e}"))?
         .stderr;
-    let help_output = str::from_utf8(&stderr).expect("The -help=1 output must be valid text");
+    let help_output = str::from_utf8(&stderr)
-    help_output.contains("libFuzzer")
+        .map_err(|e| format!("The libFuzzer -help=1 output must be valid text ({e})"))?;
+    Ok(help_output.contains("libFuzzer"))
 }
 
 fn deterministic_coverage(
@@ -92,25 +104,25 @@ fn deterministic_coverage(
     corpora_dir: &Path,
     fuzz_exe: &Path,
     fuzz_target: &str,
-) {
+) -> AppResult {
-    let using_libfuzzer = using_libfuzzer(fuzz_exe);
+    let using_libfuzzer = using_libfuzzer(fuzz_exe)?;
     let profraw_file = build_dir.join("fuzz_det_cov.profraw");
     let profdata_file = build_dir.join("fuzz_det_cov.profdata");
     let corpus_dir = corpora_dir.join(fuzz_target);
     let mut entries = read_dir(&corpus_dir)
-        .unwrap_or_else(|err| {
+        .map_err(|err| {
             exit_help(&format!(
                 "The fuzz target's input directory must exist! ({}; {})",
                 corpus_dir.display(),
                 err
             ))
-        })
+        })?
         .map(|entry| entry.expect("IO error"))
         .collect::<Vec<_>>();
     entries.sort_by_key(|entry| entry.file_name());
-    let run_single = |run_id: u8, entry: &Path| {
+    let run_single = |run_id: u8, entry: &Path| -> Result<PathBuf, AppError> {
         let cov_txt_path = build_dir.join(format!("fuzz_det_cov.show.{run_id}.txt"));
-        assert!({
+        if !{
             {
                 let mut cmd = Command::new(fuzz_exe);
                 if using_libfuzzer {
@@ -122,20 +134,26 @@ fn deterministic_coverage(
             .env("FUZZ", fuzz_target)
             .arg(entry)
             .status()
-            .expect("fuzz failed")
+            .map_err(|e| format!("fuzz failed with {e}"))?
             .success()
-        });
+        } {
-        assert!(Command::new(LLVM_PROFDATA)
+            Err("fuzz failed".to_string())?;
+        }
+        if !Command::new(LLVM_PROFDATA)
             .arg("merge")
             .arg("--sparse")
             .arg(&profraw_file)
             .arg("-o")
             .arg(&profdata_file)
             .status()
-            .expect("merge failed")
+            .map_err(|e| format!("{LLVM_PROFDATA} merge failed with {e}"))?
-            .success());
+            .success()
-        let cov_file = File::create(&cov_txt_path).expect("Failed to create coverage txt file");
+        {
-        assert!(Command::new(LLVM_COV)
+            Err(format!("{LLVM_PROFDATA} merge failed"))?;
+        }
+        let cov_file = File::create(&cov_txt_path)
+            .map_err(|e| format!("Failed to create coverage txt file ({e})"))?;
+        if !Command::new(LLVM_COV)
             .args([
                 "show",
                 "--show-line-counts-or-regions",
@@ -146,27 +164,31 @@ fn deterministic_coverage(
             .arg(fuzz_exe)
             .stdout(cov_file)
             .spawn()
-            .expect("Failed to execute llvm-cov")
+            .map_err(|e| format!("{LLVM_COV} show failed with {e}"))?
             .wait()
-            .expect("Failed to execute llvm-cov")
+            .map_err(|e| format!("{LLVM_COV} show failed with {e}"))?
-            .success());
+            .success()
-        cov_txt_path
+        {
+            Err(format!("{LLVM_COV} show failed"))?;
+        };
+        Ok(cov_txt_path)
     };
-    let check_diff = |a: &Path, b: &Path, err: &str| {
+    let check_diff = |a: &Path, b: &Path, err: &str| -> AppResult {
         let same = Command::new(GIT)
             .args(["--no-pager", "diff", "--no-index"])
             .arg(a)
             .arg(b)
             .status()
-            .expect("Failed to execute git command")
+            .map_err(|e| format!("{GIT} diff failed with {e}"))?
             .success();
         if !same {
-            eprintln!();
+            Err(format!(
-            eprintln!("The coverage was not deterministic between runs.");
+                r#"
-            eprintln!("{}", err);
+The coverage was not deterministic between runs.
-            eprintln!("Exiting.");
+{err}"#
-            exit(1);
+            ))?;
         }
+        Ok(())
     };
     // First, check that each fuzz input is deterministic running by itself in a process.
     //
@@ -175,29 +197,36 @@ fn deterministic_coverage(
     //
     // Also, This can catch issues where several fuzz inputs are non-deterministic, but the sum of
     // their overall coverage trace remains the same across runs and thus remains undetected.
+    println!("Check each fuzz input individually ...");
     for entry in entries {
         let entry = entry.path();
-        assert!(entry.is_file());
+        if !entry.is_file() {
-        let cov_txt_base = run_single(0, &entry);
+            Err(format!("{} should be a file", entry.display()))?;
-        let cov_txt_repeat = run_single(1, &entry);
+        }
+        let cov_txt_base = run_single(0, &entry)?;
+        let cov_txt_repeat = run_single(1, &entry)?;
         check_diff(
             &cov_txt_base,
             &cov_txt_repeat,
             &format!("The fuzz target input was {}.", entry.display()),
-        );
+        )?;
     }
     // Finally, check that running over all fuzz inputs in one process is deterministic as well.
     // This can catch issues where mutable global state is leaked from one fuzz input execution to
     // the next.
+    println!("Check all fuzz inputs in one go ...");
     {
-        assert!(corpus_dir.is_dir());
+        if !corpus_dir.is_dir() {
-        let cov_txt_base = run_single(0, &corpus_dir);
+            Err(format!("{} should be a folder", corpus_dir.display()))?;
-        let cov_txt_repeat = run_single(1, &corpus_dir);
+        }
+        let cov_txt_base = run_single(0, &corpus_dir)?;
+        let cov_txt_repeat = run_single(1, &corpus_dir)?;
         check_diff(
             &cov_txt_base,
             &cov_txt_repeat,
             &format!("All fuzz inputs in {} were used.", corpus_dir.display()),
-        );
+        )?;
     }
     println!("Coverage test passed for {fuzz_target}.");
+    Ok(())
 }

contrib/devtools/deterministic-unittest-coverage/src/main.rs

@@ -4,90 +4,111 @@
 
 use std::env;
 use std::fs::File;
-use std::path::Path;
+use std::path::{Path, PathBuf};
-use std::process::{exit, Command};
+use std::process::{Command, ExitCode};
 use std::str;
 
 const LLVM_PROFDATA: &str = "llvm-profdata";
 const LLVM_COV: &str = "llvm-cov";
 const GIT: &str = "git";
 
-fn exit_help(err: &str) -> ! {
+/// A type for a complete and readable error message.
-    eprintln!("Error: {}", err);
+type AppError = String;
-    eprintln!();
+type AppResult = Result<(), AppError>;
-    eprintln!("Usage: program ./build_dir boost_unittest_filter");
+
-    eprintln!();
+fn main() -> ExitCode {
-    eprintln!("Refer to the devtools/README.md for more details.");
+    match app() {
-    exit(1)
+        Ok(()) => ExitCode::SUCCESS,
+        Err(err) => {
+            eprintln!("{}", err);
+            ExitCode::FAILURE
+        }
+    }
 }
 
-fn sanity_check(test_exe: &Path) {
+fn exit_help(err: &str) -> AppError {
+    format!(
+        r#"
+Error: {err}
+
+Usage: program ./build_dir boost_unittest_filter
+
+Refer to the devtools/README.md for more details."#
+    )
+}
+
+fn sanity_check(test_exe: &Path) -> AppResult {
     for tool in [LLVM_PROFDATA, LLVM_COV, GIT] {
         let output = Command::new(tool).arg("--help").output();
         match output {
             Ok(output) if output.status.success() => {}
-            _ => {
+            _ => Err(exit_help(&format!("The tool {} is not installed", tool)))?,
-                exit_help(&format!("The tool {} is not installed", tool));
-            }
         }
     }
     if !test_exe.exists() {
-        exit_help(&format!(
+        Err(exit_help(&format!(
             "Test executable ({}) not found",
             test_exe.display()
-        ));
+        )))?;
     }
+    Ok(())
 }
 
-fn main() {
+fn app() -> AppResult {
     // Parse args
     let args = env::args().collect::<Vec<_>>();
-    let build_dir = args
+    let build_dir = args.get(1).ok_or(exit_help("Must set build dir"))?;
-        .get(1)
-        .unwrap_or_else(|| exit_help("Must set build dir"));
     if build_dir == "--help" {
-        exit_help("--help requested")
+        Err(exit_help("--help requested"))?;
     }
     let filter = args
         .get(2)
         // Require filter for now. In the future it could be optional and the tool could provide a
         // default filter.
-        .unwrap_or_else(|| exit_help("Must set boost test filter"));
+        .ok_or(exit_help("Must set boost test filter"))?;
     if args.get(3).is_some() {
-        exit_help("Too many args")
+        Err(exit_help("Too many args"))?;
     }
 
     let build_dir = Path::new(build_dir);
     let test_exe = build_dir.join("bin/test_bitcoin");
 
-    sanity_check(&test_exe);
+    sanity_check(&test_exe)?;
 
-    deterministic_coverage(build_dir, &test_exe, filter);
+    deterministic_coverage(build_dir, &test_exe, filter)
 }
 
-fn deterministic_coverage(build_dir: &Path, test_exe: &Path, filter: &str) {
+fn deterministic_coverage(build_dir: &Path, test_exe: &Path, filter: &str) -> AppResult {
     let profraw_file = build_dir.join("test_det_cov.profraw");
     let profdata_file = build_dir.join("test_det_cov.profdata");
-    let run_single = |run_id: u8| {
+    let run_single = |run_id: u8| -> Result<PathBuf, AppError> {
+        println!("Run with id {run_id}");
         let cov_txt_path = build_dir.join(format!("test_det_cov.show.{run_id}.txt"));
-        assert!(Command::new(test_exe)
+        if !Command::new(test_exe)
             .env("LLVM_PROFILE_FILE", &profraw_file)
             .env("BOOST_TEST_RUN_FILTERS", filter)
             .env("RANDOM_CTX_SEED", "21")
             .status()
-            .expect("test failed")
+            .map_err(|e| format!("test failed with {e}"))?
-            .success());
+            .success()
-        assert!(Command::new(LLVM_PROFDATA)
+        {
+            Err("test failed".to_string())?;
+        }
+        if !Command::new(LLVM_PROFDATA)
             .arg("merge")
             .arg("--sparse")
             .arg(&profraw_file)
             .arg("-o")
             .arg(&profdata_file)
             .status()
-            .expect("merge failed")
+            .map_err(|e| format!("{LLVM_PROFDATA} merge failed with {e}"))?
-            .success());
+            .success()
-        let cov_file = File::create(&cov_txt_path).expect("Failed to create coverage txt file");
+        {
-        assert!(Command::new(LLVM_COV)
+            Err(format!("{LLVM_PROFDATA} merge failed"))?;
+        }
+        let cov_file = File::create(&cov_txt_path)
+            .map_err(|e| format!("Failed to create coverage txt file ({e})"))?;
+        if !Command::new(LLVM_COV)
             .args([
                 "show",
                 "--show-line-counts-or-regions",
@@ -98,27 +119,29 @@ fn deterministic_coverage(build_dir: &Path, test_exe: &Path, filter: &str) {
             .arg(test_exe)
             .stdout(cov_file)
             .status()
-            .expect("llvm-cov failed")
+            .map_err(|e| format!("{LLVM_COV} show failed with {e}"))?
-            .success());
+            .success()
-        cov_txt_path
+        {
+            Err(format!("{LLVM_COV} show failed"))?;
+        }
+        Ok(cov_txt_path)
     };
-    let check_diff = |a: &Path, b: &Path| {
+    let check_diff = |a: &Path, b: &Path| -> AppResult {
         let same = Command::new(GIT)
             .args(["--no-pager", "diff", "--no-index"])
             .arg(a)
             .arg(b)
             .status()
-            .expect("Failed to execute git command")
+            .map_err(|e| format!("{GIT} diff failed with {e}"))?
             .success();
         if !same {
-            eprintln!();
+            Err("The coverage was not deterministic between runs.".to_string())?;
-            eprintln!("The coverage was not deterministic between runs.");
-            eprintln!("Exiting.");
-            exit(1);
         }
+        Ok(())
     };
-    let r0 = run_single(0);
+    let r0 = run_single(0)?;
-    let r1 = run_single(1);
+    let r1 = run_single(1)?;
-    check_diff(&r0, &r1);
+    check_diff(&r0, &r1)?;
     println!("The coverage was deterministic across two runs.");
+    Ok(())
 }

test/functional/feature_init.py

@@ -88,7 +88,7 @@ class InitTest(BitcoinTestFramework):
 
         args = ['-txindex=1', '-blockfilterindex=1', '-coinstatsindex=1']
         for terminate_line in lines_to_terminate_after:
-            self.log.info(f"Starting node and will exit after line {terminate_line}")
+            self.log.info(f"Starting node and will terminate after line {terminate_line}")
             with node.busy_wait_for_debug_log([terminate_line]):
                 if platform.system() == 'Windows':
                     # CREATE_NEW_PROCESS_GROUP is required in order to be able
@@ -108,12 +108,22 @@ class InitTest(BitcoinTestFramework):
             'blocks/index/*.ldb': 'Error opening block database.',
             'chainstate/*.ldb': 'Error opening coins database.',
             'blocks/blk*.dat': 'Error loading block database.',
+            'indexes/txindex/MANIFEST*': 'LevelDB error: Corruption: CURRENT points to a non-existent file',
+            # Removing these files does not result in a startup error:
+            # 'indexes/blockfilter/basic/*.dat', 'indexes/blockfilter/basic/db/*.*', 'indexes/coinstats/db/*.*',
+            # 'indexes/txindex/*.log', 'indexes/txindex/CURRENT', 'indexes/txindex/LOCK'
         }
 
         files_to_perturb = {
             'blocks/index/*.ldb': 'Error loading block database.',
             'chainstate/*.ldb': 'Error opening coins database.',
             'blocks/blk*.dat': 'Corrupted block database detected.',
+            'indexes/blockfilter/basic/db/*.*': 'LevelDB error: Corruption',
+            'indexes/coinstats/db/*.*': 'LevelDB error: Corruption',
+            'indexes/txindex/*.log': 'LevelDB error: Corruption',
+            'indexes/txindex/CURRENT': 'LevelDB error: Corruption',
+            # Perturbing these files does not result in a startup error:
+            # 'indexes/blockfilter/basic/*.dat', 'indexes/txindex/MANIFEST*', 'indexes/txindex/LOCK'
         }
 
         for file_patt, err_fragment in files_to_delete.items():
@@ -135,9 +145,10 @@ class InitTest(BitcoinTestFramework):
             self.stop_node(0)
 
         self.log.info("Test startup errors after perturbing certain essential files")
+        dirs = ["blocks", "chainstate", "indexes"]
         for file_patt, err_fragment in files_to_perturb.items():
-            shutil.copytree(node.chain_path / "blocks", node.chain_path / "blocks_bak")
+            for dir in dirs:
-            shutil.copytree(node.chain_path / "chainstate", node.chain_path / "chainstate_bak")
+                shutil.copytree(node.chain_path / dir, node.chain_path / f"{dir}_bak")
             target_files = list(node.chain_path.glob(file_patt))
 
             for target_file in target_files:
@@ -151,10 +162,9 @@ class InitTest(BitcoinTestFramework):
 
             start_expecting_error(err_fragment)
 
-            shutil.rmtree(node.chain_path / "blocks")
+            for dir in dirs:
-            shutil.rmtree(node.chain_path / "chainstate")
+                shutil.rmtree(node.chain_path / dir)
-            shutil.move(node.chain_path / "blocks_bak", node.chain_path / "blocks")
+                shutil.move(node.chain_path / f"{dir}_bak", node.chain_path / dir)
-            shutil.move(node.chain_path / "chainstate_bak", node.chain_path / "chainstate")
 
     def init_pid_test(self):
         BITCOIN_PID_FILENAME_CUSTOM = "my_fancy_bitcoin_pid_file.foobar"

test/functional/mempool_accept.py

@@ -45,6 +45,7 @@ from test_framework.util import (
     assert_equal,
     assert_greater_than,
     assert_raises_rpc_error,
+    sync_txindex,
 )
 from test_framework.wallet import MiniWallet
 from test_framework.wallet_util import generate_keypair
@@ -270,6 +271,7 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
 
         self.log.info('A coinbase transaction')
         # Pick the input of the first tx we created, so it has to be a coinbase tx
+        sync_txindex(self, node)
         raw_tx_coinbase_spent = node.getrawtransaction(txid=node.decoderawtransaction(hexstring=raw_tx_in_block)['vin'][0]['txid'])
         tx = tx_from_hex(raw_tx_coinbase_spent)
         self.check_mempool_result(

test/functional/rpc_rawtransaction.py

@@ -34,6 +34,7 @@ from test_framework.util import (
     assert_equal,
     assert_greater_than,
     assert_raises_rpc_error,
+    sync_txindex,
 )
 from test_framework.wallet import (
     getnewdestination,
@@ -70,7 +71,7 @@ class RawTransactionsTest(BitcoinTestFramework):
         self.num_nodes = 3
         self.extra_args = [
             ["-txindex"],
-            ["-txindex"],
+            [],
             ["-fastprune", "-prune=1"],
         ]
         # whitelist peers to speed up tx relay / mempool sync
@@ -109,6 +110,7 @@ class RawTransactionsTest(BitcoinTestFramework):
             self.log.info(f"Test getrawtransaction {'with' if n == 0 else 'without'} -txindex")
 
             if n == 0:
+                sync_txindex(self, self.nodes[n])
                 # With -txindex.
                 # 1. valid parameters - only supply txid
                 assert_equal(self.nodes[n].getrawtransaction(txId), tx['hex'])

test/functional/rpc_txoutproof.py

@@ -12,6 +12,7 @@ from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_raises_rpc_error,
+    sync_txindex,
 )
 from test_framework.wallet import MiniWallet
 
@@ -77,6 +78,7 @@ class MerkleBlockTest(BitcoinTestFramework):
         assert_equal(sorted(self.nodes[0].verifytxoutproof(self.nodes[0].gettxoutproof([txid1, txid2]))), sorted(txlist))
         assert_equal(sorted(self.nodes[0].verifytxoutproof(self.nodes[0].gettxoutproof([txid2, txid1]))), sorted(txlist))
         # We can always get a proof if we have a -txindex
+        sync_txindex(self, self.nodes[1])
         assert_equal(self.nodes[0].verifytxoutproof(self.nodes[1].gettxoutproof([txid_spent])), [txid_spent])
         # We can't get a proof if we specify transactions from different blocks
         assert_raises_rpc_error(-5, "Not all transactions found in specified or retrieved block", self.nodes[0].gettxoutproof, [txid1, txid3])

test/functional/test_framework/util.py

@@ -592,3 +592,10 @@ def find_vout_for_address(node, txid, addr):
         if addr == tx["vout"][i]["scriptPubKey"]["address"]:
             return i
     raise RuntimeError("Vout not found for address: txid=%s, addr=%s" % (txid, addr))
+
+
+def sync_txindex(test_framework, node):
+    test_framework.log.debug("Waiting for node txindex to sync")
+    sync_start = int(time.time())
+    test_framework.wait_until(lambda: node.getindexinfo("txindex")["txindex"]["synced"])
+    test_framework.log.debug(f"Synced in {time.time() - sync_start} seconds")

test/functional/wallet_avoid_mixing_output_types.py

@@ -117,7 +117,6 @@ class AddressInputTypeGrouping(BitcoinTestFramework):
         self.extra_args = [
             [
                 "-addresstype=bech32",
-                "-txindex",
             ],
             [
                 "-addresstype=p2sh-segwit",