helpers

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

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

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

type AuxiliaryRequest interface {
	Request
}

type AuxiliaryResponse interface {
	Response
}

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

type CLICommand interface {
	ReadInt64(CLIFlag) int64
	ReadInt(CLIFlag) int
	ReadBool(CLIFlag) bool
	ReadString(CLIFlag) string
	ReadBaseReq(context.CLIContext) 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 Collection interface {
	GetKey() Key
	Get(Key) Mappable
	GetList() []Mappable

	Iterate(Key, func(Mappable) bool)
	Fetch(Key) Collection
	Add(Mappable) Collection
	Remove(Mappable) Collection
	Mutate(Mappable) Collection
	Initialize(sdkTypes.Context, Mapper) Collection
}

type Genesis interface {
	Default() Genesis
	Validate() error
	Import(sdkTypes.Context, Mapper, Parameters)
	Export(sdkTypes.Context, Mapper, Parameters) Genesis

	Encode() []byte
	Decode([]byte) Genesis

	Initialize([]Mappable, []parameters.Parameter) Genesis

	GetParameterList() []parameters.Parameter
	GetMappableList() []Mappable
}

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

type Key interface {
	String() string
	GenerateStoreKeyBytes() []byte
	// TODO Check is register codec is still required
	RegisterCodec(*codec.Codec)
	IsPartial() bool
	// TODO ** check all key impls
	Equals(Key) bool
}

type Mappable interface {
	GetKey() Key
	RegisterCodec(*codec.Codec)
}

type Mapper interface {
	NewCollection(sdkTypes.Context) Collection

	Create(sdkTypes.Context, Mappable)
	Read(sdkTypes.Context, Key) Mappable
	Update(sdkTypes.Context, Mappable)
	Delete(sdkTypes.Context, Key)
	Iterate(sdkTypes.Context, Key, func(Mappable) bool)
	ReverseIterate(sdkTypes.Context, Key, func(Mappable) bool)

	StoreDecoder(*codec.Codec, kv.Pair, kv.Pair) string

	Initialize(*sdkTypes.KVStoreKey) Mapper
}

type Message interface {
	// TODO check if register message code is required
	RegisterCodec(*codec.Codec)
	sdkTypes.Msg
}

type Module interface {
	sdkTypesModule.AppModuleBasic
	sdkTypesModule.AppModule
	sdkTypesModule.AppModuleSimulation

	GetAuxiliary(string) Auxiliary

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

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

type Parameters interface {
	String() string

	Validate() error
	Equal(Parameters) bool

	Get(ids.ID) parameters.Parameter
	GetList() []parameters.Parameter

	Fetch(sdkTypes.Context, ids.ID) Parameters
	Mutate(sdkTypes.Context, parameters.Parameter) Parameters

	GetKeyTable() subspace.KeyTable
	subspace.ParamSet

	Initialize(params.Subspace) Parameters
}

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

type Query interface {
	GetName() string
	Command(*codec.Codec) *cobra.Command
	HandleMessage(sdkTypes.Context, abciTypes.RequestQuery) ([]byte, error)
	RESTQueryHandler(context.CLIContext) http.HandlerFunc
	Initialize(Mapper, Parameters, ...interface{}) Query
}

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

type QueryRequest interface {
	Request
	FromCLI(CLICommand, context.CLIContext) (QueryRequest, error)
	FromMap(map[string]string) (QueryRequest, error)
	Encode() ([]byte, error)
	Decode([]byte) (QueryRequest, error)
}

type QueryResponse interface {
	Response
	Encode() ([]byte, error)
	Decode([]byte) (QueryResponse, error)
}

type Request interface {
	Validate() error
}

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

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

type StoreKeyPrefix interface {
	// TODO define types and use key and storeKey
	GenerateStoreKey(key []byte) []byte
}

type Transaction interface {
	GetName() string
	Command(*codec.Codec) *cobra.Command
	HandleMessage(sdkTypes.Context, sdkTypes.Msg) (*sdkTypes.Result, error)
	RESTRequestHandler(context.CLIContext) http.HandlerFunc
	RegisterCodec(*codec.Codec)
	DecodeTransactionRequest(json.RawMessage) (sdkTypes.Msg, error)
	InitializeKeeper(Mapper, Parameters, ...interface{}) Transaction
}

type TransactionKeeper interface {
	Transact(sdkTypes.Context, sdkTypes.Msg) TransactionResponse
	Keeper
}

type TransactionRequest interface {
	GetBaseReq() rest.BaseReq

	FromCLI(CLICommand, context.CLIContext) (TransactionRequest, error)
	FromJSON(json.RawMessage) (TransactionRequest, error)
	MakeMsg() (sdkTypes.Msg, error)
	RegisterCodec(*codec.Codec)
	Request
}

type TransactionResponse interface {
	Response
}

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

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

type WasmMessagePrototype func() WasmMessage