Add consensus block size limit (#111, from #110)

CheckBlock() validated block size against MAX_SIZE, the serializer's generic 32 MB guard rather than a block rule; MAX_BLOCK_SIZE did not exist in this tree at all, because Bitcoin's 1 MB cap arrived in 0.3.x, after the 0.1.0 this fork came from. A miner could produce a 32 MB block and every node would download, verify and store it.

Original work by mtg0001 in #110, rebased over #109 with the self-test conflict resolved, plus a comment explaining why the inherited count-against-bytes test stays.

Measured before choosing the number: 5709 blocks read from blk0001.dat give a largest block of 34,290 bytes and a median of 216, so 1 MB leaves 29x of headroom and rejects nothing that exists. A node built from this branch then synced genesis to 5706 on the live network with zero size-limit rejections and zero CheckBlock errors -- the same test that caught BIP30 rejecting a real block at height 859.

1 files changed, 21 insertions, 0 deletions

diff --git a/src/main.h b/src/main.h
index 1b0be59..768f1c7 100644
--- a/src/main.h
+++ b/src/main.h
@@ -29,6 +29,10 @@ static const unsigned int MAX_ORPHAN_BLOCKS = 200;
 // so a block within the size limit could still hold millions of them and take
 // the network minutes of CPU to reject. Same value Bitcoin settled on.
 static const unsigned int MAX_BLOCK_SIGOPS = 20000;
+// Consensus block-size ceiling. MAX_SIZE is the serializer's generic safety
+// limit (32 MB), not a block rule. Bitcoin 0.1.0 predated the later 1 MB block
+// cap, so this tree inherited no real block-size consensus limit.
+static const unsigned int MAX_BLOCK_SIZE = 1000000;
 static const int64 COIN = 100000000;
 // Total Bitflash emission: identical to Bitcoin (21 million).
 // MAX_MONEY guards against the value overflow bug (CVE-2010-5139), which in
@@ -1053,6 +1057,23 @@ public:
         return RandomXPoWHash((const void*)BEGIN(nVersion), END(nNonce) - BEGIN(nVersion));
     }
 
+    bool CheckSizeLimits() const
+    {
+        // The middle test compares a transaction *count* against a *byte*
+        // limit. It is inherited from 0.1.0, where the same line compared
+        // vtx.size() against MAX_SIZE, and it is inert: the smallest possible
+        // transaction serializes to more than sixty bytes, so a block holding
+        // over a million of them cannot also weigh under a megabyte.
+        //
+        // Kept rather than removed. This is consensus code, and a rewrite that
+        // reads better is still a rewrite that can change what the network
+        // accepts. Written down so the next reader does not have to derive it,
+        // or "fix" it into something that does.
+        return (!vtx.empty() &&
+                vtx.size() <= MAX_BLOCK_SIZE &&
+                ::GetSerializeSize(*this, SER_DISK) <= MAX_BLOCK_SIZE);
+    }
+
 
     uint256 BuildMerkleTree() const
     {