types

type Analyser interface {
	GetDBReadTime() int
	GetDBWriteCount() int
	GetDBReadCount() int
	GetNodeReadCount() int
	GetFlatKVReadTime() int
	GetFlatKVWriteTime() int
	GetFlatKVReadCount() int
	GetFlatKVWriteCount() int
	ResetCount()
}

type CacheKVRWSet struct {
	Read  map[string][]byte
	Write map[string]DirtyValue
}

type CacheKVStore interface {
	KVStore
	CacheManager
	// Writes operations to underlying KVStore
	Write()
	WriteWithSnapshotWSet() SnapshotWSet
	RevertDBWithSnapshotRWSet(set SnapshotWSet)
}

type CacheManager interface {
	IteratorCache(isdirty bool, cb func(key string, value []byte, isDirty bool, isDelete bool, storeKey StoreKey) bool, sKey StoreKey) bool
	// Clear the cache without writing
	Clear()
	DisableCacheReadList()
	GetRWSet(set MsRWSet)
}

type CacheMultiStore interface {
	MultiStore
	CacheManager
	Write() // Writes operations to underlying KVStore
	WriteGetMultiSnapshotWSet() MultiSnapshotWSet
	RevertDBWithMultiSnapshotRWSet(set MultiSnapshotWSet)
}

type CacheMultiStoreResetter interface {
	CacheMultiStore
	Reset(MultiStore) bool
}

type CacheWrap interface {
	CacheManager
	// Write syncs with the underlying store.
	Write()
	WriteWithSnapshotWSet() SnapshotWSet
	RevertDBWithSnapshotRWSet(set SnapshotWSet)
	// CacheWrap recursively wraps again.
	CacheWrap() CacheWrap

	// CacheWrapWithTrace recursively wraps again with tracing enabled.
	CacheWrapWithTrace(w io.Writer, tc TraceContext) CacheWrap
}

type CacheWrapper interface {
	// CacheWrap cache wraps.
	CacheWrap() CacheWrap

	// CacheWrapWithTrace cache wraps with tracing enabled.
	CacheWrapWithTrace(w io.Writer, tc TraceContext) CacheWrap
}

type CommitID struct {
	Version int64  `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	Hash    []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
}

type CommitInfo struct {
	Version    int64       `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	StoreInfos []StoreInfo `protobuf:"bytes,2,rep,name=store_infos,json=storeInfos,proto3" json:"store_infos"`
}

type CommitKVStore interface {
	Committer
	KVStore
}

type CommitMultiStore interface {
	Committer
	MultiStore
	CommitMultiStorePipeline
	CommitterCommitMap(*types.TreeDelta) (CommitID, *types.TreeDelta) // CommitterCommit

	// Mount a store of type using the given db.
	// If db == nil, the new store will use the CommitMultiStore db.
	MountStoreWithDB(key StoreKey, typ StoreType, db dbm.DB)

	// Panics on a nil key.
	GetCommitStore(key StoreKey) CommitStore

	// Panics on a nil key.
	GetCommitKVStore(key StoreKey) CommitKVStore

	// Load the latest persisted version. Called once after all calls to
	// Mount*Store() are complete.
	LoadLatestVersion() error

	// LoadLatestVersionAndUpgrade will load the latest version, but also
	// rename/delete/create sub-store keys, before registering all the keys
	// in order to handle breaking formats in migrations
	LoadLatestVersionAndUpgrade(upgrades *StoreUpgrades) error

	// LoadVersionAndUpgrade will load the named version, but also
	// rename/delete/create sub-store keys, before registering all the keys
	// in order to handle breaking formats in migrations
	LoadVersionAndUpgrade(ver int64, upgrades *StoreUpgrades) error

	// Load a specific persisted version. When you load an old version, or when
	// the last commit attempt didn't complete, the next commit after loading
	// must be idempotent (return the same commit id). Otherwise the behavior is
	// undefined.
	LoadVersion(ver int64) error
	GetCommitVersion() (int64, error)

	// Set an inter-block (persistent) cache that maintains a mapping from
	// StoreKeys to CommitKVStores.
	SetInterBlockCache(MultiStorePersistentCache)

	StopStore()

	SetLogger(log log.Logger)

	CleanBrcRpcState()
}

type CommitMultiStorePipeline interface {
	AppendVersionFilters(filters []VersionFilter)
	AppendCommitFilters(filters []StoreFilter)
	AppendPruneFilters(filters []StoreFilter)
}

type CommitStore interface {
	Committer
	Store
}

type CommitmentOp struct {
	Type  string
	Spec  *ics23.ProofSpec
	Key   []byte
	Proof *ics23.CommitmentProof
}

type Committer interface {
	CommitterCommit(interface{}) (CommitID, interface{}) // CommitterCommit
	//for add module to init store version eg:ibc/erc20/capabilty module
	SetUpgradeVersion(int64)

	LastCommitID() CommitID
	LastCommitVersion() int64

	// TODO: Deprecate after 0.38.5
	SetPruning(PruningOptions)
	Analyser
}

type DirtyValue struct {
	Deleted bool
	Value   []byte
}

type ErrorGasOverflow struct {
	Descriptor string
}

type ErrorOutOfGas struct {
	Descriptor string
}

type Gas = uint64

type GasConfig struct {
	HasCost          Gas `json:"hasCost"`
	DeleteCost       Gas `json:"deleteCost"`
	ReadCostFlat     Gas `json:"readCostFlat"`
	ReadCostPerByte  Gas `json:"readCostPerByte"`
	WriteCostFlat    Gas `json:"writeCostFlat"`
	WriteCostPerByte Gas `json:"writeCostPerByte"`
	IterNextCostFlat Gas `json:"iterNextCostFlat"`
}

type GasMeter interface {
	GasConsumed() Gas
	GasConsumedToLimit() Gas
	Limit() Gas
	ConsumeGas(amount Gas, descriptor string)
	SetGas(val Gas)
	IsPastLimit() bool
	IsOutOfGas() bool
}

type Iterator = dbm.Iterator

type KVPair tmkv.Pair

type KVStore interface {
	Store

	// Get returns nil iff key doesn't exist. Panics on nil key.
	Get(key []byte) []byte

	// Has checks if a key exists. Panics on nil key.
	Has(key []byte) bool

	// Set sets the key. Panics on nil key or value.
	Set(key, value []byte)

	// Delete deletes the key. Panics on nil key.
	Delete(key []byte)

	// Iterator over a domain of keys in ascending order. End is exclusive.
	// Start must be less than end, or the Iterator is invalid.
	// Iterator must be closed by caller.
	// To iterate over entire domain, use store.Iterator(nil, nil)
	// CONTRACT: No writes may happen within a domain while an iterator exists over it.
	// Exceptionally allowed for cachekv.Store, safe to write in the modules.
	Iterator(start, end []byte) Iterator

	// Iterator over a domain of keys in descending order. End is exclusive.
	// Start must be less than end, or the Iterator is invalid.
	// Iterator must be closed by caller.
	// CONTRACT: No writes may happen within a domain while an iterator exists over it.
	// Exceptionally allowed for cachekv.Store, safe to write in the modules.
	ReverseIterator(start, end []byte) Iterator

	CleanBrcRpcState()
}

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

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

type MsRWSet = map[StoreKey]CacheKVRWSet

type MultiSnapshotWSet struct {
	Root   SnapshotWSet
	Stores map[StoreKey]SnapshotWSet
}

type MultiStore interface {
	Store

	// Cache wrap MultiStore.
	// NOTE: Caller should probably not call .Write() on each, but
	// call CacheMultiStore.Write().
	CacheMultiStore() CacheMultiStore

	// CacheMultiStoreWithVersion cache-wraps the underlying MultiStore where
	// each stored is loaded at a specific version (height).
	CacheMultiStoreWithVersion(version int64) (CacheMultiStore, error)

	// Convenience for fetching substores.
	// If the store does not exist, panics.
	GetStore(StoreKey) Store
	GetKVStore(StoreKey) KVStore

	// TracingEnabled returns if tracing is enabled for the MultiStore.
	TracingEnabled() bool

	// SetTracer sets the tracer for the MultiStore that the underlying
	// stores will utilize to trace operations. The modified MultiStore is
	// returned.
	SetTracer(w io.Writer) MultiStore

	// SetTracingContext sets the tracing context for a MultiStore. It is
	// implied that the caller should update the context when necessary between
	// tracing operations. The modified MultiStore is returned.
	SetTracingContext(TraceContext) MultiStore
}

type MultiStorePersistentCache interface {
	// Wrap and return the provided CommitKVStore with an inter-block (persistent)
	// cache.
	GetStoreCache(key StoreKey, store CommitKVStore) CommitKVStore

	// Return the underlying CommitKVStore for a StoreKey.
	Unwrap(key StoreKey) CommitKVStore

	// Reset the entire set of internal caches.
	Reset()
}

type PaginatedIterator struct {
	Iterator
	// contains filtered or unexported fields
}

type PruningOptions struct {
	// KeepRecent defines how many recent heights to keep on disk.
	KeepRecent uint64

	// KeepEvery defines how many offset heights are kept on disk past KeepRecent.
	KeepEvery uint64

	// Interval defines when the pruned heights are removed from disk.
	Interval uint64

	// MaxRetainNum defines how many historic states to keep on disk.
	MaxRetainNum uint64
}

type Queryable interface {
	Query(abci.RequestQuery) abci.ResponseQuery
}

type ReusableGasMeter interface {
	GasMeter
	Reset()
}

type RevertWriteChange struct {
	PrevValue []byte
}

type SnapshotWSet struct {
	Write map[string]RevertWriteChange
}

type Store interface {
	GetStoreType() StoreType
	GetStoreName() string
	CacheWrapper
}

type StoreFilter func(module string, h int64, store CommitKVStore) bool

type StoreInfo struct {
	Name     string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	CommitId CommitID `protobuf:"bytes,2,opt,name=commit_id,json=commitId,proto3" json:"commit_id"`
}

type StoreKVPair struct {
	StoreKey string `protobuf:"bytes,1,opt,name=store_key,json=storeKey,proto3" json:"store_key,omitempty"`
	Delete   bool   `protobuf:"varint,2,opt,name=delete,proto3" json:"delete,omitempty"`
	Key      []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
	Value    []byte `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
}

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

type StoreKey interface {
	Name() string
	String() string
}

type StoreRename struct {
	OldKey string `json:"old_key"`
	NewKey string `json:"new_key"`
}

type StoreType int

type StoreUpgrades struct {
	Added   []string      `json:"added"`
	Renamed []StoreRename `json:"renamed"`
	Deleted []string      `json:"deleted"`
}

type TraceContext map[string]interface{}

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

type VersionCallback = func(name string, version int64)

type VersionFilter func(h int64) func(callback VersionCallback)

type WriteListener interface {
	// if value is nil then it was deleted
	// storeKey indicates the source KVStore, to facilitate using the the same WriteListener across separate KVStores
	// delete bool indicates if it was a delete; true: delete, false: set
	OnWrite(storeKey StoreKey, key []byte, value []byte, delete bool) error
}