Merge branch 'chore/main-catchup-2026-08-26' into 'main'HEADmain

Bring main onto the line this project actually ships (incl. the 1.2.23 compactblock port)

Closes #6, #7, #8, #11, #35, #34, #29, #28, #27, and #16

See merge request !16

1 files changed, 113 insertions, 0 deletions

diff --git a/src/compactblock.h b/src/compactblock.h
new file mode 100644
index 0000000..745ee3b
--- /dev/null
+++ b/src/compactblock.h
@@ -0,0 +1,113 @@
+// Copyright (c) 2026 Bitflash developers
+// Distributed under the MIT/X11 software license.
+//
+// Compact block relay (BIP152-style). Instead of sending a peer's full set
+// of transactions for a block they're about to receive -- almost all of
+// which they already have in their mempool from normal tx relay -- send a
+// short (48-bit, keyed-hash) ID per transaction instead. A peer that already
+// has every referenced transaction reconstructs the full block locally from
+// its mempool without any of the transaction bytes crossing the wire at
+// all; only genuinely missing transactions (typically just the coinbase)
+// need a follow-up round trip.
+//
+// Compatibility: this is purely additive. A peer that never sends
+// "sendcmpct" is never sent a compact block -- it keeps getting full
+// "block" messages exactly as before (see the getdata handler in
+// main.cpp). Old, unupgraded nodes on the live network are completely
+// unaffected; ProcessMessage's unknown-command handling means they simply
+// never see the new message types. No coordinated network upgrade needed.
+//
+// Deliberately scoped down from full BIP152: no high-bandwidth (unsolicited
+// push) mode, no differential-index encoding for prefilled transactions,
+// only the current chain tip is ever offered in compact form (an old block
+// is unlikely to still overlap much with any peer's current mempool, so the
+// bandwidth win doesn't apply -- full "block" is sent for those, same as
+// today). Only the coinbase is prefilled; every other transaction position
+// carries a short ID.
+
+#ifndef BITFLASH_COMPACTBLOCK_H
+#define BITFLASH_COMPACTBLOCK_H
+
+// Requires CBlock/CTransaction already visible -- #include "headers.h" (or
+// main.h) before this file. Deliberately doesn't include main.h itself:
+// main.h has no include guard (matches this codebase's existing headers, it
+// relies on being pulled in exactly once via headers.h), so a second
+// #include "main.h" here would break every translation unit that already
+// brought it in via headers.h first.
+#include <vector>
+
+// The compact representation of a block: header fields, a per-block nonce
+// (keys the short-ID hash so IDs can't be precomputed/ground across blocks),
+// the coinbase in full, and a 48-bit short ID for every other transaction
+// in block order.
+class CCmpctBlock
+{
+public:
+    // header
+    int          nVersion;
+    uint256      hashPrevBlock;
+    uint256      hashMerkleRoot;
+    unsigned int nTime;
+    unsigned int nBits;
+    unsigned int nNonce;
+
+    // Keys the short-ID hash for this block specifically -- chosen fresh
+    // per block (not reused from nNonce, which is public PoW data an
+    // attacker already knows and could otherwise grind against).
+    uint64 shortIdNonce;
+
+    // Sent in full. In this implementation: always exactly the coinbase,
+    // at index 0.
+    std::vector<unsigned int> vPrefilledIndex;
+    std::vector<CTransaction> vPrefilledTx;
+
+    // One short ID per NON-prefilled transaction, in ascending block-index
+    // order (i.e. the Nth entry here belongs to the Nth block position that
+    // isn't in vPrefilledIndex).
+    std::vector<uint64> vShortTxId;
+
+    IMPLEMENT_SERIALIZE
+    (
+        READWRITE(this->nVersion);
+        nVersion = this->nVersion;
+        READWRITE(hashPrevBlock);
+        READWRITE(hashMerkleRoot);
+        READWRITE(nTime);
+        READWRITE(nBits);
+        READWRITE(nNonce);
+        READWRITE(shortIdNonce);
+        READWRITE(vPrefilledIndex);
+        READWRITE(vPrefilledTx);
+        READWRITE(vShortTxId);
+    )
+
+    uint256 HeaderHash() const;
+};
+
+// Compute the 48-bit short ID for a transaction under a given block's
+// short-ID nonce. Keyed (via the block's hashPrevBlock + shortIdNonce) so
+// IDs from one block can't be precomputed before that block exists, and
+// differ block to block even for the same transaction.
+uint64 ComputeShortTxId(const uint256& hashPrevBlock, uint64 shortIdNonce, const uint256& txid);
+
+// Build the compact form of `block` (which must have vtx[0] as the
+// coinbase, as every block on this chain does).
+bool BuildCompactBlock(const CBlock& block, CCmpctBlock& out);
+
+// Attempt to reconstruct a full block from a received compact block using
+// the local mempool. On full success, returns true and fills `outBlock`.
+// On partial success (some transactions not found locally), returns false
+// and fills `vMissingIndex` with the block-position indices that still need
+// to be requested via "getblocktxn" -- outBlock is left partially built
+// (coinbase and any resolved positions filled; caller must not use it until
+// FillMissingAndFinish completes it).
+bool TryReconstructBlock(const CCmpctBlock& cmpct, CBlock& outBlock, std::vector<unsigned int>& vMissingIndex);
+
+// Complete a partially-reconstructed block (from a prior TryReconstructBlock
+// that returned false) using the transactions received in a "blocktxn"
+// response. vTxn must be in the same order as the indices this node
+// requested via "getblocktxn" for this block.
+bool FillMissingAndFinish(CBlock& outBlock, const std::vector<unsigned int>& vMissingIndex,
+                           const std::vector<CTransaction>& vTxn);
+
+#endif