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

于 2023-02-27 15:29:07 发布
阅读量400 收藏 1
点赞数
文章标签： golang 区块链 共识算法 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/john_hai/article/details/129242851
版权
以太坊BeaconChain是其2.0协议的关键部分，引入了ProofofStake共识机制，通过验证人质押以太币来选择新区块的创建者。此外，BeaconChain还计划采用分片技术，提高网络性能和可扩展性。验证人在网络中扮演重要角色，他们的行为受质押的以太币约束，以保证网络的安全和效率。
摘要由CSDN通过智能技术生成

以太坊 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
关注
共识算法5：PoS的GO实现
欧阳桫的技术博客
11-16 617
package main import ( “time” “crypto/sha256” “encoding/hex” “strconv” “math/rand” “fmt” ) //PoW,PoS,DPoS等共识算法都是为了解决挖矿的问题 //PoS共识算法的使用 //定义区块 type Block struct { //高度 Index int //时间戳 TimeStamp string /...
（二）区块链的共识算法：PoS 及其 例子 代码 实现
weixin_34248023的博客
09-10 888
作者：林冠宏 / 指尖下的幽灵 掘金：juejin.im/user/587f0d… 博客：www.cnblogs.com/linguanh/ GitHub ： github.com/af913337456… 腾讯云专栏： cloud.tencent.com/developer/u… 目录 前序 PoS 共识算法 PoS 的特点 编写 PoS 代码 候选块数组 块中的节点...
使用Go语言从零编写PoS区块链
weixin_45583158的博客
04-27 608
导语：本文作者在前几篇文章中展示了一个简单的区块链，包括生成块，验证数据，广播通信等。本文继续前文，介绍了PoS算法的基本原理，并且用golang实现了简单的PoS区块链...
共识算法POS原理及实现
自媒体软件
06-29 3753
POS简介 POS：Proof of Stake，股权证明 类似于财产储存在银行，这种模式会根据你持有数字货币的量和时间，分配给你相应的利息。 简单来说，就是一个根据你持有货币的量和时间，给你发利息的一个制度，在股权证明POS模式下，有一个名词叫币龄，每个币每天产生1币龄，比如你持有100个币，总共持有了30天，那么，此时你的币龄就为3000，这个时候，如果你发现了一个POS区块，...
go语言实现Pos算法
sdadaaagfsee3的博客
08-18 965
权益证明机制最开始是由点点币提出并应用（出块概率=代币数量 * 币龄） 简单来说谁的币多，谁就有更大的出块概率 package pos import ( "crypto/rand" "crypto/sha256" "encoding/hex" "fmt" "log" "math/big" "strconv" "time" ) // 实现pos算法 // 相比于pow的暴力计算哈希值，pos相对环保一些 // 类比点点币实现 // 区块结构 type Block struct { La
go语言实现PoS共识机制_pos.zip
02-18
系统是利用go语言进行编码的，包含了go程序运行所需的依赖包 操作过程： 1.在一个终端里运行main.go文件 2.打开新的终端，使用nc localhost 9000命令进入9000端口 再输入当前余额以及要记录的消息，等待结果
go语言实现PoS共识机制
张永杰的博客
02-18 920
1.新建main.go文件 package main import ( "bufio" "crypto/sha256" "encoding/hex" "encoding/json" "fmt" "io" "log" "math/rand" "net" "os" "strconv" "sync" ...
go语言实现区块链的共识算法
它通过将数据以区块的形式串联起来，形成一个不可篡改的链式结构，实现了去中心化、去信任化的数据交换与存储。区块链具有去中心化、可追溯、安全可靠等特点，被广泛应用于数字货币、供应链管理、智能合约等领域。 ...
（译)使用Go语言从零编写PoS区块链
Sunface撩技术
03-26 7231
原文发表日期： 2018-03-26 原文链接：https://medium.com/@mycoralhealth/code-your-own-proof-of-stake-blockchain-in-go-610cd99aa658 转载请在文章开头注明作者和出处 作者: ChainGod(孙飞) 原文链接: http://chaingod.io/article...
PoS——权益证明 go简单实现
s15738841819的博客
11-20 776
⚫PoS（Proof of Stake）译为权益证明，是一种在公链中的共识算法，可作为 PoW 算 法的一种替换 ⚫基于权益证明的数字货币中，下一个区块的选择是根据不同节点的股份和时间进行 随机选择的 ⚫PoS 的设计理念，来自于对比特币危机的思考，比特币的区块产量每 4 年会减半， 在不久的未来，随着比特币区块包含的产量越来越低，大家挖矿的动力将会不断下 降，矿工人数越来越少，整个比...
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..
go语言实现工作量证明（POW）共识算法
04-27
用go语言实现的一个简单的工作量证明算法，代码和可执行程序都有，下载后放在gopath路径下就可直接运行演示
Raft共识协议的Golang实现-Golang开发
05-26
raft raft是一个Go库，它管理复制的日志，并且可以与FSM一起使用以管理复制的状态机。 它是一个用于提供共识的库。 这种库的用例范围很广，例如repli raft raft是Go库，它管理复制的日志，并且可以与FSM一起使用以管理复制的状态机。 它是一个用于提供共识的库。 这种库的用例范围很广，例如复制状态机是许多分布式系统的关键组成部分。 它们使构建一致的，分区容错（CP）的系统也具有有限的容错能力。 构建如果要构建木筏，则需要安装Go 1.2+版本。 请检查一下
GOPOS开源最优控制软件包5.1版
11-18
gpops 最优化 最优控制 开源 国外
POS共识机制
qq_38465408的博客
08-29 2723
POS共识机制   在上篇文章中，我大概介绍了一下整个区块链的共识机制的重要性以及工作原理，用简单的一句话来概括总结，其实共识机制，就是现实生活的国家法律，在区块链的世界中用代码的形式做到了整个区块链网络的“法律法规”，因此说共识机制是区块链网络中的灵魂，在我眼中看来是毫不为过的。紧接着，我又介绍了现阶段最常用以及最稳定的POW共识算法，虽然他很暴力，利用计算机的算力来保证了区块链网络的一致性...
共识算法9：拜占庭算法的GO实现
欧阳桫的技术博客
11-16 923
package main import ( “os” “fmt” “net/http” “io” ) //声明nodeInfo节点，代表各个小国家 type nodeInfo struct { //节点名称 id string //节点路径 path string //http响应，每个终端代表一个小国家 writer http.ResponseWriter } //创建map，存处各个国家的IP...
共识算法2：PoW的GO实现
欧阳桫的技术博客
11-17 453
package main // 01.挖矿的实现 import ( “time” “strconv” “encoding/hex” “crypto/sha256” “fmt” “strings” ) // 通过代码，完成PoW挖矿 // 用结构体创建区块 //命名规范参照比特币源码 type Block struct { // 上一个区块的哈希 PreHash string // 当前区块的哈希 ...
这可能是全网最简单的POS共识机制算法
reigns的博客
11-13 2881
共识算法是区块链非常重要的一种算法，简单来说，共识算法就是为了使网络中的节点得到一致的认可。就比如说合作双方达成一致，共同遵守某个合约。 传统的分布式系统中，由于有着中心服务器进行统一管理，各个子服务器只需要跟着中心服务器进行操作即可。而区块链作为一种去中心化分布式系统，并没有传统意义上的中心服务器，因此传统的分布一致性算法并不适用于区块链网络。每个服务器都可以是中心服务器，那么这样就需要一种新...
Golang：共识算法的实现原理（PoW工作量证明共识算法的简单实现）
YSS_33521的博客
12-04 500
关于本专栏：共识算法的（code）实现原理。将主要用于代码的实现研究，而文章将通过其他方式呈现，直接点击链接，即可呈现。之所以没有在这个位置呈现，是为了保证文章的整洁性。主要用于讨论。 https://thoughts.teambition.com/share/5fc9e6dfeb63b100468d5af1#title=PoW ...
python实现pos共识机制
最新发布
05-31
POS（Proof of Stake）是一种区块链共识机制，与POW（Proof of Work）不同，它并不需要大量的计算资源。在POS中，节点的权益（通常是代币）越多，出块的概率就越大。下面是一个简单的Python实现： 1. 定义节点类 ``` class Node: def __init__(self, name, balance): self.name = name # 节点名称 self.balance = balance # 节点权益 def __str__(self): return self.name ``` 2. 定义区块类 ``` class Block: def __init__(self, previous_hash, transactions, timestamp): self.previous_hash = previous_hash # 前一个区块的哈希值 self.transactions = transactions # 区块中的交易信息 self.timestamp = timestamp # 区块创建时间 def __str__(self): return str(self.transactions) ``` 3. 定义区块链类 ``` class Blockchain: def __init__(self, nodes): self.nodes = nodes # 所有节点 self.chain = [Block("", [], datetime.datetime.now())] # 初始区块 self.current_transactions = [] # 当前未打包的交易 def add_transaction(self, sender, recipient, amount): self.current_transactions.append({ "sender": sender, "recipient": recipient, "amount": amount }) def get_valid_nodes(self): # 获取所有权益大于0的节点 return [node for node in self.nodes if node.balance > 0] def get_winner(self): # 根据节点权益大小，计算获胜者 valid_nodes = self.get_valid_nodes() total_balance = sum([node.balance for node in valid_nodes]) winner = None rand = random.uniform(0, total_balance) for node in valid_nodes: if rand <= node.balance: winner = node break rand -= node.balance return winner def mine(self): # 打包交易，生成新的区块 winner = self.get_winner() transactions = self.current_transactions.copy() self.current_transactions = [] block = Block(self.chain[-1].previous_hash, transactions, datetime.datetime.now()) self.chain.append(block) # 奖励获胜者 if winner: winner.balance += 1 def __str__(self): return str([str(block) for block in self.chain]) ``` 4. 测试代码 ``` # 创建节点 alice = Node("Alice", 5) bob = Node("Bob", 3) charlie = Node("Charlie", 2) # 创建区块链 blockchain = Blockchain([alice, bob, charlie]) # 添加交易 blockchain.add_transaction(alice, bob, 1) blockchain.add_transaction(bob, charlie, 2) # 开始挖矿 blockchain.mine() # 查看区块链信息 print(blockchain) ``` 输出： ``` [[], [{'sender': <__main__.Node object at 0x10e7c3d90>, 'recipient': <__main__.Node object at 0x10e7c3d60>, 'amount': 1}, {'sender': <__main__.Node object at 0x10e7c3d60>, 'recipient': <__main__.Node object at 0x10e7c3df0>, 'amount': 2}]] ``` 注意：这只是一个简单的实现，实际应用中需要考虑更多因素，如节点的信誉度、网络延迟等。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值