implement crypto for tree; add govendor;

Author: begmaroman

database.go

@@ -1,5 +1,26 @@
-// TODO: need to implement DB feature
+// TODO: need to implement database functional
 package mpt
 
+import (
+	"github.com/begmaroman/mpt/enc"
+	"github.com/begmaroman/mpt/node"
+	"sync"
+)
+
 type Database struct {
+	sync.Mutex
+}
+
+func NewDatabase() *Database {
+	return &Database{}
+}
+
+func (db *Database) GetNode(hash enc.Hash, cGen uint16) node.Node {
+	return nil
+}
+
+func (db *Database) Insert(hash enc.Hash, blob []byte, node node.Node) {
+	db.Lock()
+	defer db.Unlock()
+	// TODO: need to implement storing logic
 }

enc/encoding.go

@@ -0,0 +1,64 @@
+package enc
+
+// BytesToHex encoding byte array to hex
+func BytesToHex(str []byte) []byte {
+	l := len(str)*2 + 1
+	var nibbles = make([]byte, l)
+	for i, b := range str {
+		nibbles[i*2] = b / 16
+		nibbles[i*2+1] = b % 16
+	}
+	nibbles[l-1] = 16
+	return nibbles
+}
+
+// PrefixLen returns the length of the common prefix of a and b.
+func PrefixLen(a, b []byte) int {
+	var i, length = 0, len(a)
+	if len(b) < length {
+		length = len(b)
+	}
+	for ; i < length; i++ {
+		if a[i] != b[i] {
+			break
+		}
+	}
+	return i
+}
+
+func HexToCompact(hex []byte) []byte {
+	terminator := byte(0)
+	if hasTerm(hex) {
+		terminator = 1
+		hex = hex[:len(hex)-1]
+	}
+	buf := make([]byte, len(hex)/2+1)
+	buf[0] = terminator << 5 // the flag byte
+	if len(hex)&1 == 1 {
+		buf[0] |= 1 << 4 // odd flag
+		buf[0] |= hex[0] // first nibble is contained in the first byte
+		hex = hex[1:]
+	}
+	decodeNibbles(hex, buf[1:])
+	return buf
+}
+
+func CopyBytes(b []byte) (copiedBytes []byte) {
+	if b == nil {
+		return nil
+	}
+	copiedBytes = make([]byte, len(b))
+	copy(copiedBytes, b)
+
+	return
+}
+
+func hasTerm(s []byte) bool {
+	return len(s) > 0 && s[len(s)-1] == 16
+}
+
+func decodeNibbles(nibbles []byte, bytes []byte) {
+	for bi, ni := 0, 0; ni < len(nibbles); bi, ni = bi+1, ni+2 {
+		bytes[bi] = nibbles[ni]<<4 | nibbles[ni+1]
+	}
+}

type.go enc/type.go

@@ -1,4 +1,4 @@
-package mpt
+package enc
 
 import (
 	"encoding/hex"
@@ -92,6 +92,18 @@ func (h *Hash) Scan(src interface{}) error {
 	return nil
 }
 
+// Useful type :)
+type SliceBuffer []byte
+
+func (b *SliceBuffer) Write(data []byte) (n int, err error) {
+	*b = append(*b, data...)
+	return len(data), nil
+}
+
+func (b *SliceBuffer) Reset() {
+	*b = (*b)[:0]
+}
+
 // FromHex returns the bytes represented by the hexadecimal string s.
 // s may be prefixed with "0x".
 func FromHex(s string) []byte {

encoding.go

@@ -0,0 +1,23 @@
+package mpt
+
+import (
+	"fmt"
+
+	"github.com/begmaroman/mpt/enc"
+)
+
+type ErrNodeNotFound struct {
+	Key  []byte
+	Hash enc.Hash
+}
+
+func NewErrNodeNotFound(key []byte, hash enc.Hash) *ErrNodeNotFound {
+	return &ErrNodeNotFound{
+		Key:  key,
+		Hash: hash,
+	}
+}
+
+func (e *ErrNodeNotFound) Error() string {
+	return fmt.Sprintf("node not found: hash %v key %v", e.Hash, e.Key)
+}

error.go

@@ -21,19 +21,24 @@ func main() {
 	fmt.Println()
 
 	// try to update value
-	ok = trie.Update([]byte("key_new"), []byte("val_new_updated"))
-	fmt.Println("updated:", ok)
-	fmt.Println()
+	//ok, _ = trie.Update([]byte("key_new"), []byte("val_new_updated"))
+	//fmt.Println("updated:", ok)
+	//fmt.Println()
 
 	// try to find value
 	found, ok = trie.Get([]byte("key_new"))
 	fmt.Println("value:", string(found))
 	fmt.Println("found:", ok)
 	fmt.Println()
 
-	ok = trie.Delete([]byte("key_new"))
+	ok, _ = trie.Delete([]byte("key_new"))
 	fmt.Println("deleted:", ok)
 	found, ok = trie.Get([]byte("key_new"))
 	fmt.Println("value:", string(found))
 	fmt.Println("found:", ok)
+	fmt.Println()
+
+	h, err := trie.Hash()
+	fmt.Println("hash of the tree:", h.String())
+	fmt.Println("error of hash:", err)
 }

example/simple.go

@@ -0,0 +1,156 @@
+package mpt
+
+import (
+	"hash"
+	"sync"
+
+	"github.com/begmaroman/mpt/enc"
+	"github.com/begmaroman/mpt/node"
+	"github.com/ethereum/go-ethereum/crypto/sha3"
+	"github.com/ethereum/go-ethereum/rlp"
+)
+
+var (
+	hPool = sync.Pool{
+		New: func() interface{} {
+			return &Encryptor{
+				rlpBuf: make(enc.SliceBuffer, 0, 550),
+				sha:    sha3.NewKeccak256().(keccakState),
+			}
+		},
+	}
+)
+
+type keccakState interface {
+	hash.Hash
+	Read([]byte) (int, error)
+}
+
+type Encryptor struct {
+	rlpBuf enc.SliceBuffer
+	sha    keccakState
+}
+
+func NewEncryptor() *Encryptor {
+	h := hPool.Get().(*Encryptor)
+	return h
+}
+
+// hash recursive hash the trie based on keccak256 and sha3
+func (sh *Encryptor) hash(n node.Node, db *Database, force bool) (node.Node, node.Node, error) {
+	// If we're not storing the node, just hashing, use available cached data
+	if cHach, dirty := n.Cache(); cHach != nil && !dirty {
+		return node.NewHashNode(cHach), n, nil
+	}
+
+	// Trie not processed yet or needs storage, walk the children
+	collapsed, cached, err := sh.getChildHash(n, db)
+	if err != nil {
+		return node.NewHashNode(nil), n, err
+	}
+
+	hashed, err := sh.store(collapsed, db, force)
+	if err != nil {
+		return node.NewHashNode(nil), n, err
+	}
+
+	cachedHash, _ := hashed.(node.HashNode)
+	switch cn := cached.(type) {
+	case *node.ExtensionNode:
+		cn.Hash = cachedHash
+		if db != nil {
+			cn.Dirty = false
+		}
+	case *node.BranchNode:
+		cn.Hash = cachedHash
+		if db != nil {
+			cn.Dirty = false
+		}
+	}
+
+	return hashed, cached, nil
+}
+
+// getChildHash hash children nodes
+func (sh *Encryptor) getChildHash(original node.Node, db *Database) (node.Node, node.Node, error) {
+	var err error
+
+	switch n := original.(type) {
+	case *node.ExtensionNode:
+		// Hash the short node's child, caching the newly hashed subtree
+		collapsed, cached := n.Copy(), n.Copy()
+		collapsed.Key = enc.HexToCompact(n.Key)
+		cached.Key = enc.CopyBytes(n.Key)
+
+		switch n.Value.(type) {
+		case node.LeafNode:
+		default:
+			if collapsed.Value, cached.Value, err = sh.hash(n.Value, db, false); err != nil {
+				return original, original, err
+			}
+		}
+
+		return collapsed, cached, nil
+
+	case *node.BranchNode:
+		// Hash the full node's children, caching the newly hashed subtrees
+		collapsed, cached := n.Copy(), n.Copy()
+
+		for i := 0; i < 16; i++ {
+			if n.Children[i] == nil {
+				continue
+			}
+
+			if collapsed.Children[i], cached.Children[i], err = sh.hash(n.Children[i], db, false); err != nil {
+				return original, original, err
+			}
+		}
+
+		cached.Children[16] = n.Children[16]
+
+		return collapsed, cached, nil
+
+	default:
+		// Value and hash nodes don't have children so they're left as were
+		return n, original, nil
+	}
+}
+
+func (sh *Encryptor) store(n node.Node, db *Database, force bool) (node.Node, error) {
+	// Don't store hashes or empty nodes.
+	if _, isHash := n.(node.HashNode); n == nil || isHash {
+		return n, nil
+	}
+
+	// Generate the RLP encoding of the node
+	sh.rlpBuf.Reset()
+	if err := rlp.Encode(&sh.rlpBuf, n); err != nil {
+		return n, err
+	}
+
+	// Nodes smaller than 32 bytes are stored inside their parent
+	if len(sh.rlpBuf) < 32 && !force {
+		return n, nil
+	}
+
+	// Larger nodes are replaced by their hash and stored in the database.
+	hash, dirty := n.Cache()
+	if hash == nil || dirty {
+		hash = sh.makeHashNode(sh.rlpBuf)
+	}
+
+	if db != nil {
+		// We are pooling the trie nodes into an intermediate memory cache
+		db.Insert(enc.BytesToHash(hash), sh.rlpBuf, n)
+	}
+
+	return node.NewHashNode(hash), nil
+}
+
+func (sh *Encryptor) makeHashNode(data []byte) node.HashNode {
+	n := make(node.HashNode, sh.sha.Size())
+	sh.sha.Reset()
+	sh.sha.Write(data)
+	sh.sha.Read(n)
+	return n
+}