helpers

type Auxiliaries interface {
	Get() []Auxiliary
	GetAuxiliary(string) Auxiliary
}

type Auxiliary interface {
	GetName() string
	GetKeeper() AuxiliaryKeeper
	Initialize(Mapper, ParameterManager, ...interface{}) Auxiliary
}

type AuxiliaryKeeper interface {
	Help(context.Context, AuxiliaryRequest) (AuxiliaryResponse, error)
	Keeper
}

type AuxiliaryRequest interface {
	Request
}

type AuxiliaryResponse interface {
}

type Block interface {
	Begin(context.Context, abciTypes.RequestBeginBlock)
	End(context.Context, abciTypes.RequestEndBlock)
	Initialize(Mapper, ParameterManager, ...interface{}) Block
}

type CLICommand interface {
	ReadInt64(CLIFlag) int64
	ReadInt(CLIFlag) int
	ReadBool(CLIFlag) bool
	ReadString(CLIFlag) string
	ReadBaseReq(client.Context) rest.BaseReq

	CreateCommand(func(command *cobra.Command, args []string) error) *cobra.Command
}

type CLIFlag interface {
	GetName() string
	GetValue() interface{}
	Register(*cobra.Command)
	ReadCLIValue() interface{}
}

type Codec interface {
	client.TxConfig
	codec.Codec

	GetProtoCodec() *codec.ProtoCodec
	GetLegacyAmino() *codec.LegacyAmino
	InterfaceRegistry() types.InterfaceRegistry
	Initialize(module.BasicManager) Codec
}

type Collection interface {
	GetMappable(Key) Mappable
	Get() []Record
	GetMappables() []Mappable

	// TODO convert rest of the accumulators to below logic
	// The accumulator function should return true if the iterated Mappable is to be included in the returned collection
	IterateAll(func(Record) bool) Collection
	Iterate(Key, func(Record) bool)
	IteratePaginated(Key, int32, func(Record) bool)
	Fetch(Key) Collection
	FetchRecord(Key) Record
	FetchAll() Collection
	FetchPaginated(Key, int32) Collection
	Add(Record) Collection
	Remove(Record) Collection
	Mutate(Record) Collection
	Initialize(context.Context, Mapper) Collection
}

type Genesis interface {
	proto.Message

	Default() Genesis

	ValidateBasic(ParameterManager) error

	Import(context.Context, Mapper, ParameterManager)
	Export(context.Context, Mapper, ParameterManager) Genesis

	Encode(sdkCodec.JSONCodec) []byte
	Decode(sdkCodec.JSONCodec, []byte) Genesis

	Initialize([]Record, lists.ParameterList) Genesis
}

type Invariants interface {
	Register(sdkTypes.InvariantRegistry)
}

type Keeper interface {
	Initialize(Mapper, ParameterManager, []interface{}) Keeper
}

type Key interface {
	GenerateStorePrefixBytes() []byte
	GenerateStoreKeyBytes() []byte
	GeneratePrefixedStoreKeyBytes() []byte
	IsPartial() bool
	// TODO ** check all key impls
	Equals(Key) bool
}

type Mappable interface {
	codec.ProtoMarshaler
	RegisterLegacyAminoCodec(*codec.LegacyAmino)
	ValidateBasic() error
}

type Mapper interface {
	NewCollection(context.Context) Collection

	Upsert(context.Context, Record)
	Read(context.Context, Key) Record
	Delete(context.Context, Key)
	FetchAll(context.Context) []Record
	Iterate(context.Context, Key, func(Record) bool)
	IterateAll(context.Context, func(Record) bool)
	IteratePaginated(context.Context, Key, int32, func(Record) bool)

	StoreDecoder(kv.Pair, kv.Pair) string
	Initialize(*sdkTypes.KVStoreKey) Mapper
}

type Message interface {
	// TODO check if register message code is required
	RegisterLegacyAminoCodec(*codec.LegacyAmino)
	RegisterInterface(types.InterfaceRegistry)
	Type() string
	sdkTypes.Msg
}

type Module interface {
	sdkModuleTypes.EndBlockAppModule
	sdkModuleTypes.BeginBlockAppModule
	sdkModuleTypes.AppModuleSimulation

	GetAuxiliary(string) Auxiliary

	DecodeModuleTransactionRequest(string, json.RawMessage) (sdkTypes.Msg, error)

	Initialize(*sdkTypes.KVStoreKey, paramsTypes.Subspace, ...interface{}) Module

	GetTransactions() Transactions
}

type ParameterManager interface {
	Get() lists.ParameterList
	GetValidatableParameter(ids.PropertyID) ValidatableParameter
	GetParameter(ids.PropertyID) parameters.Parameter
	ValidateParameter(parameters.Parameter) error

	Fetch(context.Context) ParameterManager
	Set(context.Context, lists.ParameterList)

	GetKeyTable() paramsTypes.KeyTable
	RESTQueryHandler(client.Context) http.HandlerFunc
	Initialize(paramsTypes.Subspace) ParameterManager
}

type Queries interface {
	Get() []Query
	GetQuery(string) Query
}

type Query interface {
	GetName() string
	Command() *cobra.Command
	HandleQuery(context.Context, abciTypes.RequestQuery) ([]byte, error)
	RESTQueryHandler(client.Context) http.HandlerFunc
	RegisterService(module.Configurator)
	RegisterGRPCGatewayRoute(client.Context, *runtime.ServeMux)
	Initialize(Mapper, ParameterManager, ...interface{}) Query
}

type QueryKeeper interface {
	Enquire(context.Context, QueryRequest) (QueryResponse, error)
	Keeper
}

type QueryRequest interface {
	Request
	FromCLI(CLICommand, client.Context) (QueryRequest, error)
	FromHTTPRequest(*http.Request) (QueryRequest, error)
	Encode() ([]byte, error)
	Decode([]byte) (QueryRequest, error)
}

type QueryResponse interface {
	proto.Message
	Encode() ([]byte, error)
	Decode([]byte) (QueryResponse, error)
}

type Record interface {
	GetKey() Key
	GetMappable() Mappable

	WithKey(Key) Record

	ReadFromIterator(types.Iterator) Record
	Read(types.KVStore) Record
	Write(types.KVStore) Record
	Delete(types.KVStore)
}

type Request interface {
	Validate() error
}

type Response interface {
	IsSuccessful() bool
	GetError() error
}

type Simulator interface {
	RandomizedGenesisState(*module.SimulationState)
	WeightedOperations(module.SimulationState, Module) simulation.WeightedOperations
	WeightedProposalContentList(module.SimulationState) []simulationTypes.WeightedProposalContent
	ParamChangeList(*rand.Rand) []simulationTypes.ParamChange
}

type Transaction interface {
	GetName() string
	Command() *cobra.Command
	HandleMessage(context.Context, Message) (*sdkTypes.Result, error)
	RESTRequestHandler(client.Context) http.HandlerFunc
	RegisterLegacyAminoCodec(amino *codec.LegacyAmino)
	RegisterInterfaces(types.InterfaceRegistry)
	RegisterService(module.Configurator)
	RegisterGRPCGatewayRoute(client.Context, *runtime.ServeMux)
	DecodeTransactionRequest(json.RawMessage) (sdkTypes.Msg, error)
	InitializeKeeper(Mapper, ParameterManager, ...interface{}) Transaction
}

type TransactionKeeper interface {
	Transact(context.Context, Message) (TransactionResponse, error)
	Keeper
}

type TransactionRequest interface {
	GetBaseReq() rest.BaseReq

	FromCLI(CLICommand, client.Context) (TransactionRequest, error)
	FromJSON(json.RawMessage) (TransactionRequest, error)
	MakeMsg() (sdkTypes.Msg, error)
	RegisterLegacyAminoCodec(*codec.LegacyAmino)
	Request
}

type TransactionResponse interface {
	GetResult() *sdkTypes.Result
}

type Transactions interface {
	Get() []Transaction
	GetTransaction(string) Transaction
}

type ValidatableParameter interface {
	GetParameter() parameters.Parameter
	Mutate(data.Data) ValidatableParameter
	GetValidator() func(i interface{}) error
	Validate() error
}

type WasmMessage interface {
	GetType() string
	GetRawMessage() json.RawMessage
}

type WasmMessagePrototype func() WasmMessage