iavl

Jul 31, 2024

Changes in this version

type MutableTree

+ func (tree *MutableTree) DeleteVersionsFrom(fromVersion int64) error

Jul 31, 2024

Changes in this version

+ type Logger interface

+ Debug func(msg string, keyVals ...any)

+ Error func(msg string, keyVals ...any)

+ Info func(msg string, keyVals ...any)

+ Warn func(msg string, keyVals ...any)

+ func NewNopLogger() Logger

type MutableTree

+ func (tree *MutableTree) GetLatestVersion() (int64, error)

May 8, 2024

retracted

Changes in this version

type MutableTree

+ func (tree *MutableTree) SetCommitting()

+ func (tree *MutableTree) UnsetCommitting()

type Option

+ func AsyncPruningOption(asyncPruning bool) Option

type Options

+ AsyncPruning bool

Mar 16, 2024

retracted

Changes in this version

type MutableTree

+ func (tree *MutableTree) Close() error

Oct 30, 2023

retracted

Changes in this version

+ const ModeLegacyLeftNode

+ const ModeLegacyRightNode

+ var ErrEmptyChild = fmt.Errorf("found an empty child")

+ var ErrKeyDoesNotExist = errors.New("key does not exist")

+ var ErrLeftNodeKeyEmpty = fmt.Errorf("node.leftNodeKey was empty in writeBytes")

+ var ErrNodeMissingNodeKey = fmt.Errorf("node does not have a nodeKey")

+ var ErrRightNodeKeyEmpty = fmt.Errorf("node.rightNodeKey was empty in writeBytes")

+ func GetRootKey(version int64) []byte

+ func WriteDOTGraphToFile(filename string, tree *ImmutableTree)

+ func WriteDotGraphv2(w io.Writer, tree *ImmutableTree)

+ type BatchWithFlusher struct

+ func NewBatchWithFlusher(db dbm.DB, flushThreshold int) *BatchWithFlusher

+ func (b *BatchWithFlusher) Close() error

+ func (b *BatchWithFlusher) Delete(key []byte) error

+ func (b *BatchWithFlusher) GetByteSize() (int, error)

+ func (b *BatchWithFlusher) Set(key, value []byte) error

+ func (b *BatchWithFlusher) Write() error

+ func (b *BatchWithFlusher) WriteSync() error

+ type CompressExporter struct

+ func (e *CompressExporter) Next() (*ExportNode, error)

+ type CompressImporter struct

+ func (i *CompressImporter) Add(node *ExportNode) error

type MutableTree

+ func (tree *MutableTree) DeleteVersionsTo(toVersion int64) error

+ func (tree *MutableTree) WorkingVersion() int64

type Node

+ func MakeLegacyNode(hash, buf []byte) (*Node, error)

+ type NodeExporter interface

+ Next func() (*ExportNode, error)

+ func NewCompressExporter(exporter NodeExporter) NodeExporter

+ type NodeImporter interface

+ Add func(*ExportNode) error

+ func NewCompressImporter(importer NodeImporter) NodeImporter

+ type NodeKey struct

+ func GetNodeKey(key []byte) *NodeKey

+ func (nk *NodeKey) GetKey() []byte

+ func (nk *NodeKey) String() string

+ type Option func(*Options)

+ func FlushThresholdOption(ft int) Option

+ func InitialVersionOption(iv uint64) Option

+ func StatOption(stats *Statistics) Option

+ func SyncOption(sync bool) Option

type Options

+ FlushThreshold int

Sep 5, 2023

Changes in this version

type MutableTree

+ func (tree *MutableTree) SaveChangeSet(cs *ChangeSet) (int64, error)

Mar 14, 2023

Changes in this version

+ var ErrorExportDone = errors.New("export is complete")

type ImmutableTree

+ func (t *ImmutableTree) GetProof(key []byte) (*ics23.CommitmentProof, error)

+ func (t *ImmutableTree) VerifyMembership(proof *ics23.CommitmentProof, key []byte) (bool, error)

+ func (t *ImmutableTree) VerifyNonMembership(proof *ics23.CommitmentProof, key []byte) (bool, error)

+ func (t *ImmutableTree) VerifyProof(proof *ics23.CommitmentProof, key []byte) (bool, error)

type MutableTree

+ func (tree *MutableTree) GetVersionedProof(key []byte, version int64) (*ics23.CommitmentProof, error)

Feb 1, 2023

Changes in this version

+ var ErrNotInitalizedTree = errors.New("iavl/export newExporter failed to create")

+ type ChangeSet struct

+ Pairs []KVPair

type ImmutableTree

+ func (t *ImmutableTree) TraverseStateChanges(startVersion, endVersion int64, ...) error

+ type KVPair struct

+ Delete bool

+ Key []byte

+ Value []byte

+ type KVPairReceiver func(pair *KVPair) error

type MutableTree

+ func (tree *MutableTree) LazyLoadVersionForOverwriting(targetVersion int64) (int64, error)

+ type NodeIterator struct

+ func NewNodeIterator(root []byte, ndb *nodeDB) (*NodeIterator, error)

+ func (iter *NodeIterator) Error() error

+ func (iter *NodeIterator) GetNode() *Node

+ func (iter *NodeIterator) Next(isSkipped bool)

+ func (iter *NodeIterator) Valid() bool

Aug 3, 2022

Changes in this version

type FastNode

+ func (fn *FastNode) GetKey() []byte

type Node

+ func (n *Node) GetKey() []byte

Jul 18, 2022

Changes in this version

+ var ErrCloneLeafNode = fmt.Errorf("attempt to copy a leaf node")

+ var ErrEmptyChildHash = fmt.Errorf("found an empty child hash")

+ var ErrLeftHashIsNil = fmt.Errorf("node.leftHash was nil in writeBytes")

+ var ErrNodeAlreadyPersisted = fmt.Errorf("shouldn't be calling save on an already persisted node")

+ var ErrNodeMissingHash = fmt.Errorf("node does not have a hash")

+ var ErrRightHashIsNil = fmt.Errorf("node.rightHash was nil in writeBytes")

+ var ErrRootMissingHash = fmt.Errorf("root hash must not be empty")

+ func NewIterator(start, end []byte, ascending bool, tree *ImmutableTree) dbm.Iterator

+ type FastIterator struct

+ func NewFastIterator(start, end []byte, ascending bool, ndb *nodeDB) *FastIterator

+ func (iter *FastIterator) Close() error

+ func (iter *FastIterator) Domain() ([]byte, []byte)

+ func (iter *FastIterator) Error() error

+ func (iter *FastIterator) Key() []byte

+ func (iter *FastIterator) Next()

+ func (iter *FastIterator) Valid() bool

+ func (iter *FastIterator) Value() []byte

+ type FastNode struct

+ func DeserializeFastNode(key []byte, buf []byte) (*FastNode, error)

+ func NewFastNode(key []byte, value []byte, version int64) *FastNode

type ImmutableTree

+ func (t *ImmutableTree) GetWithIndex(key []byte) (int64, []byte, error)

+ func (t *ImmutableTree) IsFastCacheEnabled() (bool, error)

type Iterator

+ func (iter *Iterator) IsFast() bool

type MutableTree

+ func (tree *MutableTree) Get(key []byte) ([]byte, error)

+ func (tree *MutableTree) IsUpgradeable() (bool, error)

+ func (tree *MutableTree) Iterate(fn func(key []byte, value []byte) bool) (stopped bool, err error)

+ func (tree *MutableTree) Iterator(start, end []byte, ascending bool) (dbm.Iterator, error)

type Options

+ Stat *Statistics

+ type Statistics struct

+ func (stat *Statistics) GetCacheHitCnt() uint64

+ func (stat *Statistics) GetCacheMissCnt() uint64

+ func (stat *Statistics) GetFastCacheHitCnt() uint64

+ func (stat *Statistics) GetFastCacheMissCnt() uint64

+ func (stat *Statistics) IncCacheHitCnt()

+ func (stat *Statistics) IncCacheMissCnt()

+ func (stat *Statistics) IncFastCacheHitCnt()

+ func (stat *Statistics) IncFastCacheMissCnt()

+ func (stat *Statistics) Reset()

+ type UnsavedFastIterator struct

+ func NewUnsavedFastIterator(start, end []byte, ascending bool, ndb *nodeDB, ...) *UnsavedFastIterator

+ func (iter *UnsavedFastIterator) Close() error

+ func (iter *UnsavedFastIterator) Domain() ([]byte, []byte)

+ func (iter *UnsavedFastIterator) Error() error

+ func (iter *UnsavedFastIterator) Key() []byte

+ func (iter *UnsavedFastIterator) Next()

+ func (iter *UnsavedFastIterator) Valid() bool

+ func (iter *UnsavedFastIterator) Value() []byte

Nov 15, 2021

Changes in this version

type ImmutableTree

+ func (t *ImmutableTree) Iterator(start, end []byte, ascending bool) *Iterator

+ type Iterator struct

+ func (iter *Iterator) Close() error

+ func (iter *Iterator) Domain() ([]byte, []byte)

+ func (iter *Iterator) Error() error

+ func (iter *Iterator) Key() []byte

+ func (iter *Iterator) Next()

+ func (iter *Iterator) Valid() bool

+ func (iter *Iterator) Value() []byte

Nov 23, 2020

Changes in this version

+ const ANSIBright

+ const ANSIFgBlue

+ const ANSIFgCyan

+ const ANSIFgGreen

+ const ANSIReset

+ var Branch = ""

+ var Commit = ""

+ var ErrNoImport = errors.New("no import in progress")

+ var ExportDone = errors.New("export is complete")

+ func AbsenceOpDecoder(pop tmmerkle.ProofOp) (merkle.ProofOperator, error)

+ func Blue(args ...interface{}) string

+ func ColoredBytes(data []byte, textColor, bytesColor func(...interface{}) string) string

+ func Cyan(args ...interface{}) string

+ func Green(args ...interface{}) string

+ func Repair013Orphans(db dbm.DB) (uint64, error)

+ func ValueOpDecoder(pop tmmerkle.ProofOp) (merkle.ProofOperator, error)

+ type AbsenceOp struct

+ Proof *RangeProof

+ func NewAbsenceOp(key []byte, proof *RangeProof) AbsenceOp

+ func (op AbsenceOp) GetKey() []byte

+ func (op AbsenceOp) ProofOp() tmmerkle.ProofOp

+ func (op AbsenceOp) Run(args [][]byte) ([][]byte, error)

+ func (op AbsenceOp) String() string

+ type ExportNode struct

+ Height int8

+ Key []byte

+ Value []byte

+ Version int64

+ type Exporter struct

+ func (e *Exporter) Close()

+ func (e *Exporter) Next() (*ExportNode, error)

type ImmutableTree

+ func NewImmutableTreeWithOpts(db dbm.DB, cacheSize int, opts *Options) *ImmutableTree

+ func (t *ImmutableTree) Export() *Exporter

+ func (t *ImmutableTree) GetMembershipProof(key []byte) (*ics23.CommitmentProof, error)

+ func (t *ImmutableTree) GetNonMembershipProof(key []byte) (*ics23.CommitmentProof, error)

+ func (t *ImmutableTree) RenderShape(indent string, encoder NodeEncoder) []string

+ type Importer struct

+ func (i *Importer) Add(exportNode *ExportNode) error

+ func (i *Importer) Close()

+ func (i *Importer) Commit() error

type MutableTree

+ func NewMutableTreeWithOpts(db dbm.DB, cacheSize int, opts *Options) (*MutableTree, error)

+ func (tree *MutableTree) AvailableVersions() []int

+ func (tree *MutableTree) DeleteVersions(versions ...int64) error

+ func (tree *MutableTree) DeleteVersionsRange(fromVersion, toVersion int64) error

+ func (tree *MutableTree) Import(version int64) (*Importer, error)

+ func (tree *MutableTree) LazyLoadVersion(targetVersion int64) (int64, error)

+ func (tree *MutableTree) SetInitialVersion(version uint64)

+ type NodeEncoder func(id []byte, depth int, isLeaf bool) string

+ type Options struct

+ InitialVersion uint64

+ Sync bool

+ func DefaultOptions() Options

+ type ProofInnerNode struct

+ Height int8

+ Left []byte

+ Right []byte

+ Size int64

+ Version int64

+ func (pin ProofInnerNode) Hash(childHash []byte) []byte

+ func (pin ProofInnerNode) String() string

+ type ProofLeafNode struct

+ Key cmn.HexBytes

+ ValueHash cmn.HexBytes

+ Version int64

+ func (pln ProofLeafNode) Hash() []byte

+ func (pln ProofLeafNode) String() string

type RangeProof

+ func RangeProofFromProto(pbProof *iavlproto.RangeProof) (RangeProof, error)

+ func (proof *RangeProof) ToProto() *iavlproto.RangeProof

+ type ValueOp struct

+ Proof *RangeProof

+ func NewValueOp(key []byte, proof *RangeProof) ValueOp

+ func (op ValueOp) GetKey() []byte

+ func (op ValueOp) ProofOp() tmmerkle.ProofOp

+ func (op ValueOp) Run(args [][]byte) ([][]byte, error)

+ func (op ValueOp) String() string

+ type VersionInfo struct

+ Branch string

+ GitCommit string

+ GoVersion string

+ IAVL string

+ func GetVersionInfo() VersionInfo

+ func (v VersionInfo) String() string

Oct 29, 2018

Changes in this version

+ const ProofOpIAVLAbsence

+ const ProofOpIAVLValue

+ func IAVLAbsenceOpDecoder(pop merkle.ProofOp) (merkle.ProofOperator, error)

+ func IAVLValueOpDecoder(pop merkle.ProofOp) (merkle.ProofOperator, error)

+ type IAVLAbsenceOp struct

+ Proof *RangeProof

+ func NewIAVLAbsenceOp(key []byte, proof *RangeProof) IAVLAbsenceOp

+ func (op IAVLAbsenceOp) GetKey() []byte

+ func (op IAVLAbsenceOp) ProofOp() merkle.ProofOp

+ func (op IAVLAbsenceOp) Run(args [][]byte) ([][]byte, error)

+ func (op IAVLAbsenceOp) String() string

+ type IAVLValueOp struct

+ Proof *RangeProof

+ func NewIAVLValueOp(key []byte, proof *RangeProof) IAVLValueOp

+ func (op IAVLValueOp) GetKey() []byte

+ func (op IAVLValueOp) ProofOp() merkle.ProofOp

+ func (op IAVLValueOp) Run(args [][]byte) ([][]byte, error)

+ func (op IAVLValueOp) String() string

type MutableTree

+ func (tree *MutableTree) LoadVersionForOverwriting(targetVersion int64) (int64, error)

Sep 8, 2018

Changes in this version

+ type KeyFormat struct

+ func NewKeyFormat(prefix byte, layout ...int) *KeyFormat

+ func (kf *KeyFormat) Key(args ...interface{}) []byte

+ func (kf *KeyFormat) KeyBytes(segments ...[]byte) []byte

+ func (kf *KeyFormat) Prefix() string

+ func (kf *KeyFormat) Scan(key []byte, args ...interface{})

+ func (kf *KeyFormat) ScanBytes(key []byte) [][]byte

Aug 15, 2018

Changes in this version

+ type ImmutableTree struct

+ func NewImmutableTree(db dbm.DB, cacheSize int) *ImmutableTree

+ func (t *ImmutableTree) Get(key []byte) (index int, value []byte)

+ func (t *ImmutableTree) Get64(key []byte) (index int64, value []byte)

+ func (t *ImmutableTree) GetByIndex(index int) (key []byte, value []byte)

+ func (t *ImmutableTree) GetByIndex64(index int64) (key []byte, value []byte)

+ func (t *ImmutableTree) GetRangeWithProof(startKey []byte, endKey []byte, limit int) (keys, values [][]byte, proof *RangeProof, err error)

+ func (t *ImmutableTree) GetWithProof(key []byte) (value []byte, proof *RangeProof, err error)

+ func (t *ImmutableTree) Has(key []byte) bool

+ func (t *ImmutableTree) Hash() []byte

+ func (t *ImmutableTree) Height() int

+ func (t *ImmutableTree) Height8() int8

+ func (t *ImmutableTree) Iterate(fn func(key []byte, value []byte) bool) (stopped bool)

+ func (t *ImmutableTree) IterateRange(start, end []byte, ascending bool, fn func(key []byte, value []byte) bool) (stopped bool)

+ func (t *ImmutableTree) IterateRangeInclusive(start, end []byte, ascending bool, ...) (stopped bool)

+ func (t *ImmutableTree) Size() int

+ func (t *ImmutableTree) Size64() int64

+ func (t *ImmutableTree) String() string

+ func (t *ImmutableTree) Version() int

+ func (t *ImmutableTree) Version64() int64

+ type MutableTree struct

+ func NewMutableTree(db dbm.DB, cacheSize int) *MutableTree

+ func (tree *MutableTree) DeleteVersion(version int64) error

+ func (tree *MutableTree) GetImmutable(version int64) (*ImmutableTree, error)

+ func (tree *MutableTree) GetVersioned(key []byte, version int64) (index int, value []byte)

+ func (tree *MutableTree) GetVersionedRangeWithProof(startKey, endKey []byte, limit int, version int64) (keys, values [][]byte, proof *RangeProof, err error)

+ func (tree *MutableTree) GetVersionedWithProof(key []byte, version int64) ([]byte, *RangeProof, error)

+ func (tree *MutableTree) Hash() []byte

+ func (tree *MutableTree) IsEmpty() bool

+ func (tree *MutableTree) Load() (int64, error)

+ func (tree *MutableTree) LoadVersion(targetVersion int64) (int64, error)

+ func (tree *MutableTree) Remove(key []byte) ([]byte, bool)

+ func (tree *MutableTree) Rollback()

+ func (tree *MutableTree) SaveVersion() ([]byte, int64, error)

+ func (tree *MutableTree) Set(key, value []byte) bool

+ func (tree *MutableTree) String() string

+ func (tree *MutableTree) VersionExists(version int64) bool

+ func (tree *MutableTree) WorkingHash() []byte

Jul 3, 2018

Changes in this version

type PathToLeaf

+ func (pl PathToLeaf) Index() (idx int64)

type RangeProof

+ func (proof *RangeProof) ComputeRootHash() []byte

+ func (proof *RangeProof) Keys() (keys [][]byte)

+ func (proof *RangeProof) LeftIndex() int64

Jun 25, 2018

Changes in this version

+ func PrintTree(tree *Tree)

+ func RegisterWire(cdc *amino.Codec)

type Node

+ func (node *Node) PathToLeaf(t *Tree, key []byte) (PathToLeaf, *Node, error)

+ type PathToLeaf []proofInnerNode

+ func (pl PathToLeaf) String() string

+ func (pl PathToLeaf) StringIndented(indent string) string

+ type RangeProof struct

+ InnerNodes []PathToLeaf

+ Leaves []proofLeafNode

+ LeftPath PathToLeaf

+ RootHash cmn.HexBytes

+ func (proof *RangeProof) String() string

+ func (proof *RangeProof) StringIndented(indent string) string

+ func (proof *RangeProof) Verify(root []byte) error

+ func (proof *RangeProof) VerifyAbsence(key []byte) error

+ func (proof *RangeProof) VerifyItem(i int, key, value []byte) error

Mar 2, 2018

Changes in this version

+ func Restore(empty *Tree, kvs []NodeData)

+ func RestoreUsingDepth(empty *Tree, kvs []NodeData)

+ type Chunk []OrderedNodeData

+ func GetChunk(tree *Tree, depth, count uint) Chunk

+ func MergeChunks(left, right Chunk) Chunk

+ func (c Chunk) CalculateRoot() []byte

+ func (c Chunk) PopulateTree(empty *Tree)

+ func (c Chunk) Sort()

+ type InnerKeyProof struct

+ func GetChunkHashesWithProofs(tree *Tree) ([][]byte, []*InnerKeyProof, uint)

+ func ReadInnerKeyProof(data []byte) (*InnerKeyProof, error)

+ func (proof *InnerKeyProof) Verify(hash []byte, value []byte, root []byte) error

type KeyProof

+ func ReadKeyProof(data []byte) (KeyProof, error)

type KeyRangeProof

+ Versions []int64

+ type NodeData struct

+ Depth uint8

+ Key []byte

+ Value []byte

+ func InOrderSerialize(t *Tree, root *Node) []NodeData

+ func StableSerializeBFS(t *Tree, root *Node) []NodeData

+ func StableSerializeFrey(t *Tree, top *Node) []NodeData

+ type OrderedNodeData struct

+ SortOrder uint64

+ func NewOrderedNode(leaf *Node, prefix uint64) OrderedNodeData

+ type RestoreFunc func(*Tree, []NodeData)

+ type SerializeFunc func(*Tree, *Node) []NodeData

type Tree

+ func (t *Tree) Get64(key []byte) (index int64, value []byte)

+ func (t *Tree) GetByIndex64(index int64) (key []byte, value []byte)

+ func (t *Tree) Height8() int8

+ func (t *Tree) Size64() int64

+ func (t *Tree) Version() int

+ func (t *Tree) Version64() int64

type VersionedTree

+ func (tree *VersionedTree) LoadVersion(targetVersion int64) error

+ func (tree *VersionedTree) Rollback()

+ func (tree VersionedTree) SaveAs(version int64)

Oct 27, 2017

Changes in this version

+ const Version

+ var ErrInvalidInputs = fmt.Errorf("invalid inputs")

+ var ErrInvalidProof = fmt.Errorf("invalid proof")

+ var ErrInvalidRoot = fmt.Errorf("invalid root")

+ var ErrNilRoot = fmt.Errorf("tree root is nil")

+ var ErrVersionDoesNotExist = fmt.Errorf("version does not exist")

+ func WriteDOTGraph(w io.Writer, tree *Tree, paths []*PathToKey)

+ type KeyAbsentProof struct

+ Left *pathWithNode

+ Right *pathWithNode

+ RootHash data.Bytes

+ Version uint64

+ func ReadKeyAbsentProof(data []byte) (*KeyAbsentProof, error)

+ func (p *KeyAbsentProof) String() string

+ func (proof *KeyAbsentProof) Bytes() []byte

+ func (proof *KeyAbsentProof) Root() []byte

+ func (proof *KeyAbsentProof) Verify(key, value []byte, root []byte) error

+ type KeyExistsProof struct

+ RootHash data.Bytes

+ Version uint64

+ func ReadKeyExistsProof(data []byte) (*KeyExistsProof, error)

+ func (proof *KeyExistsProof) Bytes() []byte

+ func (proof *KeyExistsProof) Root() []byte

+ func (proof *KeyExistsProof) Verify(key []byte, value []byte, root []byte) error

+ type KeyFirstInRangeProof struct

+ Left *pathWithNode

+ Right *pathWithNode

+ func (proof *KeyFirstInRangeProof) String() string

+ func (proof *KeyFirstInRangeProof) Verify(startKey, endKey, key, value []byte, root []byte) error

+ type KeyInRangeProof interface

+ Verify func(startKey, endKey, key, value, root []byte) error

+ type KeyLastInRangeProof struct

+ Left *pathWithNode

+ Right *pathWithNode

+ func (proof *KeyLastInRangeProof) String() string

+ func (proof *KeyLastInRangeProof) Verify(startKey, endKey, key, value []byte, root []byte) error

+ type KeyProof interface

+ Bytes func() []byte

+ Root func() []byte

+ Verify func(key, value, root []byte) error

+ type KeyRangeProof struct

+ Left *pathWithNode

+ PathToKeys []*PathToKey

+ Right *pathWithNode

+ RootHash data.Bytes

+ Version uint64

+ func (proof *KeyRangeProof) String() string

+ func (proof *KeyRangeProof) Verify(startKey, endKey []byte, limit int, keys, values [][]byte, root []byte) error

+ type Node struct

+ func MakeNode(buf []byte) (node *Node, err error)

+ func NewNode(key []byte, value []byte) *Node

+ func (node *Node) String() string

+ type PathToKey struct

+ InnerNodes []proofInnerNode

+ func (p *PathToKey) String() string

+ type Tree struct

+ func NewTree(cacheSize int, db dbm.DB) *Tree

+ func (t *Tree) Get(key []byte) (index int, value []byte)

+ func (t *Tree) GetByIndex(index int) (key []byte, value []byte)

+ func (t *Tree) GetFirstInRangeWithProof(startKey, endKey []byte) ([]byte, []byte, *KeyFirstInRangeProof, error)

+ func (t *Tree) GetLastInRangeWithProof(startKey, endKey []byte) ([]byte, []byte, *KeyLastInRangeProof, error)

+ func (t *Tree) GetRangeWithProof(startKey []byte, endKey []byte, limit int) ([][]byte, [][]byte, *KeyRangeProof, error)

+ func (t *Tree) GetWithProof(key []byte) ([]byte, KeyProof, error)

+ func (t *Tree) Has(key []byte) bool

+ func (t *Tree) Hash() []byte

+ func (t *Tree) Height() int8

+ func (t *Tree) Iterate(fn func(key []byte, value []byte) bool) (stopped bool)

+ func (t *Tree) IterateRange(start, end []byte, ascending bool, fn func(key []byte, value []byte) bool) (stopped bool)

+ func (t *Tree) IterateRangeInclusive(start, end []byte, ascending bool, fn func(key []byte, value []byte) bool) (stopped bool)

+ func (t *Tree) Remove(key []byte) ([]byte, bool)

+ func (t *Tree) Set(key []byte, value []byte) (updated bool)

+ func (t *Tree) Size() int

+ func (t *Tree) String() string

+ type VersionedTree struct

+ func NewVersionedTree(cacheSize int, db dbm.DB) *VersionedTree

+ func (tree *VersionedTree) DeleteVersion(version uint64) error

+ func (tree *VersionedTree) GetVersioned(key []byte, version uint64) (index int, value []byte)

+ func (tree *VersionedTree) GetVersionedFirstInRangeWithProof(startKey, endKey []byte, version uint64) ([]byte, []byte, *KeyFirstInRangeProof, error)

+ func (tree *VersionedTree) GetVersionedLastInRangeWithProof(startKey, endKey []byte, version uint64) ([]byte, []byte, *KeyLastInRangeProof, error)

+ func (tree *VersionedTree) GetVersionedRangeWithProof(startKey, endKey []byte, limit int, version uint64) ([][]byte, [][]byte, *KeyRangeProof, error)

+ func (tree *VersionedTree) GetVersionedWithProof(key []byte, version uint64) ([]byte, KeyProof, error)

+ func (tree *VersionedTree) Hash() []byte

+ func (tree *VersionedTree) IsEmpty() bool

+ func (tree *VersionedTree) LatestVersion() uint64

+ func (tree *VersionedTree) Load() error

+ func (tree *VersionedTree) Remove(key []byte) ([]byte, bool)

+ func (tree *VersionedTree) SaveVersion(version uint64) ([]byte, error)

+ func (tree *VersionedTree) Set(key, val []byte) bool

+ func (tree *VersionedTree) String() string

+ func (tree *VersionedTree) Tree() *Tree

+ func (tree *VersionedTree) VersionExists(version uint64) bool