Stage 3 of dBFT (Commit)

neo/Consensus/CommitAgreement.cs

@@ -0,0 +1,39 @@
+using System.IO;
+using Neo.IO;
+
+namespace Neo.Consensus
+{
+    internal class CommitAgreement : ConsensusMessage
+    {
+        /// <summary>
+        /// Block hash of the signature
+        /// </summary>
+        public UInt256 BlockHash;
+
+        /// <summary>
+        /// Signature
+        /// </summary>
+        public byte[] Signature;
+
+        /// <summary>
+        /// Constructors
+        /// </summary>
+        public CommitAgreement() : base(ConsensusMessageType.CommitAgreement) { }
+
+        public override void Deserialize(BinaryReader reader)
+        {
+            base.Deserialize(reader);
+
+            BlockHash = reader.ReadSerializable<UInt256>();
+            Signature = reader.ReadBytes(64);
+        }
+
+        public override void Serialize(BinaryWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write(BlockHash);
+            writer.Write(Signature);
+        }
+    }
+}

neo/Consensus/ConsensusContext.cs

@@ -1,11 +1,11 @@
-using Neo.Core;
+using System.Collections.Generic;
+using System.Linq;
+using Neo.Core;
 using Neo.Cryptography;
 using Neo.Cryptography.ECC;
 using Neo.IO;
 using Neo.Network.Payloads;
 using Neo.Wallets;
-using System.Collections.Generic;
-using System.Linq;
 
 namespace Neo.Consensus
 {
@@ -28,21 +28,63 @@ internal class ConsensusContext
         public byte[] ExpectedView;
         public KeyPair KeyPair;
 
+        private UInt256[] Commits;
+        private Block _header = null;
+        public bool CommitAgreementSent = false;
+
         public int M => Validators.Length - (Validators.Length - 1) / 3;
 
+        public bool TryToCommit(ConsensusPayload payload, CommitAgreement message)
+        {
+            // Already received
+
+            if (Commits[payload.ValidatorIndex] != null)
+            {
+                return false;
+            }
+
+            // Check signature of the validator
+
+            if (!Crypto.Default.VerifySignature
+                (
+                    message.BlockHash.ToArray(), message.Signature,
+                    Validators[payload.ValidatorIndex].EncodePoint(false)
+                ))
+            {
+                return false;
+            }
+
+            // Store received block hash
+
+            Commits[payload.ValidatorIndex] = message.BlockHash;
+
+            // Check count
+
+            if (_header == null) return false;
+
+            return Commits.Where(u => u != null && u == _header.Hash).Count() >= M;
+        }
+
         public void ChangeView(byte view_number)
         {
             int p = ((int)BlockIndex - view_number) % Validators.Length;
             State &= ConsensusState.SignatureSent;
             ViewNumber = view_number;
             PrimaryIndex = p >= 0 ? (uint)p : (uint)(p + Validators.Length);
+
             if (State == ConsensusState.Initial)
             {
                 TransactionHashes = null;
                 Signatures = new byte[Validators.Length][];
+                Commits = new UInt256[Validators.Length];
+                CommitAgreementSent = false;
             }
+
             if (MyIndex >= 0)
+            {
                 ExpectedView[MyIndex] = view_number;
+            }
+
             _header = null;
         }
 
@@ -54,10 +96,10 @@ public ConsensusPayload MakeChangeView()
             });
         }
 
-        private Block _header = null;
         public Block MakeHeader()
         {
             if (TransactionHashes == null) return null;
+
             if (_header == null)
             {
                 _header = new Block
@@ -71,10 +113,24 @@ public Block MakeHeader()
                     NextConsensus = NextConsensus,
                     Transactions = new Transaction[0]
                 };
+
+                Commits[MyIndex] = _header.Hash;
             }
+
             return _header;
         }
 
+        public ConsensusPayload MakeCommitAgreement()
+        {
+            if (_header == null) return null;
+
+            return MakePayload(new CommitAgreement()
+            {
+                BlockHash = _header.Hash,
+                Signature = _header.Hash.ToArray().Sign(KeyPair)
+            });
+        }
+
         private ConsensusPayload MakePayload(ConsensusMessage message)
         {
             message.ViewNumber = ViewNumber;
@@ -122,6 +178,9 @@ public void Reset(Wallet wallet)
             Signatures = new byte[Validators.Length][];
             ExpectedView = new byte[Validators.Length];
             KeyPair = null;
+            Commits = new UInt256[Validators.Length];
+            CommitAgreementSent = false;
+
             for (int i = 0; i < Validators.Length; i++)
             {
                 WalletAccount account = wallet.GetAccount(Validators[i]);

neo/Consensus/ConsensusMessageType.cs

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

neo/Consensus/ConsensusService.cs

@@ -85,8 +85,11 @@ private bool CheckPolicy(Transaction tx)
             return true;
         }
 
-        private void CheckSignatures()
+        private void OnCommitAgreement(ConsensusPayload payload, CommitAgreement message)
         {
+            if (context.State.HasFlag(ConsensusState.BlockSent)) return;
+            if (!context.TryToCommit(payload, message)) return;
+
             if (context.Signatures.Count(p => p != null) >= context.M && context.TransactionHashes.All(p => context.Transactions.ContainsKey(p)))
             {
                 Contract contract = Contract.CreateMultiSigContract(context.M, context.Validators);
@@ -101,12 +104,28 @@ private void CheckSignatures()
                 sc.Verifiable.Scripts = sc.GetScripts();
                 block.Transactions = context.TransactionHashes.Select(p => context.Transactions[p]).ToArray();
                 Log($"relay block: {block.Hash}");
+
                 if (!localNode.Relay(block))
                     Log($"reject block: {block.Hash}");
+
                 context.State |= ConsensusState.BlockSent;
             }
         }
 
+        private void CheckSignatures()
+        {
+            if (!context.CommitAgreementSent)
+            {
+                if (context.Signatures.Count(p => p != null) >= context.M && context.TransactionHashes.All(p => context.Transactions.ContainsKey(p)))
+                {
+                    // Sent i'm ready!
+
+                    context.CommitAgreementSent = true;
+                    SignAndRelay(context.MakeCommitAgreement());
+                }
+            }
+        }
+
         public void Dispose()
         {
             Log("OnStop");
@@ -206,61 +225,62 @@ private void InitializeConsensus(byte view_number)
 
         private void LocalNode_InventoryReceived(object sender, IInventory inventory)
         {
-            ConsensusPayload payload = inventory as ConsensusPayload;
-            if (payload != null)
+            if (inventory == null || !(inventory is ConsensusPayload payload)) return;
+
+            lock (context)
             {
-                lock (context)
+                if (payload.ValidatorIndex == context.MyIndex ||
+                    payload.ValidatorIndex >= context.Validators.Length ||
+                    payload.Version != ConsensusContext.Version) return;
+
+                if (payload.PrevHash != context.PrevHash || payload.BlockIndex != context.BlockIndex)
                 {
-                    if (payload.ValidatorIndex == context.MyIndex) return;
+                    // Request blocks
 
-                    if (payload.Version != ConsensusContext.Version)
-                        return;
-                    if (payload.PrevHash != context.PrevHash || payload.BlockIndex != context.BlockIndex)
+                    if (Blockchain.Default?.Height + 1 < payload.BlockIndex)
                     {
-                        // Request blocks
+                        Log($"chain sync: expected={payload.BlockIndex} current: {Blockchain.Default?.Height} nodes={localNode.RemoteNodeCount}");
 
-                        if (Blockchain.Default?.Height + 1 < payload.BlockIndex)
-                        {
-                            Log($"chain sync: expected={payload.BlockIndex} current: {Blockchain.Default?.Height} nodes={localNode.RemoteNodeCount}");
+                        localNode.RequestGetBlocks();
+                    }
 
-                            localNode.RequestGetBlocks();
-                        }
+                    return;
+                }
 
-                        return;
-                    }
+                ConsensusMessage message;
+                try
+                {
+                    message = ConsensusMessage.DeserializeFrom(payload.Data);
+                }
+                catch
+                {
+                    return;
+                }
 
-                    if (payload.ValidatorIndex >= context.Validators.Length) return;
-                    ConsensusMessage message;
-                    try
-                    {
-                        message = ConsensusMessage.DeserializeFrom(payload.Data);
-                    }
-                    catch
-                    {
-                        return;
-                    }
-                    if (message.ViewNumber != context.ViewNumber && message.Type != ConsensusMessageType.ChangeView)
-                        return;
-                    switch (message.Type)
-                    {
-                        case ConsensusMessageType.ChangeView:
-                            OnChangeViewReceived(payload, (ChangeView)message);
-                            break;
-                        case ConsensusMessageType.PrepareRequest:
-                            OnPrepareRequestReceived(payload, (PrepareRequest)message);
-                            break;
-                        case ConsensusMessageType.PrepareResponse:
-                            OnPrepareResponseReceived(payload, (PrepareResponse)message);
-                            break;
-                    }
+                if (message.ViewNumber != context.ViewNumber && message.Type != ConsensusMessageType.ChangeView)
+                    return;
+
+                switch (message.Type)
+                {
+                    case ConsensusMessageType.ChangeView:
+                        OnChangeViewReceived(payload, (ChangeView)message);
+                        break;
+                    case ConsensusMessageType.PrepareRequest:
+                        OnPrepareRequestReceived(payload, (PrepareRequest)message);
+                        break;
+                    case ConsensusMessageType.PrepareResponse:
+                        OnPrepareResponseReceived(payload, (PrepareResponse)message);
+                        break;
+                    case ConsensusMessageType.CommitAgreement:
+                        OnCommitAgreement(payload, (CommitAgreement)message);
+                        break;
                 }
             }
         }
 
         private void LocalNode_InventoryReceiving(object sender, InventoryReceivingEventArgs e)
         {
-            Transaction tx = e.Inventory as Transaction;
-            if (tx != null)
+            if (e.Inventory is Transaction tx)
             {
                 lock (context)
                 {
@@ -373,6 +393,8 @@ private void RequestChangeView()
 
         private void SignAndRelay(ConsensusPayload payload)
         {
+            if (payload == null) return;
+
             ContractParametersContext sc;
             try
             {

neo/Core/Helper.cs

@@ -38,6 +38,14 @@ public static byte[] Sign(this IVerifiable verifiable, KeyPair key)
             }
         }
 
+        public static byte[] Sign(this byte[] message, KeyPair key)
+        {
+            using (key.Decrypt())
+            {
+                return Crypto.Default.Sign(message, key.PrivateKey, key.PublicKey.EncodePoint(false).Skip(1).ToArray());
+            }
+        }
+
         public static UInt160 ToScriptHash(this byte[] script)
         {
             return new UInt160(Crypto.Default.Hash160(script));