6. Adding Digital Signatures
지갑에 디지털 서명을 추가해보자.
TxInput에 wallet의 private key를 이용해서 sign을 하고 검증하는 과정을 추가.
Sign
wallet의 privateKey와 해당 TxInput이 참조하는 TxOutput의 public key hash, random number를 섞어서 ecdsa를 이용해 만든다.
esdsa 함수를 이용하면 r, s 2개의 수가 나오는데 이 두 수를 바이트로 변환해서 합하면 signature가 된다.
이 과정을 반대로 하여 r, s를 뽑아내어 비교하는 것이 verify 함수다.
wallet.go
address 검증 함수 추가.
package wallet
import (
"bytes"
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/sha256"
"fmt"
"log"
"golang.org/x/crypto/ripemd160"
)
const (
// checksum length in byte.
// 4byte length
checksumLength = 4
// 0 byte를 16진법으로 표현.
version = byte(0x00)
)
// Wallet : PrivateKey와 PublicKey를 가지고 있는 Wallet structure.
type Wallet struct {
PrivateKey ecdsa.PrivateKey
PublicKey []byte
}
// Address : version, publicKeyHash, checksum 3가지를 concatenate한 후에 Base58로 인코딩해서 address를 만든다.
func (w Wallet) Address() []byte {
pubHash := PublicKeyHash(w.PublicKey)
versionedHash := append([]byte{version}, pubHash...)
checksum := Checksum(versionedHash)
fullHash := append(versionedHash, checksum...)
address := Base58Encode(fullHash)
fmt.Printf("pub key: %x\n", w.PublicKey)
fmt.Printf("pub hash: %x\n", pubHash)
fmt.Printf("address: %s\n", address)
fmt.Printf("fullHash: %x\n", fullHash)
fmt.Printf("checksum: %x\n", checksum)
fmt.Printf("version: %x\n", versionedHash)
return address
}
// Address: 1EwsppsVck2B5Ndf7nPyHi8uYtEhK44ndm
// FullHash: 0098fa85f9e6b04827b2ce6db7e8e18ff8e9882c99eefb8610
// [Version] 00
// [Pub Key Hash] 98fa85f9e6b04827b2ce6db7e8e18ff8e9882c99
// [CheckSum] eefb8610
// FullHash = Version + Pub Key Hash + CheckSum
// ValidateAddress : Address의 유효성을 검증한다.
// 1 : address의 checksum 부분 (address를 base58로 디코드하여 나온 배열에서 마지막 checksumLength만큼의 부분)
// 2 : address의 version부분과 pubKeyHash 부분을 뽑아서 만든 checksum 부분.
// 1과 2가 같은지 확인.
func ValidateAddress(address string) bool {
// 1 : address의 checksum 부분
pubKeyHash := Base58Decode([]byte(address))
actualChecksum := pubKeyHash[len(pubKeyHash)-checksumLength:]
// 2 : address의 version부분과 pubKeyHash 부분을 뽑아서 만든 checksum 부분.
version := pubKeyHash[0]
pubKeyHash = pubKeyHash[1 : len(pubKeyHash)-checksumLength]
targetChecksum := Checksum(append([]byte{version}, pubKeyHash...))
return bytes.Compare(actualChecksum, targetChecksum) == 0
}
// NewKeyPair : 새로운 키페어를 만든다.
// ecdsa라는 비대칭키 암호 알고리즘을 사용.
func NewKeyPair() (ecdsa.PrivateKey, []byte) {
curve := elliptic.P256()
// private key는 랜덤하게 뽑혀진 256bit의 숫자이다.
private, err := ecdsa.GenerateKey(curve, rand.Reader)
if err != nil {
log.Panic(err)
}
// X, Y가 concatenate 되어 pub이 됨.
// private key로부터 public key를 생성함.
pub := append(private.PublicKey.X.Bytes(), private.PublicKey.Y.Bytes()...)
return *private, pub
}
// MakeWallet : NewKeyPair를 이용해서 Wallet을 만든다.
func MakeWallet() *Wallet {
private, public := NewKeyPair()
wallet := Wallet{private, public}
return &wallet
}
// PublicKeyHash : sha256, ripemd160을 이용해 퍼블릭키를 해쉬로 변환.
// address 생성에 쓰임.
func PublicKeyHash(pubKey []byte) []byte {
pubHash := sha256.Sum256(pubKey)
hasher := ripemd160.New()
_, err := hasher.Write(pubHash[:])
if err != nil {
log.Panic(err)
}
publicRipMD := hasher.Sum(nil)
return publicRipMD
}
// Checksum : payload를 sha256을 이용해 해쉬로 변환하고 checksumLength만큼의 바이트만 사용한다.
func Checksum(payload []byte) []byte {
firstHash := sha256.Sum256(payload)
secondHash := sha256.Sum256(firstHash[:])
return secondHash[:checksumLength]
}
transaction.go
sign과 verify 함수 구현.
새로운 tx 생성시 sign과정 추가.
package blockchain
import (
"bytes"
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/sha256"
"encoding/gob"
"encoding/hex"
"fmt"
"log"
"math/big"
"strings"
"github.com/HTaeha/Blockchain-in-Golang/wallet"
)
// Transaction : 블록에 쓰여질 데이터.
type Transaction struct {
// hash
ID []byte
// Array of input
Inputs []TxInput
// Array of output
Outputs []TxOutput
}
// Serialize : Bytes로 변환.
func (tx Transaction) Serialize() []byte {
var encoded bytes.Buffer
enc := gob.NewEncoder(&encoded)
err := enc.Encode(tx)
if err != nil {
log.Panic(err)
}
return encoded.Bytes()
}
// Hash : Transaction의 ID를 비우고 hashing한 값을 리턴한다.
func (tx *Transaction) Hash() []byte {
var hash [32]byte
txCopy := *tx
txCopy.ID = []byte{}
hash = sha256.Sum256(txCopy.Serialize())
return hash[:]
}
// CoinbaseTx : 하나의 인풋과 하나의 아웃풋이 있음. 채굴자가 아웃풋을 받는다.
// to : data 받을 사람의 address
func CoinbaseTx(to, data string) *Transaction {
if data == "" {
data = fmt.Sprintf("Coins to %s", to)
}
// 참조하는 TxOutput이 없다.
txin := TxInput{[]byte{}, -1, nil, []byte(data)}
// 100 coin을 to에게 보낸다.
txout := NewTXOutput(100, to)
// Transaction Init
tx := Transaction{nil, []TxInput{txin}, []TxOutput{*txout}}
return &tx
}
// NewTransaction : from account, to account
// amount : 보내고 싶은 코인의 양
// from이 to에게 amount만큼의 코인을 보낸다.
func NewTransaction(from, to string, amount int, chain *BlockChain) *Transaction {
var inputs []TxInput
var outputs []TxOutput
// from의 wallet 생성.
wallets, err := wallet.CreateWallets()
Handle(err)
w := wallets.GetWallet(from)
pubKeyHash := wallet.PublicKeyHash(w.PublicKey)
acc, validOutputs := chain.FindSpendableOutputs(pubKeyHash, amount)
// 보내고 싶은 만큼의 코인이 없다.
if acc < amount {
// 시간과 에러 문자열을 출력한 뒤 패닉을 발생시킴.
// 패닉 : 프로그램을 종료시킨다. (런타임 에러)
// recover 함수를 사용하면 panic 후에 복구할 수 있다. (프로그램이 종료되지 않음.)
log.Panic("Error: not enough funds")
}
// 사용할 수 있는 아웃풋의 인덱스들.
for txid, outs := range validOutputs {
txID, err := hex.DecodeString(txid)
Handle(err)
for _, out := range outs {
input := TxInput{txID, out, nil, w.PublicKey}
inputs = append(inputs, input)
}
}
// to address로 amount만큼의 코인을 보낸다.
outputs = append(outputs, *NewTXOutput(amount, to))
// 모은 UTXO의 양이 보낼 양보다 크면 거스름돈을 받는다.
if acc > amount {
outputs = append(outputs, *NewTXOutput(acc-amount, from))
}
tx := Transaction{nil, inputs, outputs}
tx.ID = tx.Hash()
chain.SignTransaction(&tx, w.PrivateKey)
return &tx
}
// IsCoinbase : Coinbase 인지 판별한다.
func (tx *Transaction) IsCoinbase() bool {
return len(tx.Inputs) == 1 && len(tx.Inputs[0].ID) == 0 && tx.Inputs[0].Out == -1
}
// Sign : Tx의 Input들에게 privateKey를 이용하여 Sign을 한다.
// prevTXs : 현재 Tx의 인풋들이 사용한 이전 Tx.
func (tx *Transaction) Sign(privKey ecdsa.PrivateKey, prevTXs map[string]Transaction) {
// coinbase는 sign이 필요없음.
if tx.IsCoinbase() {
return
}
for _, in := range tx.Inputs {
// input의 ID가 nil인지 체크.
// 이전 Tx가 유효하지 않다.
if prevTXs[hex.EncodeToString(in.ID)].ID == nil {
log.Panic("ERROR: Previous transaction is not correct")
}
}
txCopy := tx.TrimmedCopy()
for inID, in := range txCopy.Inputs {
prevTX := prevTXs[hex.EncodeToString(in.ID)]
txCopy.Inputs[inID].Signature = nil
txCopy.Inputs[inID].PubKey = prevTX.Outputs[in.Out].PubKeyHash
txCopy.ID = txCopy.Hash()
txCopy.Inputs[inID].PubKey = nil
// random number generator, privKey, txCopy.ID(txCopy.Hash)를 ecdsa.Sign함수에 넣으면 2개의 수가 나온다.
// 두 수를 바이트로 변환해서 signature를 만든다.
r, s, err := ecdsa.Sign(rand.Reader, &privKey, txCopy.ID)
Handle(err)
signature := append(r.Bytes(), s.Bytes()...)
tx.Inputs[inID].Signature = signature
}
}
// TrimmedCopy method
// Trim : 잘라 내다, 다듬다
// TxInput의 Signature과 PubKey 부분을 nil로 하여 새로운 Transaction을 만들어 리턴한다.
func (tx *Transaction) TrimmedCopy() Transaction {
var inputs []TxInput
var outputs []TxOutput
for _, in := range tx.Inputs {
inputs = append(inputs, TxInput{in.ID, in.Out, nil, nil})
}
for _, out := range tx.Outputs {
outputs = append(outputs, TxOutput{out.Value, out.PubKeyHash})
}
txCopy := Transaction{tx.ID, inputs, outputs}
return txCopy
}
// Verify : Sign이 유효한지 검증한다.
func (tx *Transaction) Verify(prevTXs map[string]Transaction) bool {
if tx.IsCoinbase() {
return true
}
// input을 돌며 존재하는지 체크.
for _, in := range tx.Inputs {
if prevTXs[hex.EncodeToString(in.ID)].ID == nil {
log.Panic("Previous transaction does not exist")
}
}
txCopy := tx.TrimmedCopy()
curve := elliptic.P256()
for inID, in := range txCopy.Inputs {
prevTX := prevTXs[hex.EncodeToString(in.ID)]
txCopy.Inputs[inID].Signature = nil
txCopy.Inputs[inID].PubKey = prevTX.Outputs[in.Out].PubKeyHash
txCopy.ID = txCopy.Hash()
txCopy.Inputs[inID].PubKey = nil
r := big.Int{}
s := big.Int{}
sigLen := len(in.Signature)
// Signature를 반으로 나눠서 r, s에 할당.
r.SetBytes(in.Signature[:(sigLen / 2)])
s.SetBytes(in.Signature[(sigLen / 2):])
x := big.Int{}
y := big.Int{}
keyLen := len(in.PubKey)
x.SetBytes(in.PubKey[:(keyLen / 2)])
y.SetBytes(in.PubKey[(keyLen / 2):])
// 잘못된 Sign이 하나라도 있으면 false
rawPubKey := ecdsa.PublicKey{Curve: curve, X: &x, Y: &y}
if ecdsa.Verify(&rawPubKey, txCopy.ID, &r, &s) == false {
return false
}
}
return true
}
// String : Trnasaction에 대한 정보 출력.
func (tx Transaction) String() string {
var lines []string
lines = append(lines, fmt.Sprintf("--- Transaction %x:", tx.ID))
for i, input := range tx.Inputs {
lines = append(lines, fmt.Sprintf(" Input %d:", i))
lines = append(lines, fmt.Sprintf(" TXID: %x", input.ID))
lines = append(lines, fmt.Sprintf(" Out: %d", input.Out))
lines = append(lines, fmt.Sprintf(" Signature: %x", input.Signature))
lines = append(lines, fmt.Sprintf(" PubKey: %x", input.PubKey))
}
for i, output := range tx.Outputs {
lines = append(lines, fmt.Sprintf(" Output %d:", i))
lines = append(lines, fmt.Sprintf(" Value: %d", output.Value))
lines = append(lines, fmt.Sprintf(" Script: %x", output.PubKeyHash))
}
return strings.Join(lines, "\n")
}
tx.go
package blockchain
import (
"bytes"
"github.com/HTaeha/Blockchain-in-Golang/wallet"
)
// TxOutput : Transaction Output
// Indivisible - 나눌 수 없는, 불가분의
// Output은 쪼갤 수 없다.
// ex) 500원짜리 물건을 사는데 1000원을 내면 1000원을 반으로 쪼개는 것이 아니라 500원(새로운 아웃풋)을 돌려준다.
// Value만큼의 값을 PubKey가 받는다.
type TxOutput struct {
// locked value in token
Value int
// 공개키 : token을 언락하기 위해 필요하다. (value의 안쪽을 보기 위해)
// Bitcoin에서는 Pubkey가 복잡한 스크립트 언어로 되어 있다.
// address의 public key hash 부분.
PubKeyHash []byte
}
// TxInput : Transaction Input
// ID에 해당하는 Transaction의 아웃풋에서 Out값 위치에 있는 UTXO를 Sig가 보낸다.
type TxInput struct {
// Input의 ID
// 사용할 Transaction의 ID.
ID []byte
// Output 의 인덱스.
// 해당 transaction에서 몇 번째 위치한 output과 연결되어 있는지 알려줌.
Out int
// Signature : TxOutput의 PubKey와 비슷한 역할.
// User's account, address
Signature []byte
// 소유자 지갑의 public key.
PubKey []byte
}
// NewTXOutput : 새로운 TXO를 생성해서 리턴.
func NewTXOutput(value int, address string) *TxOutput {
txo := &TxOutput{value, nil}
txo.Lock([]byte(address))
return txo
}
// UsesKey : TxInput의 public key hash와 pubKeyHash인자가 같은지 판별.
func (in *TxInput) UsesKey(pubKeyHash []byte) bool {
lockingHash := wallet.PublicKeyHash(in.PubKey)
return bytes.Compare(lockingHash, pubKeyHash) == 0
}
// Lock : Output의 PubKeyHash를 할당.
func (out *TxOutput) Lock(address []byte) {
pubKeyHash := wallet.Base58Decode(address)
// 4 : version byte
pubKeyHash = pubKeyHash[1 : len(pubKeyHash)-4]
out.PubKeyHash = pubKeyHash
}
// IsLockedWithKey : TxOutput의 public key hash와 pubKeyHash가 같은지 판별.
func (out *TxOutput) IsLockedWithKey(pubKeyHash []byte) bool {
return bytes.Compare(out.PubKeyHash, pubKeyHash) == 0
}
blockchain.go
기존의 address로 TxInput, TxOutput을 검증하던 것을 pubKeyHash로 검증한다.
package blockchain
import (
"bytes"
"crypto/ecdsa"
"encoding/hex"
"errors"
"fmt"
"os"
"runtime"
"github.com/dgraph-io/badger/v3"
)
const (
// database Path.
dbPath = "./tmp/blocks"
// DB가 존재하는지 체크하기 위한 MANIFEST file.
dbFile = "./tmp/blocks/MANIFEST"
genesisData = "First Transaction from Genesis"
)
// BlockChain structure
// 마지막 해쉬를 저장하고 DB 포인터를 저장해서 블록을 관리.
type BlockChain struct {
LastHash []byte
Database *badger.DB
}
// BlockChainIterator : DB에 저장된 블록체인을 순회하기 위해 생성.
type BlockChainIterator struct {
// 현재 가리키고 있는 hash
CurrentHash []byte
Database *badger.DB
}
// DBexists : DB가 존재하는지 체크.
func DBexists() bool {
if _, err := os.Stat(dbFile); os.IsNotExist(err) {
return false
}
return true
}
// InitBlockChain : Genesis 블록을 시작으로 하는 블록체인을 생성한다.
func InitBlockChain(address string) *BlockChain {
var lastHash []byte
// DB가 이미 존재하면 종료.
if DBexists() {
fmt.Println("Blockchain already exists")
runtime.Goexit()
}
opts := badger.DefaultOptions(dbPath)
// store key and metadata
opts.Dir = dbPath
// store all values
opts.ValueDir = dbPath
db, err := badger.Open(opts)
Handle(err)
// Update : read and write transactions on our databases.
// Txn : Transaction, which can be read-only or read-write.
err = db.Update(func(txn *badger.Txn) error {
// 첫 블록을 Coinbase로 한다.
cbtx := CoinbaseTx(address, genesisData)
genesis := Genesis(cbtx)
fmt.Println("Genesis created")
err = txn.Set(genesis.Hash, genesis.Serialize())
Handle(err)
err = txn.Set([]byte("lh"), genesis.Hash)
lastHash = genesis.Hash
return err
})
Handle(err)
blockchain := BlockChain{lastHash, db}
return &blockchain
}
// ContinueBlockChain : Blockchain이 이미 존재하고 있을 경우 그 블록체인을 리턴.
// address를 인자로 받고 있지만 이 함수 어디에서도 쓰이지 않는다.
// 현재는 블록체인이 하나만 생성되도록 되어 있어서 address에 아무 값이나 넣어도 상관이 없다.
// DB에 하나의 블록체인만 존재.
func ContinueBlockChain(address string) *BlockChain {
// DB가 존재하지 않으면 종료.
if DBexists() == false {
fmt.Println("No existing blockchain found, create one!")
runtime.Goexit()
}
var lastHash []byte
opts := badger.DefaultOptions(dbPath)
// store key and metadata
opts.Dir = dbPath
// store all values
opts.ValueDir = dbPath
db, err := badger.Open(opts)
Handle(err)
// Update : read and write transactions on our databases.
// Txn : Transaction, which can be read-only or read-write.
err = db.Update(func(txn *badger.Txn) error {
// 마지막 해쉬를 찾는다.
item, err := txn.Get([]byte("lh"))
Handle(err)
lastHash, err = item.ValueCopy(nil)
return err
})
Handle(err)
blockchain := BlockChain{lastHash, db}
return &blockchain
}
// AddBlock : transactions를 가지고 있는 블록을 추가한다.
func (chain *BlockChain) AddBlock(transactions []*Transaction) {
var lastHash []byte
// View : read-only type of transaction
err := chain.Database.View(func(txn *badger.Txn) error {
// 마지막 해쉬를 찾는다.
item, err := txn.Get([]byte("lh"))
Handle(err)
lastHash, err = item.ValueCopy(nil)
return err
})
Handle(err)
// 이전 해쉬값과 데이터로 새로운 블록을 생성.
newBlock := CreateBlock(transactions, lastHash)
err = chain.Database.Update(func(txn *badger.Txn) error {
// 새로운 블록의 해쉬값을 저장한다.
err := txn.Set(newBlock.Hash, newBlock.Serialize())
Handle(err)
// lh 키값을 새로운 블록의 해쉬값으로 바꾼다.
err = txn.Set([]byte("lh"), newBlock.Hash)
// BlockChain의 마지막 해쉬를 새로운 블록의 해쉬값으로 지정한다.
chain.LastHash = newBlock.Hash
return err
})
Handle(err)
}
// Iterator : 블록체인 이터레이터. LastHash부터 이전 해쉬로 가며 순회할 수 있다.
func (chain *BlockChain) Iterator() *BlockChainIterator {
iter := &BlockChainIterator{chain.LastHash, chain.Database}
return iter
}
// Next : BlockChain의 다음 블록을 반환한다.
func (iter *BlockChainIterator) Next() *Block {
var block *Block
err := iter.Database.View(func(txn *badger.Txn) error {
// 현재 가리키고 있는 hash를 deserialize해서 Block을 복원한다.
item, err := txn.Get(iter.CurrentHash)
Handle(err)
encodedBlock, err := item.ValueCopy(nil)
block = Deserialize(encodedBlock)
return err
})
Handle(err)
// iter가 이전 해시를 가리키도록 한다.
iter.CurrentHash = block.PrevHash
return block
}
// FindUnspentTransactions : 사용하지 않은 Transaction들을 찾는다.
// Transaction에 사용하지 않은 output이 한개라도 있으면 추가해서 반환한다.
func (chain *BlockChain) FindUnspentTransactions(pubKeyHash []byte) []Transaction {
var unspentTxs []Transaction
// key : string
// value : []int
spentTXOs := make(map[string][]int)
iter := chain.Iterator()
for {
block := iter.Next()
for _, tx := range block.Transactions {
txID := hex.EncodeToString(tx.ID)
Outputs:
for outIdx, out := range tx.Outputs {
// 사용한 TXO인지 체크.
// 사용했다면 (spentTXOs에 들어있다면) continue
if spentTXOs[txID] != nil {
for _, spentOut := range spentTXOs[txID] {
if spentOut == outIdx {
continue Outputs
}
}
}
// 사용하지 않았고 unlock할 수 있다면 unspentTxs에 추가.
if out.IsLockedWithKey(pubKeyHash) {
unspentTxs = append(unspentTxs, *tx)
// 강의에서는 break문이 없다.
// tx를 unspentTxs에 추가했다면 다음 tx로 넘어가야하지 않을까?
// 같은 tx가 여러개 추가되는 현상이 발생할 것 같음.
break
}
}
// Coinbase가 아닐 때
if tx.IsCoinbase() == false {
// Output을 찾기 위해 Input을 돈다.
// inTxID를 ID로 가지는 Tx 의 in.Out 번째 output은 사용한 output이다.
for _, in := range tx.Inputs {
if in.UsesKey(pubKeyHash) {
inTxID := hex.EncodeToString(in.ID)
spentTXOs[inTxID] = append(spentTXOs[inTxID], in.Out)
}
}
}
}
// Genesis block 까지 오면 break.
if len(block.PrevHash) == 0 {
break
}
}
return unspentTxs
}
// FindUTXO : 사용하지 않은 모든 output을 리턴한다.
// UTXOs의 Value를 모두 더하면 총잔고가 된다.
func (chain *BlockChain) FindUTXO(pubKeyHash []byte) []TxOutput {
var UTXOs []TxOutput
unspentTransactions := chain.FindUnspentTransactions(pubKeyHash)
// UTXO중에 unlock할 수 있는(해당 address 소유자) 것만 모아서 리턴.
for _, tx := range unspentTransactions {
for _, out := range tx.Outputs {
if out.IsLockedWithKey(pubKeyHash) {
UTXOs = append(UTXOs, out)
}
}
}
return UTXOs
}
// FindSpendableOutputs : coin based transaction이 아닌 보통의 transaction을 생성한다.
// address로 amount만큼의 코인을 보낸다.
func (chain *BlockChain) FindSpendableOutputs(pubKeyHash []byte, amount int) (int, map[string][]int) {
unspentOuts := make(map[string][]int)
unspentTxs := chain.FindUnspentTransactions(pubKeyHash)
accumulated := 0
Work:
// UTX 를 순회
for _, tx := range unspentTxs {
txID := hex.EncodeToString(tx.ID)
// 한 transaction의 output을 순회.
for outIdx, out := range tx.Outputs {
// unlock할 수 있어야 하고 보내고 싶은 코인의 수가 UTXO로부터 모든 금액보다 클 때
// 보낼 금액이 부족할 때 (accumulated를 더 증가시켜야 함.)
if out.IsLockedWithKey(pubKeyHash) && accumulated < amount {
accumulated += out.Value
unspentOuts[txID] = append(unspentOuts[txID], outIdx)
// 금액이 다 모임.
if accumulated >= amount {
break Work
}
}
}
}
return accumulated, unspentOuts
}
// FindTransaction : ID 와 일치하느 Tx를 찾는다.
func (chain *BlockChain) FindTransaction(ID []byte) (Transaction, error) {
iter := chain.Iterator()
for {
block := iter.Next()
for _, tx := range block.Transactions {
// 원하는 Tx 발견.
if bytes.Compare(tx.ID, ID) == 0 {
return *tx, nil
}
}
if len(block.PrevHash) == 0 {
break
}
}
// 블록을 전부 돌았는데 같은 ID를 가진 Tx가 없다.
return Transaction{}, errors.New("Transaction does not exist")
}
// SignTransaction : Tx에 sign을 하는 메소드.
func (chain *BlockChain) SignTransaction(tx *Transaction, privKey ecdsa.PrivateKey) {
// key : ID (hex)
// value : Transaction
prevTXs := make(map[string]Transaction)
// 해당 Tx의 모든 인풋을 돌면서 그 인풋이 사용한 이전 Tx를 찾아 prevTXs에 저장한다.
for _, in := range tx.Inputs {
prevTX, err := chain.FindTransaction(in.ID)
Handle(err)
prevTXs[hex.EncodeToString(prevTX.ID)] = prevTX
}
tx.Sign(privKey, prevTXs)
}
// VerifyTransaction : Tx를 검증하는 메소드.
func (chain *BlockChain) VerifyTransaction(tx *Transaction) bool {
// key : ID (hex)
// value : Transaction
prevTXs := make(map[string]Transaction)
// 해당 Tx의 모든 인풋을 돌면서 그 인풋이 사용한 이전 Tx를 찾아 prevTXs에 저장한다.
for _, in := range tx.Inputs {
prevTX, err := chain.FindTransaction(in.ID)
Handle(err)
prevTXs[hex.EncodeToString(prevTX.ID)] = prevTX
}
return tx.Verify(prevTXs)
}
Result
// 지갑 2개 생성.
❯ go run main.go createwallet
pub key: a4cf5c97b5634e47d8a92a8f21d5106b0b713e9fb36c79220d862d940211605c3d9db8d89add0e15ccf55a00cfa9b7effd51dfcbd10099a29e081b639e4dcc65
pub hash: 1325c81699162278f70e2365aac0a26139398b8e
address: 12kF6krD5gvWRUJVYw47T1as2aj3jxAcvA
fullHash: 001325c81699162278f70e2365aac0a26139398b8ecc618e8f
checksum: cc618e8f
version: 001325c81699162278f70e2365aac0a26139398b8e
New address is: 12kF6krD5gvWRUJVYw47T1as2aj3jxAcvA
❯ go run main.go createwallet
pub key: 47fc9ef4bc384a021d5ee3cc74760e167c27b7598d5bc82e490029318d2a22d61e957a193bae09775f70a4418105f89d78e082cae266f463ee4883e517137ac6
pub hash: 3043ec936f036df9d40c8231f109dd8846cb987f
address: 15QCofD8geLRwRnhVpNardj6jUHHWGtdRN
fullHash: 003043ec936f036df9d40c8231f109dd8846cb987fccc35a9d
checksum: ccc35a9d
version: 003043ec936f036df9d40c8231f109dd8846cb987f
New address is: 15QCofD8geLRwRnhVpNardj6jUHHWGtdRN// 첫 블록 생성. 100코인 받음.
❯ go run main.go createblockchain -address 12kF6krD5gvWRUJVYw47T1as2aj3jxAcvA
0005c62f997aaeac45e0009b933fb8595904f8f0fc0447a7594fa93b120b8fb1
Genesis created
Finished!
❯ go run main.go printchain
Previous Hash:
Hash: 0005c62f997aaeac45e0009b933fb8595904f8f0fc0447a7594fa93b120b8fb1
PoW: true
--- Transaction 7d20dd944b63bb401cdf016f18a6d587c56ec4507a3dca084079b95fd514e7cf:
Input 0:
TXID:
Out: -1
Signature:
PubKey: 4669727374205472616e73616374696f6e2066726f6d2047656e65736973
Output 0:
Value: 100
Script: 1325c81699162278f70e2365aac0a26139398b8e// A가 B에게 30코인 전송.
❯ go run main.go send -from 12kF6krD5gvWRUJVYw47T1as2aj3jxAcvA -to 15QCofD8geLRwRnhVpNardj6jUHHWGtdRN -amount 30
0001f084ad32fb322eb8f5381c268d3f27026c91b602a21476f09e740396b38c
Successful send
❯ go run main.go printchain
Previous Hash: 0005c62f997aaeac45e0009b933fb8595904f8f0fc0447a7594fa93b120b8fb1
Hash: 0001f084ad32fb322eb8f5381c268d3f27026c91b602a21476f09e740396b38c
PoW: true
--- Transaction 82f65affcede27a85259be9dedf63d3fa9a073d114c59062713279bf9acac1e4:
Input 0:
TXID: 7d20dd944b63bb401cdf016f18a6d587c56ec4507a3dca084079b95fd514e7cf
Out: 0
Signature: 3d0ffa6793d50f78ce9075e63504e2d6e9a9942638ad9c8eee233ed7ae510749656ef7e3b374cec58267baa05af6bd1748cef56f21c23f34e6a988f74be49b7e
PubKey: a4cf5c97b5634e47d8a92a8f21d5106b0b713e9fb36c79220d862d940211605c3d9db8d89add0e15ccf55a00cfa9b7effd51dfcbd10099a29e081b639e4dcc65
Output 0:
Value: 30
Script: 3043ec936f036df9d40c8231f109dd8846cb987f
Output 1:
Value: 70
Script: 1325c81699162278f70e2365aac0a26139398b8e
Previous Hash:
Hash: 0005c62f997aaeac45e0009b933fb8595904f8f0fc0447a7594fa93b120b8fb1
PoW: true
--- Transaction 7d20dd944b63bb401cdf016f18a6d587c56ec4507a3dca084079b95fd514e7cf:
Input 0:
TXID:
Out: -1
Signature:
PubKey: 4669727374205472616e73616374696f6e2066726f6d2047656e65736973
Output 0:
Value: 100
Script: 1325c81699162278f70e2365aac0a26139398b8e// 남은 잔고
❯ go run main.go getbalance -address 12kF6krD5gvWRUJVYw47T1as2aj3jxAcvA
Balance of 12kF6krD5gvWRUJVYw47T1as2aj3jxAcvA: 70
❯ go run main.go getbalance -address 15QCofD8geLRwRnhVpNardj6jUHHWGtdRN
Balance of 15QCofD8geLRwRnhVpNardj6jUHHWGtdRN: 30Last updated
