neo-共识算法dBFT 源码解析


声明:本文转载自https://my.oschina.net/hunjixin/blog/1801892,转载目的在于传递更多信息,仅供学习交流之用。如有侵权行为,请联系我,我会及时删除。

插播一条广告→2021 ByteDance字节跳动内推←各城市、各方向的岗位都有,大量招人!


NEO PDFT共识算法

dbft算法,通过多次网络请求确认,最终获得多数共识。缺点是网络开销大,如果网络有问题或者记账人性能不够会拖慢系统速度,如果记账人过多也会导致网络通信膨胀,难以快速达成一致。不适合在公链使用。而NEO定位是私有链或联盟链。记账人节点有限,而且机器,网络环境可以控制,因此适用于这种算法。既能避免较大的算力开销也能保证一致性。

代码结构说明

├── Consensus │   ├── ChangeView.cs           //viewchange 消息 │   ├── ConsensusContext.cs     //共识上下文 │   ├── ConsensusMessage.cs     //共识消息 │   ├── ConsensusMessageType.cs //共识消息类型 ChangeView/PrepareRequest/PrepareResponse │   ├── ConsensusService.cs     //共识核心代码     │   ├── ConsensusState.cs       //节点共识状态 │   ├── PrepareRequest.cs       //请求消息 │   └── PrepareResponse.cs      //签名返回消息 

共识状态变化流程

  • 1:开启共识的节点分为两大类,非记账人和记账人节点,非记账人的不参与共识,记账人参与共识流程
  • 2:选择议长,Neo议长产生机制是根据当前块高度和记账人数量做MOD运算得到,议长实际上按顺序当选
  • 3:节点初始化,议长为primary节点,议员为backup节点。
  • 4:满足出块条件后议长发送PrepareRequest
  • 5:议员收到请求后,验证通过签名发送PrepareResponse
  • 6:记账节点接收到PrepareResponse后,节点保存对方的签名信息,检查如果超过三分之二则发送 block
  • 7:节点接收到block,PersistCompleted事件触发后整体重新初始化,

输入图片说明

共识上下文核心成员

        public const uint Version = 0;         public ConsensusState State;       //节点当前共识状态         public UInt256 PrevHash;         public uint BlockIndex;            //块高度         public byte ViewNumber;            //试图状态         public ECPoint[] Validators;       //记账人              public int MyIndex;                //当前记账人次序         public uint PrimaryIndex;          //当前记账的记账人         public uint Timestamp;         public ulong Nonce;         public UInt160 NextConsensus;      //共识标识         public UInt256[] TransactionHashes;         public Dictionary<UInt256, Transaction> Transactions;         public byte[][] Signatures;        //记账人签名         public byte[] ExpectedView;        //记账人试图         public KeyPair KeyPair;          public int M => Validators.Length - (Validators.Length - 1) / 3;   //三分之二数量 

ExpectedView 维护视图状态中,用于在议长无法正常工作时重新发起新一轮共识。

Signatures 用于维护共识过程中的确认状态。

节点共识状态

    [Flags]     internal enum ConsensusState : byte     {         Initial = 0x00,           //      0         Primary = 0x01,           //      1         Backup = 0x02,            //     10         RequestSent = 0x04,       //    100         RequestReceived = 0x08,   //   1000         SignatureSent = 0x10,     //  10000         BlockSent = 0x20,         // 100000         ViewChanging = 0x40,      //1000000     } 

议长选择

在初始化共识状态的时候会设置PrimaryIndex,获知当前议长。原理就是简单的MOD运算。 这里有分为两种情况,如果节点正常则直接块高度和记账人数量mod运算即可,如果存在一场情况,则需要根据view_number进行调整。

    //file /Consensus/ConsensusService.cs   InitializeConsensus方法      if (view_number == 0)         context.Reset(wallet);     else         context.ChangeView(view_number); 
    //file /Consensus/ConsensusContext.cs     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][];         }         ExpectedView[MyIndex] = view_number;         _header = null;     } 
    //file /Consensus/ConsensusContext.cs     public void Reset(Wallet wallet)     {         State = ConsensusState.Initial;         PrevHash = Blockchain.Default.CurrentBlockHash;         BlockIndex = Blockchain.Default.Height + 1;         ViewNumber = 0;         Validators = Blockchain.Default.GetValidators();         MyIndex = -1;         PrimaryIndex = BlockIndex % (uint)Validators.Length; //当前记账人         TransactionHashes = null;         Signatures = 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]);             if (account?.HasKey == true)             {                 MyIndex = i;                 KeyPair = account.GetKey();                 break;             }         }         _header = null;     } 

状态初始化

如果是议长则状态标记为ConsensusState.Primary,同时改变定时器触发事件,再上次出块15s后触发。议员则设置状态为 ConsensusState.Backup,时间调整为30s后触发,如果议长不能正常工作,则这个触发器会开始起作用(具体后边再详细分析)。

    //file /Consensus/ConsensusContext.cs     private void InitializeConsensus(byte view_number)     {         lock (context)         {             if (view_number == 0)                 context.Reset(wallet);             else                 context.ChangeView(view_number);             if (context.MyIndex < 0) return;             Log($"initialize: height={context.BlockIndex} view={view_number} index={context.MyIndex} role={(context.MyIndex == context.PrimaryIndex ? ConsensusState.Primary : ConsensusState.Backup)}");             if (context.MyIndex == context.PrimaryIndex)             {                 context.State |= ConsensusState.Primary;                 if (!context.State.HasFlag(ConsensusState.SignatureSent))                 {                     FillContext();  //生成mine区块                 }                 if (context.TransactionHashes.Length > 1)                 {   //广播自身的交易                       InvPayload invPayload = InvPayload.Create(InventoryType.TX, context.TransactionHashes.Skip(1).ToArray());                     foreach (RemoteNode node in localNode.GetRemoteNodes())                         node.EnqueueMessage("inv", invPayload);                 }                 timer_height = context.BlockIndex;                 timer_view = view_number;                 TimeSpan span = DateTime.Now - block_received_time;                 if (span >= Blockchain.TimePerBlock)                     timer.Change(0, Timeout.Infinite);                 else                     timer.Change(Blockchain.TimePerBlock - span, Timeout.InfiniteTimeSpan);             }             else             {                 context.State = ConsensusState.Backup;                 timer_height = context.BlockIndex;                 timer_view = view_number;                 timer.Change(TimeSpan.FromSeconds(Blockchain.SecondsPerBlock << (view_number + 1)), Timeout.InfiniteTimeSpan);             }         }     } 

议长发起请求

议长到了该记账的时间后,执行下面方法,发送MakePrepareRequest请求,自身状态转变为RequestSent,也设置了30s后重复触发定时器(同样也是再议长工作异常时起效)。

    //file /Consensus/ConsensusContext.cs     private void OnTimeout(object state)     {         lock (context)         {             if (timer_height != context.BlockIndex || timer_view != context.ViewNumber) return;             Log($"timeout: height={timer_height} view={timer_view} state={context.State}");             if (context.State.HasFlag(ConsensusState.Primary) && !context.State.HasFlag(ConsensusState.RequestSent))             {                 Log($"send perpare request: height={timer_height} view={timer_view}");                 context.State |= ConsensusState.RequestSent;                 if (!context.State.HasFlag(ConsensusState.SignatureSent))                 {                     context.Timestamp = Math.Max(DateTime.Now.ToTimestamp(), Blockchain.Default.GetHeader(context.PrevHash).Timestamp + 1);                     context.Signatures[context.MyIndex] = context.MakeHeader().Sign(context.KeyPair);                 }                 SignAndRelay(context.MakePrepareRequest());                 timer.Change(TimeSpan.FromSeconds(Blockchain.SecondsPerBlock << (timer_view + 1)), Timeout.InfiniteTimeSpan);             }             else if ((context.State.HasFlag(ConsensusState.Primary) && context.State.HasFlag(ConsensusState.RequestSent)) || context.State.HasFlag(ConsensusState.Backup))             {                 RequestChangeView();             }         }     }     } 

议员广播信任信息

议员接收到PrepareRequest,会对节点信息进行验证,自身不存在的交易会去同步交易。交易同步完成后,验证通过会进行发送PrepareResponse ,包含自己的签名信息,表示自己已经通过了节点验证。状态转变为ConsensusState.SignatureSent。

    //file /Consensus/ConsensusContext.cs     private void OnPrepareRequestReceived(ConsensusPayload payload, PrepareRequest message)     {         Log($"{nameof(OnPrepareRequestReceived)}: height={payload.BlockIndex} view={message.ViewNumber} index={payload.ValidatorIndex} tx={message.TransactionHashes.Length}");         if (!context.State.HasFlag(ConsensusState.Backup) || context.State.HasFlag(ConsensusState.RequestReceived))             return;         if (payload.ValidatorIndex != context.PrimaryIndex) return;         if (payload.Timestamp <= Blockchain.Default.GetHeader(context.PrevHash).Timestamp || payload.Timestamp > DateTime.Now.AddMinutes(10).ToTimestamp())         {             Log($"Timestamp incorrect: {payload.Timestamp}");             return;         }         context.State |= ConsensusState.RequestReceived;         context.Timestamp = payload.Timestamp;         context.Nonce = message.Nonce;         context.NextConsensus = message.NextConsensus;         context.TransactionHashes = message.TransactionHashes;         context.Transactions = new Dictionary<UInt256, Transaction>();         if (!Crypto.Default.VerifySignature(context.MakeHeader().GetHashData(), message.Signature, context.Validators[payload.ValidatorIndex].EncodePoint(false))) return;         context.Signatures = new byte[context.Validators.Length][];         context.Signatures[payload.ValidatorIndex] = message.Signature;         Dictionary<UInt256, Transaction> mempool = LocalNode.GetMemoryPool().ToDictionary(p => p.Hash);         foreach (UInt256 hash in context.TransactionHashes.Skip(1))         {             if (mempool.TryGetValue(hash, out Transaction tx))                 if (!AddTransaction(tx, false))                     return;         }         if (!AddTransaction(message.MinerTransaction, true)) return;         if (context.Transactions.Count < context.TransactionHashes.Length)         {             UInt256[] hashes = context.TransactionHashes.Where(i => !context.Transactions.ContainsKey(i)).ToArray();             LocalNode.AllowHashes(hashes);             InvPayload msg = InvPayload.Create(InventoryType.TX, hashes);             foreach (RemoteNode node in localNode.GetRemoteNodes())                 node.EnqueueMessage("getdata", msg);         }     } 
    //file /Consensus/ConsensusContext.cs     private bool AddTransaction(Transaction tx, bool verify)     {         if (Blockchain.Default.ContainsTransaction(tx.Hash) ||             (verify && !tx.Verify(context.Transactions.Values)) ||             !CheckPolicy(tx))         {             Log($"reject tx: {tx.Hash}{Environment.NewLine}{tx.ToArray().ToHexString()}");             RequestChangeView();             return false;         }         context.Transactions[tx.Hash] = tx;         if (context.TransactionHashes.Length == context.Transactions.Count)         {             if (Blockchain.GetConsensusAddress(Blockchain.Default.GetValidators(context.Transactions.Values).ToArray()).Equals(context.NextConsensus))             {                 Log($"send perpare response");                 context.State |= ConsensusState.SignatureSent;                 context.Signatures[context.MyIndex] = context.MakeHeader().Sign(context.KeyPair);                 SignAndRelay(context.MakePrepareResponse(context.Signatures[context.MyIndex]));                 CheckSignatures();             }             else             {                 RequestChangeView();                 return false;             }         }         return true;     } 

共识达成后广播区块

其他节点接收到PrepareResponse后,在自己的签名列表中记录对方的签名信息,再检查自己的签名列表是否有超过三分之二的签名了,有则判断共识达成开始广播生成的区块。状态状变为ConsensusState.BlockSent。

    private void CheckSignatures()     {         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);             Block block = context.MakeHeader();             ContractParametersContext sc = new ContractParametersContext(block);             for (int i = 0, j = 0; i < context.Validators.Length && j < context.M; i++)                 if (context.Signatures[i] != null)                 {                     sc.AddSignature(contract, context.Validators[i], context.Signatures[i]);                     j++;                 }             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;         }     } 

Blockchain_PersistCompleted后恢复状态

区块广播后,节点接收到这个信息,会保存区块,保存完成后触发PersistCompleted事件,最终回到初始状态,重新开始新一轮的共识。

    private void Blockchain_PersistCompleted(object sender, Block block)     {         Log($"persist block: {block.Hash}");         block_received_time = DateTime.Now;         InitializeConsensus(0);     } 

错误分析

如果当前记账的记账人无法完成记账任务

这种情况下议长在超出时间之后依然无法达成共识,此时议员会增长自身的ExpectedView值,并且广播出去,如果检查到三分之二的成员viewnumber都加了1,则在这些相同viewnumber的节点之间开始新一轮共识,重新选择议长,发起共识。如果此时原来的议长恢复正常,time到时间后会增长自身的viewnumber,慢慢追上当前的视图状态。

输入图片说明

参考

源码 :[https://github.com/neo-project/neo/tree/master/neo/Consensus)

官方白皮书:http://docs.neo.org/zh-cn/basic/consensus/consensus.html

DBFT :https://www.jianshu.com/p/2383c7841d41

本文发表于2018年04月27日 22:38
(c)注:本文转载自https://my.oschina.net/hunjixin/blog/1801892,转载目的在于传递更多信息,并不代表本网赞同其观点和对其真实性负责。如有侵权行为,请联系我们,我们会及时删除.

阅读 798 讨论 1 喜欢 0

抢先体验

扫码体验
趣味小程序
文字表情生成器

闪念胶囊

你要过得好哇,这样我才能恨你啊,你要是过得不好,我都不知道该恨你还是拥抱你啊。

直抵黄龙府,与诸君痛饮尔。

那时陪伴我的人啊,你们如今在何方。

不出意外的话,我们再也不会见了,祝你前程似锦。

这世界真好,吃野东西也要留出这条命来看看

快捷链接
网站地图
提交友链
Copyright © 2016 - 2021 Cion.
All Rights Reserved.
京ICP备2021004668号-1