Set max block size

neo.UnitTests/UT_Policy.cs

@@ -32,12 +32,16 @@ public void Check_Initialize()
 
             NativeContract.Policy.Initialize(new ApplicationEngine(TriggerType.Application, null, snapshot, 0)).Should().BeTrue();
 
-            (keyCount + 3).Should().Be(snapshot.Storages.GetChangeSet().Count());
+            (keyCount + 4).Should().Be(snapshot.Storages.GetChangeSet().Count());
 
             var ret = NativeContract.Policy.Call(snapshot, "getMaxTransactionsPerBlock");
             ret.Should().BeOfType<VM.Types.Integer>();
             ret.GetBigInteger().Should().Be(512);
 
+            ret = NativeContract.Policy.Call(snapshot, "getMaxBlockSize");
+            ret.Should().BeOfType<VM.Types.Integer>();
+            ret.GetBigInteger().Should().Be(1024 * 256);
+
             ret = NativeContract.Policy.Call(snapshot, "getFeePerByte");
             ret.Should().BeOfType<VM.Types.Integer>();
             ret.GetBigInteger().Should().Be(1000);
@@ -47,6 +51,52 @@ public void Check_Initialize()
             ((VM.Types.Array)ret).Count.Should().Be(0);
         }
 
+        [TestMethod]
+        public void Check_SetMaxBlockSize()
+        {
+            var snapshot = Store.GetSnapshot().Clone();
+
+            // Fake blockchain
+
+            snapshot.PersistingBlock = new Block() { Index = 1000, PrevHash = UInt256.Zero };
+            snapshot.Blocks.Add(UInt256.Zero, new Ledger.TrimmedBlock() { NextConsensus = UInt160.Zero });
+
+            NativeContract.Policy.Initialize(new ApplicationEngine(TriggerType.Application, null, snapshot, 0)).Should().BeTrue();
+
+            // Without signature
+
+            var ret = NativeContract.Policy.Call(snapshot, new Nep5NativeContractExtensions.ManualWitness(null),
+                "setMaxBlockSize", new ContractParameter(ContractParameterType.Integer) { Value = 1024 });
+            ret.Should().BeOfType<VM.Types.Boolean>();
+            ret.GetBoolean().Should().BeFalse();
+
+            ret = NativeContract.Policy.Call(snapshot, "getMaxBlockSize");
+            ret.Should().BeOfType<VM.Types.Integer>();
+            ret.GetBigInteger().Should().Be(1024 * 256);
+
+            // More than expected
+
+            ret = NativeContract.Policy.Call(snapshot, new Nep5NativeContractExtensions.ManualWitness(UInt160.Zero),
+                 "setMaxBlockSize", new ContractParameter(ContractParameterType.Integer) { Value = Network.P2P.Message.PayloadMaxSize });
+            ret.Should().BeOfType<VM.Types.Boolean>();
+            ret.GetBoolean().Should().BeFalse();
+
+            ret = NativeContract.Policy.Call(snapshot, "getMaxBlockSize");
+            ret.Should().BeOfType<VM.Types.Integer>();
+            ret.GetBigInteger().Should().Be(1024 * 256);
+
+            // With signature
+
+            ret = NativeContract.Policy.Call(snapshot, new Nep5NativeContractExtensions.ManualWitness(UInt160.Zero),
+                "setMaxBlockSize", new ContractParameter(ContractParameterType.Integer) { Value = 1024 });
+            ret.Should().BeOfType<VM.Types.Boolean>();
+            ret.GetBoolean().Should().BeTrue();
+
+            ret = NativeContract.Policy.Call(snapshot, "getMaxBlockSize");
+            ret.Should().BeOfType<VM.Types.Integer>();
+            ret.GetBigInteger().Should().Be(1024);
+        }
+
         [TestMethod]
         public void Check_SetMaxTransactionsPerBlock()
         {

neo/Consensus/ChangeViewReason.cs

@@ -7,5 +7,6 @@ public enum ChangeViewReason : byte
         TxNotFound = 0x2,
         TxRejectedByPolicy = 0x3,
         TxInvalid = 0x4,
+        BlockRejectedByPolicy = 0x5
     }
 }

neo/Consensus/ConsensusContext.cs

@@ -210,14 +210,45 @@ public ConsensusPayload MakePrepareRequest()
         {
             byte[] buffer = new byte[sizeof(ulong)];
             random.NextBytes(buffer);
+            Block.ConsensusData.Nonce = BitConverter.ToUInt64(buffer, 0);
+
             IEnumerable<Transaction> memoryPoolTransactions = Blockchain.Singleton.MemPool.GetSortedVerifiedTransactions();
             foreach (IPolicyPlugin plugin in Plugin.Policies)
                 memoryPoolTransactions = plugin.FilterForBlock(memoryPoolTransactions);
+
             List<Transaction> transactions = memoryPoolTransactions.ToList();
-            TransactionHashes = transactions.Select(p => p.Hash).ToArray();
-            Transactions = transactions.ToDictionary(p => p.Hash);
+
+            uint maxBlockSize;
+            Transactions = new Dictionary<UInt256, Transaction>();
+            using (var snapshot = Blockchain.Singleton.GetSnapshot())
+            {
+                maxBlockSize = NativeContract.Policy.GetMaxBlockSize(snapshot);
+                TransactionHashes = new UInt256[NativeContract.Policy.GetMaxTransactionsPerBlock(snapshot)];
+            }
+
+            // Prevent that block exceed the max size
+
+            Block.Transactions = new Transaction[0];
+            var fixedSize = Block.Size + IO.Helper.GetVarSize(TransactionHashes.Length); // ensure that the var size grows without exceed the max size
+
+            for (int x = 0, max = Math.Min(Transactions.Count, transactions.Count); x < max; x++)
+            {
+                var tx = transactions[x];
+
+                // Check if exceed
+                if (fixedSize + UInt256.Length + tx.Size > maxBlockSize) break;
+
+                TransactionHashes[x] = tx.Hash;
+                Transactions.Add(tx.Hash, tx);
+            }
+
+            // Truncate null values
+
+            Array.Resize(ref TransactionHashes, Transactions.Count);
+
+            // Create valid request
+
             Block.Timestamp = Math.Max(TimeProvider.Current.UtcNow.ToTimestampMS(), PrevHeader.Timestamp + 1);
-            Block.ConsensusData.Nonce = BitConverter.ToUInt64(buffer, 0);
             return PreparationPayloads[MyIndex] = MakeSignedPayload(new PrepareRequest
             {
                 Timestamp = Block.Timestamp,

neo/Consensus/ConsensusService.cs

@@ -8,6 +8,7 @@
 using Neo.Network.P2P.Payloads;
 using Neo.Persistence;
 using Neo.Plugins;
+using Neo.SmartContract.Native;
 using Neo.Wallets;
 using System;
 using System.Collections.Generic;
@@ -79,6 +80,19 @@ private bool AddTransaction(Transaction tx, bool verify)
                 // previously sent prepare request, then we don't want to send a prepare response.
                 if (context.IsPrimary || context.WatchOnly) return true;
 
+                // Check policy
+                using (var snapshot = Blockchain.Singleton.GetSnapshot())
+                {
+                    var block = context.CreateBlock();
+
+                    if (block.Size > NativeContract.Policy.GetMaxBlockSize(snapshot))
+                    {
+                        Log($"rejected block: {block.Hash}{Environment.NewLine} The size '{block.Size}' exceed the policy", LogLevel.Warning);
+                        RequestChangeView(ChangeViewReason.BlockRejectedByPolicy);
+                        return false;
+                    }
+                }
+
                 // Timeout extension due to prepare response sent
                 // around 2*15/M=30.0/5 ~ 40% block time (for M=5)
                 ExtendTimerByFactor(2);

neo/SmartContract/Native/PolicyContract.cs

@@ -20,6 +20,7 @@ public sealed class PolicyContract : NativeContract
         private const byte Prefix_MaxTransactionsPerBlock = 23;
         private const byte Prefix_FeePerByte = 10;
         private const byte Prefix_BlockedAccounts = 15;
+        private const byte Prefix_MaxBlockSize = 16;
 
         public PolicyContract()
         {
@@ -36,6 +37,10 @@ private bool CheckValidators(ApplicationEngine engine)
         internal override bool Initialize(ApplicationEngine engine)
         {
             if (!base.Initialize(engine)) return false;
+            engine.Snapshot.Storages.Add(CreateStorageKey(Prefix_MaxBlockSize), new StorageItem
+            {
+                Value = BitConverter.GetBytes(1024u * 256u)
+            });
             engine.Snapshot.Storages.Add(CreateStorageKey(Prefix_MaxTransactionsPerBlock), new StorageItem
             {
                 Value = BitConverter.GetBytes(512u)
@@ -62,6 +67,17 @@ public uint GetMaxTransactionsPerBlock(Snapshot snapshot)
             return BitConverter.ToUInt32(snapshot.Storages[CreateStorageKey(Prefix_MaxTransactionsPerBlock)].Value, 0);
         }
 
+        [ContractMethod(0_01000000, ContractParameterType.Integer, SafeMethod = true)]
+        private StackItem GetMaxBlockSize(ApplicationEngine engine, VMArray args)
+        {
+            return GetMaxBlockSize(engine.Snapshot);
+        }
+
+        public uint GetMaxBlockSize(Snapshot snapshot)
+        {
+            return BitConverter.ToUInt32(snapshot.Storages[CreateStorageKey(Prefix_MaxBlockSize)].Value, 0);
+        }
+
         [ContractMethod(0_01000000, ContractParameterType.Integer, SafeMethod = true)]
         private StackItem GetFeePerByte(ApplicationEngine engine, VMArray args)
         {
@@ -84,6 +100,17 @@ public UInt160[] GetBlockedAccounts(Snapshot snapshot)
             return snapshot.Storages[CreateStorageKey(Prefix_BlockedAccounts)].Value.AsSerializableArray<UInt160>();
         }
 
+        [ContractMethod(0_03000000, ContractParameterType.Boolean, ParameterTypes = new[] { ContractParameterType.Integer }, ParameterNames = new[] { "value" })]
+        private StackItem SetMaxBlockSize(ApplicationEngine engine, VMArray args)
+        {
+            if (!CheckValidators(engine)) return false;
+            uint value = (uint)args[0].GetBigInteger();
+            if (Network.P2P.Message.PayloadMaxSize <= value) return false;
+            StorageItem storage = engine.Snapshot.Storages.GetAndChange(CreateStorageKey(Prefix_MaxBlockSize));
+            storage.Value = BitConverter.GetBytes(value);
+            return true;
+        }
+
         [ContractMethod(0_03000000, ContractParameterType.Boolean, ParameterTypes = new[] { ContractParameterType.Integer }, ParameterNames = new[] { "value" })]
         private StackItem SetMaxTransactionsPerBlock(ApplicationEngine engine, VMArray args)
         {