header是什么意思中文翻译

大家好，给大家分享一下header是什么意思。很多人还不知道这一点。下面详细解释一下。现在让我们来看看！

目前，在区块链中，有几种常见的共识算法来保持节点书的一致性:以比特币(BTC)为代表的PoW，以及区块链1.0。Pos，以以太坊(ETH)为代表，正在从Pow向PoS过渡，区块链2.0。残疾人组织，

目前，在区块链中，有几种常见的共识算法来保持节点书的一致性:以比特币(BTC)为代表的PoW，以及区块链1.0。Pos，以以太坊(ETH)为代表，正在从Pow向PoS过渡，区块链2.0。残疾人组织，

目前，在区块链中，有以下常见的一致性算法来保持节点书的一致性:

以比特币(BTC)、区块链1.0为代表的PoW。

Pos，以以太坊(ETH)为代表，正在从Pow向PoS过渡，区块链2.0。

以Pomelo (EOS)、区块链3.0为代表的DPoS。

PBFT拜占庭容错常用于联盟链。

以下是前三种共识算法的概念和优缺点。

幂算法

PoW(工作证明)字面意思是谁多劳谁有更大的话语权，这在一定程度上类似于现实生活中“多劳多得”的观念。

以比特币为例。比特币挖矿就是通过计算匹配某个比特币块头的哈希值来争夺记账权。这个过程需要通过大量的计算来实现。简单理解就是矿工进行的计算量(工作量)越大，尝试解决问题的次数就越多。自然，解出正确答案的概率越高，获得记账权的概率也就越高，也就是矿工挖出来的块会串联到主链上。

以下是对上一段所涉及的几个术语的解释。

标题:区块链中块的标题。比如你有一个饭盒，饭盒的第一层酷似一个动物的头，叫做头；一楼有饭，那是人头装的。

哈希:数学中的哈希函数(数学公式)。

哈希值:通过哈希函数获得的值。比如有加法公式“1 2=3”，那么哈希公式hash(1，2)计算的结果就是哈希哈希值。

头的Hash哈希值:饭盒的第一层装的是米饭，所以这个值就是块头所容纳的。

记账权，话语权:当所有人都参与挖块的时候，谁挖的块有效，谁就有记账权或者话语权。

在PoW共识算法下，当多个节点都在挖掘时，每个节点都有可能挖出一块。比特币链定义是一个块被挖出来后，会广播到其他节点，然后每个节点会根据相应的验证方法验证这个块是否合法，被确认合法的块会被合并到主链中。

相对于现实生活，比如一场数学竞赛，参赛选手相当于矿工，一个题目，谁先出谁就宣布计算过程和答案，不会由裁判评判，而是由参赛选手共同验证；大家都同意后，话题就宣告结束，解题者和相关信息被记录在纸质小册子或数据库中，然后继续下一个话题。

回到比特币挖矿，其实就是计算正确的hash哈希值。计算完成后，将生成一个新的块，并将生成的块信息广播给其他节点。收到广播信息后，其他节点停止计算并开始验证该块的信息。如果信息有效，当前最新的块被节点识别，每个节点开始挖掘下一个块；如果信息无效，各节点将继续自助机的计算。这里的难点在于，hash哈希值的计算会随着比特币中难度系数(一个可以增加计算难度的变量)的增加而变得越来越困难，导致大量的电力资源和巨大的工作量。

此外，在项目中挖出有效区块的矿工(节点)将获得奖励。在不同的区块链体系中，奖励是不同的。比特币区块链系统的奖励是比特币。

下图是节点利用Pow共识算法联合识别获胜块，并将获胜块串联起来的模型图。

通过PoW共识算法选择获胜区块。

Pow一致性算法具有以下优点和缺点:

优势

这个机制是独一无二的。比如挖矿难度系数自动调整，区块奖励逐步减半。这些因素基于经济学原理，可以吸引和鼓励更多的节点参与挖掘。

早参与早盈利。人们越早参与，得到的就越多。初期会促进加密货币的快速发展和节点网络的快速扩张。

通过“挖矿”发行硬币，向个人发放代币，相对公平。

缺点

计算能力由计算机硬件(CPU、GPU等)提供。)，而且它耗电，是直接消耗能源，与人类追求节能、清洁、环保的理念背道而驰。

随着PoW机制的发展，提供计算能力的不再是单纯的CPU，而是逐渐发展到GPU、FPGA甚至ASIC矿机。用户也从单个矿发展到大型矿池和矿，计算能力的集中越来越明显。这与分权的理念背道而驰。

按照现在的挖矿速度，随着难度的增加，当挖矿成本高于挖矿收益时，人们挖矿的积极性就会降低，导致计算能力大量降低。

基于功率节点网络的安全性令人担忧。

计算能力超过51%的攻击。将在“PoW共识机制的51%计算攻击”一节中详细描述。

PoS算法

PoS(股权证明)最早由PPCoin应用。该算法没有挖掘过程，而是将股权分配比例写入创世区块，然后通过转让、交易等方式逐步分配到用户的钱包地址，即首次公开发行，通过“利息”加钱奖励节点地址。

PoS的意思是股份制。也就是说，谁的股份多，谁的话语权就大，类似于现实生活中的股份公司股东。然而，在区块链的应用中，我们不能真正地将份额分配给链中的节点。取而代之的是一些别的东西，比如令牌，用来充当份额，然后这些东西被分发到链中的节点。让我们用例子来说明这个概念。

比如在虚拟货币的应用中，我们可以把我们持有的货币量看成是我们拥有的股份数。假设区块链公共链使用尚未开发的最基本的PoS共识机制，节点使用的XXX个令牌的数量用于测量该节点拥有的股份数量。假设有A、B、C三个节点，其中节点A有10000个XXX代币，而节点B和C分别是1000个和2000个，那么节点A生成的块最有可能在这个区块链网络中被选中，话语权比较大。

再举个例子，假设一个与虚拟货币无关，与实体行业相结合的公链——车链，我们可以按照每个车主拥有的车辆数量和他的车的价值来分配股份(比如规定一个公式:车辆*车价值=股份数量)。

可见，在PoS中，股份只是一个衡量话语权的概念。我们可以在自己的PoS应用中进行更复杂的实现，比如使用多个变量参与份额值的计算。

共识算法通过拥有某物的数量来衡量话语权。只要一个节点拥有这样的东西，哪怕只拥有一个，就有话语权，哪怕话语权很小。

在PoS中，块已经被铸造。PoW有挖矿的概念，PoS没有。在BTC比特币公链，可以挖矿；而在不使用PoS共识算法的公链节点中，则没有挖掘这一说。当然，如果把挖矿的概念扩展到其他方面，那就另当别论了。

PoS的一致性算法具有以下优点和缺点:

优势

为了缩短达成共识的时间，链中共识块的速度更快。

不再需要消耗大量能源进行开采，节约能源。

出轨得不偿失。如果一个持有50%以上股权的人(节点)作弊，就相当于自己作弊，因为他才是拥有最多股权的人。作弊的结果是，人的股权越多，损失越多。

缺点

攻击成本低。只要节点拥有令牌等数量的项，就可以发起脏数据的block攻击。

代币的初次发行是通过IPO发行，导致“少数人”(通常是开发者)以极低的成本获得了大量的加密货币。在利益面前，很难保证这些人不会大量抛售。

代币数量多的节点会有更大的概率获得记账权，使得网络共识被少数有钱人的账户所主导，从而失去公正性。

DPoS算法

虽然PoW和PoS都可以在一定程度上有效解决记账行为的一致性问题，但它们也各有利弊。但目前的比特币PoW机制是纯粹依赖于计算能力的，这就导致了专门挖矿的矿工们似乎完全脱离了比特币社区，一些挖矿池的巨大计算能力成为了另一个中心，这与比特币去中心化的思想相冲突。虽然PoS机制考虑到了PoW的不足，但是IPO发行的代币数量导致少数账户中有大量代币，权力很大，可能主导记账权。DPoS(Delegated Proof of Stake)一致性算法的出现就是为了解决PoW和PoS的缺点。

DPoS引入了“见证节点”的概念。见证节点可以生成块。注意，是见证节点，而不是股东节点，有权限在这里生成块。

让我们以EOS区块链为例来介绍DPoS算法。

持有EOS令牌的节点是持有节点，但不一定是见证节点。见证节点由股东节点选举产生。DPoS的选举方式为:每个持有股份的节点可以投票选举见证节点，被追踪到的总同意票数前N名候选人可以当选为见证节点。n的这个值需要满足:至少有一半的投票参与者认为n已经完全去中心化(至少有一半的投票股东认为在有n个见证人的情况下这个区块链已经完全去中心化)，最好是奇数。请注意奇数的原因最好在分叉部分解释。

见证节点的候选列表在每个维护周期都会更新。见证节点选定后，会随机排列。每个见证节点都有一定的权利按顺序生成块。如果见证服务器无法在给定的时间片内生成块，块生成权限将授予与下一个时间片对应的见证服务器。DPoS的这种设计使得块生成更快、更节能。这里，“某个许可时间”不受算法的限制。另外，见证节点按照一定的算法随机排序。

DPoS一致性算法有以下优点和缺点:

优势

能耗更低。DPoS机制进一步将节点数量减少到n个，在保证网络安全的前提下，进一步降低了整个网络的能耗，网络的运行成本更低。

更分散，选举的N值必须充分体现集权。

避免了少数PoS账户的巨额代币带来的组织权力过大的问题，话语权在N个选举节点。

更快的确认速度，由见证节点确认，而不是所有持股节点。

缺点

投票热情不高。大部分持股节点没有参与投票。因为投票需要时间，精力等。

选举固定数量的见证人作为簿记候选人可能不适合完全分散的场景，并且在网络节点很少的场景中，选举出的见证人的代表性不强。

处理坏节点有很多困难。社区选举不能及时有效地防止一些受损节点，给节点网络带来安全隐患。

DPoS共识算法选举通用模型图

目前EOS的超级节点有21个，也就是说N=21，但是有很多有EOS令牌的节点可以投票。那么为什么N这么小呢？原因是这样的:虽然n代表一个节点一致认为可以代表足够去中心化的值，但是n可以取23，25，或者更多。这些数字似乎都足够分散了。事实上，在EOS公链的发展过程中，n的取值逐渐趋向于足够的去中心化和性能的跟上，也就是在中间，为了在满足去中心化的同时平衡性能。

EOS的投票其实是一种抵押。投票EOS会作为资源抵押，比如CPU、网络资源等，但抵押的EOS也可以换回。抵押的资源改回EOS一般需要3天。

一致性算法的编码尝试

本节尝试用伪代码实现三种一致性算法。之所以用伪代码，是为了让读者更容易理解。

1。实现PoW一致性算法

首先，区块链中的每个节点将相互通信以广播新生成的块。这里可以用“生成”一次或者“挖掘”一次来描述，意思是一样的，两者都是指生成块。

此时，我们需要使用一个候选块数组来保存每个节点广播的、由其当前节点生成的块对象，并使用一个全局块数组来表示当前公共链的块。数组的定义如下:

GlobalBlocks []Blocks //公共链块数组brcandidateBlock []Blocks //候选块数组假设块结构中的数据类型如下:

type struct { timestamp string//timestamp，Hash string代表这个块的生成时间//Hash pre Hash string这个块的前一个块的Hash节点地址串//生成这个块的节点地址数据串//块携带的数据}那么我们需要一个难度系数的变量，比如难度，来控制PoW算法的难度。数字越大，难度越大。它只需要反映PoW算法描述的工作负载难度。假设是整数，数字越大，计算难度越大，那么难度系数就会处于随时调整的状态。例如，在区块链的设计中，比特币BTC的难度系数有其动态调整算法。

这里，我们假设难度系数难度=1。

有了难度系数之后，我们还需要一个特殊的函数来根据难度检查块的哈希值。现在我们需要假设一个难度验证算法，假设哈希前缀0(值0x后的0)的个数与难度进行比较。如果哈希值包含这些前缀0，则验证通过。请注意，这是一个非常简单的验证算法，数量非常有限，而在比特币公链中，要复杂得多。

func isBlockHashMatchDifficulty(哈希字符串，难度int) bool {前缀:=字符串。重复("0 & gt；，难度)；//根据难度值生成相应数量的前缀0 returnstrings.hasprerfix (hash，prefix)；//比较前缀0的个数，如果包含，则返回true}现在假设节点启动一个子进程，一个生成块的方法，并将其添加到候选块数组中，等待验证。以下方法(函数)用于生成新块:

// oldBlock将从globalBlocks中删除block func generate block(旧块，数据字符串)block {var new block block}。T :=二级时间戳new block . index = old block . index 1 new block . timestamp = t . string()new block . data = data//块的附属数据new block . pre hash = I:= 0的块的父块的oldblock.hash//the哈希值； {//for循环不跳出表达式，代表不断计算合法块New Block . nonce = hex New Block . hash = calculate hash(New Block)if isblockash difference(New Block . difference){//自检一次难度系数，输入这个if，证明难度一致，计算答案CadidateBlocks = append(候选块，新块)//并添加到候选区域break} }返回newBlock}假设节点启动一个子协进程，不断计算候选块数组中块的哈希值，计算出的哈希值满足难度系数难度的检验。

var resultBlock块；For Block ~候选块{ If isblockmatch difference(Block，difference){//请注意，为什么这里还要再检查一遍？不是生成的时候查过一次吗？resultBlock =块；}继续；}//然后该块将会广播信息。目前这个节点已经确定。在每个节点确认的过程中，如果达到了指定的节点数，那么我们就判断区块获胜，最终被公共链路接受。

节点最后伪代码留下的问题——为什么播快之前还要再检查一遍？因为难度系数难度是动态变化的，而候选块数组中的难度不一定是我们当前节点产生的，即使是当前节点产生的，也有可能是难度系数已经快速产生了，所以需要铲除最新的难度系数，在最后一次广播时再检查一遍。

2。实现PoS一致性算法

与PoW相比，由于PoS共识算法没有“挖掘”的概念，不依赖计算工作量达成共识，所以在代码上会是另外一种情况。

首先，我们仍然需要定义一个候选区域数组来存储每个节点广播的、由我们当前节点生成的块对象:

CandidateBlocks []Blocks //候选块数组每个块结构都有一个变量，用来记录生成这个块的节点的地址。这个变量在PoW的伪代码实现中不起作用，但在PoS中非常重要。类似地，与上面的PoW一样，我们定义了下面的块结构:

type block struct { timestamp string//timestamp，代表块hash string的生成时间//本块的Hash值PreHash string //本块前一块的Hash值NodeAddress string //块携带的数据}其中NodeAddress变量用于记录块的节点地址。

其次，需要有一个子协进程，负责遍历候选区域数组，根据块的nodeAddress获取节点拥有的令牌数，然后进行股权分配。

star ecord[]string//Equity record数组for block ~ candidate blocks { coin num = getcoinbalance(block . node address)//获取节点的令牌数，即i ~ coinNum {//的权益数，加上ifstakerecord。包含(块。nodeaddress)任意多次{//如果已经包含break //如果包含，就不要重复添加} stakerecord = append (block。nodeaddrees)；//添加，循环越多，权益越多}}接下来，从stakeRecord中选择一个竞选赢家。这个概率和上面的coinNum有关。硬币越大，机会越大。为什么？因为它的统计方法是用coinNum作为循环极限，然后相应地加上nodeAddress的coinNum次，coinNum越大，加上的nodeAddress越多，后面的节点能被快速选中的概率就越高。

在这里，我们要回答一个问题，为什么不把已经包含的东西加上去呢？因为当前candidateBlocks数组可能包含同一个节点的多个块，而每个节点中的equity只需要计算一次，也就是coinNum只需要循环一次。如果重复，会造成不公平，因为会造成多重相加。

股权分配后，接下来就是选择节点赢家。选择的方式就是用算法。在这个例子中，我们仍然选择最简单的随机数。注意，不要这样限制自己的思维。这种选择算法可以定制，因此它可以是更复杂的算法。

Index := randInt() //获取一个整数随机数winner:= stake record[index]//取出赢家节点的地址。最后一步，你可以根据这个获胜者从所有候选块中选择节点地址相同的块。这个区块是胜利区块，将被广播。

Var结果块for block ~候选块{ if(block . node address = = winner){结果块= block//Add break；} }//广播出去，一定数量的节点同步后，被公共链路接受。以上是一个非常简单的PoS算法机制的代码实现，只根据持有的钱数来分配股权。其实事情往往很复杂。设想的股权分配不仅与代币数量有关。比如以太坊设想的PoS共识算法的实现中加入了硬币时代。会发生什么？此时，候选成功后，以太坊会扣除币龄。作为开发者，我们应该明白PoS的本质——其算法的实现往往会导致各种变种。只有知道这一点，我们才能在开发自己的公链时，遵从自己的内心。

3。实现DPoS的一致性算法

DPoS的伪代码实现可以理解为PoS的升级版，上例中相同数据结构的定义在此不再赘述。

首先，定义见证节点的结构:

type witness node struct { name string//name Address string//node Address votes int//当前票数，见证节点由投票产生}然后我们用一个由每个见证节点组成的数组来表示这组见证节点，以后随机排序操作也会在这个数组中进行。

var WitnessList[]witness node//witness node现在我们需要准备一个专门用来对witness list进行随机排序的方法。这种方法必须依靠某种算法来对证人名单进行排序。具体算法可以定制，但要看不同的业务需求。

我们还是以最简单的随机数排序为例。

funsortwitnesslist(){ if Needrestvotes(){//判断是否需要对witness重新投票~ witness list { witness . votes = rand . intn(1000)//vote } } sortbytvotes()//根据投票顺序}上面的Needrestvotes()的作用是判断见证节点是否需要重新投票，对应的DPoS算法描述每个周期开始重新排序。在这个阶段，需要剔除节点，比如一些坏节点。

这里以检查坏节点为例。因为对坏节点的检查一直在进行，所以我们可以使用一个子进程(在Go语言中，协进程是一个轻量级的线程，为了更恰当，下面的Go代码将线程统称为协进程)来专门检查坏节点。

FunCheckBadNode(){ for witness ~ witness slide { if is badnode(witness){//判断是否为坏节点见证列表。remove it(witness)//如果是，则将其移出}}同时不断检查是否有新的见证节点被投票，如果是，则将该节点信息添加到见证阶段数组中。同时，见证节点的总数应受N值的限制。

func check newwitnessnode(){ for { if(witness list . size()& lt；N) {//判断是否超过n newwitness的值:= isnewnodecom()//检查是否有新的见证节点到达if (newWitness！= nil) {WitnessList = append(见证列表，NES见证)//add} time.sleep(50ms) //延迟下一轮检测}}最后我们使用block-out函数从见证列表的见证列表中自上而下逐个找出block节点，block out，检查当前节点是否超时，超时就轮到它了。

在funmakeblock(){ sorttwitnesslist()//的开头，做一个sort for {//一个没有跳转表达式的for循环，代表合法块见证的内部计算:= GetWitnessByIndex(见证列表)//Get if witness top to bottom = = nil { break//所有见证都有block的问题} block . time out:= generate block(witness)//传入见证节点if timeOut {//如果超时继续//如果超时就是下一个}//将块广播出去， 然后结束这一轮，等待下一次休息}}广播结束后，其他见证人收到广播，会签名见证本块。 当它达到我们设定的某个值，认为见证够了，那么这个块就被确认了。

从上面的伪代码中发现，直接应用传统的DPoS算法时，存在以下问题:每个见证节点循环使用其他节点的信息生成块，而不是使用自己节点的信息。假设见证节点A、B、C处于分块的第一顺序，A、B两个节点中使用节点C生成的块都没有错，那么A、B两个节点中都会生成一次节点C，由于时间戳不同，这个块的hash是不确定的，但最终只能选择一个块，导致计算能力的浪费。当然，也有可能不仅是节点A和B，更多的节点都使用节点C生成块，那么结果就是更多的认证方节点生成一个节点的块来广播。

要解决上述问题，可以使用EOS:EOS通过见证节点的信息进行注册，使每个节点都知道所有见证节点的信息，注册的节点必须满足投票条件。

当每个见证节点具有所有见证节点的信息时，在每个最终块出现后，将使用特定的算法对节点列表进行排序。这样，在需要封锁的时候，节点会根据区块链跟踪最后一个块的时间参与一些计算，得到列表中当前应该封锁的见证节点的下标，然后判断这个节点是不是自己。如果没有，你就拖延自己一段时间，然后重复上面的步骤。这个延迟的时间就是DPoS中该块的超时，然后它会自动转向下一个见证节点。如果你自己做一个区块，做好一个区块后广播，等到2/3的见证节点都签字确认了，那么这个区块才最终有效。因此，EOS中的DPoS不像传统的模型代码，其中一个节点循环地生成包含其他节点信息的块。

EOS的要点是每个见证节点自己的代码对所有见证节点的顺序都不一样，每个节点可能同时封锁出去，但它提供了2/3见证节点全部签字确认的环节，即2/3见证节点谁最快确认谁就是最终有效，解决了多个节点同时快速生成一个节点的问题。

问题[/s2/]

这里有两个问题留给你考虑:

同一块有问题怎么办？有案子会同时解决。即使我们将块生成时间的时间戳定义到秒或毫秒的级别，仍然会出现同时挖掘的情况。在这种情况下，PoW共识算法是无能为力的。

为什么是51%的计算能力而不是50.1%？

以上解释了header的意思。这篇文章的中文翻译已经分享到这里了。希望能帮到大家。如果信息有误，请联系边肖进行更正。

标签： 区块链共识算法 PoW算法原理 PoS算法特点 DPoS算法优势