nmt

Sep 24, 2025

Changes in this version

type NamespacedMerkleTree

+ func (n *NamespacedMerkleTree) Reset()

type Option

+ func ReuseBuffers(reuse bool) Option

type Options

+ ReuseBuffers bool

May 23, 2025

Changes in this version

+ func ComputeAndValidateLeafHashes(nth *NmtHasher, nid namespace.ID, leaves [][]byte) ([][]byte, error)

+ func ComputePrefixedLeafHashes(nth *NmtHasher, nid namespace.ID, leaves [][]byte) ([][]byte, error)

type Proof

+ func (proof Proof) ComputeRootWithBasicValidation(nth *NmtHasher, nID namespace.ID, leafHashes [][]byte, isNamespace bool) ([]byte, error)

Jul 16, 2024

Changes in this version

+ type LeafRange struct

+ End int

+ Start int

+ func ToLeafRanges(proofStart, proofEnd, subtreeWidth int) ([]LeafRange, error)

type NamespacedMerkleTree

+ func (n *NamespacedMerkleTree) ComputeSubtreeRoot(start, end int) ([]byte, error)

type Proof

+ func (proof Proof) VerifySubtreeRootInclusion(nth *NmtHasher, subtreeRoots [][]byte, subtreeWidth int, root []byte) (bool, error)

May 24, 2024

Changes in this version

+ var ErrWrongLeafHashesSize = errors.New("wrong leafHashes size")

Jul 19, 2023

Changes in this version

type Proof

+ func ProtoToProof(protoProof pb.Proof) Proof

Jun 27, 2023

Changes in this version

type NamespacedMerkleTree

+ func (n *NamespacedMerkleTree) ForceAddLeaf(leaf namespace.PrefixedData) error

+ type NmtHasher struct

+ NamespaceLen namespace.IDSize

+ func (n *NmtHasher) BlockSize() int

+ func (n *NmtHasher) EmptyRoot() []byte

+ func (n *NmtHasher) HashLeaf(ndata []byte) ([]byte, error)

+ func (n *NmtHasher) HashNode(left, right []byte) ([]byte, error)

+ func (n *NmtHasher) IsMaxNamespaceIDIgnored() bool

+ func (n *NmtHasher) MustHashLeaf(ndata []byte) []byte

+ func (n *NmtHasher) NamespaceSize() namespace.IDSize

+ func (n *NmtHasher) Reset()

+ func (n *NmtHasher) Size() int

+ func (n *NmtHasher) Sum([]byte) []byte

+ func (n *NmtHasher) ValidateLeaf(data []byte) (err error)

+ func (n *NmtHasher) ValidateNodeFormat(node []byte) (err error)

+ func (n *NmtHasher) ValidateNodes(left, right []byte) error

+ func (n *NmtHasher) Write(data []byte) (int, error)

type Option

+ func CustomHasher(h Hasher) Option

type Options

+ Hasher Hasher

type Proof

+ func (proof *Proof) UnmarshalJSON(data []byte) error

+ func (proof Proof) MarshalJSON() ([]byte, error)

May 18, 2023

Changes in this version

+ var ErrInvalidNodeNamespaceOrder = errors.New("invalid NMT node namespace order")

type Hasher

+ func (n *Hasher) MustHashLeaf(ndata []byte) []byte

type NamespacedMerkleTree

+ func (n *NamespacedMerkleTree) Size() int

type Proof

+ func (proof Proof) IsEmptyProof() bool

+ func (proof Proof) VerifyLeafHashes(nth *Hasher, verifyCompleteness bool, nID namespace.ID, leafHashes [][]byte, ...) (bool, error)

Mar 30, 2023

Changes in this version

+ var ErrFailedCompletenessCheck = errors.New("failed completeness check")

+ var ErrInvalidLeafLen = errors.New("invalid NMT leaf size")

+ var ErrInvalidNodeLen = errors.New("invalid NMT node size")

+ var ErrUnorderedSiblings = errors.New("NMT sibling nodes should be ordered lexicographically by namespace IDs")

type Hasher

+ func (n *Hasher) ValidateLeaf(data []byte) (err error)

+ func (n *Hasher) ValidateNodeFormat(node []byte) (err error)

+ func (n *Hasher) ValidateNodes(left, right []byte) error

type NamespacedMerkleTree

+ func (n *NamespacedMerkleTree) MaxNamespace() (namespace.ID, error)

+ func (n *NamespacedMerkleTree) MinNamespace() (namespace.ID, error)

Jan 23, 2023

Changes in this version

+ const DefaultCapacity

type Hasher

+ func (n *Hasher) BlockSize() int

+ func (n *Hasher) Reset()

+ func (n *Hasher) Size() int

+ func (n *Hasher) Sum([]byte) []byte

+ func (n *Hasher) Write(data []byte) (int, error)

Oct 12, 2022

Changes in this version

+ const DefaultNamespaceIDLen

+ const LeafPrefix

+ const NodePrefix

+ var ErrInvalidPushOrder = errors.New("pushed data has to be lexicographically ordered by namespace IDs")

+ var ErrInvalidRange = errors.New("invalid proof range")

+ var ErrMismatchedNamespaceSize = errors.New("mismatching namespace sizes")

+ func GetSubrootPaths(squareSize uint, idxStart uint, shareCount uint) ([][][]int, error)

+ func MaxNamespace(hash []byte, size namespace.IDSize) []byte

+ func MinNamespace(hash []byte, size namespace.IDSize) []byte

+ func Sha256Namespace8FlaggedInner(leftRight []byte) []byte

+ func Sha256Namespace8FlaggedLeaf(namespacedData []byte) []byte

+ type Hasher struct

+ NamespaceLen namespace.IDSize

+ func NewNmtHasher(baseHasher hash.Hash, nidLen namespace.IDSize, ignoreMaxNamespace bool) *Hasher

+ func (n *Hasher) EmptyRoot() []byte

+ func (n *Hasher) HashLeaf(leaf []byte) []byte

+ func (n *Hasher) HashNode(l, r []byte) []byte

+ func (n *Hasher) IsMaxNamespaceIDIgnored() bool

+ func (n *Hasher) NamespaceSize() namespace.IDSize

+ type NamespacedMerkleTree struct

+ func New(h hash.Hash, setters ...Option) *NamespacedMerkleTree

+ func (n *NamespacedMerkleTree) Push(namespacedData namespace.PrefixedData) error

+ func (n *NamespacedMerkleTree) Root() []byte

+ func (n NamespacedMerkleTree) Get(nID namespace.ID) [][]byte

+ func (n NamespacedMerkleTree) GetWithProof(nID namespace.ID) ([][]byte, Proof, error)

+ func (n NamespacedMerkleTree) NamespaceSize() namespace.IDSize

+ func (n NamespacedMerkleTree) Prove(index int) (Proof, error)

+ func (n NamespacedMerkleTree) ProveNamespace(nID namespace.ID) (Proof, error)

+ func (n NamespacedMerkleTree) ProveRange(start, end int) (Proof, error)

+ type NodeVisitorFn = func(hash []byte, children ...[]byte)

+ type Option func(*Options)

+ func IgnoreMaxNamespace(ignore bool) Option

+ func InitialCapacity(cap int) Option

+ func NamespaceIDSize(size int) Option

+ func NodeVisitor(nodeVisitorFn NodeVisitorFn) Option

+ type Options struct

+ IgnoreMaxNamespace bool

+ InitialCapacity int

+ NamespaceIDSize namespace.IDSize

+ NodeVisitor NodeVisitorFn

+ type Proof struct

+ func NewAbsenceProof(proofStart, proofEnd int, proofNodes [][]byte, leafHash []byte, ...) Proof

+ func NewEmptyRangeProof(ignoreMaxNamespace bool) Proof

+ func NewInclusionProof(proofStart, proofEnd int, proofNodes [][]byte, ignoreMaxNamespace bool) Proof

+ func (proof Proof) End() int

+ func (proof Proof) IsMaxNamespaceIDIgnored() bool

+ func (proof Proof) IsNonEmptyRange() bool

+ func (proof Proof) IsOfAbsence() bool

+ func (proof Proof) LeafHash() []byte

+ func (proof Proof) Nodes() [][]byte

+ func (proof Proof) Start() int

+ func (proof Proof) VerifyInclusion(h hash.Hash, nid namespace.ID, leaves [][]byte, root []byte) bool

+ func (proof Proof) VerifyNamespace(h hash.Hash, nID namespace.ID, data [][]byte, root []byte) bool