I'm wondering whether the accurate mode should be enabled by default. If an application or a user uses the scanblocks RPC, they'll need to filter out false positives anyway, so maybe Bitcoin Core should do it?

Also, is there a way to reproduce false positives? It would be nice to add a test but I haven't figured out how?

Thanks for the tips @theStack.
I tried creating a test as well. I managed to generate false positives using the following test, but it only happens once every few runs. I'll continue to work on it later, but here's my snippet in case you have ideas.

diff --git a/test/functional/rpc_scanblocks.py b/test/functional/rpc_scanblocks.py
index 0ba5f12bd..e7d26a5ef 100755
--- a/test/functional/rpc_scanblocks.py
+++ b/test/functional/rpc_scanblocks.py
@@ -102,6 +102,42 @@ class ScanblocksTest(BitcoinTestFramework):
         # test invalid command
         assert_raises_rpc_error(-8, "Invalid command", node.scanblocks, "foobar")
 
+        # generate block with a lot of random outputs
+        print("Generate block with random transactions")
+        for i in range(500): # should be deterministic and give false positives
+            _, spk, _ = getnewdestination()
+            wallet.send_to(from_node=self.nodes[1], scriptPubKey=spk, amount=400)
+
+        blockhash = self.generate(self.nodes[1], 1)[0]
+        print(blockhash)
+
+        # scan the block with the ranged descriptor
+        height = node.getblockheader(blockhash)['height']
+        desc = f"pkh({parent_key}/*)"
+
+        # begin debug
+        blocks = node.scanblocks(
+            action="start",
+            scanobjects=[{"desc": desc, "range": [0, 200000]}],
+            start_height=height,
+            accurate=False)['relevant_blocks']
+
+        print(blocks)
+        # end debug
+
+        for v in [False, True]:
+            blocks = node.scanblocks(
+                action="start",
+                scanobjects=[{"desc": desc, "range": [0, 200000]}],
+                start_height=height,
+                accurate=v)['relevant_blocks']
+
+            if v:
+                assert_equal(len(blocks), 0)
+            else:
+                assert_equal(len(blocks), 1)
+                assert_equal(blocks[0], blockhash)
+
 
 if __name__ == '__main__':
     ScanblocksTest().main()

The only part that isn't deterministic is:

for i in range(500): # should be deterministic and give false positives
	_, spk, _ = getnewdestination()
	wallet.send_to(from_node=self.nodes[1], scriptPubKey=spk, amount=400)

Maybe we could use i to generate deterministic scriptPubKeys and hope a certain arrangement always gives false positives? Not sure how reliable this is.

I'm able to generate false positives consistently enough with this test by increasing nblocks but the test is very slow and still likely to cause intermittent failures so not worth adding it to the PR.

diff --git a/test/functional/rpc_scanblocks.py b/test/functional/rpc_scanblocks.py
index 0ba5f12bd..05779973e 100755
--- a/test/functional/rpc_scanblocks.py
+++ b/test/functional/rpc_scanblocks.py
@@ -102,6 +102,34 @@ class ScanblocksTest(BitcoinTestFramework):
         # test invalid command
         assert_raises_rpc_error(-8, "Invalid command", node.scanblocks, "foobar")
 
+        # generate block with a lot of random outputs
+        print("Generate block with random transactions")
+        height = node.getblockcount() + 1
+        nblocks = 10
+        for i in range(nblocks):
+            for _ in range(550):
+                _, spk, _ = getnewdestination()
+                wallet.send_to(from_node=self.nodes[1], scriptPubKey=spk, amount=400)
+
+            print(f"Generate block {i}/{nblocks}")
+            self.generate(self.nodes[1], 1)[0]
+
+        # scan the block with the ranged descriptor
+        desc = f"pkh({parent_key}/*)"
+        print(desc)
+
+        for v in [False, True]:
+            blocks = node.scanblocks(
+                action="start",
+                scanobjects=[{"desc": desc, "range": [0, 200000]}],
+                start_height=height,
+                accurate=v)['relevant_blocks']
+
+            if v:
+                assert_equal(len(blocks), 0)
+            else:
+                assert len(blocks) > 1
+
 
 if __name__ == '__main__':
     ScanblocksTest().main()

I'm not sure accurate is very descriptive about what this feature does. Would filter_false_positives be a better name for this option?

I'm wondering whether the accurate mode should be enabled by default. If an application or a user uses the scanblocks RPC, they'll need to filter out false positives anyway, so maybe Bitcoin Core should do it?

With this feature enabled Bitcoin Core will be reading from disk and scanning both the block and undo files for each block, which would then be read again when fetched and then scanned by the user. I don't think it would be worth this extra effort unless the user's network latency or scanning code is very slow so that a single false positive block getting to them would be slower than having Bitcoin Core do it for every block. So IMO it should be disabled by default.

I believe scanblocks is compatible with a pruned node as long as the block filters were generated before the blocks were pruned (#15946). If so, then this mode will fail silently for the pruned blocks and just not return the hashes, even if the blocks can be retrieved by another node. But also more generally if a block read fails for any reason it should throw and not return false.

Also see #26316.

I'm able to generate false positives consistently enough with this test by increasing nblocks but the test is very slow and still likely to cause intermittent failures so not worth adding it to the PR.

I digged a bit deeper into the rabbit-hole and ended up opening #26341, adding a testing for a fixed false-positive for the genesis block and also verifying it with the ranged hashes described in BIP158. Feel free to base you PR on that (though I think the PR is already in a pretty good state and it's also fine if the test is add in a follow-up). With the newly introduced helpers, it would be possible to calculate false-positives for newly created blocks at runtime, but at least in my impression that takes too much time for a functional test -- about ~800k scriptPubKeys have to be tried out on average until one of them corresponds to a scriptPubKey already on the block.

Thank you @andrewtoth for the review.

• Rebased this PR on top of test: add BIP158 false-positive element check in rpc_scanblocks.py #26341 as suggested by @theStack.
• Added a test case to filter false positives
• Added a check to not fetch block undo data for the genesis block
• Throw if ReadBlockFromDisk or UndoReadFromDisk fails instead of returning false
• Renamed accurate mode to filter_false_positives

Rebased to remove the LOCK on cs_main in CheckBlockFilterMatches.

Thanks @achow101 I added your suggestion.

Rebased.

ACK 5ca7a7b