From 60538c5a935787521a5ad8c2a7dce52b5f250f3a Mon Sep 17 00:00:00 2001 From: bitflash-maintainer Date: Sat, 5 Sep 2026 03:16:00 +0000 Subject: compactblock: import BIP152-style compact block relay from upstream 1.2.23 Brings src/compactblock.{cpp,h} and test_compactblock.cpp across verbatim from the upstream-v1.2.23 tag, and gives them a build. 1.2.23 is not a newer release of the line this fork ships. It is a lightweight tag (7ab5a8c) cut 2026-07-30, on a lineage that upstream/main (e0be70e, 2026-08-20) does not contain and no remote branch carries -- 272 commits that are not ours, against 376 of ours that are not theirs, from a merge-base at 56df983. Merging that tag would have deleted 18 files from src/, selftest.{cpp,h} and the whole 14-test suite among them, so the content is ported file by file instead. Compact block relay is the piece worth having: a peer that advertises sendcmpct gets 48-bit keyed short IDs per transaction rather than the transaction bytes, and reconstructs the block from its own mempool. It is purely additive on the wire -- a peer that never sends sendcmpct keeps receiving full block messages, so no coordinated upgrade is needed. This commit is the primitives and their unit test only. Nothing calls BuildCompactBlock or TryReconstructBlock yet: the P2P message handlers (sendcmpct/cmpctblock/getblocktxn/blocktxn) live in 1.2.23's main.cpp and are deliberately left for a follow-up, so that no attacker-controlled bytes reach this code until that wiring is reviewed on its own. The files needed no API adaptation -- mapTransactions, BEGIN/END and IMPLEMENT_SERIALIZE are unchanged across the divergence, and it compiled clean first time. Upstream never wired test_compactblock.cpp into its own Makefile, so it had never been built there; it links standalone the way test_bip32 does, supplying its own mapTransactions and GetAppDir to keep main.cpp out of the link. TEST_LIBS is overridable for the same reason NODE_LIBS is: the pinned dep tree ships libsodium as a static archive only. All 17 checks in test_compactblock pass, all 14 selftests still pass, and the consensus constants are unchanged against e4f898c. --- src/test_compactblock.cpp | 133 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 133 insertions(+) create mode 100644 src/test_compactblock.cpp (limited to 'src/test_compactblock.cpp') diff --git a/src/test_compactblock.cpp b/src/test_compactblock.cpp new file mode 100644 index 0000000..f4b5583 --- /dev/null +++ b/src/test_compactblock.cpp @@ -0,0 +1,133 @@ +// Standalone test of compactblock.cpp's core logic: build a compact block, +// reconstruct it from a simulated mempool, including the missing-tx path. +// Not wired into the P2P layer -- proves BuildCompactBlock/ +// TryReconstructBlock/FillMissingAndFinish are correct in isolation. + +#include "headers.h" +#include "compactblock.h" +#include +#include + +// main.cpp defines this; we're not linking main.cpp, so define it here. +map mapTransactions; +string GetAppDir() { return "."; } // util.h's debug-log path helper needs this + +static int g_fail = 0; +#define CHECK(cond, msg) do { \ + if (cond) printf(" ok %s\n", msg); \ + else { printf(" FAIL %s\n", msg); g_fail++; } \ +} while (0) + +// Build a syntactically-valid-enough CTransaction that GetHash()s uniquely +// per `nSeed` -- doesn't need to be consensus-valid, this test only +// exercises short-ID computation and reconstruction, not script validation. +static CTransaction MakeTx(int nSeed) +{ + CTransaction tx; + tx.nVersion = 1; + tx.nLockTime = nSeed; // cheapest way to make each tx's serialization (and hash) unique + return tx; +} + +int main() +{ + // Build a block: coinbase + 20 regular transactions. + CBlock block; + block.nVersion = 1; + block.hashPrevBlock = uint256("0x00000000000000000000000000000000000000000000000000000000000abc"); + block.nTime = 1234567890; + block.nBits = 0x1f0fffff; + block.nNonce = 42; + block.vtx.push_back(MakeTx(0)); // coinbase + for (int i = 1; i <= 20; i++) + block.vtx.push_back(MakeTx(i)); + block.hashMerkleRoot = block.BuildMerkleTree(); + + printf("build_and_reconstruct_full_mempool\n"); + { + CCmpctBlock cmpct; + CHECK(BuildCompactBlock(block, cmpct), "BuildCompactBlock succeeds"); + CHECK(cmpct.vPrefilledIndex.size() == 1 && cmpct.vPrefilledIndex[0] == 0, "only the coinbase is prefilled"); + CHECK(cmpct.vShortTxId.size() == 20, "one short ID per remaining tx"); + + // Simulate a peer with every transaction already in its mempool. + mapTransactions.clear(); + for (size_t i = 1; i < block.vtx.size(); i++) + mapTransactions[block.vtx[i].GetHash()] = block.vtx[i]; + + CBlock rebuilt; + vector vMissing; + CHECK(TryReconstructBlock(cmpct, rebuilt, vMissing), "fully reconstructs when mempool has everything"); + CHECK(vMissing.empty(), "nothing reported missing"); + CHECK(rebuilt.GetHash() == block.GetHash(), "reconstructed block hash matches original exactly"); + CHECK(rebuilt.vtx.size() == block.vtx.size(), "same transaction count"); + bool fAllMatch = true; + for (size_t i = 0; i < block.vtx.size(); i++) + if (rebuilt.vtx[i].GetHash() != block.vtx[i].GetHash()) fAllMatch = false; + CHECK(fAllMatch, "every transaction in the right position"); + } + + printf("partial_mempool_then_getblocktxn_completes_it\n"); + { + CCmpctBlock cmpct; + BuildCompactBlock(block, cmpct); + + // Simulate a peer missing 3 of the 20 non-coinbase transactions. + mapTransactions.clear(); + vector expectMissing; + for (size_t i = 1; i < block.vtx.size(); i++) + { + if (i == 5 || i == 12 || i == 19) { expectMissing.push_back((unsigned int)i); continue; } + mapTransactions[block.vtx[i].GetHash()] = block.vtx[i]; + } + + CBlock rebuilt; + vector vMissing; + CHECK(!TryReconstructBlock(cmpct, rebuilt, vMissing), "reports incomplete when mempool is missing some tx"); + CHECK(vMissing == expectMissing, "missing indices are exactly the ones not in mempool"); + + // Simulate the getblocktxn round trip: peer sends back the missing txs. + vector vTxn; + foreach(unsigned int idx, vMissing) + vTxn.push_back(block.vtx[idx]); + + CHECK(FillMissingAndFinish(rebuilt, vMissing, vTxn), "FillMissingAndFinish succeeds with matching response"); + CHECK(rebuilt.GetHash() == block.GetHash(), "block hash matches after filling in the missing tx"); + } + + printf("mismatched_blocktxn_response_rejected\n"); + { + CCmpctBlock cmpct; + BuildCompactBlock(block, cmpct); + mapTransactions.clear(); + mapTransactions[block.vtx[1].GetHash()] = block.vtx[1]; // only one in mempool + + CBlock rebuilt; + vector vMissing; + TryReconstructBlock(cmpct, rebuilt, vMissing); + CHECK(vMissing.size() == 19, "19 missing when mempool has only 1 of 20"); + + vector vWrongCount; + vWrongCount.push_back(block.vtx[2]); // way fewer than vMissing.size() + CHECK(!FillMissingAndFinish(rebuilt, vMissing, vWrongCount), "rejects a response with the wrong tx count"); + } + + printf("different_blocks_give_different_short_ids_for_same_tx\n"); + { + // Same transaction, two different (simulated) blocks -- short IDs + // must differ, since they're keyed per-block (hashPrevBlock + + // fresh nonce each time), not just derived from the txid alone. + CTransaction tx = MakeTx(99); + uint256 prevA = uint256("0x1111111111111111111111111111111111111111111111111111111111111111"); + uint256 prevB = uint256("0x2222222222222222222222222222222222222222222222222222222222222222"); + uint64 id1 = ComputeShortTxId(prevA, 0xAAAABBBBCCCCDDDDULL, tx.GetHash()); + uint64 id2 = ComputeShortTxId(prevB, 0xAAAABBBBCCCCDDDDULL, tx.GetHash()); + uint64 id3 = ComputeShortTxId(prevA, 0x1111222233334444ULL, tx.GetHash()); + CHECK(id1 != id2, "different hashPrevBlock -> different short ID"); + CHECK(id1 != id3, "different nonce -> different short ID"); + CHECK(id1 <= 0xFFFFFFFFFFFFULL, "short ID fits in 48 bits"); + } + + printf("\n%s (%d failures)\n", g_fail == 0 ? "ALL TESTS PASSED" : "TESTS FAILED", g_fail); + return g_fail == 0 ? 0 : 1; +} -- cgit v1.2.3