Implement DB persistence

blockchain.go

@@ -1,18 +1,143 @@
 package main
 
+import (
+	"fmt"
+	"log"
+	"os"
+
+	"github.com/boltdb/bolt"
+)
+
+const dbFile = "blockchain.db"
+const blocksBucket = "blocks"
+
 // Blockchain keeps a sequence of Blocks
 type Blockchain struct {
 	blocks []*Block
+	tip    []byte
+}
+
+// BlockchainIterator is used to iterate over blockchain blocks
+type BlockchainIterator struct {
+	currentHash []byte
 }
 
 // AddBlock saves provided data as a block in the blockchain
 func (bc *Blockchain) AddBlock(data string) {
-	prevBlock := bc.blocks[len(bc.blocks)-1]
+	var lastHash []byte
-	newBlock := NewBlock(data, prevBlock.Hash)
+
-	bc.blocks = append(bc.blocks, newBlock)
+	db, err := bolt.Open(dbFile, 0600, nil)
+	if err != nil {
+		log.Panic(err)
+	}
+	defer db.Close()
+
+	err = db.View(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte(blocksBucket))
+		lastHash = b.Get([]byte("l"))
+
+		return nil
+	})
+
+	newBlock := NewBlock(data, lastHash)
+
+	err = db.Update(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte(blocksBucket))
+		err := b.Put(newBlock.Hash, newBlock.Serialize())
+		if err != nil {
+			log.Panic(err)
+		}
+
+		err = b.Put([]byte("l"), newBlock.Hash)
+		if err != nil {
+			log.Panic(err)
+		}
+
+		bc.tip = newBlock.Hash
+
+		return nil
+	})
+}
+
+// Iterator ...
+func (bc *Blockchain) Iterator() *BlockchainIterator {
+	bci := &BlockchainIterator{bc.tip}
+
+	return bci
+}
+
+// Next returns next block starting from the tip
+func (i *BlockchainIterator) Next() *Block {
+	var block *Block
+	db, err := bolt.Open(dbFile, 0600, nil)
+	if err != nil {
+		log.Panic(err)
+	}
+	defer db.Close()
+
+	err = db.View(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte(blocksBucket))
+		encodedBlock := b.Get(i.currentHash)
+		block = DeserializeBlock(encodedBlock)
+
+		return nil
+	})
+
+	i.currentHash = block.PrevBlockHash
+
+	return block
 }
 
 // NewBlockchain creates a new Blockchain with genesis Block
 func NewBlockchain() *Blockchain {
-	return &Blockchain{[]*Block{NewGenesisBlock()}}
+	bc := Blockchain{}
+
+	if _, err := os.Stat(dbFile); os.IsNotExist(err) {
+		fmt.Println("Creating a new blockchain...")
+		db, err := bolt.Open(dbFile, 0600, nil)
+		if err != nil {
+			log.Panic(err)
+		}
+		defer db.Close()
+
+		genesis := NewGenesisBlock()
+
+		err = db.Update(func(tx *bolt.Tx) error {
+			b, err := tx.CreateBucket([]byte(blocksBucket))
+			if err != nil {
+				log.Panic(err)
+			}
+
+			err = b.Put(genesis.Hash, genesis.Serialize())
+			if err != nil {
+				log.Panic(err)
+			}
+
+			err = b.Put([]byte("l"), genesis.Hash)
+			if err != nil {
+				log.Panic(err)
+			}
+
+			return nil
+		})
+
+		bc.tip = genesis.Hash
+	} else {
+		// TODO: remove the duplication, check for the "l" key
+		db, err := bolt.Open(dbFile, 0600, nil)
+		if err != nil {
+			log.Panic(err)
+		}
+		defer db.Close()
+
+		err = db.View(func(tx *bolt.Tx) error {
+			b := tx.Bucket([]byte(blocksBucket))
+			tip := b.Get([]byte("l"))
+			bc.tip = tip
+
+			return nil
+		})
+	}
+
+	return &bc
 }

main.go

@@ -8,15 +8,23 @@ import (
 func main() {
 	bc := NewBlockchain()
 
-	bc.AddBlock("Send 1 BTC to Ivan")
+	// bc.AddBlock("Send 1 BTC to Ivan")
-	bc.AddBlock("Send 2 more BTC to Ivan")
+	// bc.AddBlock("Send 2 more BTC to Ivan")
+
+	bci := bc.Iterator()
+
+	for {
+		block := bci.Next()
 
-	for _, block := range bc.blocks {
 		fmt.Printf("Prev. hash: %x\n", block.PrevBlockHash)
 		fmt.Printf("Data: %s\n", block.Data)
 		fmt.Printf("Hash: %x\n", block.Hash)
 		pow := NewProofOfWork(block)
 		fmt.Printf("PoW: %s\n", strconv.FormatBool(pow.Validate()))
 		fmt.Println()
+
+		if len(block.PrevBlockHash) == 0 {
+			break
+		}
 	}
 }