Unified deterministic merkle tree computation. Now we have 2 types of

trees... IAVL (nondeterministic) and Simple (deterministic)

merkle/simple_tree.go

@@ -0,0 +1,173 @@
+/*
+Computes a deterministic minimal height merkle tree hash.
+If the number of items is not a power of two, some leaves
+will be at different levels, leaning left.
+
+Use this for shorter deterministic trees, such as the validator list.
+For larger datasets, use IAVLTree.
+
+				*
+			   / \
+			 /     \
+		   /         \
+		 /             \
+		*               *
+	   / \             / \
+	  /   \           /   \
+	 /     \         /     \
+	*       *       *       h6
+   / \     / \     / \
+  h0  h1  h2  h3  h4  h5
+
+*/
+
+package merkle
+
+import (
+	"bytes"
+	"crypto/sha256"
+
+	. "github.com/tendermint/tendermint/binary"
+)
+
+func HashFromTwoHashes(left []byte, right []byte) []byte {
+	var n int64
+	var err error
+	var hasher = sha256.New()
+	WriteByteSlice(hasher, left, &n, &err)
+	WriteByteSlice(hasher, right, &n, &err)
+	if err != nil {
+		panic(err)
+	}
+	return hasher.Sum(nil)
+}
+
+func HashFromHashes(hashes [][]byte) []byte {
+	// Recursive impl.
+	switch len(hashes) {
+	case 0:
+		panic("Cannot call HashFromHashes() with 0 length arg")
+	case 1:
+		return hashes[0]
+	default:
+		left := HashFromHashes(hashes[:(len(hashes)+1)/2])
+		right := HashFromHashes(hashes[(len(hashes)+1)/2:])
+		return HashFromTwoHashes(left, right)
+	}
+}
+
+// Convenience for HashFromHashes.
+func HashFromBinaries(items []Binary) []byte {
+	hashes := [][]byte{}
+	for _, item := range items {
+		hasher := sha256.New()
+		_, err := item.WriteTo(hasher)
+		if err != nil {
+			panic(err)
+		}
+		hash := hasher.Sum(nil)
+		hashes = append(hashes, hash)
+	}
+	return HashFromHashes(hashes)
+}
+
+// Convenience for HashFromHashes.
+func HashFromHashables(items []Hashable) []byte {
+	hashes := [][]byte{}
+	for _, item := range items {
+		hash := item.Hash()
+		hashes = append(hashes, hash)
+	}
+	return HashFromHashes(hashes)
+}
+
+type HashTrail struct {
+	Hash   []byte
+	Parent *HashTrail
+	Left   *HashTrail
+	Right  *HashTrail
+}
+
+func (ht *HashTrail) Flatten() [][]byte {
+	// Nonrecursive impl.
+	trail := [][]byte{}
+	for ht != nil {
+		if ht.Left != nil {
+			trail = append(trail, ht.Left.Hash)
+		} else if ht.Right != nil {
+			trail = append(trail, ht.Right.Hash)
+		} else {
+			break
+		}
+		ht = ht.Parent
+	}
+	return trail
+}
+
+// returned trails[0].Hash is the leaf hash.
+// trails[0].Parent.Hash is the hash above that, etc.
+func HashTrailsFromHashables(items []Hashable) (trails []*HashTrail, root *HashTrail) {
+	// Recursive impl.
+	switch len(items) {
+	case 0:
+		panic("Cannot call HashTrailsFromHashables() with 0 length arg")
+	case 1:
+		trail := &HashTrail{items[0].Hash(), nil, nil, nil}
+		return []*HashTrail{trail}, trail
+	default:
+		lefts, leftRoot := HashTrailsFromHashables(items[:(len(items)+1)/2])
+		rights, rightRoot := HashTrailsFromHashables(items[(len(items)+1)/2:])
+		rootHash := HashFromTwoHashes(leftRoot.Hash, rightRoot.Hash)
+		root := &HashTrail{rootHash, nil, nil, nil}
+		leftRoot.Parent = root
+		leftRoot.Right = rightRoot
+		rightRoot.Parent = root
+		rightRoot.Left = leftRoot
+		return append(lefts, rights...), root
+	}
+}
+
+// Ensures that leafHash is part of rootHash.
+func VerifyHashTrail(index uint, total uint, leafHash []byte, trail [][]byte, rootHash []byte) bool {
+	computedRoot := ComputeRootFromTrail(index, total, leafHash, trail)
+	if computedRoot == nil {
+		return false
+	}
+	return bytes.Equal(computedRoot, rootHash)
+}
+
+// Use the leafHash and trail to get the root merkle hash.
+// If the length of the trail slice isn't exactly correct, the result is nil.
+func ComputeRootFromTrail(index uint, total uint, leafHash []byte, trail [][]byte) []byte {
+	// Recursive impl.
+	if index >= total {
+		return nil
+	}
+	switch total {
+	case 0:
+		panic("Cannot call ComputeRootFromTrail() with 0 total")
+	case 1:
+		if len(trail) != 0 {
+			return nil
+		}
+		return leafHash
+	default:
+		if len(trail) == 0 {
+			return nil
+		}
+		numLeft := (total + 1) / 2
+		if index < numLeft {
+			leftRoot := ComputeRootFromTrail(index, numLeft, leafHash, trail[:len(trail)-1])
+			if leftRoot == nil {
+				return nil
+			}
+			return HashFromTwoHashes(leftRoot, trail[len(trail)-1])
+		} else {
+			rightRoot := ComputeRootFromTrail(index-numLeft, total-numLeft, leafHash, trail[:len(trail)-1])
+			if rightRoot == nil {
+				return nil
+			}
+			return HashFromTwoHashes(trail[len(trail)-1], rightRoot)
+		}
+	}
+}