iavl

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