GolangでブロックチェーンのPoWの簡易的な実装をしてみた

package bchain

import (
	"crypto/sha256"
	"fmt"
	"time"
)

type (
	block struct {
		timestamp    time.Time
		transactions []*transaction
		previousHash [32]byte
		hash         [32]byte
		nonce        int
	}
)

func NewBlock(timestamp time.Time, transactions []*transaction, previousHash [32]byte) *block {
	b := block{
		timestamp:    timestamp,
		transactions: transactions,
		previousHash: previousHash,
		nonce:        0,
	}
	b.hash = b.calcHash()

	return &b
}

func (b block) String() string {
	return fmt.Sprintf("%s", b.transactions)
}

// private

// nonceの値をインクリメントしていき、条件に合致するハッシュ値が見つかるまで計算を続ける
func (b *block) mining() {
	var isSuccess bool
	for i := 0; isContinue; i++ {
		b.nonce++
		b.hash = b.calcHash()

		strSha256 := fmt.Sprintf("%x", b.hash)
		isContinue = string([]rune(strSha256)[:2]) != "00"
	}
	fmt.Println("Succeeded to mining")
}

func (b block) calcHash() [32]byte {
	s := fmt.Sprintf(
		"%s:%s:%s:%s",
		b.previousHash,
		b.timestamp,
		b.transactions,
		string(rune(b.nonce)),
	)
	byteSha256 := sha256.Sum256([]byte(s))

	return byteSha256
}

package bchain

import "fmt"

type (
	address string
	money   float64

	transaction struct {
		sender    address
		recipient address
		amount    money
	}
)

func NewTransaction(sender string, recipient string, amount float64) *transaction {
	t := transaction{
		sender:    address(sender),
		recipient: address(recipient),
		amount:    money(amount),
	}

	return &t
}

func (tx transaction) String() string {
	return fmt.Sprintf(
		"{ %s sent %v => %s }",
		tx.sender,
		tx.amount,
		tx.recipient,
	)
}

package bchain

import (
	"crypto/sha256"
	"fmt"
	"time"
)

type BlockChain struct {
	blocks              []*block
	pendingTransactions []*transaction
	miningReward        money
}

// チェーンの中の最初のブロック(genesis block)を精製して、structを返す
func NewBlockChain() *BlockChain {
	genesisBlock := NewBlock(
		time.Now(),
		make([]*transaction, 0),
		sha256.Sum256([]byte(fmt.Sprintf("0"))),
	)

	return &BlockChain{
		miningReward: money(12.5),
		blocks:       []*block{genesisBlock},
	}
}

func (bc BlockChain) String() string {
	return fmt.Sprintf("blocks: %s", bc.blocks)
}

func (bc *BlockChain) AddTransaction(tx *transaction) {
	bc.pendingTransactions = append(bc.pendingTransactions, tx)
}

// チェーンに記録されている未処理のトランザクションに対してマイニングを行い確定する
func (bc *BlockChain) Mine(rewardAddress address) {
	// ブロックの生成とマイニングを行いチェーンに追加する
	block := NewBlock(
		time.Now(),
		bc.pendingTransactions,
		bc.lastBlock().hash,
	)
	block.mining()
	bc.blocks = append(bc.blocks, block)

	// pendingTransactionの初期化
	bc.pendingTransactions = make([]*transaction, 0)

	// マイニングの報酬を記録。次のマイニングで確定される
	bc.pendingTransactions = append(
		bc.pendingTransactions,
		NewTransaction(
			"",
			string(rewardAddress),
			float64(bc.miningReward),
		),
	)
}

// ブロックチェーンが全体で整合性を持っているか計算
func (bc BlockChain) IsValid() bool {
	for i := len(bc.blocks) - 1; i >= 0; i-- {
		b := bc.blocks[i]

		// ハッシュ値が書き換えられていないか
		if b.hash != b.calcHash() {
			return false
		}

		// 前のハッシュ値が一致するか
		if i != 0 && b.previousHash != bc.blocks[i-1].hash {
			return false
		}
	}

	return true
}

// 取引記録を全て参照し、保持金額を計算する
func (bc BlockChain) GetBalanceOfAddress(a string) money {
	var balance money
	for _, block := range bc.blocks {
		for _, transaction := range block.transactions {
			if transaction.sender == address(a) {
				balance -= transaction.amount
			}
			if transaction.recipient == address(a) {
				balance += transaction.amount
			}
		}
	}

	return balance
}

// private

func (bc BlockChain) lastBlock() block {
	return *bc.blocks[len(bc.blocks)-1]
}

package main

import (
	"fmt"
	"goTestProject/block_chain/bchain"
)

func main() {
	// ブロックチェーンの生成
	bc := bchain.NewBlockChain()
	// 取引の記録
	bc.AddTransaction(
		bchain.NewTransaction(
			"Ken",
			"Taro",
			2,
		),
	)
	bc.AddTransaction(
		bchain.NewTransaction(
			"Taro",
			"Ken",
			10,
		),
	)

	// 上で作成した記録に対してマイニングを行い確定する
	bc.Mine("Ken")
	// マイニングの報酬が支払われているので、もう一度マイニングを行い確定する
	bc.Mine("Ken")

	fmt.Printf("%+v\n", bc)
	fmt.Printf("block Chain valid: %v\n", bc.IsValid())

	fmt.Printf("Ken balance: %f\n", bc.GetBalanceOfAddress("Ken"))
	fmt.Printf("Taro balance: %f\n", bc.GetBalanceOfAddress("Taro"))
}

Succeeded to mining
Succeeded to mining
blocks: [[] [{ Ken sent 2 => Taro } { Taro sent 10 => Ken }] [{  sent 12.5 => Ken }]]
block Chain valid: true
Ken balance: 20.500000
Taro balance: -8.000000