2. 程式人生 > >go實現區塊鏈[2]-整合默克爾樹+POW

go實現區塊鏈[2]-整合默克爾樹+POW

阿新 • • 發佈：2018-12-20

新增merkleRoot

merkleTree.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
package main

import "crypto/sha256"


//默克爾樹節點
type MerkleTree struct{
	RootNode *MerkleNode
}

//默克爾根節點
type MerkleNode struct{
	Left *MerkleNode
	Right *MerkleNode
 

	Data []byte
}
//生成默克爾樹中的節點，如果是葉子節點，則Left，right為nil ，如果為非葉子節點，根據Left，right生成當前節點的hash
func NewMerkleNode(left,right *MerkleNode,data []byte) *MerkleNode{
	mnode := MerkleNode{}

	if left ==nil && right==nil{
		mnode.Data = data
	}else{
		prevhashes := append(left.Data,right.Data...)
		firsthash:= sha256.Sum256(prevhashes)
 

		hash:=sha256.Sum256(firsthash[:])
		mnode.Data = hash[:]
	}

	mnode.Left = left
	mnode.Right = right

	return &mnode
}

//構建默克爾樹
func NewMerkleTree(data [][]byte) *MerkleTree{
	var nodes []MerkleNode
	//構建葉子節點。
	for _,datum := range data{
		node:= NewMerkleNode(nil,nil,datum)
		nodes =  append(nodes,*node)
	}
 

	//j代表的是某一層的第一個元素
	j:=0
	//第一層迴圈代表 nSize代表某一層的個數，每迴圈一次減半
	for nSize :=len(data);nSize >1;nSize = (nSize+1)/2{
		//第二條迴圈i+=2代表兩兩拼接。 i2是為了當個數是基數的時候，拷貝最後的元素。
		for i:=0 ; i<nSize ;i+=2{
			i2 := min(i+1,nSize-1)

			node := NewMerkleNode(&nodes[j+i],&nodes[j+i2],nil)
			nodes = append(nodes,*node)
		}
		//j代表的是某一層的第一個元素
		j+=nSize

	}

	mTree := MerkleTree{&(nodes[len(nodes)-1])}
	return &mTree
}

根據交易建立merkleROOT

1
2
3
4
5
6
7
8
9
10
11
12
13
 

func (b*Block) createMerkelTreeRoot(transations []*Transation){
	var tranHash [][]byte

	for _,tx:= range transations{

		tranHash = append(tranHash,tx.Hash())
	}

	mTree := NewMerkleTree(tranHash)

	b.Merkleroot =  mTree.RootNode.Data
}

測試merkle

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 


func TestCreateMerkleTreeRoot(){
	//初始化區塊
	block := &Block{
		2,
		[]byte{},
		[]byte{},
		[]byte{},
		1418755780,
		404454260,
		0,
		[]*Transation{},
	}



	txin := TXInput{[]byte{},-1,nil}
	txout := NewTXOutput(subsidy,"first")
	tx := Transation{nil,[]TXInput{txin},[]TXOutput{*txout}}

	txin2 := TXInput{[]byte{},-1,nil}
	txout2 := NewTXOutput(subsidy,"second")
	tx2 := Transation{nil,[]TXInput{txin2},[]TXOutput{*txout2}}

	var Transations []*Transation

	Transations = append(Transations,&tx,&tx2)

	block.createMerkelTreeRoot(Transations)

	fmt.Printf("%x\n",block.Merkleroot)
}

增加挖礦邏輯

proofofwork.go:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
package main

import (
	"math/big"
	"bytes"
	"crypto/sha256"
)

type  ProofOfWork struct{
	block * Block
	tartget * big.Int
}
const targetBits = 16


func NewProofofWork(b*Block) * ProofOfWork{

	target := big.NewInt(1)
	target.Lsh(target,uint(256-targetBits))
	pow := &ProofOfWork{b,target}
	return pow
}

func (pow * ProofOfWork) prepareData(nonce int32) []byte{

	data := bytes.Join(
		[][]byte{
			IntToHex(pow.block.Version),
			pow.block.PrevBlockHash,
			pow.block.Merkleroot,
			IntToHex(pow.block.Time),
			IntToHex(pow.block.Bits),
			IntToHex(nonce)},
		[]byte{},
	)
	return data
}

func (pow * ProofOfWork) Run() (int32,[]byte){

		var nonce int32
		var secondhash [32]byte
		nonce = 0
		var currenthash big.Int

		for  nonce < maxnonce{


			//序列化
			data:= pow.prepareData(nonce)
			//double hash
			fitstHash := sha256.Sum256(data)
			secondhash = sha256.Sum256(fitstHash[:])
		//	fmt.Printf("%x\n",secondhash)


			currenthash.SetBytes(secondhash[:])
			//比較
			if currenthash.Cmp(pow.tartget) == -1{
				break
			}else{
				nonce++
			}
		}


		return nonce,secondhash[:]
}

func (pow * ProofOfWork) Validate() bool{
	var hashInt big.Int

	data:=pow.prepareData(pow.block.Nonce)

	fitstHash := sha256.Sum256(data)
	secondhash := sha256.Sum256(fitstHash[:])
	hashInt.SetBytes(secondhash[:])
	isValid:= hashInt.Cmp(pow.tartget) == -1

	return isValid
}

測試：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
func TestPow(){
	//初始化區塊
	block := &Block{
		2,
		[]byte{},
		[]byte{},
		[]byte{},
		1418755780,
		404454260,
		0,
		[]*Transation{},
	}

	pow:=NewProofofWork(block)

	nonce,_:= pow.Run()
 
 

            
  

           

              
              

            

            
相關推薦

			   
            
            
            
 

    


    
    
go實現區塊鏈[2]-整合默克爾樹+POW

     
 
 新增merkleRoot
 merkleTree.go
 
  
   
    1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606 



  
 

    


    
    
golang[42]-區塊鏈-go實戰比特幣默克爾樹

     
 
 go實戰比特幣默克爾樹
 
  
   
    12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686 



  
 

    


    
    
golang[41]-區塊鏈-默克爾樹構建

     
 
 大自然的啟示
 Banyan樹的啟示：印度banyan樹，最大的一顆可以長到1萬平方米以上。其如此巨大的祕密就在於其枝幹也會產生根，起到支撐，從而作為附屬樹幹，繼續生成分支。大自然給人太多啟示……
 Merkle Tree
 Merkle Tree，通常也被稱作Hash Tree，顧名思義，就是儲存has 



  
 

    


    
    
go實現區塊鏈[3]-遍歷區塊鏈與資料庫持久化

     
 
 新建blockchain.go
 
  
   
    1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666 



  
 

    


    
    
【區塊鏈學習】Merkle Patricia Tree (MPT) 以太坊中的默克爾樹

     
 
                
本篇博文是自己學習mpt的過程，邊學邊記錄，很多原理性內容非自己原創，好的博文將會以連結形式進行共享。
一、什麼是mpt
MPT是以太坊中的merkle改進樹，基於基數樹，即字首樹改進而來，大大提高了查詢效率。
二、字首樹
MPT中的P，就是字首樹，也叫trie或字典樹。t 



  
 

    


    
    
區塊鏈--默克爾樹（Merkle Tree）

     
 
                Merkle Tree

默克爾樹是一種二叉樹，由一個根節點、一組中間節點和一些葉子節點組成。形狀如下：



D0、D1、D2和D3是葉子節點包含的資料，也就是葉子節點的value。繼續往上看，N0、N1、N2和N3就是葉子節點，它是將資料（也就是D0、D1、D2和D3）進 



  
 

    


    
    
【我的區塊鏈之路】- go實現區塊鏈中常見的各類演算法

     
 
                

咳咳，為什麼要出這一篇文章呢？首先，這段時間本人在找工作，然後被問到了各類演算法的底層細節，有些確實很懵逼。這裡做個總結，也順便給大家歸納歸納一下！

上主題：

橢圓曲線加密：

我們先來說一說最常用的 ECC 吧，ECC 就是 Elliptic Curve Crypt 



  
 

    


    
    
Merkle Tree（默克爾樹）演算法解析

     
  
  
  
 Merkle Tree概念 
   Merkle Tree，通常也被稱作Hash Tree，顧名思義，就是儲存hash值的一棵樹。Merkle樹的葉子是資料塊(例如，檔案或者檔案的集合)的hash值。非葉節點是其對應子節點串聯字串的hash。[1] 
 1、Hash 
 Hash是一個把任意 



  
 

    


    
    
Merkle Tree（默克爾樹）

     
 
							
							
							

　　Merkle Tree，通常也被稱作Hash Tree，顧名思義，就是儲存hash值的一棵樹。Merkle樹的葉子是資料塊(例如，檔案或者檔案的集合)的hash值。非葉節點是其對應子節點串聯字串的hash。

　*　1. Hash*

　　Hash是一個 



  
 

    


    
    
eos原始碼賞析（二十三）：默克爾樹在EOS中的應用（上）

     
 
							
							
							前面文章中在分析push_transactioneos原始碼賞析（二十）：EOS智慧合約之push_transaction的天龍八“步”以及區塊簽名eos原始碼賞析（二十一）：EOS智慧合約之區塊簽名的天龍八“步”的時候都提到了默克爾樹，受限於篇幅未做具體分析。 



  
 

    


    
    
Merkle Tree（默克爾樹或梅爾克爾樹）基礎概念及操作

     
 
                Merkle Tree概念　　　　Merkle Tree，通常也被稱作Hash Tree，顧名思義，就是儲存hash值的一棵樹。Merkle樹的葉子是資料塊(例如，檔案或者檔案的集合)的hash值。非葉節點是其對應子節點串聯字串的hash。[1]　　1. Hash　　Hash 



  
 

    


    
    
Merkle Tree（默克爾樹）演算法的 查詢(不是查詢節點用的,而是查詢錯亂節點),新建,更新

     
 
                fei33423 Merkle Tree  注意比特幣的 tree , spv 簡單支付證明,先通過服務端找到交易的塊. 即證明了.Merkle Tree概念Merkle Tree，通常也被稱作Hash Tree，顧名思義，就是儲存hash值的一棵樹。Merkle樹的葉子是資 



  
 

    


    
    
比特幣中的默克爾樹Merkle

     
 
							
							
							簡介

Merkle Tree，通常也被稱作Hash Tree，顧名思義，就是儲存hash值的一棵樹。Merkle樹的葉子是資料塊(例如，檔案或者檔案的集合)的hash值。非葉節點是其對應子節點串聯字串的hash。 




比特幣中對應的默克爾樹


比特幣中 



  
 

    


    
    
SPV中如何利用默克爾樹證明某個交易是否存在

     
 
							
							
							SPV 是“Simplified Payment Verification”（簡單支付驗證）的縮寫。中本聰論文簡要地提及了這一概念，指出：不執行完全節點也可驗證支付，使用者只需要儲存所有的block header就可以了。使用者雖然不能自己驗證交易，但如果能夠從 



  
 

    


    
    
Go語言實現區塊鏈與加密貨幣-Part3（交易優化，單機模擬多節點通訊）

     
  
  
  
 交易（二） 
 在這個系列文章的一開始，我們就提到了，區塊鏈是一個分散式資料庫。不過在之前的文章中，我們選擇性地跳過了“分散式”這個部分，而是將注意力都放到了“資料庫”部分。到目前為止，我們幾乎已經實現了一個區塊鏈資料庫的所有元素。今天，我們將會分析之前跳過的一些機制。而在本篇文章中，我們將 



  
 

    


    
    
Go語言實現區塊鏈與加密貨幣-Part2（交易與地址，餘額翻倍漏洞）

     
  
  
  
 準備工作： 安裝依賴包：$ go get golang.org/x/crypto/ripemd160 安裝失敗請檢視：https://blog.csdn.net/ak47000gb/article/details/79561358 
 交易 
  
  交易（transaction）是比特幣 



  
 

    


    
    
Go語言實現區塊鏈與加密貨幣(用3臺計算機通過區域網模擬3個節點通訊)

     
  
  
  
 本文要實現3臺計算機通過區域網模擬3個節點通訊。（windows環境下） 這是在上一步的基礎上修改而來的。 三個節點所扮演的角色分別是：中心節點、錢包節點、礦工節點 首先3臺計算機要通過區域網連線在一起（可以通過wifi等方式）。 注意要把各自的防火牆關掉。 可以用ping命令測試，互相間的 



  
 

    


    
    
用go編寫區塊鏈系列之6--交易2

     
  
 
 0 概述 
 在這個系列的前面幾篇文章我們說區塊鏈是一個分散式資料庫，但是在實踐中，我們選擇忽略了“分散式”而只關注“資料庫”。目前為止我們我們實現了區塊鏈作為資料庫的所有特性。這篇文章中我們將實現前面幾篇中我們忽略的一些機制，下篇文章我們將實現分散式特性。 
 1 挖礦獎勵 
 我們忽略的一件事情 



  
 

    


    
    
用go編寫區塊鏈系列之2---PoW

     
  
 
 在前一篇文章中，我們構建了一個最簡單的額區塊鏈，本文中我們將改進這個區塊鏈，加入PoW機制，使得這個區塊鏈變成一個可以挖礦的區塊鏈。原文見https://jeiwan.cc/posts/building-blockchain-in-go-part-2/ 
 1 Proof-of-Work(PoW)  



  
 

    


    
    
Go語言實現區塊鏈與加密貨幣(用3臺計算機通過區域網模擬3節點通訊)

     
 
							
							
							本文要實現3臺計算機通過區域網模擬3節點通訊。（windows環境下）
這是在上一步的基礎上修改而來的。
首先3臺計算機要通過區域網連線在一起（可以通過wifi等方式）。
注意要把各自的防火牆關掉。
可以用ping命令測試，互相間的通訊是否正常。
一切正常後，需