merkle

Documentation

Index

• func LeafHash(h hash.Hash, out, in []byte) []byte
• type HTree
  • func NewHTree(hasher hash.Hash) *HTree
  • func NewProofHTree(hasher hash.Hash, ref []byte) *HTree
  • func (h *HTree) Add(item []byte)
  • func (h *HTree) Proof() Proof
  • func (h *HTree) Root() []byte
• type Proof
  • func (p Proof) Hash(hasher hash.Hash, ref []byte) []byte
• type ProofStep
• type Tree
  • func NewProofTree(hasher hash.Hash, ref []byte) *Tree
  • func NewTree(hasher hash.Hash) *Tree
  • func (m *Tree) Add(str []byte)
  • func (m *Tree) Proof() Proof
  • func (m *Tree) Root() []byte

Functions

func LeafHash

func LeafHash(h hash.Hash, out, in []byte) []byte

LeafHash produces the hash of a leaf of a Tree.

Types

type HTree

type HTree struct {
	// contains filtered or unexported fields
}

HTree accepts a sequence of leaf hashes via its Add method. A leaf hash is the result of calling LeafHash on a string. After adding all leaf hashes in the sequence, their merkle root hash may be read via the Root method.

Note that a Tree works by converting its input from a sequence of strings to the corresponding sequence of leaf hashes and feeding those to an HTree.

func NewHTree

func NewHTree(hasher hash.Hash) *HTree

NewHTree produces a new HTree.

func NewProofHTree

func NewProofHTree(hasher hash.Hash, ref []byte) *HTree

NewProofHTree produces a new HTree that can compactly prove a given reference hash is in it. After adding elements to the tree, call Proof to get the proof.

func (*HTree) Add

func (h *HTree) Add(item []byte)

Add adds a leaf hash to the sequence in h. The caller must not reuse the space in item. It is an error to call Add after a call to Root or Proof.

func (*HTree) Proof

func (h *HTree) Proof() Proof

Proof returns the merkle proof for the reference hash given to NewProofHTree. It is an error to call Add after a call to Proof.

func (*HTree) Root

func (h *HTree) Root() []byte

Root returns the merkle root hash for the sequence of leaf hashes that have been added to h with Add. It is an error to call Add after a call to Root.

type Proof

type Proof struct {
	Steps []ProofStep
	// contains filtered or unexported fields
}

Proof is a merkle proof.

func (Proof) Hash

func (p Proof) Hash(hasher hash.Hash, ref []byte) []byte

Hash computes the hash of a merkle proof. A valid merkle proof hash matches the root hash of the merkle tree it came from.

To prove that x is in a tree, create a tree t with NewProofTree(h, x). Then fill the tree with calls to t.Add. Then get the proof p with t.Proof(). Then check that p.Hash(h, x) is the same as t.Root(). This will be true only if there was a call t.Add(x).

type ProofStep

type ProofStep struct {
	H    []byte
	Left bool
}

ProofStep is one step in a merkle proof.

type Tree

type Tree struct {
	// contains filtered or unexported fields
}

Tree accepts a sequence of strings via its Add method. It builds a merkle hash tree from them. After adding all strings in the sequence, their merkle root hash may be read via the Root method.

func NewProofTree

func NewProofTree(hasher hash.Hash, ref []byte) *Tree

NewProofTree produces a new Tree that can compactly prove a given string is in it. After adding elements to the tree, call Proof to get the proof.

func NewTree

func NewTree(hasher hash.Hash) *Tree

NewTree produces a new Tree.

func (*Tree) Add

func (m *Tree) Add(str []byte)

Add adds a string to the sequence in m. The caller may reuse the space in str. It is an error to call Add after a call to Root or Proof.

func (*Tree) Proof

func (m *Tree) Proof() Proof

Proof returns the merkle proof for the reference string given to NewProofTree. It is an error to call Add after a call to Proof.

func (*Tree) Root

func (m *Tree) Root() []byte

Root returns the merkle root hash for the sequence of strings that have been added to m with Add. It is an error to call Add after a call to Root.