package internal
import (
"bytes"
"crypto/sha256"
"time"
)
// We need to define the Block| A Blocck represent a single block in a chain of blocks(Blockchain)
type Block struct {
Index int
TimesTamp time.Time
Data []byte
PreviosHash []byte
Hash []byte
}
// we need to define a newBlock and returns a new empty `Block`
func newBlock() Block {
n := Block{}
n.TimesTamp = time.Now()
n.Hash = hashBlock(n)
return n
}
func hashBlock(b Block) []byte {
h := sha256.New()
h.Write(Int64Bytes(int64(b.Index)))
h.Write(Int64Bytes(b.TimesTamp.Unix()))
h.Write(b.Data)
h.Write(b.PreviosHash)
return h.Sum(nil)
}
//isValidate validites the current block ('b') with previos block in a chain
func (b Block) Validate(o Block) bool {
if (bytes.Compare(b.Hash, hashBlock(b)) != 0) ||
(b.Index != (o.Index + 1)) ||
(bytes.Compare(b.PreviosHash, o.Hash) != 0) {
return false
}
return true
}
// Generate creates a new block from the current block which is assumed to be the
// last block in the chain.
func (b Block) Generate(data []byte) Block{
n := Block{
Index: b.Index+1,
TimesTamp: time.Now(),
Data: make([]byte, data[0]),
PreviosHash: b.Hash,
}
return n
}
package internal
import "errors"
var (
// ErrInvalidBlock is an error returned if an invalid block is added to
// a block chain where the new block's has and index are invalid
ErrInvalidBlock = errors.New("error: invalid block")
)
// Chain is a slice of blocks to form the "block chain". Each block is
// connected to the previous block cryptographically by each block's hash
// being in corporated into the next block in the chain. The larger the chain
// grows the higher the integrity of the chain and the more difficult it is to
// temper with or modify previous blocks in the chain.
type Chain []Block
// NewChain creates a new "block chain" `Chain` with an initial block already
// created called the "genesis block"
func NewChain() *Chain {
return &Chain{newBlock()}
}
// Add adds a new block (`block`) to the chain verifying its validty
// If the block is invalid an error is returned otherwise the block is appended
// to the block chain.
func (c *Chain) Add(block Block) error {
prevBlock := (*c)[len(*c)-1]
if !block.Validate(prevBlock) {
return ErrInvalidBlock
}
*c = append(*c, block)
return nil
}
// Write creates a new block with the given data (`data`) and appends it to the
// block chain. This implements the `io.Writer` interface so you can treat the
// block chain as a valid Writer.
func (c *Chain) Write(data []byte) (int, error) {
prevBlock := (*c)[len(*c)-1]
block := prevBlock.Generate(data)
if err := c.Add(block); err != nil {
return 0, ErrInvalidBlock
}
return len(data), nil
}
// Verify verifies the cryptographic hashes of every block inthe chain
// ensuring all blocks are valid and their integrity in tact
func (c *Chain) Verify() bool {
prevBlock := (*c)[0]
for _, block := range (*c)[1:] {
if !block.Validate(prevBlock) {
return false
}
prevBlock = block
}
return true
}
package internal
import "encoding/binary"
// Int64Bytes converts the integer `i` an `int64` into a byte array
// using Big Endian encoding
func Int64Bytes(i int64) []byte{
b := make([]byte, 8)
binary.BigEndian.PutUint64(b, uint64(i))
return b
}
package main
import (
"SimpleBlock/internal"
"encoding/json"
"fmt"
)
func main() {
c := internal.NewChain()
c.Write([]byte("foo"))
c.Write([]byte("bar"))
if !c.Verify() {
panic("Blockchain verification failure")
}
data, _ := json.Marshal(c)
fmt.Print(string(data))
}
