Merge pull request #1708 from evoskuil/master

evoskuil · web-flow · commit 8d533a6c5e0b · 2025-07-04T03:20:21.000-04:00
Rename compute_filter_header to compute_filter and add override.
diff --git a/include/bitcoin/system/wallet/neutrino.hpp b/include/bitcoin/system/wallet/neutrino.hpp
@@ -41,9 +41,12 @@ struct BC_API block_filter
 BC_API bool compute_filter(data_chunk& out,
     const chain::block& block) NOEXCEPT;
 
-BC_API hash_digest compute_filter_header(const hash_digest& previous_header,
+BC_API hash_digest compute_header(const hash_digest& previous_header,
     const data_chunk& filter) NOEXCEPT;
 
+BC_API hash_digest compute_header(hash_digest& filter_hash,
+    const hash_digest& previous_header, const data_chunk& filter) NOEXCEPT;
+
 BC_API bool match_filter(const block_filter& filter,
     const chain::script& script) NOEXCEPT;
 
diff --git a/src/wallet/neutrino.cpp b/src/wallet/neutrino.cpp
@@ -81,10 +81,17 @@ bool compute_filter(data_chunk& out, const chain::block& block) NOEXCEPT
     return !!writer;
 }
 
-hash_digest compute_filter_header(const hash_digest& previous_header,
+hash_digest compute_header(const hash_digest& previous_header,
     const data_chunk& filter) NOEXCEPT
 {
-    return bitcoin_hash(splice(bitcoin_hash(filter), previous_header));
+    return bitcoin_hash(bitcoin_hash(filter), previous_header);
+}
+
+hash_digest compute_header(hash_digest& filter_hash,
+    const hash_digest& previous_header, const data_chunk& filter) NOEXCEPT
+{
+    filter_hash = bitcoin_hash(filter);
+    return bitcoin_hash(filter_hash, previous_header);
 }
 
 bool match_filter(const block_filter& filter,
diff --git a/test/wallet/neutrino.cpp b/test/wallet/neutrino.cpp
@@ -107,101 +107,101 @@ BOOST_AUTO_TEST_CASE(neutrino__compute__first_11_blocks__success)
         const chain::block block(data, true);
         data_chunk filter;
         BOOST_REQUIRE(neutrino::compute_filter(filter, block));
-        const auto header = neutrino::compute_filter_header(previous_filter_header, filter);
+        const auto header = neutrino::compute_header(previous_filter_header, filter);
         ////std::cout << "header: " << encode_base16(header) << std::endl;
         ////std::cout << "filter: " << encode_base16(filter) << std::endl;
         previous_filter_header = header;
     }
 }
 
-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_0__success)
+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_0__success)
 {
     const auto expected = base16_hash("21584579b7eb08997773e5aeff3a7f932700042d0ed2a6129012b7d7ae81b750");
     const auto previous_header = base16_hash("0000000000000000000000000000000000000000000000000000000000000000");
     const auto filter = base16_chunk("019dfca8");
-    const auto result = neutrino::compute_filter_header(previous_header, filter);
+    const auto result = neutrino::compute_header(previous_header, filter);
     BOOST_REQUIRE_EQUAL(result, expected);
 }
 
-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_2__success)
+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_2__success)
 {
     const auto expected = base16_hash("186afd11ef2b5e7e3504f2e8cbf8df28a1fd251fe53d60dff8b1467d1b386cf0");
     const auto previous_header = base16_hash("d7bdac13a59d745b1add0d2ce852f1a0442e8945fc1bf3848d3cbffd88c24fe1");
     const auto filter = base16_chunk("0174a170");
-    const auto result = neutrino::compute_filter_header(previous_header, filter);
+    const auto result = neutrino::compute_header(previous_header, filter);
     BOOST_REQUIRE_EQUAL(result, expected);
 }
 
-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_3__success)
+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_3__success)
 {
     const auto expected = base16_hash("8d63aadf5ab7257cb6d2316a57b16f517bff1c6388f124ec4c04af1212729d2a");
     const auto previous_header = base16_hash("186afd11ef2b5e7e3504f2e8cbf8df28a1fd251fe53d60dff8b1467d1b386cf0");
     const auto filter = base16_chunk("016cf7a0");
-    const auto result = neutrino::compute_filter_header(previous_header, filter);
+    const auto result = neutrino::compute_header(previous_header, filter);
     BOOST_REQUIRE_EQUAL(result, expected);
 }
 
-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_15007__success)
+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_15007__success)
 {
     const auto expected = base16_hash("07384b01311867949e0c046607c66b7a766d338474bb67f66c8ae9dbd454b20e");
     const auto previous_header = base16_hash("18b5c2b0146d2d09d24fb00ff5b52bd0742f36c9e65527abdb9de30c027a4748");
     const auto filter = base16_chunk("013c3710");
-    const auto result = neutrino::compute_filter_header(previous_header, filter);
+    const auto result = neutrino::compute_header(previous_header, filter);
     BOOST_REQUIRE_EQUAL(result, expected);
 }
 
-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_49291__success)
+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_49291__success)
 {
     const auto expected = base16_hash("b6d98692cec5145f67585f3434ec3c2b3030182e1cb3ec58b855c5c164dfaaa3");
     const auto previous_header = base16_hash("ed47705334f4643892ca46396eb3f4196a5e30880589e4009ef38eae895d4a13");
     const auto filter = base16_chunk("0afbc2920af1b027f31f87b592276eb4c32094bb4d3697021b4c6380");
-    const auto result = neutrino::compute_filter_header(previous_header, filter);
+    const auto result = neutrino::compute_header(previous_header, filter);
     BOOST_REQUIRE_EQUAL(result, expected);
 }
 
-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_180480__success)
+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_180480__success)
 {
     const auto expected = base16_hash("c582d51c0ca365e3fcf36c51cb646d7f83a67e867cb4743fd2128e3e022b700c");
     const auto previous_header = base16_hash("d34ef98386f413769502808d4bac5f20f8dfd5bffc9eedafaa71de0eb1f01489");
     const auto filter = base16_chunk("0db414c859a07e8205876354a210a75042d0463404913d61a8e068e58a3ae2aa080026");
-    const auto result = neutrino::compute_filter_header(previous_header, filter);
+    const auto result = neutrino::compute_header(previous_header, filter);
     BOOST_REQUIRE_EQUAL(result, expected);
 }
 
-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_926485__success)
+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_926485__success)
 {
     const auto expected = base16_hash("546c574a0472144bcaf9b6aeabf26372ad87c7af7d1ee0dbfae5e099abeae49c");
     const auto previous_header = base16_hash("8f13b9a9c85611635b47906c3053ac53cfcec7211455d4cb0d63dc9acc13d472");
     const auto filter = base16_chunk("09027acea61b6cc3fb33f5d52f7d088a6b2f75d234e89ca800");
-    const auto result = neutrino::compute_filter_header(previous_header, filter);
+    const auto result = neutrino::compute_header(previous_header, filter);
     BOOST_REQUIRE_EQUAL(result, expected);
 }
 
-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_987876__success)
+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_987876__success)
 {
     const auto expected = base16_hash("0965a544743bbfa36f254446e75630c09404b3d164a261892372977538928ed5");
     const auto previous_header = base16_hash("fe4d230dbb0f4fec9bed23a5283e08baf996e3f32b93f52c7de1f641ddfd04ad");
     const auto filter = base16_chunk("010c0b40");
-    const auto result = neutrino::compute_filter_header(previous_header, filter);
+    const auto result = neutrino::compute_header(previous_header, filter);
     BOOST_REQUIRE_EQUAL(result, expected);
 }
 
-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_1263442__success)
+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_1263442__success)
 {
     const auto expected = base16_hash("4e6d564c2a2452065c205dd7eb2791124e0c4e0dbb064c410c24968572589dec");
     const auto previous_header = base16_hash("31d66d516a9eda7de865df29f6ef6cb8e4bf9309e5dac899968a9a62a5df61e3");
     const auto filter = base16_chunk("0385acb4f0fe889ef0");
-    const auto result = neutrino::compute_filter_header(previous_header, filter);
+    const auto result = neutrino::compute_header(previous_header, filter);
 
     BOOST_REQUIRE_EQUAL(result, expected);
 }
 
-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_1414221__success)
+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_1414221__success)
 {
     const auto expected = base16_hash("021e8882ef5a0ed932edeebbecfeda1d7ce528ec7b3daa27641acf1189d7b5dc");
     const auto previous_header = base16_hash("5e5e12d90693c8e936f01847859404c67482439681928353ca1296982042864e");
     const auto filter = base16_chunk("00");
-    const auto result = neutrino::compute_filter_header(previous_header, filter);
+    const auto result = neutrino::compute_header(previous_header, filter);
     BOOST_REQUIRE_EQUAL(result, expected);
 }
 

Original file line number	Diff line number	Diff line change
`@@ -81,10 +81,17 @@ bool compute_filter(data_chunk& out, const chain::block& block) NOEXCEPT`
`81`	`81`	`return !!writer;`
`82`	`82`	`}`
`83`	`83`
`84`		`-hash_digest compute_filter_header(const hash_digest& previous_header,`
	`84`	`+hash_digest compute_header(const hash_digest& previous_header,`
`85`	`85`	`const data_chunk& filter) NOEXCEPT`
`86`	`86`	`{`
`87`		`- return bitcoin_hash(splice(bitcoin_hash(filter), previous_header));`
	`87`	`+ return bitcoin_hash(bitcoin_hash(filter), previous_header);`
	`88`	`+}`
	`89`	`+`
	`90`	`+hash_digest compute_header(hash_digest& filter_hash,`
	`91`	`+ const hash_digest& previous_header, const data_chunk& filter) NOEXCEPT`
	`92`	`+{`
	`93`	`+ filter_hash = bitcoin_hash(filter);`
	`94`	`+ return bitcoin_hash(filter_hash, previous_header);`
`88`	`95`	`}`
`89`	`96`
`90`	`97`	`bool match_filter(const block_filter& filter,`
Original file line number	Diff line number	Diff line change
`@@ -107,101 +107,101 @@ BOOST_AUTO_TEST_CASE(neutrino__compute__first_11_blocks__success)`
`107`	`107`	`const chain::block block(data, true);`
`108`	`108`	`data_chunk filter;`
`109`	`109`	`BOOST_REQUIRE(neutrino::compute_filter(filter, block));`
`110`		`- const auto header = neutrino::compute_filter_header(previous_filter_header, filter);`
	`110`	`+ const auto header = neutrino::compute_header(previous_filter_header, filter);`
`111`	`111`	`////std::cout << "header: " << encode_base16(header) << std::endl;`
`112`	`112`	`////std::cout << "filter: " << encode_base16(filter) << std::endl;`
`113`	`113`	`previous_filter_header = header;`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`
`117`		`-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_0__success)`
	`117`	`+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_0__success)`
`118`	`118`	`{`
`119`	`119`	`const auto expected = base16_hash("21584579b7eb08997773e5aeff3a7f932700042d0ed2a6129012b7d7ae81b750");`
`120`	`120`	`const auto previous_header = base16_hash("0000000000000000000000000000000000000000000000000000000000000000");`
`121`	`121`	`const auto filter = base16_chunk("019dfca8");`
`122`		`- const auto result = neutrino::compute_filter_header(previous_header, filter);`
	`122`	`+ const auto result = neutrino::compute_header(previous_header, filter);`
`123`	`123`	`BOOST_REQUIRE_EQUAL(result, expected);`
`124`	`124`	`}`
`125`	`125`
`126`		`-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_2__success)`
	`126`	`+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_2__success)`
`127`	`127`	`{`
`128`	`128`	`const auto expected = base16_hash("186afd11ef2b5e7e3504f2e8cbf8df28a1fd251fe53d60dff8b1467d1b386cf0");`
`129`	`129`	`const auto previous_header = base16_hash("d7bdac13a59d745b1add0d2ce852f1a0442e8945fc1bf3848d3cbffd88c24fe1");`
`130`	`130`	`const auto filter = base16_chunk("0174a170");`
`131`		`- const auto result = neutrino::compute_filter_header(previous_header, filter);`
	`131`	`+ const auto result = neutrino::compute_header(previous_header, filter);`
`132`	`132`	`BOOST_REQUIRE_EQUAL(result, expected);`
`133`	`133`	`}`
`134`	`134`
`135`		`-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_3__success)`
	`135`	`+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_3__success)`
`136`	`136`	`{`
`137`	`137`	`const auto expected = base16_hash("8d63aadf5ab7257cb6d2316a57b16f517bff1c6388f124ec4c04af1212729d2a");`
`138`	`138`	`const auto previous_header = base16_hash("186afd11ef2b5e7e3504f2e8cbf8df28a1fd251fe53d60dff8b1467d1b386cf0");`
`139`	`139`	`const auto filter = base16_chunk("016cf7a0");`
`140`		`- const auto result = neutrino::compute_filter_header(previous_header, filter);`
	`140`	`+ const auto result = neutrino::compute_header(previous_header, filter);`
`141`	`141`	`BOOST_REQUIRE_EQUAL(result, expected);`
`142`	`142`	`}`
`143`	`143`
`144`		`-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_15007__success)`
	`144`	`+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_15007__success)`
`145`	`145`	`{`
`146`	`146`	`const auto expected = base16_hash("07384b01311867949e0c046607c66b7a766d338474bb67f66c8ae9dbd454b20e");`
`147`	`147`	`const auto previous_header = base16_hash("18b5c2b0146d2d09d24fb00ff5b52bd0742f36c9e65527abdb9de30c027a4748");`
`148`	`148`	`const auto filter = base16_chunk("013c3710");`
`149`		`- const auto result = neutrino::compute_filter_header(previous_header, filter);`
	`149`	`+ const auto result = neutrino::compute_header(previous_header, filter);`
`150`	`150`	`BOOST_REQUIRE_EQUAL(result, expected);`
`151`	`151`	`}`
`152`	`152`
`153`		`-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_49291__success)`
	`153`	`+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_49291__success)`
`154`	`154`	`{`
`155`	`155`	`const auto expected = base16_hash("b6d98692cec5145f67585f3434ec3c2b3030182e1cb3ec58b855c5c164dfaaa3");`
`156`	`156`	`const auto previous_header = base16_hash("ed47705334f4643892ca46396eb3f4196a5e30880589e4009ef38eae895d4a13");`
`157`	`157`	`const auto filter = base16_chunk("0afbc2920af1b027f31f87b592276eb4c32094bb4d3697021b4c6380");`
`158`		`- const auto result = neutrino::compute_filter_header(previous_header, filter);`
	`158`	`+ const auto result = neutrino::compute_header(previous_header, filter);`
`159`	`159`	`BOOST_REQUIRE_EQUAL(result, expected);`
`160`	`160`	`}`
`161`	`161`
`162`		`-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_180480__success)`
	`162`	`+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_180480__success)`
`163`	`163`	`{`
`164`	`164`	`const auto expected = base16_hash("c582d51c0ca365e3fcf36c51cb646d7f83a67e867cb4743fd2128e3e022b700c");`
`165`	`165`	`const auto previous_header = base16_hash("d34ef98386f413769502808d4bac5f20f8dfd5bffc9eedafaa71de0eb1f01489");`
`166`	`166`	`const auto filter = base16_chunk("0db414c859a07e8205876354a210a75042d0463404913d61a8e068e58a3ae2aa080026");`
`167`		`- const auto result = neutrino::compute_filter_header(previous_header, filter);`
	`167`	`+ const auto result = neutrino::compute_header(previous_header, filter);`
`168`	`168`	`BOOST_REQUIRE_EQUAL(result, expected);`
`169`	`169`	`}`
`170`	`170`
`171`		`-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_926485__success)`
	`171`	`+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_926485__success)`
`172`	`172`	`{`
`173`	`173`	`const auto expected = base16_hash("546c574a0472144bcaf9b6aeabf26372ad87c7af7d1ee0dbfae5e099abeae49c");`
`174`	`174`	`const auto previous_header = base16_hash("8f13b9a9c85611635b47906c3053ac53cfcec7211455d4cb0d63dc9acc13d472");`
`175`	`175`	`const auto filter = base16_chunk("09027acea61b6cc3fb33f5d52f7d088a6b2f75d234e89ca800");`
`176`		`- const auto result = neutrino::compute_filter_header(previous_header, filter);`
	`176`	`+ const auto result = neutrino::compute_header(previous_header, filter);`
`177`	`177`	`BOOST_REQUIRE_EQUAL(result, expected);`
`178`	`178`	`}`
`179`	`179`
`180`		`-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_987876__success)`
	`180`	`+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_987876__success)`
`181`	`181`	`{`
`182`	`182`	`const auto expected = base16_hash("0965a544743bbfa36f254446e75630c09404b3d164a261892372977538928ed5");`
`183`	`183`	`const auto previous_header = base16_hash("fe4d230dbb0f4fec9bed23a5283e08baf996e3f32b93f52c7de1f641ddfd04ad");`
`184`	`184`	`const auto filter = base16_chunk("010c0b40");`
`185`		`- const auto result = neutrino::compute_filter_header(previous_header, filter);`
	`185`	`+ const auto result = neutrino::compute_header(previous_header, filter);`
`186`	`186`	`BOOST_REQUIRE_EQUAL(result, expected);`
`187`	`187`	`}`
`188`	`188`
`189`		`-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_1263442__success)`
	`189`	`+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_1263442__success)`
`190`	`190`	`{`
`191`	`191`	`const auto expected = base16_hash("4e6d564c2a2452065c205dd7eb2791124e0c4e0dbb064c410c24968572589dec");`
`192`	`192`	`const auto previous_header = base16_hash("31d66d516a9eda7de865df29f6ef6cb8e4bf9309e5dac899968a9a62a5df61e3");`
`193`	`193`	`const auto filter = base16_chunk("0385acb4f0fe889ef0");`
`194`		`- const auto result = neutrino::compute_filter_header(previous_header, filter);`
	`194`	`+ const auto result = neutrino::compute_header(previous_header, filter);`
`195`	`195`
`196`	`196`	`BOOST_REQUIRE_EQUAL(result, expected);`
`197`	`197`	`}`
`198`	`198`
`199`		`-BOOST_AUTO_TEST_CASE(neutrino__compute_filter_header__block_1414221__success)`
	`199`	`+BOOST_AUTO_TEST_CASE(neutrino__compute_header__block_1414221__success)`
`200`	`200`	`{`
`201`	`201`	`const auto expected = base16_hash("021e8882ef5a0ed932edeebbecfeda1d7ce528ec7b3daa27641acf1189d7b5dc");`
`202`	`202`	`const auto previous_header = base16_hash("5e5e12d90693c8e936f01847859404c67482439681928353ca1296982042864e");`
`203`	`203`	`const auto filter = base16_chunk("00");`
`204`		`- const auto result = neutrino::compute_filter_header(previous_header, filter);`
	`204`	`+ const auto result = neutrino::compute_header(previous_header, filter);`
`205`	`205`	`BOOST_REQUIRE_EQUAL(result, expected);`
`206`	`206`	`}`
`207`	`207`