Go语言PoS共识的一个简单实现

最新推荐文章于 2024-04-23 23:27:26 发布
最新推荐文章于 2024-04-23 23:27:26 发布
阅读量302 收藏 1
点赞数
文章标签： golang 区块链 共识算法 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/john_hai/article/details/129242851
版权

以太坊 Beacon Chain 是以太坊2.0协议的一部分，它是以太坊区块链的新版本。以太坊2.0旨在提高以太坊网络的性能和可扩展性，以满足日益增长的用户需求。

以太坊 Beacon Chain 是一个全新的区块链，它运行一个新的共识机制，称为Proof of Stake（PoS）共识机制。这种机制是通过验证网络中的质押（即锁定）以太币的方式来选择下一个区块的矿工，而不是使用以太坊现有的Proof of Work（PoW）共识机制。

以太坊 Beacon Chain 还引入了一个新的角色，称为验证人。验证人是负责验证交易和创建区块的用户。验证人必须锁定一定数量的以太币作为质押，以确保他们在网络中的行为符合规则。验证人可以获得奖励，如果他们恶意行为将被罚款。

以太坊 Beacon Chain 还将启用分片技术，这意味着网络将被分成许多小的区块链，每个区块链都称为分片。每个分片都可以处理一部分交易，从而提高整个网络的吞吐量和可扩展性。

总的来说，以太坊 Beacon Chain 是以太坊2.0协议的核心，它引入了新的共识机制、新的角色和分片技术，以提高整个以太坊网络的性能和可扩展性。

POS共识是一种基于持有虚拟货币的数量来决定区块链网络中节点的权益和记账权的共识算法。

  1. 创建一个区块链网络节点类，该类应该包含以下属性：

  • 区块链的当前状态，包括最新的区块和未处理的交易列表。

  • 节点的地址和权益值。

  • 节点的公钥和私钥，用于签署交易和验证区块。

  1. 创建一个交易类，该类应该包含以下属性：

  • 交易的发送方和接收方地址。

  • 交易的金额和手续费。

  • 交易的签名和时间戳。

  1. 创建一个区块类，该类应该包含以下属性：

  • 区块的索引、时间戳和前一个区块的哈希值。

  • 区块中的交易列表和随机数。

  • 区块的哈希值和签名。

  1. 实现一个POS共识算法，在该算法中，每个节点的权益值等于其持有的虚拟货币数量。每个节点可以使用其权益值作为随机数来生成一个哈希值，并将其与其他节点的哈希值进行比较。最终，权益值最高的节点将被选为下一个区块的记账节点。

  1. 实现一个区块链网络的验证算法，该算法应该验证每个区块的哈希值和签名，并确保每个区块中的交易是有效的。

 packagemain
 ​
 import (
     "bytes"
 ​
     "crypto/rand"
     "crypto/sha256"
     "fmt"
     "math/big"
     myrand"math/rand"
     "time"
 )
 ​
 const (
     stake  =10// 投注数量
     period=3  // 周期长度
 ​
     difficulty=4
 )
 ​
 typeBlockstruct {
     Index     int
     Timestampstring
     Data      string
     PrevHash  []byte
     Nonce     int
     Hash      []byte
 }
 ​
 func (b*Block) SetHash() {
     timestamp := []byte(b.Timestamp)
     data := []byte(b.Data)
     index := []byte(fmt.Sprintf("%d", b.Index))
     nonce := []byte(fmt.Sprintf("%d", b.Nonce))
     headers :=bytes.Join([][]byte{timestamp, data, index, nonce, b.PrevHash}, []byte{})
     hash :=sha256.Sum256(headers)
     b.Hash=hash[:]
 }
 ​
 typeBlockchainstruct {
     blocks []*Block
 }
 ​
 funcNewBlock(datastring, prevHash []byte, indexint) *Block {
     block :=&Block{
         Index:     index,
         Timestamp: time.Now().String(),
         Data:      data,
         PrevHash:  prevHash,
         Nonce:     0,
     }
     block.SetHash()
     returnblock
 }
 ​
 func (bc*Blockchain) AddBlock(datastring) {
     prevBlock :=bc.blocks[len(bc.blocks)-1]
     newBlock :=NewBlock(data, prevBlock.Hash, prevBlock.Index+1)
     bc.blocks=append(bc.blocks, newBlock)
 }
 ​
 func (bc*Blockchain) LastBlock() *Block {
     returnbc.blocks[len(bc.blocks)-1]
 }
 ​
 funcgenerateNonce() int {
     // maxNonce := big.NewInt(1 << 64)
     // maxNonce := new(big.Int).SetUint64(1 << 64)
     maxNonce :=new(big.Int).SetUint64(^uint64(0))
     nonce, _ :=rand.Int(rand.Reader, maxNonce)
     returnint(nonce.Int64())
 }
 ​
 func (bc*Blockchain) GenerateBlock(datastring) {
     lastBlock :=bc.LastBlock()
     newBlock :=&Block{
         Index:     lastBlock.Index+1,
         Timestamp: time.Now().String(),
         Data:      data,
         PrevHash:  lastBlock.Hash,
         Nonce:     0,
     }
 ​
     for {
         newBlock.Nonce=generateNonce()
         newBlock.SetHash()
 ​
         hashInt :=big.Int{}
         hashInt.SetBytes(newBlock.Hash)
 ​
         ifhashInt.Cmp(big.NewInt(0).Lsh(big.NewInt(1), 256-difficulty)) ==-1 {
             bc.blocks=append(bc.blocks, newBlock)
             // fmt.Printf("Block added: %s\n", newBlock.Hash)
             fmt.Printf("Block added(16进制): %x\n", newBlock.Hash)
 ​
             break
         }
     }
 }
 ​
 // 定义账户结构体
 typeAccountstruct {
     Addressstring
     Balanceint
 }
 ​
 // 定义验证器结构体
 typeValidatorstruct {
     Addressstring
     Stake   int
 }
 ​
 // 定义POS算法函数
 funcPOS(accounts []Account, validators []Validator, datastring) {
     // 选择验证器
     totalStake :=0
     for_, v :=rangevalidators {
         totalStake+=v.Stake
     }
 ​
     chosenValidatorIndex :=-1
     chosenValidatorHash := []byte{}
     chosenValidatorStake :=0
 ​
     fori, v :=rangevalidators {
         ifv.Stake*period>=totalStake*myrand.Intn(period) {
             // 选择当前验证器
             hash :=sha256.Sum256([]byte(fmt.Sprintf("%s%d", v.Address, myrand.Int())))
             ifchosenValidatorIndex==-1||bytes.Compare(hash[:], chosenValidatorHash) ==-1 {
                 chosenValidatorIndex=i
                 chosenValidatorHash=hash[:]
                 chosenValidatorStake=v.Stake
             }
         }
     }
 ​
     chosenValidator :=validators[chosenValidatorIndex]
     fmt.Printf("Chosen Validator(选择验证器): %s, Stake(质押): %d\n", chosenValidator.Address, chosenValidatorStake)
 ​
     // 生成新块
     blockchain :=Blockchain{blocks: []*Block{NewBlock("Genesis Block", []byte{}, 0)}}
     blockchain.GenerateBlock(fmt.Sprintf("%s (Validator: %s, Stake: %d)", data, chosenValidator.Address, chosenValidatorStake))
 ​
     // 更新账户余额
     reward :=chosenValidatorStake*period
     fori, a :=rangeaccounts {
         ifa.Address==chosenValidator.Address {
             accounts[i].Balance+=reward
             fmt.Printf("      获得奖励：账户:%s 余额:%d  reward:%d \n", accounts[i].Address, accounts[i].Balance, reward)
         } else {
             accounts[i].Balance-=stake
             fmt.Printf("      扣除投注质押：账户:%s  余额:%d  reward:%d \n", accounts[i].Address, accounts[i].Balance, stake)
         }
     }
 }
 ​
 funcmain() {
     accounts := []Account{
         {Address: "addr1", Balance: 1000},
         {Address: "addr2", Balance: 1000},
         {Address: "addr3", Balance: 1000},
         {Address: "addr4", Balance: 1000},
         {Address: "addr5", Balance: 1000},
     }
 ​
     validators := []Validator{
         {Address: "addr1", Stake: 5},
         {Address: "addr2", Stake: 5},
         {Address: "addr3", Stake: 5},
     }
 ​
 ​
     POS(accounts, validators, "Transaction 1")
     POS(accounts, validators, "Transaction 2")
     POS(accounts, validators, "Transaction 3")
     POS(accounts, validators, "Transaction 4")
 ​
 }

​

运行结果如下：

 D:\XXXX>go run ./PoS/.
 Chosen Validator(选择验证器): addr2, Stake(质押): 5
 Block added(16进制): 01d3c778080abcfc3edb1f6f5df1d4aebcba1292e8b336e38ab6badd58beb709
       扣除投注质押：账户:addr1  余额:990  reward:10
       获得奖励：账户:addr2 余额:1015  reward:15 
       扣除投注质押：账户:addr3  余额:990  reward:10
       扣除投注质押：账户:addr4  余额:990  reward:10
       扣除投注质押：账户:addr5  余额:990  reward:10
 Chosen Validator(选择验证器): addr3, Stake(质押): 5
 Block added(16进制): 03d82a10862097a041dd813552cfd975c77af48d4e8e1d6bba00ca1c8ed8b2b4
       扣除投注质押：账户:addr1  余额:980  reward:10
       扣除投注质押：账户:addr2  余额:1005  reward:10
       获得奖励：账户:addr3 余额:1005  reward:15
       扣除投注质押：账户:addr4  余额:980  reward:10
       扣除投注质押：账户:addr5  余额:980  reward:10
 Chosen Validator(选择验证器): addr2, Stake(质押): 5
 Block added(16进制): 0fe59ecd0ff214b43235ddf09033382a911399dc617a7a3942ee1e6772a022e4
       扣除投注质押：账户:addr1  余额:970  reward:10
       获得奖励：账户:addr2 余额:1020  reward:15
       扣除投注质押：账户:addr3  余额:995  reward:10
       扣除投注质押：账户:addr4  余额:970  reward:10
       扣除投注质押：账户:addr5  余额:970  reward:10
 Chosen Validator(选择验证器): addr1, Stake(质押): 5
 Block added(16进制): 0c68a6c50f9d983b58f59276130584d5b43637f8bba1a2cf2210b5d79a75ca1b
       获得奖励：账户:addr1 余额:985  reward:15
       扣除投注质押：账户:addr2  余额:1010  reward:10
       扣除投注质押：账户:addr3  余额:985  reward:10
       扣除投注质押：账户:addr4  余额:960  reward:10
       扣除投注质押：账户:addr5  余额:960  reward:10

这段代码的主要目的是演示基于POS算法的区块链。这个POS算法实现的过程中，程序会选出验证器来生成新的块。生成块之后，它会更新参与者的账户余额，以反映他们是否赢得了奖励或扣除了投注的质押。

程序包含三个主要的数据结构：Block，Blockchain和Validator。Block包含块的所有信息。Blockchain是一个块的有序列表。Validator包含验证者的地址和质押量。

在程序中，有一个POS函数。这个函数使用POS算法来选择验证者，生成新的块，以及更新参与者的账户余额。它将accounts数组和validators数组作为参数传入，以及data字符串。accounts数组中包含所有参与者的账户地址和余额。validators数组中包含验证器的地址和质押量。POS函数使用这些参数来选择验证器和更新账户余额。

在程序中，还有其他的函数和常量。generateNonce函数用于生成随机整数。AddBlock和LastBlock函数用于向Blockchain中添加和返回块。NewBlock函数用于创建新的块。stake和period常量定义了投注和周期的数量。difficulty常量定义了挖矿难度。

程序的主函数main()创建了三个账户，三个验证器和一些初始的块。然后，它多次调用POS函数，每次传入一个不同的字符串。在调用POS函数之后，它会打印每个账户的最新余额。这个过程会重复多次，直到程序终止。

john_hai
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
go语言实现PoS共识机制_pos.zip
02-18
系统是利用go语言进行编码的，包含了go程序运行所需的依赖包 操作过程： 1.在一个终端里运行main.go文件 2.打开新的终端，使用nc localhost 9000命令进入9000端口 再输入当前余额以及要记录的消息，等待结果
基于嵌入式的移动公交一卡通POS机的设计与实现
01-28
为了实现IC卡在不同领域的消费，促进电子支付行业的发展，本文对一卡通消费的POS机的实现机理进行研究，提出基于嵌入式的移动公交一卡通POS机的解决方案。对开发过程中的关键技术如无线射频识别技术、移动网络通讯技术进行了深入研究，在硬件上集成无线射频芯片、GPRS通信模块及热敏打印机，在移动POS机上实现公交一卡通消费、账户余额查询、交易数据上传以及交易凭证的打印。经过测试，功能上达到设计目标。
go语言实现工作量证明（POW）共识算法
04-27
用go语言实现的一个简单的工作量证明算法，代码和可执行程序都有，下载后放在gopath路径下就可直接运行演示
gopos:用于Golang的ESCPOS库
05-11
gopos 带有模板的Golang分布式ESC / POS库 如何使用 使用REDIS发布 特征.. ESC / POS命令库 模板化（最佳功能恕我直言） 您可以通过按入redis进行打印，如果有很多打印机，它非常有用。 JSON已推送至Redis： { "print": "... template ..." } Redis> publish print "...blob of json..." 示例模板 [[justify 1]]Kitchen receipt[[lf]][[justify 2]] justified just right [[justify 0]]justified left.. [[cut]] 印刷： Kitchen receipt justified just right justified left..
一种基于区块链PoS共识算法的改进研究.pdf
08-15
#资源达人分享计划#
Golang语言实现PBFT共识算法
weixin_42612804的博客
02-13 311
PBFT(Practical Byzantine Fault Tolerance)共识算法是一种分布式系统中的共识算法，它用于在存在恶意节点的情况下达成一致。在Go语言中，可以使用Go的标准库以及第三方库来实现PBFT共识算法。 具体实现步骤如下： 定义网络中的节点数量以及角色(例如：主节点，从节点)。 实现请求阶段，即请求节点向其他节点发送请求消息。 实现预备阶段，即其他节点对请求消息进行...
共识算法5：PoS的GO实现
欧阳桫的技术博客
11-16 566
package main import ( “time” “crypto/sha256” “encoding/hex” “strconv” “math/rand” “fmt” ) //PoW,PoS,DPoS等共识算法都是为了解决挖矿的问题 //PoS共识算法的使用 //定义区块 type Block struct { //高度 Index int //时间戳 TimeStamp string /...
Go语言实现PoW共识算法（一）区块定义与数据串行化
weixin_45133652的博客
02-22 239
在实现PoW算法之前，需要搭建基本的区块链，不然挖矿没有目标。下面将比特币的基本结构简化，设计一个最简单的区块结构，在使用切片来存储产生的区块，并用hash联系起来。
Golang：共识算法的实现原理（PoW工作量证明共识算法的简单实现）
YSS_33521的博客
12-04 399
关于本专栏：共识算法的（code）实现原理。将主要用于代码的实现研究，而文章将通过其他方式呈现，直接点击链接，即可呈现。之所以没有在这个位置呈现，是为了保证文章的整洁性。主要用于讨论。 https://thoughts.teambition.com/share/5fc9e6dfeb63b100468d5af1#title=PoW ...
golang几种post请求方式
weixin_34008933的博客
06-23 712
get请求 get请求可以直接http.Get方法，非常简单。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 func httpGet() {     resp, err := http.Get("http://www.01happy.com/demo/accept.php?id=1")     if er...
多语言POS 多语言pos中英文进销存收银软件 v1901
10-20
多语言pos中英文进销存收银软件，多语言进销存/服装/餐饮收银管理支持平板安卓点餐，有简体繁体英语法语俄语西班牙阿拉伯等语言，有应用于各行业收银管理系统软件，仓库进销存
区块链POS机制简易实现
06-06
一个简单的区块链POS机制实现。原有的POS中还是要对区块头进行哈希运算，运算出的哈希值要小于难度值，难度值为币龄*目标值，币龄越大，出块的概率越高。这里简化了很多东西，简单实现了一下，只需要存入，然后开始...
共识算法11：Raft的GO实现
欧阳桫的技术博客
11-16 1351
package main import ( “sync” “math/rand” “fmt” “time” “log” ) //3节点的分布式一致性演示 //设置节点的个数为3 //main中创建节点可声明 const raftCount = 3 //声明leader的存储对象 type AppendEntiresArgs struct { //声明任期 Term int //设置领导编号 Lea...
使用Go语言从零编写PoS区块链
weixin_45583158的博客
04-27 538
导语：本文作者在前几篇文章中展示了一个简单的区块链，包括生成块，验证数据，广播通信等。本文继续前文，介绍了PoS算法的基本原理，并且用golang实现了简单的PoS区块链...
【Golang】分布式 raft 共识算法 go 实现
FixPng的博客
04-07 24
本篇文章为 Raft 系列文章中的第一篇，Raft 的介绍。整个系列文章描述了 Raft 分布式共识算法及其在 Go 中的完整实现。Raft 是一种相对较新的算法（2014），但是它在业界已经被大量使用。最为大家所熟知的当属 K8s，它依赖于 Raft 通过 etcd 分布式键值存储。本系列文章的目的是描述 Raft 的功能齐全且经过严格测试的实现，并捎带介绍 Raft 的工作方式。我们假设读者至少了解过 Raft 相关文章。不要指望在一天内完全掌握 Raft。
15种区块链共识算法全面详解
leaning_java的博客
08-23 5378
15种区块链共识算法详解
共识算法9：拜占庭算法的GO实现
欧阳桫的技术博客
11-16 886
package main import ( “os” “fmt” “net/http” “io” ) //声明nodeInfo节点，代表各个小国家 type nodeInfo struct { //节点名称 id string //节点路径 path string //http响应，每个终端代表一个小国家 writer http.ResponseWriter } //创建map，存处各个国家的IP...
（二）区块链的共识算法：PoS 及其 例子 代码 实现
weixin_34248023的博客
09-10 778
作者：林冠宏 / 指尖下的幽灵 掘金：juejin.im/user/587f0d… 博客：www.cnblogs.com/linguanh/ GitHub ： github.com/af913337456… 腾讯云专栏： cloud.tencent.com/developer/u… 目录 前序 PoS 共识算法 PoS 的特点 编写 PoS 代码 候选块数组 块中的节点...
Golang基础3-函数、nil相关
最新发布
m0_61973596的博客
04-23 1005
1.利用recover处理panic指令，defer 必须放在 panic 之前定义，另外 recover 只有在 defer 调用的函数中才有效。函数返回值可以无名、有名，这个是方便理解的不全代码，有名res的话本质局部变量，因此defer后会可能会影响res的返回值。使用panic抛出错误，defer捕获错误，一般panic中抛出异常，defer中捕获异常，之后正常处理。因此传入指针等等，defer函数，有无名返回值均会影响main函数中接收到的最终return的值，请注意。
python实现pos共识机制
05-31
下面是一个简单的Python实现： 1. 定义节点类 ``` class Node: def __init__(self, name, balance): self.name = name # 节点名称 self.balance = balance # 节点权益 def __str__(self): return self.name ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值