Jeiwan · Sep 7, 2017 · Sep 7, 2017 · Sep 7, 2017 · Sep 7, 2017 · Sep 7, 2017
diff --git a/.gitignore b/.gitignore
@@ -1 +1,2 @@
 *.db
+wallet.dat
diff --git a/README.md b/README.md
@@ -2,7 +2,8 @@
 
 A blockchain implementation in Go, as described in these articles:
 
-1. [Basic Prototype](https://jeiwan.cc/posts/building-blockchain-in-go-part-1/)
-2. [Proof-of-Work](https://jeiwan.cc/posts/building-blockchain-in-go-part-2/)
-2. [Persistence and CLI](https://jeiwan.cc/posts/building-blockchain-in-go-part-3/)
-3. [Transactions 1](https://jeiwan.cc/posts/building-blockchain-in-go-part-4/)
+1. [Basic Prototype](https://jeiwan.net/posts/building-blockchain-in-go-part-1/)
+2. [Proof-of-Work](https://jeiwan.net/posts/building-blockchain-in-go-part-2/)
+2. [Persistence and CLI](https://jeiwan.net/posts/building-blockchain-in-go-part-3/)
+3. [Transactions 1](https://jeiwan.net/posts/building-blockchain-in-go-part-4/)
+3. [Addresses](https://jeiwan.net/posts/building-blockchain-in-go-part-5/)
diff --git a/base58.go b/base58.go
@@ -0,0 +1,59 @@
+package main
+
+import (
+	"bytes"
+	"math/big"
+)
+
+var b58Alphabet = []byte("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
+
+// Base58Encode encodes a byte array to Base58
+func Base58Encode(input []byte) []byte {
+	var result []byte
+
+	x := big.NewInt(0).SetBytes(input)
+
+	base := big.NewInt(int64(len(b58Alphabet)))
+	zero := big.NewInt(0)
+	mod := &big.Int{}
+
+	for x.Cmp(zero) != 0 {
+		x.DivMod(x, base, mod)
+		result = append(result, b58Alphabet[mod.Int64()])
+	}
+
+	ReverseBytes(result)
+	for b := range input {
+		if b == 0x00 {
+			result = append([]byte{b58Alphabet[0]}, result...)
+		} else {
+			break
+		}
+	}
+
+	return result
+}
+
+// Base58Decode decodes Base58-encoded data
+func Base58Decode(input []byte) []byte {
+	result := big.NewInt(0)
+	zeroBytes := 0
+
+	for b := range input {
+		if b == 0x00 {
+			zeroBytes++
+		}
+	}
+
+	payload := input[zeroBytes:]
+	for _, b := range payload {
+		charIndex := bytes.IndexByte(b58Alphabet, b)
+		result.Mul(result, big.NewInt(58))
+		result.Add(result, big.NewInt(int64(charIndex)))
+	}
+
+	decoded := result.Bytes()
+	decoded = append(bytes.Repeat([]byte{byte(0x00)}, zeroBytes), decoded...)
+
+	return decoded
+}
diff --git a/block.go b/block.go
@@ -8,7 +8,7 @@ import (
 	"time"
 )
 
-// Block keeps block headers
+// Block represents a block in the blockchain
 type Block struct {
 	Timestamp     int64
 	Transactions  []*Transaction
@@ -17,17 +17,21 @@ type Block struct {
 	Nonce         int
 }
 
-// Serialize serializes the block
-func (b *Block) Serialize() []byte {
-	var result bytes.Buffer
-	encoder := gob.NewEncoder(&result)
+// NewBlock creates and returns Block
+func NewBlock(transactions []*Transaction, prevBlockHash []byte) *Block {
+	block := &Block{time.Now().Unix(), transactions, prevBlockHash, []byte{}, 0}
+	pow := NewProofOfWork(block)
+	nonce, hash := pow.Run()
 
-	err := encoder.Encode(b)
-	if err != nil {
-		log.Panic(err)
-	}
+	block.Hash = hash[:]
+	block.Nonce = nonce
 
-	return result.Bytes()
+	return block
+}
+
+// NewGenesisBlock creates and returns genesis Block
+func NewGenesisBlock(coinbase *Transaction) *Block {
+	return NewBlock([]*Transaction{coinbase}, []byte{})
 }
 
 // HashTransactions returns a hash of the transactions in the block
@@ -36,28 +40,24 @@ func (b *Block) HashTransactions() []byte {
 	var txHash [32]byte
 
 	for _, tx := range b.Transactions {
-		txHashes = append(txHashes, tx.ID)
+		txHashes = append(txHashes, tx.Hash())
 	}
 	txHash = sha256.Sum256(bytes.Join(txHashes, []byte{}))
 
 	return txHash[:]
 }
 
-// NewBlock creates and returns Block
-func NewBlock(transactions []*Transaction, prevBlockHash []byte) *Block {
-	block := &Block{time.Now().Unix(), transactions, prevBlockHash, []byte{}, 0}
-	pow := NewProofOfWork(block)
-	nonce, hash := pow.Run()
-
-	block.Hash = hash[:]
-	block.Nonce = nonce
+// Serialize serializes the block
+func (b *Block) Serialize() []byte {
+	var result bytes.Buffer
+	encoder := gob.NewEncoder(&result)
 
-	return block
-}
+	err := encoder.Encode(b)
+	if err != nil {
+		log.Panic(err)
+	}
 
-// NewGenesisBlock creates and returns genesis Block
-func NewGenesisBlock(coinbase *Transaction) *Block {
-	return NewBlock([]*Transaction{coinbase}, []byte{})
+	return result.Bytes()
 }
 
 // DeserializeBlock deserializes a block