① 币天销毁——应用篇

币天销毁的重要性在比特币的POW工作量证明中体现的并不明显，在后来的POS权益证明中被广泛应用。我们看看币天销毁为什么重要，和应用模型是什么。

币天销毁可以揭示市场走向

这个发现在预判市场走向的动态过程中，随着整体市场处于 下跌 通道时，币天销毁的峰值意味着市场中的弱手，因为有大户可能要抛币。当整体市场处于 上升 通道时，币天销毁的峰值则意味着市场中的强手，说明市场会走强。 ——长铗

我的理解：在整体市场下跌的时候，如果币天销毁的数据显示有多个钱包地址在更新币天销毁的数据，则说明有大量的散户（弱手）在买入货币才会造成这种现象（如果不能理解，请再看一遍币天销毁的定义）而这种行为就会造成货币短暂的走强，货币出现短时间的暴涨就会有大户砸盘，一来是为了短期的获利，二来是为了把货币的价格再砸下去，大户们再入场。但这种说法好像又不太能说的通，因为弱手总是追涨杀跌的，而强手则是追跌杀涨。这段话如果改为：随着整体市场处于 上升 通道时，币天销毁的峰值意味着市场中的弱手，因为有大户可能要抛币。当整体市场处于 下跌 通道时，币天销毁的峰值则意味着市场中的强手，说明市场会走强。

这样的逻辑好像有能说的更清楚，这段话强烈要求各位讨论，毕竟篡改长铗大神的理论，心里面还是有点虚，望各路大神给予正确的理解。

币天销毁引入POS（权益证明）

点点币创始人萨尼.肯在改进POW算力浪费的时候，将币天销毁的概念引入了进去。当创造一个权益证明的区块时，旷工需要创建一个“币权”交易，交易会按设定的比列把一些币发送给矿工本身，其原理与比特币产出25个新币有关，不同的是其难度与交易输入的“币天”成反比，而与哈希计算力无关。由于权益证明的哈希运算只是基于时间和已知数据， 因此无法通过改进芯片性能来加快其运算速度。 每一秒种，每个币的交易输出都有一定概率产生与其币天成正比的工作量。

而引入币天的初衷就是防止旷工重复使用自己的币，如果挖矿难度仅与旷工持有的币有关，那么我们把持有的每个币当做一个“模拟矿机”，持币越多的人算力也就越大，反之持币越少的人，算力也就越少，这样就会造成一种不平衡，难以被普及的推广，就成了资本游戏。币天销毁每次更迭的币天，基本上可以保证所有挖矿者的公平。这也是币天销毁应用的一个重大领域。

POW的工作量证明就存在不公平的问题，但币天销毁却无法将其解决，比特币是去中心的，而矿工则是中心的，大家都把自己的算力投到一个矿池，再均分收益，与中心化又有什么区别，所以POW更迭到POS再到DPOS，都是在改进和创新。

币天销毁引入信用评价

有一种职业叫淘宝客，主要是为淘宝商店刷信用、刷评论的水军。据我所知这个职业已经存在有一段时间了，而淘宝在应对这个问题上，投入了大量的人力。原来我们把信用当做一个道德问题，想要从道德层面去约束，在利益的推动下，根本无法行成有效的制约，甚至乎站在道德高地来批评人都要受到诟病了。淘宝试图通过大数据、用户的社会关系、职业、收入、社会公共事业缴费单来评价一个人的信用高低，然而这样不仅需要高昂的资金和人力投入，其效果仍然是收效甚微。那么当引入区块链思维的币天销毁概念可能会有效的解决这个问题。

在区块链的信用评价中，信用只是一个数学问题。区块链本就是冰冷且机器的，不讲人性化，通过复杂的程序来实现信用的评级。淘宝客的行为是作弊行为，而区块链不会区分作弊和真实交易，通过币天销毁可以真实的反应该用户的信用评价。比如：

在一次交易中，我们用销毁的币天加入信用的算法。当刷客试图给用两个账户反复交易而刷好评时，第一次交易的评价是有效的，但历史上累积的币天在交易完成之时便已销毁，当进行第二笔交易时，由于发生在第一次交易后不久，币天积累非常小。相应地，对信用评价的贡献微乎其微，其后所有交易的币天销毁之和同样也非常小，用户利用同一笔钱反复给自己刷好评，不管进行多少次，其最终效果与第一笔交易所带来的信用评价几乎一样。同样，当差评师试图通过大量小额交易给用户以恶意差评时，由于信用评价正比于币天销毁，交易的额度太小，同样也几乎不能对用户的信用产生影响。

② 点点开黑的点点币怎么变钻

答:把点点开黑的点点币积累到一定的数量后就可以换取钻石了，越多的点点币换的钻石就会有数量的。

③ 莱特币110矿机一天能挖几个币

以现在的难度计算大概一天能挖1.012个莱特币,这是在矿池的平均计算结果，如果有高效矿池或者SOLO的话，也许要多点。

莱特币Litecoin（简写：LTC，货币符号：Ł）是一种基于“点对点”(peer-to-peer)技术的网络货币，也是MIT/X11许可下的一个开源软件项目。它可以帮助用户即时付款给世界上任何一个人。

莱特币受到了比特币（BTC）的启发，并且在技术上具有相同的实现原理，莱特币的创造和转让基于一种开源的加密协议，不受到任何中央机构的管理。莱特币旨在改进比特币，与其相比，莱特币具有三种显著差异。第一，莱特币网络每2.5分钟（而不是10分钟）就可以处理一个块，因此可以提供更快的交易确认。第二，莱特币网络预期产出8400万个莱特币，是比特币网络发行货币量的四倍之多。第三，莱特币在其工作量证明算法中使用了由Colin Percival首次提出的scrypt加密算法，这使得相比于比特币，在普通计算机上进行莱特币挖掘更为容易。每一个莱特币被分成100,000,000个更小的单位，通过八位小数来界定。

设计目的

它基于比特币(Bitcoin)协议，但不同于比特币的地方在于，即使在现阶段，通过消费级的硬件也可以高效地“挖矿”。Litecoin提供给您更快速的交易确认（平均2.5分钟），它使用硬内存以及基于scrypt(一种加密算法)的挖矿工作量证明算法，面向大多数人使用的普通计算机及图形处理器(GPU)。Litecoin网络预期将生产8400万个货币单位。

Litecoin的设计目的之一是提供一种挖掘算法，使它能够在挖掘比特币的机器上被同时运行。为挖掘比特币而设计的专用集成电路(ASIC)逐渐兴起的同时，Litecoin也紧跟着技术演变。但在Litecoin货币被广泛应用之前，不太可能会出现专门为Litecoin设计的专用集成电路(ASIC)。

相关网站社区

Litecoin官方网站

Litecointalk 官方论坛

莱特币中国社区

交易

由一个类似于比特币的点对点网络，通过Scrypt工作量证明方案来处理莱特币交易、结余以及发行（当一个足够小的哈希值被发现时，一个块就会被创建，此时莱特币就会被发行，而发现这个哈希值和创建块的过程被称作“挖矿”）。莱特币的发行速率按照等比数列，每四年（每840,000个块）减少一半，最终达到总量8400万个LTC。不同于比特币，Scrypt所具有的内存密集特性让莱特币更适合用图形处理器（GPU）进行“挖矿”。为Scrypt实施的FPGA（现场可编辑逻辑门阵列）和ASIC（专用集成电路），相比于比特币使用的sha256，更为昂贵。

莱特币当前可以交换法定货币以及比特币，大多数通过线上交易平台。可撤销的交易（比如用信用卡进行的交易）一般不用于购买莱特币，因为莱特币的交易是不可逆的，因此带来了退款风险。截止到2013年4月25日，一个莱特币价值大约3.97美元或者0.028比特币。这使得莱特币成为市值最高约35,000,000美元的第二大电子货币。

客户端

Litecoin是一款在MIT/X11许可下发布的免费软件项目，它让您能够根据自己的需要对软件进行运行、修改和复制。如果你愿意，你也可以发行软件的修改版本。

该软件以完全透明的形式发布，用户可以对二进制版本以及对应源代码进行独立验证。

矿池

莱特币是需要通过“矿工挖矿“产生的，挖矿是通过计算机显卡进行哈希运算，如果计算到”爆矿“的值，则系统会一次性奖励50个莱特币，目前莱特币的算力增长很快，矿工通过几台电脑已无法挖到矿，因此需要加入矿池，矿池集合了大家所有算力，估计计算到”爆矿“值的概率更大。

目前比较出名的矿池包括：BTCC（原比特币中国）矿池、 waltc.net 鱼池(F2POOL)、WeMineLTC、Coinotron、SilverFish、LiteGuardian、LitecoinPool.org等。但目前收益最高的是F2POOL，近期推出莱特币理论收益+矿池补贴 10%=您的实际收益，受到很多矿工和业内的关注。

全球主要活跃数字货币兑换利率

货币

符号

发行时间

作者

活跃

官网

市值

比特币基础

比特币

BTC

2009

SatoshiNakamoto

是

bitcoin/org

~$243亿美元

是

SHA-256

莱特币

LTC

2011

Coblee

是

litecoin/org

~$36亿美元

是

Scrypt

数据块链

Litecoin块链与其竞争对手——比特币比起来，能够处理更大的交易量。由于数据块的生成更加频繁，该网络可以支持更多的交易，并且无需在将来修改软件。
因此，商家可以获得更快的交易确认，而且在销售大额商品时依然能够等待更多的交易确认。

市场评价事实上，数字虚拟货币远非以上这几种。美国《福布斯》杂志列举出截至美国当地时间27日上午10时，按虚拟货币总市值和价格排出的市场上前30名，法国财经网和《创投邮报》则称，目前交易的虚拟货币至少有60种。《福布斯》该报道称，比特币高居市值第一和单价两项第一，获得“二连亚”的，是由前谷歌程序员李启威设计的莱特币，在截至27日的过去一周内，莱特币价格从6美元迅速涨至26美元，涨幅可观。总市值第三至第五名，是点点币、名币和质数币。该报道统计了截至27日的24小时涨幅，这30种货币几乎全线上涨，夸克币涨幅最大，达到278.55%。该报道也称，几乎所有虚拟货币都在本轮比特币升势中搭车上涨，但大多数经营惨淡，总市值在100万美元以下的有8家，单价在1美元以下的多达19家。

④ 点点币怎么提现

点点币满足提现条件才能提现。用户打开这款软件后，就可以挑选任务并完成了，用户进入任务详细页面后，就可以看到任务的奖励额度，有点是直接奖励现金1元或者2元左右，有点任务是奖励点点币进行兑换。在提现页面，可以看到满足20元就可以提现了。一天可以获得几十元到一百元不等，一个月也就是赚到千元，当热，前提是每天坚持完成相应的任务。

⑤ 常见的共识算法介绍

在异步系统中，需要主机之间进行状态复制，以保证每个主机达成一致的状态共识。而在异步系统中，主机之间可能出现故障，因此需要在默认不可靠的异步网络中定义容错协议，以确保各个主机达到安全可靠的状态共识。

共识算法其实就是一组规则，设置一组条件，筛选出具有代表性的节点。在区块链系统中，存在很多这样的筛选方案，如在公有链中的POW、Pos、DPOS等，而在不需要货币体系的许可链或私有链中，绝对信任的节点、高效的需求是公有链共识算法不能提供的，对于这样的区块链，传统的一致性共识算法成为首选，如PBFT、PAXOS、RAFT等。

目录

一、BFT（拜占庭容错技术）

二、PBFT（实用拜占庭容错算法）

三、PAXOS

四、Raft

五、POW（工作量证明）

六、POS（权益证明）

七、DPOS（委任权益证明）

八、Ripple

拜占庭弄错技术是一类分布式计算领域的容错技术。拜占庭假设是由于硬件错误、网络拥塞或中断以及遭到恶意攻击的原因，计算机和网络出现不可预测的行为。拜占庭容错用来处理这种异常行为，并满足所要解决问题的规范。

拜占庭容错系统是一个拥有n台节点的系统，整个系统对于每一个请求，满足以下条件：

1）所有非拜占庭节点使用相同的输入信息，产生同样的结果；

2）如果输入的信息正确，那么所有非拜占庭节点必须接收这个信息，并计算相应的结果。

拜占庭系统普遍采用的假设条件包括：

1）拜占庭节点的行为可以是任意的，拜占庭节点之间可以共谋；

2）节点之间的错误是不相关的；

3）节点之间通过异步网络连接，网络中的消息可能丢失、乱序并延时到达，但大部分协议假设消息在有限的时间里能传达到目的地；

4）服务器之间传递的信息，第三方可以嗅探到，但是不能篡改、伪造信息的内容和验证信息的完整性。

拜占庭容错由于其理论上的可行性而缺乏实用性，另外还需要额外的时钟同步机制支持，算法的复杂度也是随节点的增加而指数级增加。

实用拜占庭容错降低了拜占庭协议的运行复杂度，从指数级别降低到多项式级别。

PBFT是一种状态机副本复制算法，即服务作为状态机进行建模，状态机在分布式系统的不同节点进行副本复制。PBFT要求共同维护一个状态。需要运行三类基本协议，包括一致性协议、检查点协议和视图更换协议。

一致性协议。一致性协议至少包含若干个阶段：请求（request）、序号分配（pre-prepare）和响应（reply），可能包含相互交互（prepare），序号确认（commit）等阶段。

PBFT通信模式中，每个客户端的请求需要经过5个阶段。由于客户端不能从服务器端获得任何服务器运行状态的信息，PBFT中主节点是否发生错误只能由服务器监测。如果服务器在一段时间内都不能完成客户端的请求，则会触发视图更换协议。

整个协议的基本过程如下：

1）客户端发送请求，激活主节点的服务操作。

2）当主节点接收请求后，启动三阶段的协议以向各从节点广播请求。

［2.1］序号分配阶段，主节点给请求赋值一个序列号n，广播序号分配消息和客户端的请求消息m，并将构造PRE-PREPARE消息给各从节点；

［2.2］交互阶段，从节点接收PRE-PREPARE消息，向其他服务节点广播PREPARE消息；

［2.3］序号确认阶段，各节点对视图内的请求和次序进行验证后，广播COMMIT消息，执行收到的客户端的请求并给客户端以响应。

3）客户端等待来自不同节点的响应，若有m+1个响应相同，则该响应即为运算的结果。

PBFT一般适合有对强一致性有要求的私有链和联盟链，例如，在IBM主导的区块链超级账本项目中，PBFT是一个可选的共识协议。在Hyperledger的Fabric项目中，共识模块被设计成可插拔的模块，支持像PBFT、Raft等共识算法。

在有些分布式场景下，其假设条件不需要考虑拜占庭故障，而只是处理一般的死机故障。在这种情况下，采用Paxos等协议会更加高效。。PAXOS是一种基于消息传递且具有高度容错特性的一致性算法。

PAXOS中有三类角色Proposer、Acceptor及Learner，主要交互过程在Proposer和Acceptor之间。算法流程分为两个阶段：

phase 1

a) proposer向网络内超过半数的acceptor发送prepare消息

b) acceptor正常情况下回复promise消息

phase 2

a) 在有足够多acceptor回复promise消息时，proposer发送accept消息

b) 正常情况下acceptor回复accepted消息

流程图如图所示：

PAXOS协议用于微信PaxosStore中，每分钟调用Paxos协议过程数十亿次量级。

Paxos是Lamport设计的保持分布式系统一致性的协议。但由于Paxos非常复杂，比较难以理解，因此后来出现了各种不同的实现和变种。Raft是由Stanford提出的一种更易理解的一致性算法，意在取代目前广为使用的Paxos算法。

Raft最初是一个用于管理复制日志的共识算法，它是在非拜占庭故障下达成共识的强一致协议。Raft实现共识过程如下：首先选举一个leader，leader从客户端接收记账请求、完成记账操作、生成区块，并复制到其他记账节点。leader有完全的管理记账权利，例如，leader能够决定是否接受新的交易记录项而无需考虑其他的记账节点，leader可能失效或与其他节点失去联系，这时，重新选出新的leader。

在Raft中，每个节点会处于以下三种状态中的一种：

（1）follower：所有结点都以follower的状态开始。如果没收到leader消息则会变成candidate状态；

（2）candidate：会向其他结点“拉选票”，如果得到大部分的票则成为leader。这个过程就叫做Leader选举(Leader Election)；

（3）leader：所有对系统的修改都会先经过leader。每个修改都会写一条日志(log entry)。leader收到修改请求后的过程如下：此过程叫做日志复制（Log Replication）

1）复制日志到所有follower结点

2）大部分结点响应时才提交日志

3）通知所有follower结点日志已提交

4）所有follower也提交日志

5）现在整个系统处于一致的状态

Raft阶段主要分为两个，首先是leader选举过程，然后在选举出来的leader基础上进行正常操作，比如日志复制、记账等。

（1）leader选举

当follower在选举时间内未收到leader的消息，则转换为candidate状态。在Raft系统中：

1）任何一个服务器都可以成为候选者candidate，只要它向其他服务器follower发出选举自己的请求。

2）如果其他服务器同意了，发出OK。如果在这个过程中，有一个follower宕机，没有收到请求选举的要求，此时候选者可以自己选自己，只要达到N/2+1的大多数票，候选人还是可以成为leader的。

3）这样这个候选者就成为了leader领导人，它可以向选民也就是follower发出指令，比如进行记账。

4）以后通过心跳消息进行记账的通知。

5）一旦这个leader崩溃了，那么follower中有一个成为候选者，并发出邀票选举。

6）follower同意后，其成为leader，继续承担记账等指导工作。

（2）日志复制

记账步骤如下所示：

1）假设leader已经选出，这时客户端发出增加一个日志的要求；

2）leader要求follower遵从他的指令，将这个新的日志内容追加到各自日志中；

3）大多数follower服务器将交易记录写入账本后，确认追加成功，发出确认成功信息；

4）在下一个心跳消息中，leader会通知所有follower更新确认的项目。

对于每个新的交易记录，重复上述过程。

在这一过程中，若发生网络通信故障，使得leader不能访问大多数follower了，那么leader只能正常更新它能访问的那些follower服务器。而大多数的服务器follower因为没有了leader，他们将重新选举一个候选者作为leader，然后这个leader作为代表与外界打交道，如果外界要求其添加新的交易记录，这个新的leader就按上述步骤通知大多数follower。当网络通信恢复，原先的leader就变成follower，在失联阶段，这个老leader的任何更新都不能算确认，必须全部回滚，接收新的leader的新的更新。

在去中心账本系统中，每个加入这个系统的节点都要保存一份完整的账本，但每个节点却不能同时记账，因为节点处于不同的环境，接收不同的信息，如果同时记账，必然导致账本的不一致。因此通过同时来决定那个节点拥有记账权。

在比特币系统中，大约每10分钟进行一轮算力竞赛，竞赛的胜利者，就获得一次记账的权力，并向其他节点同步新增账本信息。

PoW系统的主要特征是计算的不对称性。工作端要做一定难度的工作才能得出一个结果，而验证方却很容易通过结果来检查工作端是不是做了相应的工作。该工作量的要求是，在某个字符串后面连接一个称为nonce的整数值串，对连接后的字符串进行SHA256哈希运算，如果得到的哈希结果（以十六进制的形式表示）是以若干个0开头的，则验证通过。

比特币网络中任何一个节点，如果想生成一个新的区块并写入区块链，必须解出比特币网络出的PoW问题。关键的3个要素是 工作量证明函数、区块及难度值 。工作量证明函数是这道题的计算方法，区块决定了这道题的输入数据，难度值决定了这道题所需要的计算量。

（1）工作量证明函数就是<u style="box-sizing: border-box;"> SHA256 </u>

比特币的区块由区块头及该区块所包含的交易列表组成。拥有80字节固定长度的区块头，就是用于比特币工作量证明的输入字符串。

（2）难度的调整是在每个完整节点中独立自动发生的。每2016个区块，所有节点都会按统一的公式自动调整难度。如果区块产生的速率比10分钟快则增加难度，比10分钟慢则降低难度。

公式可以总结为：新难度值=旧难度值×（过去2016个区块花费时长/20160分钟）

工作量证明需要有一个目标值。比特币工作量证明的目标值（Target）的计算公式：目标值=最大目标值/难度值

其中最大目标值为一个恒定值：

目标值的大小与难度值成反比。比特币工作量证明的达成就是矿工计算出来的 区块哈希值必须小于目标值 。

（3）PoW能否解决拜占庭将军问题

比特币的PoW共识算法是一种概率性的拜占庭协议（Probabilistic BA）

当不诚实的算力小于网络总算力的50%时，同时挖矿难度比较高（在大约10分钟出一个区块情况下）比特币网络达到一致性的概念会随确认区块的数目增多而呈指数型增加。但当不诚实算力具一定规模，甚至不用接近50%的时候，比特币的共识算法并不能保证正确性，也就是，不能保证大多数的区块由诚实节点来提供。

比特币的共识算法不适合于私有链和联盟链。其原因首先是它是一个最终一致性共识算法，不是一个强一致性共识算法。第二个原因是其共识效率低。

扩展知识： 一致性

严格一致性，是在系统不发生任何故障，而且所有节点之间的通信无需任何时间这种理想的条件下，才能达到。这个时候整个系统就等价于一台机器了。在现实中，是不可能达到的。

强一致性，当分布式系统中更新操作完成之后，任何多个进程或线程，访问系统都会获得最新的值。

弱一致性，是指系统并不保证后续进程或线程的访问都会返回最新的更新的值。系统在数据成功写入之后，不承诺立即可以读到最新写入的值，也不会具体承诺多久读到。但是会尽可能保证在某个时间级别（秒级）之后。可以让数据达到一致性状态。

最终一致性是弱一致性的特定形式。系统保证在没有后续更新的前提下，系统最终返回上一次更新操作的值。也就是说，如果经过一段时间后要求能访问到更新后的数据，则是最终一致性。

在股权证明PoS模式下，有一个名词叫币龄，每个币每天产生1币龄，比如你持有100个币，总共持有了30天，那么，此时你的币龄就为3000，这个时候，如果你发现了一个PoS区块，你的币龄就会被清空为0。你每被清空365币龄，你将会从区块中获得0.05个币的利息(假定利息可理解为年利率5%)，那么在这个案例中，利息 = 3000 * 5% / 365 = 0.41个币，这下就很有意思了，持币有利息。

点点币（Peercoin）是首先采用权益证明的货币。，点点币的权益证明机制结合了随机化与币龄的概念，未使用至少30天的币可以参与竞争下一区块，越久和越大的币集有更大的可能去签名下一区块。一旦币的权益被用于签名一个区块，则币龄将清为零，这样必须等待至少30日才能签署另一区块。

PoS机制虽然考虑到了PoW的不足，但依据权益结余来选择，会导致首富账户的权力更大，有可能支配记账权。股份授权证明机制（Delegated Proof of Stake，DPoS）的出现正是基于解决PoW机制和PoS机制的这类不足。

比特股（Bitshare）是一类采用DPoS机制的密码货币。它的原理是，让每一个持有比特股的人进行投票，由此产生101位代表 , 我们可以将其理解为101个超级节点或者矿池，而这101个超级节点彼此的权利是完全相等的。如果代表不能履行他们的职责（当轮到他们时，没能生成区块），他们会被除名，网络会选出新的超级节点来取代他们。

比特股引入了见证人这个概念，见证人可以生成区块，每一个持有比特股的人都可以投票选举见证人。得到总同意票数中的前N个（N通常定义为101）候选者可以当选为见证人，当选见证人的个数（N）需满足：至少一半的参与投票者相信N已经充分地去中心化。

见证人的候选名单每个维护周期（1天）更新一次。见证人然后随机排列，每个见证人按序有2秒的权限时间生成区块，若见证人在给定的时间片不能生成区块，区块生成权限交给下一个时间片对应的见证人。

比特股还设计了另外一类竞选，代表竞选。选出的代表拥有提出改变网络参数的特权，包括交易费用、区块大小、见证人费用和区块区间。若大多数代表同意所提出的改变，持股人有两周的审查期，这期间可以罢免代表并废止所提出的改变。这一设计确保代表技术上没有直接修改参数的权利以及所有的网络参数的改变最终需得到持股人的同意。

Ripple（瑞波）是一种基于互联网的开源支付协议，在Ripple的网络中，交易由客户端（应用）发起，经过追踪节点（tracking node）或验证节点（validating node）把交易广播到整个网络中。

追踪节点的主要功能是分发交易信息以及响应客户端的账本请求。验证节点除包含追踪节点的所有功能外，还能够通过共识协议，在账本中增加新的账本实例数据。

Ripple的共识达成发生在验证节点之间，每个验证节点都预先配置了一份可信任节点名单，称为UNL（Unique Node List）。在名单上的节点可对交易达成进行投票。每隔几秒，Ripple网络将进行如下共识过程：

1）每个验证节点会不断收到从网络发送过来的交易，通过与本地账本数据验证后，不合法的交易直接丢弃，合法的交易将汇总成交易候选集（candidate set）。交易候选集里面还包括之前共识过程无法确认而遗留下来的交易。

2）每个验证节点把自己的交易候选集作为提案发送给其他验证节点。

3）验证节点在收到其他节点发来的提案后，如果不是来自UNL上的节点，则忽略该提案；如果是来自UNL上的节点，就会对比提案中的交易和本地的交易候选集，如果有相同的交易，该交易就获得一票。在一定时间内，当交易获得超过50%的票数时，则该交易进入下一轮。没有超过50%的交易，将留待下一次共识过程去确认。

4）验证节点把超过50%票数的交易作为提案发给其他节点，同时提高所需票数的阈值到60%，重复步骤3）、步骤4），直到阈值达到80%。

5）验证节点把经过80%UNL节点确认的交易正式写入本地的账本数据中，称为最后关闭账本（Last Closed Ledger），即账本最后（最新）的状态。

在Ripple的共识算法中，参与投票节点的身份是事先知道的。该共识算法只适合于权限链（Permissioned chain）的场景。Ripple共识算法的拜占庭容错（BFT）能力为（n-1）/5，即可以容忍整个网络中20%的节点出现拜占庭错误而不影响正确的共识。

在区块链网络中，由于应用场景的不同，所设计的目标各异，不同的区块链系统采用了不同的共识算法。一般来说，在私有链和联盟链情况下，对一致性、正确性有很强的要求。一般来说要采用强一致性的共识算法。而在公有链情况下，对一致性和正确性通常没法做到百分之百，通常采用最终一致性（Eventual Consistency）的共识算法。

共识算法的选择与应用场景高度相关，可信环境使用paxos 或者raft，带许可的联盟可使用pbft ，非许可链可以是pow，pos，ripple共识等，根据对手方信任度分级，自由选择共识机制。

⑥ 怎样获取起点点币

充值啊

⑦ 点点开黑1000点点币能提现多少

10元。《点凯庆枝点开黑》是一款以游戏组队开黑为主的综合社交类APP，在该软件使用方法中了解到1000点差没点币能够提现10元，玩家提现前需要绑定盯敏银行卡。

⑧ 点点开黑点点币等于多少钻石

1点点币等于0.1钻石。
1点点币等于0.1钻石。点点币是《点点开黑》中的虚拟货币，可以购买许多道具，1元等于100点点币等于10钻石。
《点点开黑》，是一款以游戏组队为主的综合社交类APP。

⑨ 知链区块链金融应用实践平台成绩怎么算

1. 工作量证明（PoW）
中本聪在2009年提出的比特币（Bitcoin）是区块链技术最早的应用，其采用PoW作为共识算法，其核心思想是节点间通过哈希算力的竞争来获取记账权和比特币奖励。PoW中，不同节点根据特定信息竞争计算一个数学问题的解，这个数学问题很难求解，但却容易对结果进行验证，最先解决这个数学问题的节点可以创建下一个区块并获得一定数量的币奖励。中本聪在比特币中采用了HashCash[4]机制设计这一数学问题。本节将以比特币采用的PoW算法为例进行说明，PoW的共识步骤如下：
节点收集上一个区块产生后全网待确认的交易，将符合条件的交易记入交易内存池，然后更新并计算内存池中交易的Merkle根的值，并将其写入区块头部；
在区块头部填写如表1.1所示的区块版本号、前一区块的哈希值、时间戳、当前目标哈希值和随机数等信息；
表1.1 区块头部信息
随机数nonce在0到232之间取值，对区块头部信息进行哈希计算，当哈希值小于或等于目标值时，打包并广播该区块，待其他节点验证后完成记账；
一定时间内如果无法计算出符合要求的哈希值，则重复步骤2。如果计算过程中有其他节点完成了计算，则从步骤1重新开始。
比特币产生区块的平均时间为10分钟，想要维持这一速度，就需要根据当前全网的计算能力对目标值（难度）进行调整[5]。难度是对计算产生符合要求的区块困难程度的描述，在计算同一高度区块时，所有节点的难度都是相同的，这也保证了挖矿的公平性。难度与目标值的关系为：
难度值=最大目标值/当前目标值 （1.1）
其中最大目标值和当前目标值都是256位长度，最大目标值是难度为1时的目标值，即2224。假设当前难度为，算力为，当前目标值为，发现新区块的平均计算时间为，则
根据比特币的设计，每产生2016个区块后（约2周）系统会调整一次当前目标值。节点根据前2016个区块的实际生产时间，由公式（1.4）计算出调整后的难度值，如果实际时间生产小于2周，增大难度值；如果实际时间生产大于2周，则减小难度值。根据最长链原则，在不需要节点同步难度信息的情况下，所有节点在一定时间后会得到相同的难度值。
在使用PoW的区块链中，因为网络延迟等原因，当同一高度的两个区块产生的时间接近时，可能会产生分叉。即不同的矿工都计算出了符合要求的某一高度的区块，并得到与其相近节点的确认，全网节点会根据收到区块的时间，在先收到的区块基础上继续挖矿。这种情况下，哪个区块的后续区块先出现，其长度会变得更长，这个区块就被包括进主链，在非主链上挖矿的节点会切换到主链继续挖矿。
PoW共识算法以算力作为竞争记账权的基础，以工作量作为安全性的保障，所有矿工都遵循最长链原则。新产生的区块包含前一个区块的哈希值，现存的所有区块的形成了一条链，链的长度与工作量成正比，所有的节点均信任最长的区块链。如果当某一组织掌握了足够的算力，就可以针对比特币网络发起攻击。当攻击者拥有足够的算力时，能够最先计算出最新的区块，从而掌握最长链。此时比特币主链上的区块大部分由其生成，他可以故意拒绝某些交易的确认和进行双花攻击，这会对比特币网络的可信性造成影响，但这一行为同样会给攻击者带来损失。通过求解一维随机游走问题，可以获得恶意节点攻击成功的概率和算力之间的关系：
图1.1 攻击者算力与攻击成功概率
2. 权益证明（PoS）
随着参与比特币挖矿的人越来越多，PoW的许多问题逐渐显现，例如随着算力竞争迅速加剧，获取代币需要消耗的能源大量增加，记账权也逐渐向聚集了大量算力的“矿池”集中[6-9]。为此，研究者尝试采用新的机制取代工作量证明。PoS的概念在最早的比特币项目中曾被提及，但由于稳健性等原因没被使用。PoS最早的应用是点点币（PPCoin），PoS提出了币龄的概念，币龄是持有的代币与持有时间乘积的累加，计算如公式（1.4）所示。利用币龄竞争取代算力竞争，使区块链的证明不再仅仅依靠工作量，有效地解决了PoW的资源浪费问题。
其中持有时间为某个币距离最近一次在网络上交易的时间，每个节点持有的币龄越长，则其在网络中权益越多，同时币的持有人还会根据币龄来获得一定的收益。点点币的设计中，没有完全脱离工作量证明，PoS机制的记账权的获得同样需要进行简单的哈希计算：
其中proofhash是由权重因子、未消费的产出值和当前时间的模糊和得到的哈希值，同时对每个节点的算力进行了限制，可见币龄与计算的难度成反比。在PoS中，区块链的安全性随着区块链的价值增加而增加，对区块链的攻击需要攻击者积攒大量的币龄，也就是需要对大量数字货币持有足够长的时间，这也大大增加了攻击的难度。与PoW相比，采用PoS的区块链系统可能会面对长程攻击（Long Range Attack）和无利害攻击（Nothing at Stake）。
除了点点币，有许多币也使用了PoS，但在记账权的分配上有着不同的方法。例如，未来币（Nxt）和黑币（BlackCion）结合节点所拥有的权益，使用随机算法分配记账权。以太坊也在逐步采用PoS代替PoW。
3. 委托权益证明（DPoS）
比特币设计之初，希望所有挖矿的参与者使用CPU进行计算，算力与节点匹配，每一个节点都有足够的机会参与到区块链的决策当中。随着技术的发展，使用GPU、FPGA、ASIC等技术的矿机大量出现，算力集中于拥有大量矿机的参与者手中，而普通矿工参与的机会大大减小。
采用DPoS的区块链中，每一个节点都可以根据其拥有的股份权益投票选取代表，整个网络中参与竞选并获得选票最多的n个节点获得记账权，按照预先决定的顺序依次生产区块并因此获得一定的奖励。竞选成功的代表节点需要缴纳一定数量的保证金，而且必须保证在线的时间，如果某时刻应该产生区块的节点没有履行职责，他将会被取消代表资格，系统将继续投票选出一个新的代表来取代他。
DPoS中的所有节点都可以自主选择投票的对象，选举产生的代表按顺序记账，与PoW及PoS相比节省了计算资源，而且共识节点只有确定的有限个，效率也得到了提升。而且每个参与节点都拥有投票的权利，当网络中的节点足够多时，DPoS的安全性和去中心化也得到了保证。
4. 实用拜占庭容错算法（PBFT）
在PBFT算法中，所有节点都在相同的配置下运行，且有一个主节点，其他节点作为备份节点。主节点负责对客户端的请求进行排序，按顺序发送给备份节点。存在视图（View）的概念，在每个视图中，所有节点正常按照处理消息。但当备份节点检查到主节点出现异常，就会触发视图变换（View Change）机制更换下一编号的节点为主节点，进入新的视图。PBFT中客户端发出请求到收到答复的主要流程如图4.1所示[10] [11]，服务器之间交换信息3次，整个过程包含以下五个阶段：
图4.1 PBFT执行流程
目前以PBFT为代表的拜占庭容错算法被许多区块链项目所使用。在联盟链中，PBFT算法最早是被Hyper ledger Fabric项目采用。Hyperledger Fabric在0.6版本中采用了PBFT共识算法，授权和背书的功能集成到了共识节点之中，所有节点都是共识节点，这样的设计导致了节点的负担过于沉重，对TPS和扩展性有很大的影响。1.0之后的版本都对节点的功能进行了分离，节点分成了三个背书节点(Endorser)、排序节点(Orderer)和出块节点(Committer)，对节点的功能进行了分离，一定程度上提高了共识的效率。
Cosmos项目使用的Tendermint[12]算法结合了PBFT和PoS算法，通过代币抵押的方式选出部分共识节点进行BFT的共识，其减弱了异步假设并在PBFT的基础上融入了锁的概念，在部分同步的网络中共识节点能够通过两阶段通信达成共识。系统能够容忍1/3的故障节点，且不会产生分叉。在Tendermint的基础上，Hotstuff[13]将区块链的块链式结构和BFT的每一阶段融合，每阶段节点间对前一区块签名确认与新区块的构建同时进行，使算法在实现上更为简单，Hotstuff还使用了门限签名[14]降低算法的消息复杂度。
5. Paxos与Raft
共识算法是为了保障所存储信息的准确性与一致性而设计的一套机制。在传统的分布式系统中，最常使用的共识算法是基于Paxos的算法。在拜占庭将军问题[3]提出后，Lamport在1990年提出了Paxos算法用于解决特定条件下的系统一致性问题，Lamport于1998年重新整理并发表Paxos的论文[15]并于2001对Paxos进行了重新简述[16]。随后Paxos在一致性算法领域占据统治地位并被许多公司所采用，例如腾讯的Phxpaxos、阿里巴巴的X-Paxos、亚马逊的AWS的DynamoDB和谷歌MegaStore[17]等。这一类算法能够在节点数量有限且相对可信任的情况下，快速完成分布式系统的数据同步，同时能够容忍宕机错误（Crash Fault）。即在传统分布式系统不需要考虑参与节点恶意篡改数据等行为，只需要能够容忍部分节点发生宕机错误即可。但Paxos算法过于理论化，在理解和工程实现上都有着很大的难度。Ongaro等人在2013年发表论文提出Raft算法[18]，Raft与Paxos同样的效果并且更便于工程实现。
Raft中领导者占据绝对主导地位，必须保证服务器节点的绝对安全性，领导者一旦被恶意控制将造成巨大损失。而且交易量受到节点最大吞吐量的限制。目前许多联盟链在不考虑拜占庭容错的情况下，会使用Raft算法来提高共识效率。
6. 结合VRF的共识算法
在现有联盟链共识算法中，如果参与共识的节点数量增加，节点间的通信也会增加，系统的性能也会受到影响。如果从众多候选节点中选取部分节点组成共识组进行共识，减少共识节点的数量，则可以提高系统的性能。但这会降低安全性，而且候选节点中恶意节点的比例越高，选出来的共识组无法正常运行的概率也越高。为了实现从候选节点选出能够正常运行的共识组，并保证系统的高可用性，一方面需要设计合适的随机选举算法，保证选择的随机性，防止恶意节点对系统的攻击。另一方面需要提高候选节点中的诚实节点的比例，增加诚实节点被选进共识组的概率。
当前在公有链往往基于PoS类算法，抵押代币增加共识节点的准入门槛，通过经济学博弈增加恶意节点的作恶成本，然后再在部分通过筛选的节点中通过随机选举算法，从符合条件的候选节点中随机选举部分节点进行共识。
Dodis等人于1999年提出了可验证随机函数（Verifiable Random Functions，VRF）[19]。可验证随机函数是零知识证明的一种应用，即在公私钥体系中，持有私钥的人可以使用私钥和一条已知信息按照特定的规则生成一个随机数，在不泄露私钥的前提下，持有私钥的人能够向其他人证明随机数生成的正确性。VRF可以使用RSA或者椭圆曲线构建，Dodis等人在2002年又提出了基于Diffie-Hellman 困难性问题的可验证随机函数构造方法[20]，目前可验证随机函数在密钥传输领域和区块链领域都有了应用[21]。可验证随机函数的具体流程如下：
在公有链中，VRF已经在一些项目中得到应用，其中VRF多与PoS算法结合，所有想要参与共识的节点质押一定的代币成为候选节点，然后通过VRF从众多候选节点中随机选出部分共识节点。Zilliqa网络的新节点都必须先执行PoW，网络中的现有节点验证新节点的PoW并授权其加入网络。区块链项目Ontology设计的共识算法VBFT将VRF、PoS和BFT算法相结合，通过VRF在众多候选节点中随机选出共识节点并确定共识节点的排列顺序，可以降低恶意分叉对区块链系统的影响，保障了算法的公平性和随机性。图灵奖获得者Micali等人提出的Algorand[22]将PoS和VRF结合，节点可以采用代币质押的方式成为候选节点，然后通过非交互式的VRF算法选择部分节点组成共识委员会，然后由这部分节点执行类似PBFT共识算法，负责交易的快速验证，Algorand可以在节点为诚实节点的情况下保证系统正常运行。Kiayias等人提出的Ouroboros[23]在第二个版本Praos[24]引入了VRF代替伪随机数，进行分片中主节点的选择。以Algorand等算法使用的VRF算法为例，主要的流程如下：
公有链中设计使用的VRF中，节点被选为记账节点的概率往往和其持有的代币正相关。公有链的共识节点范围是无法预先确定的，所有满足代币持有条件的节点都可能成为共识节点，系统需要在数量和参与度都随机的节点中选择部分节点进行共识。而与公有链相比，联盟链参与共识的节点数量有限、节点已知，这种情况下联盟链节点之间可以通过已知的节点列表进行交互，这能有效防止公有链VRF设计时可能遇到的女巫攻击问题。
7. 结合分片技术的公式算法
分片技术是数据库中的一种技术，是将数据库中的数据切成多个部分，然后分别存储在多个服务器中。通过数据的分布式存储，提高服务器的搜索性能。区块链中，分片技术是将交易分配到多个由节点子集组成的共识组中进行确认，最后再将所有结果汇总确认的机制。分片技术在区块链中已经有一些应用，许多区块链设计了自己的分片方案。
Luu等人于2017年提出了Elastico协议，最先将分片技术应用于区块链中[25]。Elastico首先通过PoW算法竞争成为网络中的记账节点。然后按照预先确定的规则，这些节点被分配到不同的分片委员会中。每个分片委员会内部执行PBFT等传统拜占庭容错的共识算法，打包生成交易集合。在超过的节点对该交易集合进行了签名之后，交易集合被提交给共识委员会，共识委员会在验证签名后，最终将所有的交易集合打包成区块并记录在区块链上。
Elastico验证了分片技术在区块链中的可用性。在一定规模内，分片技术可以近乎线性地拓展吞吐量。但Elastico使用了PoW用于选举共识节点,这也导致随机数产生过程及PoW竞争共识节点的时间过长，使得交易延迟很高。而且每个分片内部采用的PBFT算法通讯复杂度较高。当单个分片中节点数量较多时，延迟也很高。
在Elastico的基础上，Kokoris-Kogias等人提出OmniLedger[26]，用加密抽签协议替代了PoW选择验证者分组，然后通过RandHound协议[27]将验证者归入不同分片。OmniLedger。OmniLedger在分片中仍然采用基于PBFT的共识算法作为分片中的共识算法[28]，并引入了Atomix协议处理跨分片的交易，共识过程中节点之间通信复杂度较高。当分片中节点数量增多、跨分片交易增多时，系统TPS会显著下降。
Wang等人在2019年提出了Monoxide[29]。在PoW区块链系统中引入了分片技术，提出了连弩挖矿算法（Chu ko-nu mining algorithm），解决了分片造成的算力分散分散问题，使得每个矿工可以同时在不同的分片进行分片，在不降低安全性的情况下提高了PoW的TPS。

⑩ 点点开黑的金币是干嘛的

点点开黑的金币是可以用来购买道具弊哗的。根据查询相关资料信息显示，点点币是游戏《点点开黑》中的虚拟塌卜旦货币团扰，可以购买许多道具，1元等于100点点币等于10钻石。

① Coin Days Destruction - Application

The importance of Coin Days destruction is not obvious in Bitcoin’s POW proof of work, but was later replaced by POS equity proof. widely used. Let’s take a look at why CoinTian’s destruction is important and what the application model is.

The destruction of Coin Days can reveal the market direction

This discovery is in the dynamic process of predicting the market direction. As the overall market is in a downward channel, the peak value of Coin Days destruction means Watch the weak hands in the market, because a big player may want to sell coins. When the overall market is in an upward channel, the peak of coin-day destruction means strong hands in the market, indicating that the market will be stronger. ——Changchao

My understanding: When the overall market is falling, if the data of BiTian’s destruction shows that there are multiple wallet addresses updating the data of BiTian’s destruction, it means that there are a large number of retail investors ( Weak hands) will cause this phenomenon when buying currency (if you can't understand, please read the definition of currency day destruction again) and this behavior will cause the currency to strengthen temporarily. If the currency surges in a short period, there will be large investors. The purpose of smashing the market is firstly to make short-term profits, and secondly to drive the currency price down again so that big investors can enter the market again. But this argument doesn’t seem to make sense, because weak players always chase the rise and kill the fall, while strong players chase the fall and kill the rise. If this paragraph is changed to: When the overall market is in an upward channel, the peak of currency day destruction means weak hands in the market, because some large players may want to sell coins. When the overall market is in a downward channel, the peak of coin-day destruction means strong hands in the market, indicating that the market will be stronger.

This kind of logic seems to be explained more clearly. This passage strongly urges everyone to discuss it. After all, I still feel a little guilty for tampering with the theory of Master Changchai. I hope all the masters can give me a correct understanding.

Coinday destruction introduces POS (Proof of Stake)

Peercoin founder Sani Ken introduced the concept of Coinday destruction when improving the waste of POW computing power. Go in. When creating a proof-of-stake block, Miner needs to create a "coin rights" transaction. The transaction will send some coins to the miners themselves according to a set ratio. The principle is related to Bitcoin's output of 25 new coins. It is different. What's more, its difficulty is inversely proportional to the "coin days" of the transaction input and has nothing to do with the hashing power. Since the hash operation of proof of stake is only based on time and known data, it cannot be accelerated by improving chip performance. Every second, the transaction output of each coin has a certain probability of generating a workload proportional to its coin days.

The original intention of introducing Bitian is to prevent Kuangong from reusing his own coins. If the mining difficulty is only related to the coins held by Kuangong, then we treat each coin held by Kuangong as a "simulated mine" "Machine", people who hold more coins have greater computing power, conversely, people who hold less coins have less computing power, soIt will create an imbalance, make it difficult to popularize, and become a capital game. CoinTian destroys each change of CoinTian, ​​which can basically ensure fairness for all miners. This is also an important area of ​​Bitian destruction application.

There is an unfair problem in POW's workload proof, but the destruction of Coin Sky cannot solve it. Bitcoin is decentralized, while miners are centralized. Everyone calculates their own calculations. What is the difference between investing in a mining pool and then sharing the profits equally with centralization? Therefore, the changes from POW to POS and then to DPOS are all improvements and innovations.

CoinTian Destruction Introduces Credit Evaluation

There is a profession called Taobao Guest, which is mainly a troll who brushes up credit and reviews for Taobao stores. As far as I know, this profession has existed for a while, and Taobao has invested a lot of manpower in dealing with this problem. It turns out that we regard credit as a moral issue and want to restrict it from a moral level. Driven by interests, we cannot effectively restrict it at all. Even criticizing people from the moral high ground will be criticized. Taobao tries to evaluate a person's creditworthiness through big data, users' social relationships, occupation, income, and public utility payment bills. However, this not only requires high capital and human investment, but the effect is still very little. Then when the concept of currency day destruction is introduced with blockchain thinking, this problem may be effectively solved.

In the credit evaluation of blockchain, credit is just a mathematical problem. Blockchain is inherently cold and machine-like, not humane, and uses complex procedures to achieve credit ratings. The behavior of Taobao customers is cheating, and the blockchain does not distinguish between cheating and real transactions. The destruction of CoinTian can truly reflect the user's credit evaluation. For example:

In a transaction, we use the algorithm of adding credit to the destroyed coins. When a brush customer attempts to give positive reviews for repeated transactions using two accounts, the review of the first transaction is valid, but the accumulated coin days in history have been destroyed when the transaction is completed. When the second transaction is made, Since it occurred shortly after the first transaction, the coin-day accumulation was very small. Correspondingly, the contribution to credit evaluation is minimal, and the sum of coin-day destruction of all subsequent transactions is also very small. Users use the same money to repeatedly give themselves good reviews. No matter how many times they are performed, the final effect will be the same as that of the first transaction. The credit rating it brings is almost the same. Similarly, when a bad reviewer tries to give a malicious negative review to a user through a large number of small-amount transactions, since the credit evaluation is destroyed in proportion to the currency day, the transaction amount is too small, and it has almost no impact on the user's credit.

② How to turn the black coins into diamonds by clicking on them

Answer: After accumulating a certain number of coins, you can exchange them for diamonds. The more coins you have, the more coins you get. There will be a certain amount of diamonds exchanged.

③ How many coins can the Litecoin 110 mining machine mine in a day?

Based on the currentThe difficulty calculation shows that 1.012 Litecoins can be mined in a day. This is the average calculation result in the mining pool. If there is an efficient mining pool or SOLO, it may be more.

Litecoin (abbreviation: LTC, currency symbol: Ł) is an online currency based on "peer-to-peer" technology. It is also an open source software project under the MIT/X11 license. . It helps users make instant payments to anyone in the world.

Litecoin is inspired by Bitcoin (BTC) and technically has the same implementation principle. The creation and transfer of Litecoin are based on an open source encryption protocol and are not managed by any central authority. . Litecoin aims to improve Bitcoin and has three significant differences compared to it. First, the Litecoin network can process a block every 2.5 minutes (instead of 10 minutes), thus providing faster transaction confirmations. Second, the Litecoin network is expected to produce 84 million Litecoins, which is four times the amount of currency issued by the Bitcoin network. Third, Litecoin uses the scrypt encryption algorithm first proposed by Colin Percival in its proof-of-work algorithm, which makes Litecoin mining easier on ordinary computers than Bitcoin. Each Litecoin is divided into 100,000,000 smaller units, defined by eight decimal places.

Design purpose

It is based on the Bitcoin (Bitcoin) protocol, but what is different from Bitcoin is that even at this stage, consumer-grade hardware can effectively "mine" mine". Litecoin provides you with faster transaction confirmations (average 2.5 minutes), it uses hard memory and a mining proof-of-work algorithm based on scrypt (an encryption algorithm), and is suitable for ordinary computers and graphics processing units (GPUs) used by most people. ). The Litecoin network is expected to produce 84 million currency units.

One of the design goals of Litecoin is to provide a mining algorithm that can be run simultaneously on the machines that mine Bitcoin. While application-specific integrated circuits (ASICs) designed for mining Bitcoin are gradually emerging, Litecoin is also following the technological evolution. But until Litecoin currency is widely used, it is unlikely that an application specific integrated circuit (ASIC) will be developed specifically for Litecoin.

Related website communities

Litecoin official website

Litecointalk official forum

Litecoin Chinese community

Transaction< /p>

A peer-to-peer network similar to Bitcoin handles Litecoin transactions, balances, and issuance through the Scrypt proof-of-work scheme (when a small enough hash is discovered, a block is created , at this time Litecoin will be issued, and the process of discovering this hash value and creating a blockcalled "mining"). The issuance rate of Litecoin follows a geometric sequence, halving every four years (every 840,000 blocks), eventually reaching a total of 84 million LTC. Unlike Bitcoin, the memory-intensive nature of Scrypt makes Litecoin more suitable for "mining" with a graphics processing unit (GPU). The FPGA (Field Programmable Gate Array) and ASIC (Application Specific Integrated Circuit) implemented for Scrypt are more expensive than the sha256 used by Bitcoin.

Litecoin can currently be exchanged for fiat currencies as well as Bitcoin, mostly through online trading platforms. Reversible transactions (such as those made with a credit card) are generally not used to purchase Litecoin because Litecoin transactions are irreversible and therefore introduce chargeback risk. As of April 25, 2013, one Litecoin was worth approximately $3.97 or 0.028 Bitcoin. This makes Litecoin the second-largest electronic currency with a market cap of around $35,000,000.

Client

Litecoin is a free software project released under the MIT/X11 license, which allows you to run, modify and copy the software according to your needs. If you wish, you may also distribute modified versions of the software.

The software is released in a completely transparent form, and users can independently verify the binary version and the corresponding source code.

Mining Pool

Litecoin needs to be generated through "mining by miners". Mining is done through hashing by computer graphics cards. If the value of "explosion" is calculated, Then the system will reward 50 Litecoins at one time. Currently, the computing power of Litecoin is growing rapidly. Miners can no longer dig mines through several computers, so they need to join the mining pool. The mining pool gathers all the computing power of everyone. It is estimated that The probability of "explosion" value is greater.

The more famous mining pools currently include: BTCC (formerly Bitcoin China) mining pool, waltc.net fish pool (F2POOL), WeMineLTC, Coinotron, SilverFish, LiteGuardian, LitecoinPool.org, etc. But currently the one with the highest income is F2POOL, which recently launched Litecoin theoretical income + mining pool subsidy 10% = your actual income, which has attracted the attention of many miners and the industry.

Exchange rates for the world's major active digital currencies

Currencies

Symbols

Issue time

Author

Active

Official website

Market capitalization

Bitcoin basics

Bitcoin

BTC

p>

2009

SatoshiNakamoto

is

bitcoin/org

~$24.3 billion

Yes

SHA-256

Litecoin

LTC

2011

Coblee

p>

Yes

litecoin/org

~$3.6 billion

Yes

Scrypt

Data Blockchain

The Litecoin blockchain is capable of handling larger transaction volumes than its competitor, Bitcoin. Since data blocks are generated more frequently, the network can support more transactions without the need to modify the software in the future.
As a result, merchants can get faster transaction confirmations and still be able to wait for more transaction confirmations when selling large-ticket items.

Market evaluation In fact, digital virtual currencies are far from the above. The American "Forbes" magazine listed the top 30 virtual currencies in the market according to the total market value and price of virtual currencies as of 10 a.m. local time on the 27th. France Finance Network and "Venture Post" stated that the currently traded virtual currencies There are at least 60 species. "Forbes" reported that Bitcoin ranks first in market value and unit price, and the winner is Litecoin designed by former Google programmer Li Qiwei. In the past week as of the 27th, Litecoin has The price of the currency rose rapidly from US$6 to US$26, a considerable increase. Ranking third to fifth in total market capitalization are Peercoin, Famous Coin and Prime Coin. The report calculated the 24-hour increase as of the 27th. Almost all of the 30 currencies rose, with Quark Coin having the largest increase, reaching 278.55%. The report also said that almost all virtual currencies have ridden in the current Bitcoin rally, but most of them are operating in dismal conditions. There are 8 companies with a total market value of less than 1 million U.S. dollars, and as many as 19 companies with a unit price of less than 1 U.S. dollars.

④ How to withdraw PeerCoin

PeerCoin can be withdrawn only when the withdrawal conditions are met. After the user opens this software, he can select the task and complete it. After the user enters the task details page, he can see the reward amount of the task. Some tasks are directly rewarded with cash rewards of 1 yuan or 2 yuan, and some tasks are rewarded with point coins. exchange. On the withdrawal page, you can see that you can withdraw money if you meet 20 yuan. You can earn anywhere from a few dozen yuan to a hundred yuan a day, or a thousand yuan a month. If you are very popular, you must persist in completing the corresponding tasks every day.

⑤ Introduction to common consensus algorithms

In an asynchronous system, state replication is required between hosts to ensure that each host reaches a consistent state consensus. In an asynchronous system, failures may occur between hosts, so a fault-tolerant protocol needs to be defined in the asynchronous network, which is unreliable by default, to ensure that each host reaches a safe and reliable state consensus.

The consensus algorithm is actually a set of rules, sets a set of conditions, and selects representative nodes. In the blockchain system, there are many such screening schemes, such as in the public chainPOW, PoS, DPOS, etc. In permissioned chains or private chains that do not require a currency system, absolute trust of nodes and high efficiency requirements cannot be provided by the public chain consensus algorithm. For such blockchains, traditional consistency Consensus algorithms have become the first choice, such as PBFT, PAXOS, RAFT, etc.

Contents

1. BFT (Byzantine Fault Tolerance Technology)

2. PBFT (Practical Byzantine Fault Tolerance Algorithm)

3. PAXOS < /p>

4. Raft

5. POW (Proof of Work)

6. POS (Proof of Stake)

7. DPOS (Delegation Proof of Stake)

8. Ripple

Byzantine error technology is a type of fault-tolerant technology in the field of distributed computing. The Byzantine hypothesis is the unpredictable behavior of computers and networks due to hardware errors, network congestion or outages, and malicious attacks. Byzantine fault tolerance is used to handle this abnormal behavior and meet the specifications of the problem to be solved.

A Byzantine fault-tolerant system is a system with n nodes. The entire system satisfies the following conditions for each request:

1) All non-Byzantine nodes use the same input information to generate The same result;

2) If the input information is correct, then all non-Byzantine nodes must receive this information and calculate the corresponding results.

Commonly used assumptions in Byzantine systems include:

1) The behavior of Byzantine nodes can be arbitrary, and Byzantine nodes can collude with each other;

2 ) Errors between nodes are irrelevant;

3) Nodes are connected through an asynchronous network. Messages in the network may be lost, out of order, and arrive delayed, but most protocols assume that messages are It can be conveyed to the destination within the time;

4) The information passed between servers can be sniffed by a third party, but it cannot tamper with or forge the content of the information and verify the integrity of the information.

Byzantine fault tolerance lacks practicality due to its theoretical feasibility. In addition, it also requires additional clock synchronization mechanism support. The complexity of the algorithm also increases exponentially with the increase of nodes.

Practical Byzantine Fault Tolerance reduces the operational complexity of Byzantine protocols from exponential level to polynomial level.

PBFT is a state machine replica replication algorithm, that is, the service is modeled as a state machine, and the state machine replicates at different nodes in the distributed system. PBFT requires joint maintenance of a state. Three basic types of protocols need to be run, including consistency protocols, checkpoint protocols, and view replacement protocols.

1consistency agreement. The consistency protocol contains at least several stages: request, sequence number allocation (pre-prepare) and response (reply), and may include mutual interaction (prepare), sequence number confirmation (commit) and other stages.

In the PBFT communication model, each client's request needs to go through 5 stages. Since the client cannot obtain any server running status information from the server, whether an error occurs on the master node in PBFT can only be monitored by the server. If the server cannot complete the client's request for a period of time, the view replacement protocol will be triggered.

The basic process of the entire protocol is as follows:

1) The client sends a request to activate the service operation of the master node.

2) When the master node receives the request, it starts a three-phase protocol to broadcast the request to each slave node.

[2.1] In the sequence number allocation stage, the master node assigns a sequence number n to the request, broadcasts the sequence number allocation message and the client's request message m, and constructs a PRE-PREPARE message to each slave node;

[2.2] In the interaction phase, the slave node receives the PRE-PREPARE message and broadcasts the PREPARE message to other service nodes;

[2.3] In the sequence number confirmation phase, each node performs the request and sequence in the view After verification, broadcast the COMMIT message, execute the received client request and respond to the client.

3) The client waits for responses from different nodes. If m+1 responses are the same, the response is the result of the operation.

PBFT is generally suitable for private chains and consortium chains that require strong consistency. For example, in the blockchain Hyperledger project led by IBM, PBFT is an optional consensus protocol. In Hyperledger's Fabric project, the consensus module is designed as a pluggable module and supports consensus algorithms such as PBFT and Raft.

In some distributed scenarios, the assumptions do not need to consider Byzantine faults, but only deal with general crash faults. In this case, it will be more efficient to adopt protocols such as Paxos. . PAXOS is a consensus algorithm based on message passing and highly fault-tolerant.

There are three types of roles in PAXOS: Proposer, Acceptor and Learner. The main interaction process is between Proposer and Acceptor. The algorithm process is divided into two stages:

phase 1

a) The proposer sends prepare messages to more than half of the acceptors in the network

b) The acceptor normally replies to the promise message

phase 2

a) When there are enough acceptors to reply to the promise message, the proposer sends the accept message

b) Under normal circumstances, the acceptor replies to the accepted message

The flow chart is shown in the figure:

The PAXOS protocol is used in WeChat PaxosStore, and the Paxos protocol process is called billions of times every minute.

Paxos is a protocol designed by Lamport to maintain the consistency of distributed systems. However, because Paxos is very complex and difficult to understand, various implementations and variants have emerged. Raft is a more understandable consensus algorithm proposed by Stanford and is intended to replace the currently widely used Paxos algorithm.

Raft was originally a consensus algorithm for managing replicated logs. It is a strong consensus protocol that achieves consensus under non-Byzantine failures. The consensus process of Raft is as follows: First, a leader is elected. The leader receives accounting requests from the client, completes accounting operations, generates blocks, and copies them to other accounting nodes. The leader has complete management and accounting rights. For example, the leader can decide whether to accept new transaction record items without considering other accounting nodes. The leader may fail or lose contact with other nodes. At this time, a new leader will be re-elected.

In Raft, each node will be in one of the following three states:

(1) Follower: All nodes start in the follower state. If the leader message is not received, it will become the candidate state;

(2) Candidate: It will "solicit votes" from other nodes. If it gets the majority of votes, it will become the leader. This process is called Leader Election;

(3) Leader: All modifications to the system will first go through the leader. A log entry will be written for each modification. The process after the leader receives the modification request is as follows: This process is called Log Replication

1) Copy the log to all follower nodes

2) When most nodes respond Only submit the log

3) Notify allThe follower node log has been submitted

4) All followers have also submitted logs

5) The entire system is now in a consistent state

The Raft phase is mainly divided into two , first is the leader election process, and then normal operations are performed based on the elected leader, such as log replication, accounting, etc.

(1) Leader election

When the follower does not receive the message from the leader within the election time, it will transition to the candidate state. In the Raft system:

1) Any server can become a candidate as long as it sends a request to other server followers to elect itself.

2) If other servers agree, issue OK. If a follower goes down during this process and does not receive an election request, the candidate can choose himself at this time. As long as a majority of N/2+1 votes is reached, the candidate can still become the leader.

3) In this way, the candidate becomes the leader, and it can issue instructions to voters, namely followers, such as accounting.

4) Notification of accounting in the future through heartbeat messages.

5) Once the leader collapses, one of the followers will become a candidate and issue an invitation to vote.

6) After the follower agrees, it becomes the leader and continues to undertake guidance work such as accounting.

(2) Log replication

The accounting steps are as follows:

1) Assume that the leader has been elected, and the client sends a message to add a log. Requirements;

2) The leader requires followers to comply with his instructions and append this new log content to their respective logs;

3) Most follower servers write transaction records into the ledger After confirming that the addition is successful, a confirmation success message is sent;

4) In the next heartbeat message, the leader will notify all followers to update the confirmed items.

Repeat the above process for each new transaction record.

During this process, if a network communication failure occurs and the leader cannot access most followers, the leader can only normally update the follower servers it can access. Since most server followers do not have a leader, they will re-elect a candidate as the leader, and then this leader will act as a representative to deal with the outside world., if the outside world requires it to add new transaction records, the new leader will notify most followers according to the above steps. When network communication is restored, the original leader becomes a follower. During the disconnection stage, any updates from the old leader cannot be considered confirmed and must all be rolled back to receive new updates from the new leader.

In a decentralized ledger system, each node joining the system must keep a complete ledger, but each node cannot keep accounts at the same time because the nodes are in different environments and receive different Information, if recorded at the same time, will inevitably lead to inconsistencies in the ledger. Therefore, it is decided at the same time which node has the accounting right.

In the Bitcoin system, a computing power competition takes place approximately every 10 minutes. The winner of the competition will obtain the right to keep accounts and synchronize new ledger information to other nodes.

The main feature of PoW systems is the asymmetry of computing. The working end has to do a certain amount of difficult work to get a result, but the verifier can easily use the results to check whether the working end has done the corresponding work. The requirement of this workload is to connect an integer value string called nonce after a certain string, and perform a SHA256 hash operation on the connected string. If the hash result obtained (expressed in hexadecimal form ) starts with several 0s, then the verification passes.

If any node in the Bitcoin network wants to generate a new block and write it into the blockchain, it must solve the PoW problem in the Bitcoin network. The three key elements are the workload proof function, block and difficulty value. The workload proof function is the calculation method of this question. The block determines the input data of this question, and the difficulty value determines the amount of calculation required for this question.

(1) The workload proof function is SHA256

Bitcoin blocks consist of block headers and the transaction list included in the block. The block header, which has a fixed length of 80 bytes, is the input string used for Bitcoin’s proof of work.

(2) Difficulty adjustment occurs independently and automatically in each complete node. Every 2016 blocks, all nodes will automatically adjust the difficulty according to a unified formula. If the block generation rate is faster than 10 minutes, the difficulty will be increased, and if the block generation rate is slower than 10 minutes, the difficulty will be decreased.

The formula can be summarized as: new difficulty value = old difficulty value × (time spent in the past 2016 blocks/20160 minutes)

Proof of work needs to have a target value. The calculation formula of the target value (Target) of Bitcoin’s proof of work: Target value=Maximum target value/difficulty value

The maximum target value is a constant value:

The size of the target value is inversely proportional to the difficulty value. The achievement of Bitcoin's proof of work is that the block hash value calculated by the miner must be less than the target value.

(3) Can PoW solve the Byzantine Generals Problem

Bitcoin’s PoW consensus algorithm is a probabilistic Byzantine Agreement (Probabilistic BA)

When When the dishonest computing power is less than 50% of the total computing power of the network, and the mining difficulty is relatively high (when a block is produced in about 10 minutes), the concept of Bitcoin network reaching consistency will appear as the number of confirmed blocks increases. Exponential increase. But when the dishonest computing power reaches a certain scale, not even close to 50%, Bitcoin's consensus algorithm cannot guarantee correctness, that is, it cannot guarantee that most blocks are provided by honest nodes.

Bitcoin’s consensus algorithm is not suitable for private chains and consortium chains. The reason is first of all that it is an eventual consistency consensus algorithm, not a strong consistency consensus algorithm. The second reason is its low consensus efficiency.

Extended knowledge: Consistency

Strict consistency can be achieved under the ideal condition that the system does not experience any failures and communication between all nodes does not require any time. . At this time, the entire system is equivalent to a machine. In reality, it is impossible to achieve.

Strong consistency, when the update operation is completed in the distributed system, any multiple processes or threads accessing the system will obtain the latest value.

Weak consistency means that the system does not guarantee that subsequent accesses by processes or threads will return the latest updated value. After the data is successfully written, the system does not promise that the latest written value can be read immediately, nor does it specifically promise how long it will take to read it. But we will try our best to ensure that it is after a certain time level (seconds). The data can be brought to a consistent state.

Eventual consistency is a specific form of weak consistency. The system guarantees that if there is no subsequent update, the system will eventually return the value of the last update operation. In other words, if it is required to access the updated data after a period of time, it is eventual consistency.

In the PoS mode, there is a term called coin age. Each coin generates 1 coin age every day. For example, if you hold 100 coins for a total of 30 days, then, at this time, you The currency age is 3000. At this time, if you find a PoS block, your currency age will be cleared to 0. Every time you are cleared of 365 coins, you will get 0.05 coins in interest from the block (assuming that the interest can be understood as an annual interest rate of 5%), then in this case, interest = 3000* 5% / 365 = 0.41 coins. This is very interesting. Holding coins has interest.

Peercoin is the first currency to adopt proof of stake. , Peitecoin’s proof-of-stake mechanism combines the concepts of randomization and currency age. Coins that have not been used for at least 30 days can participate in the competition for the next block. The longer and larger the currency set, the greater the possibility of signing the next block. . Once the equity of the coin is used to sign a block, the coin age will be reset to zero, so that you must wait at least 30 days before signing another block.

Although the PoS mechanism takes into account the shortcomings of PoW, choosing based on the equity balance will lead to the richest man's account having greater power and possibly controlling the accounting rights. The emergence of the Delegated Proof of Stake (DPoS) mechanism is precisely based on solving the shortcomings of the PoW mechanism and the PoS mechanism.

Bitshare is a type of cryptocurrency that uses the DPoS mechanism. Its principle is to let everyone who holds BitShares vote, resulting in 101 representatives. We can understand it as 101 super nodes or mining pools, and the rights of these 101 super nodes are completely equal to each other. of. If a representative fails to perform their duties (fails to generate a block when it is their turn), they will be removed from the list and a new supernode will be elected to replace them.

BitShares introduces the concept of witnesses. Witnesses can generate blocks, and everyone who holds BitShares can vote for witnesses. Candidates who get the top N (N is usually defined as 101) candidates in the total number of consent votes can be elected as witnesses. The number of elected witnesses (N) must meet: at least half of the participating voters believe that N has been fully decentralized. .

The candidate list of witnesses is updated every maintenance cycle (1 day). The witnesses are then randomly arranged, and each witness has 2 seconds of permission time to generate a block in order. If the witness cannot generate a block in a given time slice, the block generation permission is given to the witness corresponding to the next time slice. .

BitShares has also designed another type of election, the representative election. Elected representatives have the privilege of proposing changes to network parameters, including transaction fees, block sizes, witness fees, and block intervals. If a majority of representatives agree to the proposed changes, shareholders have a two-week review period during which they can remove the representatives and annul the proposed changes. This design ensures that representatives technically do not have the right to directly modify parameters and that all changes to network parameters ultimately require the consent of shareholders.

Ripple is an open source payment protocol based on the Internet. In Ripple's network, transactions are initiated by the client (application) and pass through the tracking node or validating node. Broadcast the transaction to the entire network.

ChaseThe main function of the tracking node is to distribute transaction information and respond to the client’s ledger requests. In addition to all the functions of the tracking node, the verification node can also add new ledger instance data to the ledger through the consensus protocol.

Ripple's consensus occurs between verification nodes. Each verification node is pre-configured with a list of trusted nodes, called UNL (Unique Node List). Nodes on the list can vote on the transaction. Every few seconds, the Ripple network will carry out the following consensus process:

1) Each verification node will continue to receive transactions sent from the network. After verification with the local ledger data, illegal transactions will be directly verified Discarded, legal transactions will be summarized into a transaction candidate set (candidate set). The transaction candidate set also includes transactions left over from the previous consensus process that could not be confirmed.

2) Each verification node sends its own transaction candidate set as a proposal to other verification nodes.

3) After the verification node receives a proposal from other nodes, if it is not from a node on UNL, it will ignore the proposal; if it is from a node on UNL, it will compare the transactions in the proposal If there is the same transaction as the local transaction candidate set, the transaction will receive one vote. Within a certain period of time, when a transaction receives more than 50% of the votes, the transaction enters the next round. Transactions that do not exceed 50% will be left for the next consensus process to be confirmed.

4) The verification node sends transactions with more than 50% of the votes as proposals to other nodes, and at the same time increases the threshold of the required votes to 60%, and repeats steps 3) and 4) until the threshold reaches 80% .

5) The verification node formally writes the transactions confirmed by 80% UNL nodes into the local ledger data, which is called the Last Closed Ledger, which is the last (latest) status of the ledger.

In Ripple's consensus algorithm, the identities of participating voting nodes are known in advance. This consensus algorithm is only suitable for permissioned chain scenarios. The Byzantine Fault Tolerance (BFT) capability of the Ripple consensus algorithm is (n-1)/5, which means it can tolerate Byzantine errors in 20% of the nodes in the entire network without affecting the correct consensus.

In the blockchain network, due to different application scenarios, the design goals are different, and different blockchain systems use different consensus algorithms. Generally speaking, in the case of private chains and consortium chains, there are strong requirements for consistency and correctness. Generally speaking, a consensus algorithm with strong consistency should be used. And in the public chainIn this case, it is usually impossible to achieve 100% consistency and correctness, and the consensus algorithm of eventual consistency (Eventual Consistency) is usually used.

The choice of consensus algorithm is highly related to the application scenario. Trusted environments use paxos or raft, permissioned alliances can use pbft, and non-permissioned chains can be pow, pos, ripple consensus, etc., based on the trust of the counterparty. Degree classification, free choice of consensus mechanism.

⑥ How to get Qidian Point Coins

Recharge

⑦ How much can you withdraw with 1,000 Qidian Point Coins

10 yuan. "Diankai Qingzhi Diankaihei" is a comprehensive social APP that mainly focuses on teaming up and opening black games. In the method of using the software, we learned that 10 yuan can be withdrawn for 1,000 spreads without any point coins. Players need to bind before withdrawing money. Keep an eye on bank cards.

⑧ How many diamonds are equal to a black dot coin?

1 dot coin is equal to 0.1 diamonds.
1 Peip Coin is equal to 0.1 Diamond. Peip Coin is the virtual currency in "Dian Dian Kaihei", which can purchase many props. 1 yuan is equal to 100 Peip Coins, which is equal to 10 diamonds.
"Diandiankaihei" is a comprehensive social APP focusing on game team formation.

⑨ How to calculate the results of Zhilian Blockchain Financial Application Practice Platform

1. Proof of Work (PoW)
Bitcoin proposed by Satoshi Nakamoto in 2009 ( Bitcoin) is the earliest application of blockchain technology. It uses PoW as the consensus algorithm. Its core idea is to obtain accounting rights and Bitcoin rewards through hash computing power competition between nodes. In PoW, different nodes compete to calculate the solution to a mathematical problem based on specific information. This mathematical problem is difficult to solve, but it is easy to verify the results. The node that solves the mathematical problem first can create the next block and obtain a certain amount. coin rewards. Satoshi Nakamoto used the HashCash[4] mechanism to design this mathematical problem in Bitcoin. This section will take the PoW algorithm used by Bitcoin as an example. The consensus steps of PoW are as follows:
The node collects the transactions to be confirmed on the entire network after the previous block was generated, and records the eligible transactions into the transaction memory pool. , then update and calculate the value of the Merkle root of the transaction in the memory pool, and write it into the block header;
In the block header, fill in the block version number and previous block as shown in Table 1.1 The hash value, timestamp, current target hash value and random number and other information;
Table 1.1 Block header information
The random number nonce takes a value between 0 and 232, and the block header Hash calculation is performed on the local information. When the hash value is less than or equal to the target value, the block is packaged and broadcast, and accounting is completed after verification by other nodes;
If a hash that meets the requirements cannot be calculated within a certain period of time value, repeat step 2. If other nodes have completed the calculation during the calculation process, start from step 1restart.
The average time it takes for Bitcoin to generate a block is 10 minutes. If you want to maintain this speed, you need to adjust the target value (difficulty) based on the current computing power of the entire network [5]. Difficulty is a description of the difficulty of calculating a block that meets the requirements. When calculating blocks of the same height, the difficulty of all nodes is the same, which also ensures the fairness of mining. The relationship between difficulty and target value is:
Difficulty value = maximum target value/current target value (1.1)
The maximum target value and the current target value are both 256 bits in length, and the maximum target value is a difficulty of 1 The target value at that time is 2224. Assume that the current difficulty is, the computing power is, the current target value is, and the average calculation time to find a new block is, then
According to the design of Bitcoin, the system will adjust once every 2016 blocks are generated (about 2 weeks) Current target value. The node calculates the adjusted difficulty value according to formula (1.4) based on the actual production time of the first 2016 blocks. If the actual production time is less than 2 weeks, increase the difficulty value; if the actual time production is greater than 2 weeks, decrease the difficulty value. value. According to the longest chain principle, without the need for nodes to synchronize difficulty information, all nodes will get the same difficulty value after a certain period of time.
In a blockchain using PoW, due to network delays and other reasons, when two blocks of the same height are generated close to each other, a fork may occur. That is, different miners have calculated blocks that meet the requirements of a certain height and have been confirmed by nodes close to them. The nodes in the entire network will continue to mine based on the block received first based on the time when the block was received. . In this case, whichever block's subsequent blocks appear first will become longer, and this block will be included in the main chain. Nodes mining on the non-main chain will switch to the main chain to continue mining. .
The PoW consensus algorithm uses computing power as the basis for competition for accounting rights and workload as a guarantee of security. All miners follow the longest chain principle. The newly generated block contains the hash value of the previous block. All existing blocks form a chain. The length of the chain is proportional to the workload. All nodes trust the longest blockchain. If an organization acquires enough computing power, it can launch an attack on the Bitcoin network. When an attacker has enough computing power, he can calculate the latest block first and thus master the longest chain. At this time, most of the blocks on the Bitcoin main chain are generated by it. He can deliberately refuse to confirm certain transactions and carry out double-spend attacks. This will affect the credibility of the Bitcoin network, but this behavior will also causing losses to the attacker. By solving the one-dimensional random walk problem, the relationship between the probability of successful attack by malicious nodes and the computing power can be obtained:
Figure 1.1 The attacker’s computing power and the probability of successful attack
2. Proof of Stake (PoS)
As more and more people participate in Bitcoin mining, many problems of PoW gradually emerge. For example, as the competition for computing power rapidly intensifies, the energy consumed to obtain tokens increases significantly, and the accounting rights gradually increase.Concentrate into “mining pools” that gather a large amount of computing power [6-9]. To this end, researchers are trying to use new mechanisms to replace proof of work. The concept of PoS was mentioned in the earliest Bitcoin project, but was not used due to reasons such as robustness. The earliest application of PoS is PPCoin. PoS proposes the concept of currency age. Coin age is the accumulation of the product of the held tokens and the holding time. The calculation is as shown in formula (1.4). Utilizing currency age competition to replace computing power competition enables blockchain proof to no longer rely solely on workload, effectively solving the resource waste problem of PoW.
The holding time is the time since a certain currency was last traded on the network. The longer the currency held by each node, the more rights it has in the network. At the same time, the holder of the currency will also Obtain a certain amount of income based on the age of the currency. In the design of Peercoin, it is not completely separated from the proof of work. Obtaining the accounting rights of the PoS mechanism also requires simple hash calculation:
where proofhash is composed of weight factor, unconsumed output value and current time The fuzzy and hash values ​​obtained also limit the computing power of each node. It can be seen that the currency age is inversely proportional to the difficulty of calculation. In PoS, the security of the blockchain increases as the value of the blockchain increases. Attacks on the blockchain require attackers to accumulate a large amount of currency age, which means they need to hold a large amount of digital currency for a long enough time. This also greatly increases the difficulty of the attack. Compared with PoW, blockchain systems using PoS may face Long Range Attack and Nothing at Stake.
In addition to Peercoin, many coins also use PoS, but they have different methods for allocating accounting rights. For example, Nxt and BlackCion combine the rights owned by nodes and use random algorithms to allocate accounting rights. Ethereum is also gradually adopting PoS instead of PoW.
3. Delegated Proof of Stake (DPoS)
At the beginning of the design of Bitcoin, it was hoped that all mining participants would use CPUs for calculations, and the computing power would match the nodes, so that each node would have enough opportunities to participate. Blockchain decision-making. With the development of technology, a large number of mining machines using GPU, FPGA, ASIC and other technologies have emerged. The computing power is concentrated in the hands of participants with a large number of mining machines, while the opportunities for ordinary miners to participate are greatly reduced.
In a blockchain using DPoS, each node can vote to select representatives based on the share rights it owns. The n nodes in the entire network that participate in the election and receive the most votes gain accounting rights in a predetermined order. Produce blocks in sequence and receive certain rewards for doing so. Representative nodes that succeed in the election need to pay a certain amount of deposit and must ensure online time. If the node that should generate blocks at a certain moment fails to perform its duties, he will be disqualified as a representative, and the system will continue to vote to elect a new representative. to replace him.
All sections in DPoSEach node can independently choose the object of voting, and the elected representatives are accounted for in order, which saves computing resources compared with PoW and PoS. Moreover, there are only a limited number of consensus nodes, and the efficiency has also been improved. Moreover, each participating node has the right to vote. When there are enough nodes in the network, the security and decentralization of DPoS are also guaranteed.
4. Practical Byzantine Fault Tolerance Algorithm (PBFT)
In the PBFT algorithm, all nodes run under the same configuration and have one master node, and other nodes serve as backup nodes. The primary node is responsible for sorting client requests and sending them to the backup node in order. There is the concept of View, and in each view, all nodes process messages normally. But when the backup node detects an exception on the primary node, it will trigger the View Change mechanism to replace the next numbered node as the primary node and enter a new view. The main process in PBFT from the client sending a request to receiving the reply is shown in Figure 4.1 [10] [11]. Information is exchanged between servers three times. The whole process includes the following five stages:
Figure 4.1 PBFT execution process
At present, Byzantine fault-tolerant algorithms represented by PBFT are used by many blockchain projects. In the alliance chain, the PBFT algorithm was first adopted by the Hyper ledger Fabric project. Hyperledger Fabric adopts the PBFT consensus algorithm in version 0.6. The authorization and endorsement functions are integrated into the consensus nodes. All nodes are consensus nodes. This design results in an overly heavy burden on the nodes, which has a great impact on TPS and scalability. Impact. Versions after 1.0 have separated the functions of the nodes. The nodes are divided into three endorsement nodes (Endorser), ordering nodes (Orderer) and block nodes (Committer). The functions of the nodes have been separated, which has improved the efficiency to a certain extent. Consensus efficiency.
The Tendermint[12] algorithm used by the Cosmos project combines the PBFT and PoS algorithms, and selects some consensus nodes for BFT consensus through token mortgage. It weakens the asynchronous assumption and incorporates locks on the basis of PBFT. The concept of consensus nodes in a partially synchronized network can reach consensus through two-phase communication. The system can tolerate 1/3 of failed nodes without causing forks. Based on Tendermint, Hotstuff [13] integrates the block chain structure of the blockchain with each stage of BFT. In each stage, the signature confirmation of the previous block and the construction of the new block are carried out simultaneously, making the algorithm realize Even simpler, Hotstuff also uses threshold signatures [14] to reduce the message complexity of the algorithm.
5. Paxos and Raft
The consensus algorithm is a set of mechanisms designed to ensure the accuracy and consistency of stored information. in traditionIn distributed systems, the most commonly used consensus algorithm is the Paxos-based algorithm. After the Byzantine Generals Problem [3] was raised, Lamport proposed the Paxos algorithm in 1990 to solve the system consistency problem under specific conditions. Lamport reorganized and published the Paxos paper [15] in 1998 and conducted a research on Paxos in 2001. was re-briefed [16]. Subsequently, Paxos dominated the field of consensus algorithms and was adopted by many companies, such as Tencent's Phxpaxos, Alibaba's X-Paxos, Amazon's AWS's DynamoDB, and Google's MegaStore [17]. This type of algorithm can quickly complete data synchronization in a distributed system when the number of nodes is limited and relatively trustworthy, while being able to tolerate crash faults. That is to say, in traditional distributed systems, there is no need to consider malicious tampering of data by participating nodes, and only need to be able to tolerate downtime errors on some nodes. However, the Paxos algorithm is too theoretical and is very difficult to understand and implement in engineering. Ongaro et al. published a paper in 2013 proposing the Raft algorithm [18]. Raft has the same effect as Paxos and is more convenient for engineering implementation.
The leader occupies an absolutely dominant position in Raft, and the absolute security of server nodes must be ensured. Once the leader is maliciously controlled, huge losses will be caused. And the transaction volume is limited by the maximum throughput of the node. Currently, many alliance chains use the Raft algorithm to improve consensus efficiency without considering Byzantine fault tolerance.
6. Consensus algorithm combined with VRF
In the existing alliance chain consensus algorithm, if the number of nodes participating in the consensus increases, the communication between nodes will also increase, and the performance of the system will also be affected. If some nodes are selected from many candidate nodes to form a consensus group for consensus and the number of consensus nodes is reduced, the performance of the system can be improved. But this will reduce security, and the higher the proportion of malicious nodes among candidate nodes, the higher the probability that the selected consensus group will not function properly. In order to select a consensus group that can operate normally from the candidate nodes and ensure the high availability of the system, on the one hand, it is necessary to design an appropriate random election algorithm to ensure the randomness of the selection and prevent malicious nodes from attacking the system. On the other hand, it is necessary to increase the proportion of honest nodes among candidate nodes and increase the probability of honest nodes being selected into the consensus group.
Currently, public chains are often based on PoS algorithms. Mortgage tokens increase the entry threshold for consensus nodes, increase the cost of malicious nodes through economic games, and then use random election algorithms among some nodes that pass the screening. Randomly select some nodes from qualified candidate nodes for consensus.
Dodis et al. proposed Verifiable Random Functions (VRF) in 1999 [19]. verifiably randomFunction is an application of zero-knowledge proof, that is, in the public-private key system, the person holding the private key can use the private key and a piece of known information to generate a random number according to specific rules, without revealing the private key. The person holding the private key can prove to others the correctness of the random number generation. VRF can be constructed using RSA or elliptic curves. In 2002, Dodis et al. proposed a verifiable random function construction method based on the Diffie-Hellman difficulty problem [20]. Currently, verifiable random functions are widely used in the field of key transmission and blockchain. It has applications in many fields [21]. The specific process of the verifiable random function is as follows:
In the public chain, VRF has been applied in some projects. VRF is mostly combined with the PoS algorithm. All nodes that want to participate in the consensus pledge certain tokens to become candidate nodes. , and then randomly select some consensus nodes from many candidate nodes through VRF. New nodes in the Zilliqa network must first perform PoW. Existing nodes in the network verify the new node's PoW and authorize it to join the network. The consensus algorithm VBFT designed by the blockchain project Ontology combines VRF, PoS and BFT algorithms. VRF randomly selects consensus nodes among many candidate nodes and determines the order of consensus nodes, which can reduce the impact of malicious forks on the blockchain system. The impact ensures the fairness and randomness of the algorithm. Algorand[22] proposed by Turing Award winner Micali et al. combines PoS and VRF. Nodes can become candidate nodes by pledging tokens, and then select some nodes to form a consensus committee through the non-interactive VRF algorithm, and then this will Some nodes implement a consensus algorithm similar to PBFT and are responsible for rapid verification of transactions. Algorand can ensure the normal operation of the system when the nodes are honest nodes. Ouroboros[23] proposed by Kiayias et al. introduced VRF in the second version Praos[24] to replace pseudo-random numbers to select master nodes in shards. Taking the VRF algorithm used by Algorand and other algorithms as an example, the main process is as follows:
In the VRF designed and used in public chains, the probability of a node being selected as an accounting node is often positively related to the tokens it holds. The consensus node range of the public chain cannot be determined in advance. All nodes that meet the token holding conditions may become consensus nodes. The system needs to select some nodes among the nodes with random number and participation for consensus. Compared with the public chain, the number of nodes participating in the consensus of the alliance chain is limited and the nodes are known. In this case, the nodes of the alliance chain can interact through the known node list, which can effectively prevent possible problems when designing the VRF of the public chain. to the witch attack problem.
7. Formula algorithm combined with sharding technology
Sharding technology is a technology in databases that cuts the data in the database into multiple parts and then stores them in multiple servers. Improve server search through distributed storage of dataperformance. In blockchain, sharding technology is a mechanism that allocates transactions to multiple consensus groups composed of node subsets for confirmation, and finally aggregates all results for confirmation. Sharding technology already has some applications in blockchain, and many blockchains have designed their own sharding solutions.
Luu et al. proposed the Elastico protocol in 2017, which was the first to apply sharding technology to the blockchain [25]. Elastico first competes to become the accounting node in the network through the PoW algorithm. These nodes are then assigned to different shard committees according to predetermined rules. Each sharding committee internally executes traditional Byzantine fault-tolerant consensus algorithms such as PBFT, and packages and generates transaction sets. After more than one node signs the transaction set, the transaction set is submitted to the consensus committee. After verifying the signatures, the consensus committee finally packages all the transaction sets into blocks and records them on the blockchain.
Elastico verifies the usability of sharding technology in blockchain. Within a certain scale, sharding technology can scale throughput nearly linearly. However, Elastico uses PoW to elect consensus nodes, which also causes the random number generation process and PoW competition for consensus nodes to take too long, resulting in high transaction delays. Moreover, the PBFT algorithm used within each shard has high communication complexity. Latency is also high when the number of nodes in a single shard is high.
Based on Elastico, Kokoris-Kogias et al. proposed OmniLedger [26], which used an encrypted lottery protocol to replace PoW to select validator groups, and then classified the validators into different shards through the RandHound protocol [27]. OmniLedger. OmniLedger still uses the PBFT-based consensus algorithm as the consensus algorithm in sharding [28], and introduces the Atomix protocol to handle cross-shard transactions. The communication complexity between nodes during the consensus process is high. When the number of nodes in a shard increases and cross-shard transactions increase, system TPS will drop significantly.
Wang et al. proposed Monoxide in 2019[29]. Introduced sharding technology into the PoW blockchain system and proposed the Chu ko-nu mining algorithm, which solved the problem of dispersion of computing power caused by sharding, allowing each miner to work on different locations at the same time. Sharding through sharding improves the TPS of PoW without reducing security.

⑩ What are the gold coins clicked to open black for?

The gold coins clicked to open black can be used to purchase props. According to the query of relevant information, Peip Coin is the virtual currency in the game "Dian Dian Kaihei". It can purchase many props. 1 yuan is equal to 100 Peip Coins, which is equal to 10 diamonds.