trie

type BinaryStreamFileIterator struct {
	*BinaryStreamIterator
	// contains filtered or unexported fields
}

type BinaryStreamFileWriter struct {
	*BinaryStreamWriter
	// contains filtered or unexported fields
}

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

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

type CommitmentModel interface {
	// PathArity is used by implementations to optimize operations
	PathArity() PathArity
	// EqualCommitments compares two commitments
	EqualCommitments(c1, c2 Serializable) bool
	// NewVectorCommitment creates empty trie_go.VCommitment
	NewVectorCommitment() VCommitment
	// NewTerminalCommitment creates empty trie_go.TCommitment
	NewTerminalCommitment() TCommitment
	// CommitToData calculates terminal commitment to an arbitrary data
	CommitToData([]byte) TCommitment
	// CalcNodeCommitment calculates commitment of the node data
	CalcNodeCommitment(*NodeData) VCommitment
	// UpdateNodeCommitment updates mutable NodeData with the update information.
	// It also (optionally, if 'update' != nil) updates previous commitment to the node
	// If update != nil and *update != nil, parameter calcDelta specifies if commitment is calculated
	// from scratch using CalcNodeCommitment, or it can be calculated by applying additive delta
	// I can be used by implementation to optimize the computation of update. For examples KZG implementation
	// can be made dramatically faster this way than strictly computing each time whole expensive vector commitment
	// This interface takes into account different ways how updates are propagated in the trie
	UpdateNodeCommitment(mutate *NodeData, childUpdates map[byte]VCommitment, calcDelta bool, terminal TCommitment, update *VCommitment)
	// ForceStoreTerminalWithNode if == true, terminal commitment will always be serialized with the node,
	// otherwise it may be skipped to optimize storage, depending on the trie setting
	ForceStoreTerminalWithNode(c TCommitment) bool
	// Description return description of the implementation
	Description() string
	// ShortName short name
	ShortName() string
}

type KVBatchedUpdater interface {
	Update(key, value []byte)
	Commit() error
}

type KVIterator interface {
	Iterate(func(k, v []byte) bool)
}

type KVReader interface {
	// Get retrieves value by key. Returned nil means absence of the key
	Get(key []byte) []byte
	// Has checks presence of the key in the key/value store
	Has(key []byte) bool // for performance
}

type KVStore interface {
	KVReader
	KVWriter
	KVIterator
}

type KVStreamIterator interface {
	Iterate(func(k, v []byte) bool) error
}

type KVStreamWriter interface {
	// Write writes key/value pair
	Write(key, value []byte) error
	// Stats return num k/v pairs and num bytes so far
	Stats() (int, int)
}

type KVWriter interface {
	// Set writes new or updates existing key with the value.
	// value == nil means deletion of the key from the store
	Set(key, value []byte)
}

type Node interface {
	// Key of the node
	Key() []byte
	// PathFragment of the node (committed)
	PathFragment() []byte
	// Terminal of the node (committed)
	Terminal() TCommitment
	// ChildCommitments can return old commitments if node is not committed
	ChildCommitments() map[byte]VCommitment
}

type NodeData struct {
	PathFragment     []byte
	ChildCommitments map[byte]VCommitment
	Terminal         TCommitment
}

type NodeStore interface {
	GetNode(unpackedKey []byte) (Node, bool)
	Model() CommitmentModel
	PathArity() PathArity
	Info() string
}

type PathArity byte

type ProofEndingCode byte

type ProofGeneric struct {
	Key    []byte
	Path   [][]byte
	Ending ProofEndingCode
}

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

type RandStreamParams struct {
	// Seed for deterministic randomization
	Seed int64
	// NumKVPairs maximum number of key value pairs to generate. 0 means infinite
	NumKVPairs int
	// MaxKey maximum length of key (randomly generated)
	MaxKey int
	// MaxValue maximum length of value (randomly generated)
	MaxValue int
}

type Serializable interface {
	Read(r io.Reader) error
	Write(w io.Writer) error
	Bytes() []byte
	String() string
}

type TCommitment interface {
	Clone() TCommitment
	Serializable
}

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

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

type VCommitment interface {
	Clone() VCommitment
	Serializable
}