Optimized Delegated Byzantine Fault Tolerance (ODBFT) - Part I: commit phase + regeneration strategy + minnor message p2p route optimizing

neo.UnitTests/UT_Consensus.cs

@@ -29,15 +29,15 @@ public void ConsensusService_Primary_Sends_PrepareRequest_After_OnStart()
 
             var mockConsensusContext = new Mock<IConsensusContext>();
 
-            // context.Reset(): do nothing
-            //mockConsensusContext.Setup(mr => mr.Reset()).Verifiable(); // void
             mockConsensusContext.SetupGet(mr => mr.MyIndex).Returns(2); // MyIndex == 2
             mockConsensusContext.SetupGet(mr => mr.BlockIndex).Returns(2);
             mockConsensusContext.SetupGet(mr => mr.PrimaryIndex).Returns(2);
             mockConsensusContext.SetupGet(mr => mr.ViewNumber).Returns(0);
             mockConsensusContext.SetupProperty(mr => mr.Nonce);
             mockConsensusContext.SetupProperty(mr => mr.NextConsensus);
+            mockConsensusContext.SetupProperty(mr => mr.PreparePayload);
             mockConsensusContext.Object.NextConsensus = UInt160.Zero;
+            mockConsensusContext.SetupGet(mr => mr.FinalSignatures).Returns(new byte[4][]);
             mockConsensusContext.Setup(mr => mr.GetPrimaryIndex(It.IsAny<byte>())).Returns(2);
             mockConsensusContext.SetupProperty(mr => mr.State);  // allows get and set to update mock state on Initialize method
             mockConsensusContext.Object.State = ConsensusState.Initial;
@@ -49,29 +49,15 @@ public void ConsensusService_Primary_Sends_PrepareRequest_After_OnStart()
               new DateTime(1968, 06, 01, 0, 0, 15, DateTimeKind.Utc), // For Initialize
               new DateTime(1968, 06, 01, 0, 0, 15, DateTimeKind.Utc), // unused
               new DateTime(1968, 06, 01, 0, 0, 15, DateTimeKind.Utc)  // unused
-          };
+            };
 
             Console.WriteLine($"time 0: {timeValues[0].ToString()} 1: {timeValues[1].ToString()} 2: {timeValues[2].ToString()} 3: {timeValues[3].ToString()}");
 
-            //mockConsensusContext.Object.block_received_time = new DateTime(1968, 06, 01, 0, 0, 1, DateTimeKind.Utc);
-            //mockConsensusContext.Setup(mr => mr.GetUtcNow()).Returns(new DateTime(1968, 06, 01, 0, 0, 15, DateTimeKind.Utc));
-
             var timeMock = new Mock<TimeProvider>();
             timeMock.SetupGet(tp => tp.UtcNow).Returns(() => timeValues[timeIndex])
                                               .Callback(() => timeIndex++);
-            //new DateTime(1968, 06, 01, 0, 0, 15, DateTimeKind.Utc));
             TimeProvider.Current = timeMock.Object;
 
-            //public void Log(string message, LogLevel level)
-            // TODO: create ILogPlugin for Tests
-            /*
-            mockConsensusContext.Setup(mr => mr.Log(It.IsAny<string>(), It.IsAny<LogLevel>()))
-                         .Callback((string message, LogLevel level) => {
-                                         Console.WriteLine($"CONSENSUS LOG: {message}");
-                                                                   }
-                                  );
-             */
-
             // Creating proposed block
             Header header = new Header();
             TestUtils.SetupHeaderWithValues(header, UInt256.Zero, out UInt256 merkRootVal, out UInt160 val160, out uint timestampVal, out uint indexVal, out ulong consensusDataVal, out Witness scriptVal);
@@ -83,7 +69,6 @@ public void ConsensusService_Primary_Sends_PrepareRequest_After_OnStart()
             TimeProvider.Current.UtcNow.ToTimestamp().Should().Be(4244941711); //1968-06-01 00:00:15
                                                                                // check basic ConsensusContext
             mockConsensusContext.Object.MyIndex.Should().Be(2);
-            //mockConsensusContext.Object.block_received_time.ToTimestamp().Should().Be(4244941697); //1968-06-01 00:00:01
 
             MinerTransaction minerTx = new MinerTransaction
             {
@@ -100,7 +85,8 @@ public void ConsensusService_Primary_Sends_PrepareRequest_After_OnStart()
                 NextConsensus = mockConsensusContext.Object.NextConsensus,
                 TransactionHashes = new UInt256[0],
                 MinerTransaction = minerTx, //(MinerTransaction)Transactions[TransactionHashes[0]],
-                Signature = new byte[64]//Signatures[MyIndex]
+                PrepReqSignature = new byte[64], //PrepReqSignature[MyIndex]
+                FinalSignature = new byte[64] //FinalSignature[MyIndex]
             };
 
             ConsensusMessage mprep = prep;
@@ -116,7 +102,18 @@ public void ConsensusService_Primary_Sends_PrepareRequest_After_OnStart()
                 Data = prepData
             };
 
-            mockConsensusContext.Setup(mr => mr.MakePrepareRequest()).Returns(prepPayload);
+            mockConsensusContext.Setup(mr => mr.SignBlock(It.IsAny<Block>())).Returns(new byte[64]);
+            mockConsensusContext.Setup(mr => mr.MakePrepareRequest(It.IsAny<byte[]>(), It.IsAny<byte[]>())).Returns(prepPayload);
+            mockConsensusContext.Setup(mr => mr.MakeHeader()).Returns(new Block
+            {
+                Version = header.Version,
+                PrevHash = header.PrevHash,
+                MerkleRoot = header.MerkleRoot,
+                Timestamp = header.Timestamp,
+                Index = header.Index + 1,
+                ConsensusData = prep.Nonce,
+                NextConsensus = header.NextConsensus
+            });
 
             // ============================================================================
             //                      creating ConsensusService actor
@@ -137,20 +134,19 @@ public void ConsensusService_Primary_Sends_PrepareRequest_After_OnStart()
                     MerkleRoot = header.MerkleRoot,
                     Timestamp = header.Timestamp,
                     Index = header.Index,
-                    ConsensusData = header.ConsensusData,
-                    NextConsensus = header.NextConsensus
+                    ConsensusData = prep.Nonce,
+                    NextConsensus = header.NextConsensus,
+                    Transactions = new Transaction[0]
                 }
             });
 
-            //Console.WriteLine("will start consensus!");
-            //actorConsensus.Tell(new ConsensusService.Start());
-
             Console.WriteLine("OnTimer should expire!");
-            Console.WriteLine("Waiting for subscriber message!");
 
+            Console.WriteLine("Waiting for subscriber message!");
             var answer = subscriber.ExpectMsg<LocalNode.SendDirectly>();
             Console.WriteLine($"MESSAGE 1: {answer}");
-            //var answer2 = subscriber.ExpectMsg<LocalNode.SendDirectly>(); // expects to fail!
+
+            Console.WriteLine("Ok, subscriber!");
 
             // ============================================================================
             //                      finalize ConsensusService actor

neo/Consensus/CommitAgreement.cs

@@ -0,0 +1,31 @@
+using System.IO;
+
+namespace Neo.Consensus
+{
+    internal class CommitAgreement : ConsensusMessage
+    {
+        /// <summary>
+        /// Final block signature
+        /// </summary>
+        public byte[] FinalSignature;
+
+        public override int Size => base.Size + FinalSignature.Length;
+
+        /// <summary>
+        /// Constructors
+        /// </summary>
+        public CommitAgreement() : base(ConsensusMessageType.CommitAgreement) { }
+
+        public override void Deserialize(BinaryReader reader)
+        {
+            base.Deserialize(reader);
+            FinalSignature = reader.ReadBytes(64);
+        }
+
+        public override void Serialize(BinaryWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(FinalSignature);
+        }
+    }
+}

neo/Consensus/ConsensusContext.cs

@@ -2,6 +2,7 @@
 using Neo.Cryptography.ECC;
 using Neo.IO;
 using Neo.Ledger;
+using Neo.Network.P2P;
 using Neo.Network.P2P.Payloads;
 using Neo.Persistence;
 using Neo.Plugins;
@@ -28,34 +29,65 @@ internal class ConsensusContext : IConsensusContext
         public UInt160 NextConsensus { get; set; }
         public UInt256[] TransactionHashes { get; set; }
         public Dictionary<UInt256, Transaction> Transactions { get; set; }
-        public byte[][] Signatures { get; set; }
+        public byte[][] SignedPayloads { get; set; }
+        public byte[][] FinalSignatures { get; set; }
         public byte[] ExpectedView { get; set; }
         private Snapshot snapshot;
         private KeyPair keyPair;
+
         private readonly Wallet wallet;
 
         public int M => Validators.Length - (Validators.Length - 1) / 3;
         public Header PrevHeader => snapshot.GetHeader(PrevHash);
         public bool TransactionExists(UInt256 hash) => snapshot.ContainsTransaction(hash);
         public bool VerifyTransaction(Transaction tx) => tx.Verify(snapshot, Transactions.Values);
 
+        /// <summary>
+        /// Local PrepareRequest original Payload
+        /// </summary>
+        public ConsensusPayload PreparePayload { get; set; }
+
+        /// <summary>
+        /// Update the Speaker signature inside the context PreparePayload
+        /// </summary>
+        public void UpdateSpeakerSignatureAtPreparePayload()
+        {
+            PrepareRequest tempPrePrepareWithSignature;
+
+            try
+            {
+                tempPrePrepareWithSignature = (PrepareRequest)ConsensusMessage.DeserializeFrom(PreparePayload.Data);
+            }
+            catch
+            {
+                return;
+            }
+
+            if (tempPrePrepareWithSignature == null) return;
+
+            SignedPayloads[MyIndex] = SignPreparePayload();
+            tempPrePrepareWithSignature.PrepReqSignature = SignedPayloads[MyIndex];
+            PreparePayload.Data = tempPrePrepareWithSignature.ToArray();
+        }
+
         public ConsensusContext(Wallet wallet)
         {
             this.wallet = wallet;
         }
 
         public void ChangeView(byte view_number)
         {
-            State &= ConsensusState.SignatureSent;
             ViewNumber = view_number;
             PrimaryIndex = GetPrimaryIndex(view_number);
-            if (State == ConsensusState.Initial)
-            {
-                TransactionHashes = null;
-                Signatures = new byte[Validators.Length][];
-            }
+            PreparePayload = null;
+            TransactionHashes = null;
+            SignedPayloads = new byte[Validators.Length][];
+            FinalSignatures = new byte[Validators.Length][];
             if (MyIndex >= 0)
+            {
                 ExpectedView[MyIndex] = view_number;
+            }
+
             _header = null;
         }
 
@@ -66,9 +98,19 @@ public Block CreateBlock()
             Contract contract = Contract.CreateMultiSigContract(M, Validators);
             ContractParametersContext sc = new ContractParametersContext(block);
             for (int i = 0, j = 0; i < Validators.Length && j < M; i++)
-                if (Signatures[i] != null)
+                if (FinalSignatures[i] != null)
                 {
-                    sc.AddSignature(contract, Validators[i], Signatures[i]);
+                    // Checking Speaker Final Signature that was given along with PrepareRequest Payload
+                    if (PrimaryIndex == i && !Crypto.Default.VerifySignature(block.GetHashData(), FinalSignatures[i], Validators[i].EncodePoint(false)))
+                    {
+                        // CheckFinalSignatures...It looks like that Primary tried to cheat providing wrong final signature! His header signature will not be considered
+                        if ((FinalSignatures.Count(p => p != null) - 1) >= M)
+                            continue;
+                        else
+                            return null;
+                    }
+
+                    sc.AddSignature(contract, Validators[i], FinalSignatures[i]);
                     j++;
                 }
             sc.Verifiable.Witnesses = sc.GetWitnesses();
@@ -113,6 +155,7 @@ public Block MakeHeader()
                     Transactions = new Transaction[0]
                 };
             }
+
             return _header;
         }
 
@@ -132,43 +175,42 @@ private ConsensusPayload MakeSignedPayload(ConsensusMessage message)
             return payload;
         }
 
-        public void SignHeader()
+        public ConsensusPayload MakePrepareRequest(byte[] prepReqSignature, byte[] finalSignature)
         {
-            Signatures[MyIndex] = MakeHeader()?.Sign(keyPair);
+            return MakeSignedPayload(new PrepareRequest
+            {
+                Nonce = Nonce,
+                NextConsensus = NextConsensus,
+                TransactionHashes = TransactionHashes,
+                MinerTransaction = (MinerTransaction)Transactions[TransactionHashes[0]],
+                PrepReqSignature = prepReqSignature,
+                FinalSignature = finalSignature
+            });
         }
 
-        private void SignPayload(ConsensusPayload payload)
+        public ConsensusPayload MakePrepareResponse(byte[] responseSignature)
         {
-            ContractParametersContext sc;
-            try
-            {
-                sc = new ContractParametersContext(payload);
-                wallet.Sign(sc);
-            }
-            catch (InvalidOperationException)
+            return MakeSignedPayload(new PrepareResponse
             {
-                return;
-            }
-            sc.Verifiable.Witnesses = sc.GetWitnesses();
+                PreparePayload = PreparePayload,
+                ResponseSignature = responseSignature
+            });
         }
 
-        public ConsensusPayload MakePrepareRequest()
+        public ConsensusPayload MakeCommitAgreement(byte[] finalSignature)
         {
-            return MakeSignedPayload(new PrepareRequest
+            return MakeSignedPayload(new CommitAgreement()
             {
-                Nonce = Nonce,
-                NextConsensus = NextConsensus,
-                TransactionHashes = TransactionHashes,
-                MinerTransaction = (MinerTransaction)Transactions[TransactionHashes[0]],
-                Signature = Signatures[MyIndex]
+                FinalSignature = finalSignature
             });
         }
 
-        public ConsensusPayload MakePrepareResponse(byte[] signature)
+        public ConsensusPayload MakeRegeneration()
         {
-            return MakeSignedPayload(new PrepareResponse
+            return MakeSignedPayload(new Regeneration()
             {
-                Signature = signature
+                PrepareRequestPayload = PreparePayload,
+                SignedPayloads = SignedPayloads
             });
         }
 
@@ -184,9 +226,12 @@ public void Reset()
             MyIndex = -1;
             PrimaryIndex = BlockIndex % (uint)Validators.Length;
             TransactionHashes = null;
-            Signatures = new byte[Validators.Length][];
+            PreparePayload = null;
+            SignedPayloads = new byte[Validators.Length][];
+            FinalSignatures = new byte[Validators.Length][];
             ExpectedView = new byte[Validators.Length];
             keyPair = null;
+
             for (int i = 0; i < Validators.Length; i++)
             {
                 WalletAccount account = wallet.GetAccount(Validators[i]);
@@ -237,6 +282,31 @@ public void Fill()
             Timestamp = Math.Max(TimeProvider.Current.UtcNow.ToTimestamp(), PrevHeader.Timestamp + 1);
         }
 
+        public byte[] SignBlock(Block block)
+        {
+            return block.Sign(keyPair);
+        }
+
+        public byte[] SignPreparePayload()
+        {
+            return PreparePayload.Sign(keyPair);
+        }
+
+        public void SignPayload(ConsensusPayload payload)
+        {
+            ContractParametersContext sc;
+            try
+            {
+                sc = new ContractParametersContext(payload);
+                wallet.Sign(sc);
+            }
+            catch
+            {
+                return;
+            }
+            sc.Verifiable.Witnesses = sc.GetWitnesses();
+        }
+
         private static ulong GetNonce()
         {
             byte[] nonce = new byte[sizeof(ulong)];

neo/Consensus/ConsensusMessageType.cs

@@ -10,5 +10,9 @@ internal enum ConsensusMessageType : byte
         PrepareRequest = 0x20,
         [ReflectionCache(typeof(PrepareResponse))]
         PrepareResponse = 0x21,
+        [ReflectionCache(typeof(CommitAgreement))]
+        CommitAgreement = 0x22,
+        [ReflectionCache(typeof(Regeneration))]
+        Regeneration = 0x23,
     }
 }