Goでブロックチェーンを実装してみる

この記事のPythonで書かれてたものをGoに置き換えただけ

ブロックチェーンを作ることで学ぶ 〜ブロックチェーンがどのように動いているのか学ぶ最速の方法は作ってみることだ〜 - Qiita

唯一違う点はgo funcで鯖を二つ同時に立ててる

ギフハブはこちら

変数名とかは大体同じ。

3時間くらいでサクっと作ったからおそらく変なところあります。。
間違っていたらプルリクかコメントお願いします！

PS.リファクタリングしてコメント消して本家にプルリク投げてみようかな...

main.go

package main

import (
    "time"
    "encoding/json"
    "crypto/sha256"
    "encoding/hex"
    "strconv"
    "github.com/google/uuid"
    "strings"
    "github.com/labstack/echo"
    "net/http"
)

type Blockchain struct {
    Chain              []Block
    CurrentTransaction Transaction
    Nodes []string
}

type Transaction struct {
    Sender string
    Recipient string
    Amount int
}

type Block struct {
    Index        int         `json:"index"`
    Timestamp    int64       `json:"timestamp"`
    Transactions Transaction `json:"transactions"`
    Proof        int         `json:"proof"`
    PreviousHash string      `json:"previous_hash"`
}

type FullChain struct {
    Chain []Block `json:"chain"`
    Length int ` json:"length"`
}

var blockchain Blockchain


func (Blockchain) Init(){
    //# ジェネシスブロックを作る
    blockchain = Blockchain{}
    blockchain.NewBlock("1",100)
}

/*
     ブロックチェーンに新しいブロックを作る
     :param proof: <int> プルーフ・オブ・ワークアルゴリズムから得られるプルーフ
     :param previous_hash: (オプション) <str> 前のブロックのハッシュ
     :return: <dict> 新しいブロック
*/
func (Blockchain) NewBlock(previousHash string,proof int) Block {
    pg := ""
    if previousHash != ""{
        pg = previousHash
    }else{
        pg = blockchain.Hash(blockchain.Chain[len(blockchain.Chain) - 1])
    }
    block := Block{
        Index:        len(blockchain.Chain) + 1,
        Timestamp:    time.Now().Unix(),
        Transactions: blockchain.CurrentTransaction,
        Proof:        proof,
        PreviousHash: pg, // or blockchain.Hash(blockchain.Chain[-1])
    }
    blockchain.CurrentTransaction = Transaction{}
    blockchain.Chain = append(blockchain.Chain,block)
    return block
}

/*
    次に採掘されるブロックに加える新しいトランザクションを作る
    :param sender: <str> 送信者のアドレス
    :param recipient: <str> 受信者のアドレス
    :param amount: <int> 量
    :return: <int> このトランザクションを含むブロックのアドレス
*/
func (Blockchain) NewTransaction(sender string,recipient string,amount int) int{
    // 新しいトランザクションをリストに加える
    blockchain.CurrentTransaction = Transaction{Sender:sender,Recipient:recipient,Amount:amount}
    return blockchain.LastBlock().Index + 1
}

/*
    ブロックの　SHA-256　ハッシュを作る
    :param block: <dict> ブロック
    :return: <str>
*/
func (Blockchain) Hash(block Block)string{
    // ブロックをハッシュ化する
    blockJson,err := json.Marshal(block)
    if err != nil{
        panic(err)
    }
    converted := sha256.Sum256([]byte(blockJson))
    return hex.EncodeToString(converted[:])
}

func (Blockchain) LastBlock() Block {
    // チェーンの最後のブロックをリターンする
    return blockchain.Chain[len(blockchain.Chain) - 1]
}

/*
        シンプルなプルーフ・オブ・ワークのアルゴリズム:
        - hash(pp') の最初の4つが0となるような p' を探す
        - p は1つ前のブロックのプルーフ、 p' は新しいブロックのプルーフ
        :param last_proof: <int>
        :return: <int>
*/
func (Blockchain) ProofOfWork(lastProof int)int{
    proof := 0
    for blockchain.ValidProof(lastProof,proof) == false{
        proof += 1
    }

    return proof
}

/*
        プルーフが正しいかを確認する: hash(last_proof, proof)の最初の4つが0となっているか？
        :param last_proof: <int> 前のプルーフ
        :param proof: <int> 現在のプルーフ
        :return: <bool> 正しければ true 、そうでなれけば false
*/
func (Blockchain) ValidProof(lastProof int,proof int)bool{
    guess := []byte(strconv.Itoa(lastProof) + strconv.Itoa(proof))
    sha256s := sha256.Sum256(guess)
    guessHash := hex.EncodeToString(sha256s[:])
    return guessHash[:4] == "0000"
}

/*
        ブロックチェーンが正しいかを確認する
        :param chain: <list> ブロックチェーン
        :return: <bool> True であれば正しく、 False であればそうではない
*/
func (Blockchain) ValidChain(chain []Block)bool{
    lastBlock := chain[0]
    currentIndex := 1

    for currentIndex < len(chain){
        block := chain[currentIndex]
        //# ブロックのハッシュが正しいかを確認
        if block.PreviousHash != blockchain.Hash(lastBlock){
            return false
        }
        //# プルーフ・オブ・ワークが正しいかを確認
        if !blockchain.ValidProof(lastBlock.Proof,block.Proof){
            return false
        }
        lastBlock = block
        currentIndex += 1
    }
    return true
}
/*
    これがコンセンサスアルゴリズムだ。ネットワーク上の最も長いチェーンで自らのチェーンを
    置き換えることでコンフリクトを解消する。
    :return: <bool> 自らのチェーンが置き換えられると True 、そうでなれけば False
*/
func (Blockchain) ResolveConflicts()bool{
    neighbours := blockchain.Nodes
    var newChain []Block

    //# 自らのチェーンより長いチェーンを探す必要がある
    maxLength := len(blockchain.Chain)

    for _,node := range neighbours{
        response,err := http.Get(node + "/chain")
        if err != nil{
            panic(err)
        }
        if response.StatusCode != 200{
            panic(err)
        }
        var fullChain FullChain
        if err := json.NewDecoder(response.Body).Decode(&fullChain); err != nil{
            panic(err)
            continue
        }
        length := fullChain.Length
        chain := fullChain.Chain

        if length > maxLength && blockchain.ValidChain(chain){
            maxLength =  length
            newChain = chain
        }
    }
    if len(newChain) != 0{
        blockchain.Chain = newChain
        return true
    }
    return false
}

/*
    ノードリストに新しいノードを加える
    :param address: <str> ノードのアドレス 例: 'http://192.168.0.5:5000'
    :return: None
*/
func (Blockchain) RegisterNode(address string){
    blockchain.Nodes = append(blockchain.Nodes,address)

    fix := make(map[string]bool)
    one := []string{}
    for _,a := range blockchain.Nodes{
        if !fix[a]{
            fix[a] = true
            one = append(one, a)
        }
    }
    blockchain.Nodes = one
}

var NodeIdentifire string

func main() {
    // echo server
    e := echo.New()

    //# このノードのグローバルにユニークなアドレスを作る
    NodeIdentifire = strings.Replace(uuid.New().String(),"-","",-1)

    blockchain.Init()

    e.GET("/mine", Mine)
    e.POST("/transactions/new", NewTransactionPost)
    e.GET("/chain", FullChainGET)

    e.POST("/nodes/register",RegisterNode)
    e.GET("/nodes/resolve",Consensus)

    go func(echoEcho *echo.Echo) {
        copyEcho := echoEcho
        copyEcho.Start(":5001")
    }(e)
    e.Start(":5000")
}

type Post2 struct {
    Nodes []string `json:"nodes"`
}

type Response2 struct {
    Message string `json:"message"`
    TotalNode []string `json:"total_node"`
}

func RegisterNode(e echo.Context)error{
    nodes := new(Post2)
    if err := e.Bind(nodes); err != nil{
        return e.JSON(http.StatusBadRequest,"Status Bad Request.")
    }

    for _,node := range nodes.Nodes{
        blockchain.RegisterNode(node)
    }

    var response2 Response2
    response2.Message = "新しいノードが追加されました"
    response2.TotalNode = blockchain.Nodes

    return e.JSON(http.StatusCreated,response2)
}

func Consensus(e echo.Context)error{
    replaced := blockchain.ResolveConflicts()
    if replaced{
        type Response struct {
            Message string `json:"message"`
            NewChain []Block `json:"new_chain"`
        }
        var response Response
        response.Message = "チェーンが置き換えられました"
        response.NewChain = blockchain.Chain
        return e.JSON(http.StatusOK,response)
    }else{
        type Response struct {
            Message string `json:"message"`
            Chain []Block `json:"chain"`
        }
        var response Response
        response.Message = "チェーンが確認されました"
        response.Chain = blockchain.Chain
        return e.JSON(http.StatusOK,response)
    }

}

type Post struct {
    Sender string
    Recipient string
    Amount int
}
//# メソッドはPOSTで/transactions/newエンドポイントを作る。メソッドはPOSTなのでデータを送信する
func NewTransactionPost(e echo.Context)error{
    post := new(Post)
    if err := e.Bind(post); err != nil {
        return e.JSON(http.StatusBadRequest,"Status Bad Request.")
    }

    // '新しいトランザクションを追加します'
    index := blockchain.NewTransaction(post.Sender,post.Recipient,post.Amount)
    return e.JSON(http.StatusCreated,"トランザクションはブロック" + strconv.Itoa(index) + "に追加されました")
}

//# メソッドはGETで/mineエンドポイントを作る
func Mine(e echo.Context)error{
    // '新しいブロックを採掘します'
    lastBlock := blockchain.LastBlock()
    lastProof := lastBlock.Proof
    proof := blockchain.ProofOfWork(lastProof)

    blockchain.NewTransaction("0",NodeIdentifire,1)

    block := blockchain.NewBlock("",proof)

    response := struct {
        Message string `json:"message"`
        Index int `json:"index"`
        Transactions Transaction `json:"transactions"`
        Proof int `json:"proof"`
        PreviousHash string `json:"previous_hash"`
    }{Message:"新しいブロックを採掘しました。",
    Index:block.Index,
    Transactions:block.Transactions,
    Proof:block.Proof,
    PreviousHash:block.PreviousHash}

    return e.JSON(http.StatusCreated,response)
}

//# メソッドはGETで、フルのブロックチェーンをリターンする/chainエンドポイントを作る
func FullChainGET(e echo.Context)error{
    var response FullChain
    response.Chain = blockchain.Chain
    response.Length = len(blockchain.Chain)

    return e.JSON(http.StatusOK,response)
}