common

type BatchedUpdatable interface {
	BatchedWriter() KVBatchedWriter
}

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(n *NodeData, nodePath []byte) VCommitment
	// UpdateNodeCommitment updates mutable NodeData with the update information.
	// The node commitment value is part of the mutable NodeData.
	// 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 example 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, terminal TCommitment, pathFragment, nodePath []byte, calcDelta bool)
	// 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
	// AlwaysStoreTerminalWithNode by returning true model signals that it does not optimize value commitments
	AlwaysStoreTerminalWithNode() bool
	// Description return description of the implementation
	Description() string
	// ShortName short name
	ShortName() string
}

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

type KVBatchedWriter interface {
	KVWriter
	Commit() error
}

type KVIterator interface {
	KVIteratorBase
	IterateKeys(func(k []byte) bool)
}

type KVIteratorBase 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
}

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 KVTraversableReader interface {
	KVReader
	Traversable
}

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 Mutations struct {
	// contains filtered or unexported fields
}

type NodeData struct {
	PathFragment     []byte
	ChildCommitments map[byte]VCommitment
	Terminal         TCommitment
	// used for immutable only
	// persisted in the key
	Commitment VCommitment
}

type PathArity byte

type PathEndingCode byte

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
	AsKey() []byte
}

type TCommitment interface {
	Clone() TCommitment
	ExtractValue() ([]byte, bool)
	Serializable
}

type Traversable interface {
	Iterator(prefix []byte) KVIterator
}

type VCommitment interface {
	Clone() VCommitment
	Serializable
}