keeper

type ConfigurationKeeper interface {
	// GetFees gets the fees
	GetFees(ctx sdk.Context) *configuration.Fees
	// GetConfiguration returns the configuration
	GetConfiguration(ctx sdk.Context) configuration.Config
	// IsOwner returns if the provided address is an owner or not
	IsOwner(ctx sdk.Context, addr sdk.AccAddress) bool
	// GetValidDomainNameRegexp returns the regular expression that aliceAddr domain name must match
	// in order to be valid
	GetValidDomainNameRegexp(ctx sdk.Context) string
	// GetDomainRenewDuration returns the default duration of aliceAddr domain renewal
	GetDomainRenewDuration(ctx sdk.Context) time.Duration
	// GetDomainGracePeriod returns the grace period duration
	GetDomainGracePeriod(ctx sdk.Context) time.Duration
}

type ConfigurationSetter interface {
	SetConfig(ctx types.Context, config configuration.Config)
	SetFees(ctx types.Context, fees *configuration.Fees)
}

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

type Keeper struct {
	// external keepers
	ConfigurationKeeper ConfigurationKeeper
	SupplyKeeper        SupplyKeeper
	// default fields
	StoreKey sdk.StoreKey // contains the store key for the domain module
	Cdc      *codec.Codec
	// contains filtered or unexported fields
}

type Mocks struct {
	Supply *mock.SupplyKeeperMock
}

type ParamSubspace interface {
}

type QueryAccountsInDomain struct {
	// Domain is the domain name
	Domain string `json:"domain" arg:"positional"`
	// ResultsPerPage is the results that each page should contain
	ResultsPerPage int `json:"results_per_page" arg:"positional"`
	// Offset is the page number
	Offset int `json:"offset" arg:"positional"`
}

type QueryAccountsInDomainResponse struct {
	// Accounts is a slice of the accounts found
	Accounts []*types.Account `json:"accounts"`
}

type QueryAccountsWithOwner struct {
	// Owner is the owner of the accounts
	Owner sdk.AccAddress `json:"owner"`
	// ResultsPerPage is the number of results returned in each page
	ResultsPerPage int `json:"results_per_page"`
	// Offset is the page number
	Offset int `json:"offset"`
}

type QueryAccountsWithOwnerResponse struct {
	// Accounts is a slice containing the accounts
	// returned by the query
	Accounts []types.Account `json:"accounts"`
}

type QueryDomainsWithOwner struct {
	// Owner is the address of the owner of the domains
	Owner sdk.AccAddress `json:"owner"`
	// ResultsPerPage is the number of results displayed in a page
	ResultsPerPage int `json:"results_per_page"`
	// Offset is the page number
	Offset int `json:"offset"`
}

type QueryDomainsWithOwnerResponse struct {
	// Domains is a slice of the domains
	// found by the query
	Domains []types.Domain
}

type QueryHandlerFunc func(ctx sdk.Context, path []string, query abci.RequestQuery, k Keeper) ([]byte, error)

type QueryResolveAccount struct {
	// Domain is the name of the domain of the account
	Domain string `json:"domain"`
	// Name is the name of the account
	Name string `json:"name"`
	// Starname is the representation of an account in domain*name format
	Starname string `json:"starname"`
}

type QueryResolveAccountResponse struct {
	// Account contains the resolved account
	Account types.Account `json:"account"`
}

type QueryResolveDomain struct {
	// Name is the domain name
	Name string `json:"name" arg:"positional"`
}

type QueryResolveDomainResponse struct {
	// Domain contains the queried domain information
	Domain types.Domain `json:"domain"`
}

type QueryResolveResource struct {
	// Resource is the resource we want to query
	Resource types.Resource `json:"resource"`
	// ResultsPerPage is the number of results displayed in a page
	ResultsPerPage int `json:"results_per_page"`
	// Offset is the page number
	Offset int `json:"offset"`
}

type QueryResolveResourceResponse struct {
	Accounts []types.Account `json:"accounts"`
}

type SubTest struct {
	// BeforeTestBlockTime is the block time during before test in unix seconds
	// WARNING: if block time is given 0, it will be accepted as time.Now()
	BeforeTestBlockTime int64
	// BeforeTest is the function run before doing the test,
	// used for example to store state, like configurations etc.
	// Ignored if nil
	BeforeTest func(t *testing.T, k Keeper, ctx types.Context, mocks *Mocks)
	// TestBlockTime is the block time during test in unix seconds
	// WARNING: if block time is given 0, it will be accepted as time.Now()
	TestBlockTime int64
	// Test is the function that runs the actual test
	Test func(t *testing.T, k Keeper, ctx types.Context, mocks *Mocks)
	// AfterTestBlockTime is the block time during after test in unix seconds
	// WARNING: if block time is given 0, it will be accepted as time.Now()
	AfterTestBlockTime int64
	// AfterTest performs actions after the test is run, it can
	// be used to check if the state after Test is run matches
	// the result we expect.
	// Ignored if nil
	AfterTest func(t *testing.T, k Keeper, ctx types.Context, mocks *Mocks)
}

type SupplyKeeper interface {
	SendCoinsFromAccountToModule(ctx sdk.Context, addr sdk.AccAddress, moduleName string, coins sdk.Coins) error
}