Merge pull request #11 from cakedefi/feature_newblocksize

Feature newblocksize

src/amount.h

@@ -22,7 +22,7 @@ static const CAmount COIN = 100000000;
  * critical; in unusual circumstances like a(nother) overflow bug that allowed
  * for the creation of coins out of thin air modification could lead to a fork.
  * */
-static const CAmount MAX_MONEY = 21000000 * COIN;
+static const CAmount MAX_MONEY = 21000000 * 4 * COIN;
 inline bool MoneyRange(const CAmount& nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
 
 #endif //  BITCOIN_AMOUNT_H

src/chainparams.cpp

@@ -22,9 +22,6 @@
 
 std::vector<CTransactionRef> CChainParams::CreateGenesisMasternodes() const
 {
-//    CChainParamsDummy dummy(*this);
-
-
     std::vector<CTransactionRef> mnTxs;
     for (auto const & addrs : vMasternodes)
     {
@@ -40,7 +37,7 @@ std::vector<CTransactionRef> CChainParams::CreateGenesisMasternodes() const
         assert(ownerDest.which() == 1 || ownerDest.which() == 4);
 
         CKeyID operatorAuthKey = operatorDest.which() == 1 ? CKeyID(*boost::get<PKHash>(&operatorDest)) : CKeyID(*boost::get<WitnessV0KeyHash>(&operatorDest)) ;
-        CDataStream metadata(MnTxMarker, SER_NETWORK, PROTOCOL_VERSION);
+        CDataStream metadata(DfTxMarker, SER_NETWORK, PROTOCOL_VERSION);
         metadata << static_cast<unsigned char>(MasternodesTxType::CreateMasternode)
                  << static_cast<char>(operatorDest.which()) << operatorAuthKey;
 
@@ -110,15 +107,18 @@ class CMainParams : public CChainParams {
     CMainParams() {
         strNetworkID = "main";
         consensus.nSubsidyHalvingInterval = 210000;
+        consensus.baseBlockSubsidy = 200 * COIN;
         consensus.BIP16Exception = uint256S("0x00000000000002dc756eebf4f49723ed8d30cc28a5f108eb94b1ba88ac4f9c22");
         consensus.BIP34Height = 0;
         consensus.BIP34Hash = uint256();
         consensus.BIP65Height = 0; // 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0
         consensus.BIP66Height = 0; // 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931
 
         consensus.pos.diffLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-        consensus.pos.nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
-        consensus.pos.nTargetSpacing = 10 * 60; // 10 minutes
+//        consensus.pos.nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
+//        consensus.pos.nTargetSpacing = 10 * 60; // 10 minutes
+        consensus.pos.nTargetTimespan = 12 * 60 * 60;
+        consensus.pos.nTargetSpacing = 30; // seconds
         consensus.pos.fAllowMinDifficultyBlocks = false; // only for regtest
         consensus.pos.fNoRetargeting = false; // only for regtest
 
@@ -128,8 +128,8 @@ class CMainParams : public CChainParams {
 
         consensus.CSVHeight = 1; // 000000000000000004a1b34462cb8aeebd5799177f7a29cf28f2d1961716b5b5
         consensus.SegwitHeight = 0; // 0000000000000000001c8018d9cb3b742ef25114f27563e3fc4a1902167f9893
-        consensus.nRuleChangeActivationThreshold = 1916; // 95% of 2016
-        consensus.nMinerConfirmationWindow = 2016; // nTargetTimespan / nTargetSpacing
+        consensus.nRuleChangeActivationThreshold = 1368; //1916; // 95% of 2016
+        consensus.nMinerConfirmationWindow = 1440; //2016; // nTargetTimespan / nTargetSpacing
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 1199145601; // January 1, 2008
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = 1230767999; // December 31, 2008
@@ -170,10 +170,14 @@ class CMainParams : public CChainParams {
 
         bech32_hrp = "df";
 
-        genesis = CreateGenesisBlock(1569396815, 0x1e0fffff, 1, 50 * COIN, CreateGenesisMasternodes());
+        // (!) after prefixes set
+        consensus.foundationAddress = CNoDestination();
+        consensus.foundationShare = 10;
+
+        genesis = CreateGenesisBlock(1233928877, 0x1d00ffff, 1, consensus.baseBlockSubsidy, CreateGenesisMasternodes()); // old=1231006505
         consensus.hashGenesisBlock = genesis.GetHash();
-        assert(consensus.hashGenesisBlock == uint256S("0xc0f410a59e9aa22afd67ee4671d41c2e3135c0efc589446e4b393cc534d178ac"));
-        assert(genesis.hashMerkleRoot == uint256S("0x800c7581a09c96d98bdad848db8fc027e8869d28d890ca21f6c25124baf53afe"));
+        assert(consensus.hashGenesisBlock == uint256S("0x00000eb73561bf4d6a32b49caf1576a11d4e84a214feaa213ee5ce052ccd5309"));
+        assert(genesis.hashMerkleRoot == uint256S("0x489dd73fab332bf0d894b4d8743ad65ad8ce33624e2fcbac091e25147b14293f"));
 
         // Note that of those which support the service bits prefix, most only support a subset of
         // possible options.
@@ -230,15 +234,18 @@ class CTestNetParams : public CChainParams {
     CTestNetParams() {
         strNetworkID = "test";
         consensus.nSubsidyHalvingInterval = 210000;
+        consensus.baseBlockSubsidy = 200 * COIN;
         consensus.BIP16Exception = uint256S("0x00000000dd30457c001f4095d208cc1296b0eed002427aa599874af7a432b105");
         consensus.BIP34Height = 0;
         consensus.BIP34Hash = uint256();
         consensus.BIP65Height = 0; // 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6
         consensus.BIP66Height = 0; // 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182
 
         consensus.pos.diffLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-        consensus.pos.nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
-        consensus.pos.nTargetSpacing = 10 * 60; // 10 minutes
+//        consensus.pos.nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
+//        consensus.pos.nTargetSpacing = 10 * 60; // 10 minutes
+        consensus.pos.nTargetTimespan = 5 * 60; // 5 min
+        consensus.pos.nTargetSpacing = 30;
         consensus.pos.fAllowMinDifficultyBlocks = true;
         consensus.pos.fNoRetargeting = false; // only for regtest
 
@@ -248,8 +255,8 @@ class CTestNetParams : public CChainParams {
 
         consensus.CSVHeight = 1; // 00000000025e930139bac5c6c31a403776da130831ab85be56578f3fa75369bb
         consensus.SegwitHeight = 0; // 00000000002b980fcd729daaa248fd9316a5200e9b367f4ff2c42453e84201ca
-        consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
-        consensus.nMinerConfirmationWindow = 2016; // nTargetTimespan / nTargetSpacing
+        consensus.nRuleChangeActivationThreshold = 8; //1512; // 75% for testchains
+        consensus.nMinerConfirmationWindow = 10; //2016; // nTargetTimespan / nTargetSpacing
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 1199145601; // January 1, 2008
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = 1230767999; // December 31, 2008
@@ -285,17 +292,21 @@ class CTestNetParams : public CChainParams {
 
         bech32_hrp = "tf";
 
+        // (!) after prefixes set
+        consensus.foundationAddress = DecodeDestination("774LCfQ7TAypxBcoTqhPtrnixL53bFK1Gt", *this);
+        consensus.foundationShare = 10;
+
         // owner base58, operator base58
         vMasternodes.push_back({"7M3g9CSERjLdXisE5pv2qryDbURUj9Vpi1", "7Grgx69MZJ4wDKRx1bBxLqTnU9T3quKW7n"});
         vMasternodes.push_back({"7L29itepC13pgho1X2y7mcuf4WjkBi7x2w", "773MiaEtQK2HAwWj55gyuRiU8tSwowRTTW"});
         vMasternodes.push_back({"75Wramp2iARchHedXcn1qRkQtMpSt9Mi3V", "7Ku81yvqbPkxpWjZpZWZZnWydXyzJozZfN"});
         vMasternodes.push_back({"7LfqHbyh9dBQDjWB6MxcWvH2PBC5iY4wPa", "75q6ftr3QGfBT3DBu15fVfetP6duAgfhNH"});
 
-        genesis = CreateGenesisBlock(1297053593, 0x207fffff, 1, 50 * COIN, CreateGenesisMasternodes()); // 0x1e0fffff
+        genesis = CreateGenesisBlock(1296707317, 0x1d00ffff, 1, consensus.baseBlockSubsidy, CreateGenesisMasternodes()); // old=1296688602
         consensus.hashGenesisBlock = genesis.GetHash();
 
-        assert(consensus.hashGenesisBlock == uint256S("0x00000e04e92efbd4a99b9f38abd22bc1e97651ab194a72a6390687f99c4d1555"));
-        assert(genesis.hashMerkleRoot == uint256S("0xc4b5095034837015551b4ef0eb56eab6706b3d102cc44a910c0eee084932ef5b"));
+        assert(consensus.hashGenesisBlock == uint256S("0x0000088af9af8ea4627c5fb2d6cf2075235caaaf62aae791040700cbcaa05cc7"));
+        assert(genesis.hashMerkleRoot == uint256S("0xae22df3d3b2f6a9f2e7fc8260a649a7928537445b626fa92bc977538a85ad106"));
 
         vFixedSeeds.clear();
         vSeeds.clear();
@@ -334,6 +345,7 @@ class CRegTestParams : public CChainParams {
     explicit CRegTestParams(const ArgsManager& args) {
         strNetworkID = "regtest";
         consensus.nSubsidyHalvingInterval = 150;
+        consensus.baseBlockSubsidy = 50 * COIN;
         consensus.BIP16Exception = uint256();
         consensus.BIP34Height = 500; // BIP34 activated on regtest (Used in functional tests)
         consensus.BIP34Hash = uint256();
@@ -390,6 +402,10 @@ class CRegTestParams : public CChainParams {
 
         bech32_hrp = "bcrt";
 
+        // (!) after prefixes set
+        consensus.foundationAddress = CNoDestination();
+        consensus.foundationShare = 0;
+
         // owner base58, operator base58
         vMasternodes.push_back({"mwsZw8nF7pKxWH8eoKL9tPxTpaFkz7QeLU", "mswsMVsyGMj1FzDMbbxw2QW3KvQAv2FKiy"});
         vMasternodes.push_back({"msER9bmJjyEemRpQoS8YYVL21VyZZrSgQ7", "mps7BdmwEF2vQ9DREDyNPibqsuSRZ8LuwQ"});
@@ -400,11 +416,11 @@ class CRegTestParams : public CChainParams {
         vMasternodes.push_back({"bcrt1qyrfrpadwgw7p5eh3e9h3jmu4kwlz4prx73cqny", "bcrt1qmfvw3dp3u6fdvqkdc0y3lr0e596le9cf22vtsv"});
         vMasternodes.push_back({"bcrt1qyeuu9rvq8a67j86pzvh5897afdmdjpyankp4mu", "bcrt1qurwyhta75n2g75u2u5nds9p6w9v62y8wr40d2r"});
 
-        genesis = CreateGenesisBlock(1298732709, 0x207fffff, 1, 50 * COIN, CreateGenesisMasternodes()); // old=1296688602
+        genesis = CreateGenesisBlock(1297225381, 0x207fffff, 1, consensus.baseBlockSubsidy, CreateGenesisMasternodes()); // old=1296688602
         consensus.hashGenesisBlock = genesis.GetHash();
 
-        assert(consensus.hashGenesisBlock == uint256S("0x00000089a42802dfd816d0986339546b1f33a8d0e8ce2b9a4844a301407bac13"));
-        assert(genesis.hashMerkleRoot == uint256S("0xd43efce4ced3bacf52a958ae189ba1dd977031910cbeb72eb5e7f56a59ca4f52"));
+        assert(consensus.hashGenesisBlock == uint256S("0x00000e6e3c0fff02894aea8e46f76507d6f54dbb1b227f6911c09c2ce8117351"));
+        assert(genesis.hashMerkleRoot == uint256S("0x7889a37b3cc61704417f65ec069b9da7f862bd6926329edb889835b2793942c8"));
 
         vFixedSeeds.clear(); //!< Regtest mode doesn't have any fixed seeds.
         vSeeds.clear();      //!< Regtest mode doesn't have any DNS seeds.

src/consensus/consensus.h

@@ -10,11 +10,11 @@
 #include <stdint.h>
 
 /** The maximum allowed size for a serialized block, in bytes (only for buffer size limits) */
-static const unsigned int MAX_BLOCK_SERIALIZED_SIZE = 4000000;
+static const unsigned int MAX_BLOCK_SERIALIZED_SIZE = 4000000 * 16;
 /** The maximum allowed weight for a block, see BIP 141 (network rule) */
-static const unsigned int MAX_BLOCK_WEIGHT = 4000000;
+static const unsigned int MAX_BLOCK_WEIGHT = 4000000 * 16;
 /** The maximum allowed number of signature check operations in a block (network rule) */
-static const int64_t MAX_BLOCK_SIGOPS_COST = 80000;
+static const int64_t MAX_BLOCK_SIGOPS_COST = 80000 * 16;
 /** Coinbase transaction outputs can only be spent after this number of new blocks (network rule) */
 static const int COINBASE_MATURITY = 100;
 

src/consensus/params.h

@@ -7,6 +7,7 @@
 #define BITCOIN_CONSENSUS_PARAMS_H
 
 #include <amount.h>
+#include <script/standard.h>
 #include <uint256.h>
 #include <limits>
 #include <map>
@@ -49,6 +50,9 @@ struct BIP9Deployment {
 struct Params {
     uint256 hashGenesisBlock;
     int nSubsidyHalvingInterval;
+    CAmount baseBlockSubsidy;
+    CTxDestination foundationAddress;
+    uint32_t foundationShare;
     /* Block hash that is excepted from BIP16 enforcement */
     uint256 BIP16Exception;
     /** Block height and hash at which BIP34 becomes active */

src/httpserver.cpp

@@ -387,7 +387,7 @@ bool InitHTTPServer()
 
     evhttp_set_timeout(http, gArgs.GetArg("-rpcservertimeout", DEFAULT_HTTP_SERVER_TIMEOUT));
     evhttp_set_max_headers_size(http, MAX_HEADERS_SIZE);
-    evhttp_set_max_body_size(http, MAX_SIZE);
+    evhttp_set_max_body_size(http, MAX_DESER_SIZE);
     evhttp_set_gencb(http, http_request_cb, nullptr);
 
     if (!HTTPBindAddresses(http)) {

src/masternodes/masternodes.cpp

@@ -403,11 +403,11 @@ bool CMasternodesView::ExtractCriminalCoinsFromTx(CTransaction const & tx, std::
         (opcode > OP_PUSHDATA1 &&
          opcode != OP_PUSHDATA2 &&
          opcode != OP_PUSHDATA4) ||
-        metadata.size() < MnCriminalTxMarker.size() + 1 ||
-        memcmp(&metadata[0], &MnCriminalTxMarker[0], MnCriminalTxMarker.size()) != 0) {
+        metadata.size() < DfCriminalTxMarker.size() + 1 ||
+        memcmp(&metadata[0], &DfCriminalTxMarker[0], DfCriminalTxMarker.size()) != 0) {
         return false;
     }
-    metadata.erase(metadata.begin(), metadata.begin() + MnCriminalTxMarker.size());
+    metadata.erase(metadata.begin(), metadata.begin() + DfCriminalTxMarker.size());
     return true;
 }
 
@@ -536,16 +536,16 @@ MasternodesTxType GuessMasternodeTxType(CTransaction const & tx, std::vector<uns
             (opcode > OP_PUSHDATA1 &&
              opcode != OP_PUSHDATA2 &&
              opcode != OP_PUSHDATA4) ||
-            metadata.size() < MnTxMarker.size() + 1 ||     // i don't know how much exactly, but at least MnTxSignature + type prefix
-            memcmp(&metadata[0], &MnTxMarker[0], MnTxMarker.size()) != 0)
+            metadata.size() < DfTxMarker.size() + 1 ||     // i don't know how much exactly, but at least MnTxSignature + type prefix
+            memcmp(&metadata[0], &DfTxMarker[0], DfTxMarker.size()) != 0)
     {
         return MasternodesTxType::None;
     }
-    auto const & it = MasternodesTxTypeToCode.find(metadata[MnTxMarker.size()]);
+    auto const & it = MasternodesTxTypeToCode.find(metadata[DfTxMarker.size()]);
     if (it == MasternodesTxTypeToCode.end())
     {
         return MasternodesTxType::None;
     }
-    metadata.erase(metadata.begin(), metadata.begin() + MnTxMarker.size() + 1);
+    metadata.erase(metadata.begin(), metadata.begin() + DfTxMarker.size() + 1);
     return it->second;
 }

src/masternodes/masternodes.h

@@ -21,8 +21,8 @@
 class CTransaction;
 class CBlockHeader;
 
-static const std::vector<unsigned char> MnTxMarker = {'M', 'n', 'T', 'x'};  // 4d6e5478
-static const std::vector<unsigned char> MnCriminalTxMarker = {'M', 'n', 'C', 'r'};
+static const std::vector<unsigned char> DfTxMarker = {'D', 'f', 'T', 'x'};  // 44665478
+static const std::vector<unsigned char> DfCriminalTxMarker = {'D', 'f', 'C', 'r'};
 
 static const unsigned int DOUBLE_SIGN_MINIMUM_PROOF_INTERVAL = 100;
 

src/masternodes/mn_rpc.cpp

@@ -211,7 +211,7 @@ UniValue mn_create(const JSONRPCRequest& request)
         }
     }
 
-    CDataStream metadata(MnTxMarker, SER_NETWORK, PROTOCOL_VERSION);
+    CDataStream metadata(DfTxMarker, SER_NETWORK, PROTOCOL_VERSION);
     metadata << static_cast<unsigned char>(MasternodesTxType::CreateMasternode)
              << static_cast<char>(operatorDest.which()) << operatorAuthKey;
 
@@ -310,7 +310,7 @@ UniValue mn_resign(const JSONRPCRequest& request)
         rawTx.vin.push_back(CTxIn(vecOutputs[0].tx->GetHash(), vecOutputs[0].i));
     }
 
-    CDataStream metadata(MnTxMarker, SER_NETWORK, PROTOCOL_VERSION);
+    CDataStream metadata(DfTxMarker, SER_NETWORK, PROTOCOL_VERSION);
     metadata << static_cast<unsigned char>(MasternodesTxType::ResignMasternode)
              << nodeId;
 

src/miner.cpp

@@ -152,6 +152,13 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     coinbaseTx.vout.resize(1);
     coinbaseTx.vout[0].scriptPubKey = scriptPubKeyIn;
     coinbaseTx.vout[0].nValue = nFees + GetBlockSubsidy(nHeight, chainparams.GetConsensus());
+    // Pinch off foundation share
+    if (IsValidDestination(chainparams.GetConsensus().foundationAddress) && chainparams.GetConsensus().foundationShare != 0) {
+        coinbaseTx.vout.resize(2);
+        coinbaseTx.vout[1].scriptPubKey = GetScriptForDestination(chainparams.GetConsensus().foundationAddress);
+        coinbaseTx.vout[1].nValue = coinbaseTx.vout[0].nValue * chainparams.GetConsensus().foundationShare / 100;
+        coinbaseTx.vout[0].nValue -= coinbaseTx.vout[1].nValue;
+    }
 
     bool baseScript = true;
 
@@ -164,7 +171,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
         if (criminal.first.ExtractMinterKey(key)) {
             auto itFirstMN = pmasternodesview->ExistMasternode(CMasternodesView::AuthIndex::ByOperator, key);
             if (itFirstMN) {
-                CDataStream metadata(MnCriminalTxMarker, SER_NETWORK, PROTOCOL_VERSION);
+                CDataStream metadata(DfCriminalTxMarker, SER_NETWORK, PROTOCOL_VERSION);
                 metadata << criminal.first << criminal.second << (*itFirstMN)->second << 0; // 0 - number output for blocking
                 coinbaseTx.vin[0].scriptSig = CScript() << OP_RETURN << ToByteVector(metadata);
 

src/net.cpp

@@ -655,8 +655,10 @@ int CNetMessage::readHeader(const char *pch, unsigned int nBytes)
     }
 
     // reject messages larger than MAX_SIZE
-    if (hdr.nMessageSize > MAX_SIZE)
+    if (hdr.nMessageSize > MAX_DESER_SIZE) {
+        error("Reject messages larger than max deserialization size: (%u > %u)", hdr.nMessageSize, MAX_DESER_SIZE);
         return -1;
+    }
 
     // switch state to reading message data
     in_data = true;

src/net.h

@@ -58,7 +58,7 @@ static const unsigned int MAX_LOCATOR_SZ = 101;
 /** The maximum number of new addresses to accumulate before announcing. */
 static const unsigned int MAX_ADDR_TO_SEND = 1000;
 /** Maximum length of incoming protocol messages (no message over 4 MB is currently acceptable). */
-static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = 4 * 1000 * 1000;
+static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = 16 * 4 * 1000 * 1000;
 /** Maximum length of the user agent string in `version` message */
 static const unsigned int MAX_SUBVERSION_LENGTH = 256;
 /** Maximum number of automatic outgoing nodes */
@@ -82,11 +82,11 @@ static const uint64_t MAX_UPLOAD_TIMEFRAME = 60 * 60 * 24;
 /** Default for blocks only*/
 static const bool DEFAULT_BLOCKSONLY = false;
 /** -peertimeout default */
-static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT = 60;
+static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT = 600; /// @todo @maxb old value 60
 
 static const bool DEFAULT_FORCEDNSSEED = false;
-static const size_t DEFAULT_MAXRECEIVEBUFFER = 5 * 1000;
-static const size_t DEFAULT_MAXSENDBUFFER    = 1 * 1000;
+static const size_t DEFAULT_MAXRECEIVEBUFFER = 20 * 5 * 1000;
+static const size_t DEFAULT_MAXSENDBUFFER    = 16 * 1 * 1000;
 
 typedef int64_t NodeId;
 

src/netbase.cpp

@@ -327,7 +327,7 @@ static IntrRecvError InterruptibleRecv(uint8_t* data, size_t len, int timeout, c
     int64_t endTime = curTime + timeout;
     // Maximum time to wait for I/O readiness. It will take up until this time
     // (in millis) to break off in case of an interruption.
-    const int64_t maxWait = 1000;
+    const int64_t maxWait = 1000;   /// @todo @maxb old value 1000
     while (len > 0 && curTime < endTime) {
         ssize_t ret = recv(hSocket, (char*)data, len, 0); // Optimistically try the recv first
         if (ret > 0) {

src/protocol.cpp

@@ -119,7 +119,7 @@ bool CMessageHeader::IsValid(const MessageStartChars& pchMessageStartIn) const
     }
 
     // Message size
-    if (nMessageSize > MAX_SIZE)
+    if (nMessageSize > MAX_DESER_SIZE)
     {
         LogPrintf("CMessageHeader::IsValid(): (%s, %u bytes) nMessageSize > MAX_SIZE\n", GetCommand(), nMessageSize);
         return false;