2 files changed, 20 insertions, 2 deletions

diff --git a/src/main.cpp b/src/main.cpp
index 5d0b70a..37a15c6 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -4226,7 +4226,19 @@ bool BitcoinMiner(int nThreadId)
             vector<char> vfAlreadyAdded(mapTransactions.size());
             bool fFoundSomething = true;
             unsigned int nBlockSize = 0;
-            while (fFoundSomething && nBlockSize < MAX_SIZE/2)
+            // Assembly must stop below the consensus cap that CheckBlock()
+            // enforces, or we mine a block our own node then rejects.
+            //
+            // This used to read MAX_SIZE/2 (16 MB), which was consistent while
+            // CheckBlock() also tested against MAX_SIZE (32 MB). Adding
+            // MAX_BLOCK_SIZE inverted it: assembly could fill 16 MB and
+            // validation would refuse anything over 1 MB, so a full mempool
+            // meant solving a block and throwing it away -- with this pool at
+            // ~90% of hashrate, that is the network stalling, not just us.
+            //
+            // Half the cap, keeping the original margin: the test runs before
+            // a transaction is added, so the loop can overshoot by one tx.
+            while (fFoundSomething && nBlockSize < MAX_BLOCK_SIZE/2)
             {
                 fFoundSomething = false;
                 unsigned int n = 0;
diff --git a/src/rpc.cpp b/src/rpc.cpp
index da22b1d..03d1f44 100644
--- a/src/rpc.cpp
+++ b/src/rpc.cpp
@@ -253,7 +253,13 @@ static bool RebuildJob()
                     pool = tmp;
                     block.vtx.push_back(tx);
                     sz += ::GetSerializeSize(tx, SER_NETWORK);
-                    if (sz > MAX_SIZE / 2) break;
+                    // Must stay under the consensus cap CheckBlock() enforces.
+                    // This is the pool's job builder, so a block over the cap
+                    // is not just one wasted solve -- it is every miner on the
+                    // pool working a template the network will reject. The
+                    // transaction is already pushed above, so this can overshoot
+                    // by one; half the cap leaves room for that.
+                    if (sz > MAX_BLOCK_SIZE / 2) break;
                 }
             }
         }