1009 lines
42 KiB
Go
1009 lines
42 KiB
Go
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: x/gov/testutil/expected_keepers.go
|
|
|
|
// Package testutil is a generated GoMock package.
|
|
package testutil
|
|
|
|
import (
|
|
context "context"
|
|
reflect "reflect"
|
|
|
|
math "cosmossdk.io/math"
|
|
types "github.com/cosmos/cosmos-sdk/types"
|
|
query "github.com/cosmos/cosmos-sdk/types/query"
|
|
types0 "github.com/cosmos/cosmos-sdk/x/auth/types"
|
|
keeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
|
|
types1 "github.com/cosmos/cosmos-sdk/x/bank/types"
|
|
types2 "github.com/cosmos/cosmos-sdk/x/staking/types"
|
|
gomock "github.com/golang/mock/gomock"
|
|
)
|
|
|
|
// MockAccountKeeper is a mock of AccountKeeper interface.
|
|
type MockAccountKeeper struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockAccountKeeperMockRecorder
|
|
}
|
|
|
|
// MockAccountKeeperMockRecorder is the mock recorder for MockAccountKeeper.
|
|
type MockAccountKeeperMockRecorder struct {
|
|
mock *MockAccountKeeper
|
|
}
|
|
|
|
// NewMockAccountKeeper creates a new mock instance.
|
|
func NewMockAccountKeeper(ctrl *gomock.Controller) *MockAccountKeeper {
|
|
mock := &MockAccountKeeper{ctrl: ctrl}
|
|
mock.recorder = &MockAccountKeeperMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockAccountKeeper) EXPECT() *MockAccountKeeperMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GetAccount mocks base method.
|
|
func (m *MockAccountKeeper) GetAccount(ctx types.Context, addr types.AccAddress) types0.AccountI {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetAccount", ctx, addr)
|
|
ret0, _ := ret[0].(types0.AccountI)
|
|
return ret0
|
|
}
|
|
|
|
// GetAccount indicates an expected call of GetAccount.
|
|
func (mr *MockAccountKeeperMockRecorder) GetAccount(ctx, addr interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccount", reflect.TypeOf((*MockAccountKeeper)(nil).GetAccount), ctx, addr)
|
|
}
|
|
|
|
// GetModuleAccount mocks base method.
|
|
func (m *MockAccountKeeper) GetModuleAccount(ctx types.Context, name string) types0.ModuleAccountI {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetModuleAccount", ctx, name)
|
|
ret0, _ := ret[0].(types0.ModuleAccountI)
|
|
return ret0
|
|
}
|
|
|
|
// GetModuleAccount indicates an expected call of GetModuleAccount.
|
|
func (mr *MockAccountKeeperMockRecorder) GetModuleAccount(ctx, name interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModuleAccount", reflect.TypeOf((*MockAccountKeeper)(nil).GetModuleAccount), ctx, name)
|
|
}
|
|
|
|
// GetModuleAddress mocks base method.
|
|
func (m *MockAccountKeeper) GetModuleAddress(name string) types.AccAddress {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetModuleAddress", name)
|
|
ret0, _ := ret[0].(types.AccAddress)
|
|
return ret0
|
|
}
|
|
|
|
// GetModuleAddress indicates an expected call of GetModuleAddress.
|
|
func (mr *MockAccountKeeperMockRecorder) GetModuleAddress(name interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModuleAddress", reflect.TypeOf((*MockAccountKeeper)(nil).GetModuleAddress), name)
|
|
}
|
|
|
|
// IterateAccounts mocks base method.
|
|
func (m *MockAccountKeeper) IterateAccounts(ctx types.Context, cb func(types0.AccountI) bool) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "IterateAccounts", ctx, cb)
|
|
}
|
|
|
|
// IterateAccounts indicates an expected call of IterateAccounts.
|
|
func (mr *MockAccountKeeperMockRecorder) IterateAccounts(ctx, cb interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateAccounts", reflect.TypeOf((*MockAccountKeeper)(nil).IterateAccounts), ctx, cb)
|
|
}
|
|
|
|
// SetModuleAccount mocks base method.
|
|
func (m *MockAccountKeeper) SetModuleAccount(arg0 types.Context, arg1 types0.ModuleAccountI) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetModuleAccount", arg0, arg1)
|
|
}
|
|
|
|
// SetModuleAccount indicates an expected call of SetModuleAccount.
|
|
func (mr *MockAccountKeeperMockRecorder) SetModuleAccount(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetModuleAccount", reflect.TypeOf((*MockAccountKeeper)(nil).SetModuleAccount), arg0, arg1)
|
|
}
|
|
|
|
// MockBankKeeper is a mock of BankKeeper interface.
|
|
type MockBankKeeper struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockBankKeeperMockRecorder
|
|
}
|
|
|
|
// MockBankKeeperMockRecorder is the mock recorder for MockBankKeeper.
|
|
type MockBankKeeperMockRecorder struct {
|
|
mock *MockBankKeeper
|
|
}
|
|
|
|
// NewMockBankKeeper creates a new mock instance.
|
|
func NewMockBankKeeper(ctrl *gomock.Controller) *MockBankKeeper {
|
|
mock := &MockBankKeeper{ctrl: ctrl}
|
|
mock.recorder = &MockBankKeeperMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockBankKeeper) EXPECT() *MockBankKeeperMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// AllBalances mocks base method.
|
|
func (m *MockBankKeeper) AllBalances(arg0 context.Context, arg1 *types1.QueryAllBalancesRequest) (*types1.QueryAllBalancesResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AllBalances", arg0, arg1)
|
|
ret0, _ := ret[0].(*types1.QueryAllBalancesResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AllBalances indicates an expected call of AllBalances.
|
|
func (mr *MockBankKeeperMockRecorder) AllBalances(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllBalances", reflect.TypeOf((*MockBankKeeper)(nil).AllBalances), arg0, arg1)
|
|
}
|
|
|
|
// Balance mocks base method.
|
|
func (m *MockBankKeeper) Balance(arg0 context.Context, arg1 *types1.QueryBalanceRequest) (*types1.QueryBalanceResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Balance", arg0, arg1)
|
|
ret0, _ := ret[0].(*types1.QueryBalanceResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Balance indicates an expected call of Balance.
|
|
func (mr *MockBankKeeperMockRecorder) Balance(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Balance", reflect.TypeOf((*MockBankKeeper)(nil).Balance), arg0, arg1)
|
|
}
|
|
|
|
// BlockedAddr mocks base method.
|
|
func (m *MockBankKeeper) BlockedAddr(addr types.AccAddress) bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BlockedAddr", addr)
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// BlockedAddr indicates an expected call of BlockedAddr.
|
|
func (mr *MockBankKeeperMockRecorder) BlockedAddr(addr interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockedAddr", reflect.TypeOf((*MockBankKeeper)(nil).BlockedAddr), addr)
|
|
}
|
|
|
|
// BurnCoins mocks base method.
|
|
func (m *MockBankKeeper) BurnCoins(ctx types.Context, moduleName string, amt types.Coins) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BurnCoins", ctx, moduleName, amt)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// BurnCoins indicates an expected call of BurnCoins.
|
|
func (mr *MockBankKeeperMockRecorder) BurnCoins(ctx, moduleName, amt interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BurnCoins", reflect.TypeOf((*MockBankKeeper)(nil).BurnCoins), ctx, moduleName, amt)
|
|
}
|
|
|
|
// DelegateCoins mocks base method.
|
|
func (m *MockBankKeeper) DelegateCoins(ctx types.Context, delegatorAddr, moduleAccAddr types.AccAddress, amt types.Coins) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DelegateCoins", ctx, delegatorAddr, moduleAccAddr, amt)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DelegateCoins indicates an expected call of DelegateCoins.
|
|
func (mr *MockBankKeeperMockRecorder) DelegateCoins(ctx, delegatorAddr, moduleAccAddr, amt interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelegateCoins", reflect.TypeOf((*MockBankKeeper)(nil).DelegateCoins), ctx, delegatorAddr, moduleAccAddr, amt)
|
|
}
|
|
|
|
// DelegateCoinsFromAccountToModule mocks base method.
|
|
func (m *MockBankKeeper) DelegateCoinsFromAccountToModule(ctx types.Context, senderAddr types.AccAddress, recipientModule string, amt types.Coins) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DelegateCoinsFromAccountToModule", ctx, senderAddr, recipientModule, amt)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DelegateCoinsFromAccountToModule indicates an expected call of DelegateCoinsFromAccountToModule.
|
|
func (mr *MockBankKeeperMockRecorder) DelegateCoinsFromAccountToModule(ctx, senderAddr, recipientModule, amt interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelegateCoinsFromAccountToModule", reflect.TypeOf((*MockBankKeeper)(nil).DelegateCoinsFromAccountToModule), ctx, senderAddr, recipientModule, amt)
|
|
}
|
|
|
|
// DeleteSendEnabled mocks base method.
|
|
func (m *MockBankKeeper) DeleteSendEnabled(ctx types.Context, denoms ...string) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx}
|
|
for _, a := range denoms {
|
|
varargs = append(varargs, a)
|
|
}
|
|
m.ctrl.Call(m, "DeleteSendEnabled", varargs...)
|
|
}
|
|
|
|
// DeleteSendEnabled indicates an expected call of DeleteSendEnabled.
|
|
func (mr *MockBankKeeperMockRecorder) DeleteSendEnabled(ctx interface{}, denoms ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx}, denoms...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSendEnabled", reflect.TypeOf((*MockBankKeeper)(nil).DeleteSendEnabled), varargs...)
|
|
}
|
|
|
|
// DenomMetadata mocks base method.
|
|
func (m *MockBankKeeper) DenomMetadata(arg0 context.Context, arg1 *types1.QueryDenomMetadataRequest) (*types1.QueryDenomMetadataResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DenomMetadata", arg0, arg1)
|
|
ret0, _ := ret[0].(*types1.QueryDenomMetadataResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DenomMetadata indicates an expected call of DenomMetadata.
|
|
func (mr *MockBankKeeperMockRecorder) DenomMetadata(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DenomMetadata", reflect.TypeOf((*MockBankKeeper)(nil).DenomMetadata), arg0, arg1)
|
|
}
|
|
|
|
// DenomOwners mocks base method.
|
|
func (m *MockBankKeeper) DenomOwners(arg0 context.Context, arg1 *types1.QueryDenomOwnersRequest) (*types1.QueryDenomOwnersResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DenomOwners", arg0, arg1)
|
|
ret0, _ := ret[0].(*types1.QueryDenomOwnersResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DenomOwners indicates an expected call of DenomOwners.
|
|
func (mr *MockBankKeeperMockRecorder) DenomOwners(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DenomOwners", reflect.TypeOf((*MockBankKeeper)(nil).DenomOwners), arg0, arg1)
|
|
}
|
|
|
|
// DenomsMetadata mocks base method.
|
|
func (m *MockBankKeeper) DenomsMetadata(arg0 context.Context, arg1 *types1.QueryDenomsMetadataRequest) (*types1.QueryDenomsMetadataResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DenomsMetadata", arg0, arg1)
|
|
ret0, _ := ret[0].(*types1.QueryDenomsMetadataResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DenomsMetadata indicates an expected call of DenomsMetadata.
|
|
func (mr *MockBankKeeperMockRecorder) DenomsMetadata(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DenomsMetadata", reflect.TypeOf((*MockBankKeeper)(nil).DenomsMetadata), arg0, arg1)
|
|
}
|
|
|
|
// ExportGenesis mocks base method.
|
|
func (m *MockBankKeeper) ExportGenesis(arg0 types.Context) *types1.GenesisState {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ExportGenesis", arg0)
|
|
ret0, _ := ret[0].(*types1.GenesisState)
|
|
return ret0
|
|
}
|
|
|
|
// ExportGenesis indicates an expected call of ExportGenesis.
|
|
func (mr *MockBankKeeperMockRecorder) ExportGenesis(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportGenesis", reflect.TypeOf((*MockBankKeeper)(nil).ExportGenesis), arg0)
|
|
}
|
|
|
|
// GetAccountsBalances mocks base method.
|
|
func (m *MockBankKeeper) GetAccountsBalances(ctx types.Context) []types1.Balance {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetAccountsBalances", ctx)
|
|
ret0, _ := ret[0].([]types1.Balance)
|
|
return ret0
|
|
}
|
|
|
|
// GetAccountsBalances indicates an expected call of GetAccountsBalances.
|
|
func (mr *MockBankKeeperMockRecorder) GetAccountsBalances(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountsBalances", reflect.TypeOf((*MockBankKeeper)(nil).GetAccountsBalances), ctx)
|
|
}
|
|
|
|
// GetAllBalances mocks base method.
|
|
func (m *MockBankKeeper) GetAllBalances(ctx types.Context, addr types.AccAddress) types.Coins {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetAllBalances", ctx, addr)
|
|
ret0, _ := ret[0].(types.Coins)
|
|
return ret0
|
|
}
|
|
|
|
// GetAllBalances indicates an expected call of GetAllBalances.
|
|
func (mr *MockBankKeeperMockRecorder) GetAllBalances(ctx, addr interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllBalances", reflect.TypeOf((*MockBankKeeper)(nil).GetAllBalances), ctx, addr)
|
|
}
|
|
|
|
// GetAllSendEnabledEntries mocks base method.
|
|
func (m *MockBankKeeper) GetAllSendEnabledEntries(ctx types.Context) []types1.SendEnabled {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetAllSendEnabledEntries", ctx)
|
|
ret0, _ := ret[0].([]types1.SendEnabled)
|
|
return ret0
|
|
}
|
|
|
|
// GetAllSendEnabledEntries indicates an expected call of GetAllSendEnabledEntries.
|
|
func (mr *MockBankKeeperMockRecorder) GetAllSendEnabledEntries(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllSendEnabledEntries", reflect.TypeOf((*MockBankKeeper)(nil).GetAllSendEnabledEntries), ctx)
|
|
}
|
|
|
|
// GetAuthority mocks base method.
|
|
func (m *MockBankKeeper) GetAuthority() string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetAuthority")
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// GetAuthority indicates an expected call of GetAuthority.
|
|
func (mr *MockBankKeeperMockRecorder) GetAuthority() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthority", reflect.TypeOf((*MockBankKeeper)(nil).GetAuthority))
|
|
}
|
|
|
|
// GetBalance mocks base method.
|
|
func (m *MockBankKeeper) GetBalance(ctx types.Context, addr types.AccAddress, denom string) types.Coin {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetBalance", ctx, addr, denom)
|
|
ret0, _ := ret[0].(types.Coin)
|
|
return ret0
|
|
}
|
|
|
|
// GetBalance indicates an expected call of GetBalance.
|
|
func (mr *MockBankKeeperMockRecorder) GetBalance(ctx, addr, denom interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBalance", reflect.TypeOf((*MockBankKeeper)(nil).GetBalance), ctx, addr, denom)
|
|
}
|
|
|
|
// GetBlockedAddresses mocks base method.
|
|
func (m *MockBankKeeper) GetBlockedAddresses() map[string]bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetBlockedAddresses")
|
|
ret0, _ := ret[0].(map[string]bool)
|
|
return ret0
|
|
}
|
|
|
|
// GetBlockedAddresses indicates an expected call of GetBlockedAddresses.
|
|
func (mr *MockBankKeeperMockRecorder) GetBlockedAddresses() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockedAddresses", reflect.TypeOf((*MockBankKeeper)(nil).GetBlockedAddresses))
|
|
}
|
|
|
|
// GetDenomMetaData mocks base method.
|
|
func (m *MockBankKeeper) GetDenomMetaData(ctx types.Context, denom string) (types1.Metadata, bool) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetDenomMetaData", ctx, denom)
|
|
ret0, _ := ret[0].(types1.Metadata)
|
|
ret1, _ := ret[1].(bool)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetDenomMetaData indicates an expected call of GetDenomMetaData.
|
|
func (mr *MockBankKeeperMockRecorder) GetDenomMetaData(ctx, denom interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDenomMetaData", reflect.TypeOf((*MockBankKeeper)(nil).GetDenomMetaData), ctx, denom)
|
|
}
|
|
|
|
// GetPaginatedTotalSupply mocks base method.
|
|
func (m *MockBankKeeper) GetPaginatedTotalSupply(ctx types.Context, pagination *query.PageRequest) (types.Coins, *query.PageResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPaginatedTotalSupply", ctx, pagination)
|
|
ret0, _ := ret[0].(types.Coins)
|
|
ret1, _ := ret[1].(*query.PageResponse)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetPaginatedTotalSupply indicates an expected call of GetPaginatedTotalSupply.
|
|
func (mr *MockBankKeeperMockRecorder) GetPaginatedTotalSupply(ctx, pagination interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPaginatedTotalSupply", reflect.TypeOf((*MockBankKeeper)(nil).GetPaginatedTotalSupply), ctx, pagination)
|
|
}
|
|
|
|
// GetParams mocks base method.
|
|
func (m *MockBankKeeper) GetParams(ctx types.Context) types1.Params {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetParams", ctx)
|
|
ret0, _ := ret[0].(types1.Params)
|
|
return ret0
|
|
}
|
|
|
|
// GetParams indicates an expected call of GetParams.
|
|
func (mr *MockBankKeeperMockRecorder) GetParams(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParams", reflect.TypeOf((*MockBankKeeper)(nil).GetParams), ctx)
|
|
}
|
|
|
|
// GetSendEnabledEntry mocks base method.
|
|
func (m *MockBankKeeper) GetSendEnabledEntry(ctx types.Context, denom string) (types1.SendEnabled, bool) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetSendEnabledEntry", ctx, denom)
|
|
ret0, _ := ret[0].(types1.SendEnabled)
|
|
ret1, _ := ret[1].(bool)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetSendEnabledEntry indicates an expected call of GetSendEnabledEntry.
|
|
func (mr *MockBankKeeperMockRecorder) GetSendEnabledEntry(ctx, denom interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSendEnabledEntry", reflect.TypeOf((*MockBankKeeper)(nil).GetSendEnabledEntry), ctx, denom)
|
|
}
|
|
|
|
// GetSupply mocks base method.
|
|
func (m *MockBankKeeper) GetSupply(ctx types.Context, denom string) types.Coin {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetSupply", ctx, denom)
|
|
ret0, _ := ret[0].(types.Coin)
|
|
return ret0
|
|
}
|
|
|
|
// GetSupply indicates an expected call of GetSupply.
|
|
func (mr *MockBankKeeperMockRecorder) GetSupply(ctx, denom interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSupply", reflect.TypeOf((*MockBankKeeper)(nil).GetSupply), ctx, denom)
|
|
}
|
|
|
|
// HasBalance mocks base method.
|
|
func (m *MockBankKeeper) HasBalance(ctx types.Context, addr types.AccAddress, amt types.Coin) bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HasBalance", ctx, addr, amt)
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// HasBalance indicates an expected call of HasBalance.
|
|
func (mr *MockBankKeeperMockRecorder) HasBalance(ctx, addr, amt interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasBalance", reflect.TypeOf((*MockBankKeeper)(nil).HasBalance), ctx, addr, amt)
|
|
}
|
|
|
|
// HasDenomMetaData mocks base method.
|
|
func (m *MockBankKeeper) HasDenomMetaData(ctx types.Context, denom string) bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HasDenomMetaData", ctx, denom)
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// HasDenomMetaData indicates an expected call of HasDenomMetaData.
|
|
func (mr *MockBankKeeperMockRecorder) HasDenomMetaData(ctx, denom interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasDenomMetaData", reflect.TypeOf((*MockBankKeeper)(nil).HasDenomMetaData), ctx, denom)
|
|
}
|
|
|
|
// HasSupply mocks base method.
|
|
func (m *MockBankKeeper) HasSupply(ctx types.Context, denom string) bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HasSupply", ctx, denom)
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// HasSupply indicates an expected call of HasSupply.
|
|
func (mr *MockBankKeeperMockRecorder) HasSupply(ctx, denom interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasSupply", reflect.TypeOf((*MockBankKeeper)(nil).HasSupply), ctx, denom)
|
|
}
|
|
|
|
// InitGenesis mocks base method.
|
|
func (m *MockBankKeeper) InitGenesis(arg0 types.Context, arg1 *types1.GenesisState) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "InitGenesis", arg0, arg1)
|
|
}
|
|
|
|
// InitGenesis indicates an expected call of InitGenesis.
|
|
func (mr *MockBankKeeperMockRecorder) InitGenesis(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitGenesis", reflect.TypeOf((*MockBankKeeper)(nil).InitGenesis), arg0, arg1)
|
|
}
|
|
|
|
// InputOutputCoins mocks base method.
|
|
func (m *MockBankKeeper) InputOutputCoins(ctx types.Context, inputs []types1.Input, outputs []types1.Output) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "InputOutputCoins", ctx, inputs, outputs)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// InputOutputCoins indicates an expected call of InputOutputCoins.
|
|
func (mr *MockBankKeeperMockRecorder) InputOutputCoins(ctx, inputs, outputs interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InputOutputCoins", reflect.TypeOf((*MockBankKeeper)(nil).InputOutputCoins), ctx, inputs, outputs)
|
|
}
|
|
|
|
// IsSendEnabledCoin mocks base method.
|
|
func (m *MockBankKeeper) IsSendEnabledCoin(ctx types.Context, coin types.Coin) bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsSendEnabledCoin", ctx, coin)
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsSendEnabledCoin indicates an expected call of IsSendEnabledCoin.
|
|
func (mr *MockBankKeeperMockRecorder) IsSendEnabledCoin(ctx, coin interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSendEnabledCoin", reflect.TypeOf((*MockBankKeeper)(nil).IsSendEnabledCoin), ctx, coin)
|
|
}
|
|
|
|
// IsSendEnabledCoins mocks base method.
|
|
func (m *MockBankKeeper) IsSendEnabledCoins(ctx types.Context, coins ...types.Coin) error {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx}
|
|
for _, a := range coins {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "IsSendEnabledCoins", varargs...)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// IsSendEnabledCoins indicates an expected call of IsSendEnabledCoins.
|
|
func (mr *MockBankKeeperMockRecorder) IsSendEnabledCoins(ctx interface{}, coins ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx}, coins...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSendEnabledCoins", reflect.TypeOf((*MockBankKeeper)(nil).IsSendEnabledCoins), varargs...)
|
|
}
|
|
|
|
// IsSendEnabledDenom mocks base method.
|
|
func (m *MockBankKeeper) IsSendEnabledDenom(ctx types.Context, denom string) bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsSendEnabledDenom", ctx, denom)
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsSendEnabledDenom indicates an expected call of IsSendEnabledDenom.
|
|
func (mr *MockBankKeeperMockRecorder) IsSendEnabledDenom(ctx, denom interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSendEnabledDenom", reflect.TypeOf((*MockBankKeeper)(nil).IsSendEnabledDenom), ctx, denom)
|
|
}
|
|
|
|
// IterateAccountBalances mocks base method.
|
|
func (m *MockBankKeeper) IterateAccountBalances(ctx types.Context, addr types.AccAddress, cb func(types.Coin) bool) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "IterateAccountBalances", ctx, addr, cb)
|
|
}
|
|
|
|
// IterateAccountBalances indicates an expected call of IterateAccountBalances.
|
|
func (mr *MockBankKeeperMockRecorder) IterateAccountBalances(ctx, addr, cb interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateAccountBalances", reflect.TypeOf((*MockBankKeeper)(nil).IterateAccountBalances), ctx, addr, cb)
|
|
}
|
|
|
|
// IterateAllBalances mocks base method.
|
|
func (m *MockBankKeeper) IterateAllBalances(ctx types.Context, cb func(types.AccAddress, types.Coin) bool) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "IterateAllBalances", ctx, cb)
|
|
}
|
|
|
|
// IterateAllBalances indicates an expected call of IterateAllBalances.
|
|
func (mr *MockBankKeeperMockRecorder) IterateAllBalances(ctx, cb interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateAllBalances", reflect.TypeOf((*MockBankKeeper)(nil).IterateAllBalances), ctx, cb)
|
|
}
|
|
|
|
// IterateAllDenomMetaData mocks base method.
|
|
func (m *MockBankKeeper) IterateAllDenomMetaData(ctx types.Context, cb func(types1.Metadata) bool) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "IterateAllDenomMetaData", ctx, cb)
|
|
}
|
|
|
|
// IterateAllDenomMetaData indicates an expected call of IterateAllDenomMetaData.
|
|
func (mr *MockBankKeeperMockRecorder) IterateAllDenomMetaData(ctx, cb interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateAllDenomMetaData", reflect.TypeOf((*MockBankKeeper)(nil).IterateAllDenomMetaData), ctx, cb)
|
|
}
|
|
|
|
// IterateSendEnabledEntries mocks base method.
|
|
func (m *MockBankKeeper) IterateSendEnabledEntries(ctx types.Context, cb func(string, bool) bool) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "IterateSendEnabledEntries", ctx, cb)
|
|
}
|
|
|
|
// IterateSendEnabledEntries indicates an expected call of IterateSendEnabledEntries.
|
|
func (mr *MockBankKeeperMockRecorder) IterateSendEnabledEntries(ctx, cb interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateSendEnabledEntries", reflect.TypeOf((*MockBankKeeper)(nil).IterateSendEnabledEntries), ctx, cb)
|
|
}
|
|
|
|
// IterateTotalSupply mocks base method.
|
|
func (m *MockBankKeeper) IterateTotalSupply(ctx types.Context, cb func(types.Coin) bool) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "IterateTotalSupply", ctx, cb)
|
|
}
|
|
|
|
// IterateTotalSupply indicates an expected call of IterateTotalSupply.
|
|
func (mr *MockBankKeeperMockRecorder) IterateTotalSupply(ctx, cb interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateTotalSupply", reflect.TypeOf((*MockBankKeeper)(nil).IterateTotalSupply), ctx, cb)
|
|
}
|
|
|
|
// LockedCoins mocks base method.
|
|
func (m *MockBankKeeper) LockedCoins(ctx types.Context, addr types.AccAddress) types.Coins {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "LockedCoins", ctx, addr)
|
|
ret0, _ := ret[0].(types.Coins)
|
|
return ret0
|
|
}
|
|
|
|
// LockedCoins indicates an expected call of LockedCoins.
|
|
func (mr *MockBankKeeperMockRecorder) LockedCoins(ctx, addr interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockedCoins", reflect.TypeOf((*MockBankKeeper)(nil).LockedCoins), ctx, addr)
|
|
}
|
|
|
|
// MintCoins mocks base method.
|
|
func (m *MockBankKeeper) MintCoins(ctx types.Context, moduleName string, amt types.Coins) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "MintCoins", ctx, moduleName, amt)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// MintCoins indicates an expected call of MintCoins.
|
|
func (mr *MockBankKeeperMockRecorder) MintCoins(ctx, moduleName, amt interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MintCoins", reflect.TypeOf((*MockBankKeeper)(nil).MintCoins), ctx, moduleName, amt)
|
|
}
|
|
|
|
// Params mocks base method.
|
|
func (m *MockBankKeeper) Params(arg0 context.Context, arg1 *types1.QueryParamsRequest) (*types1.QueryParamsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Params", arg0, arg1)
|
|
ret0, _ := ret[0].(*types1.QueryParamsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Params indicates an expected call of Params.
|
|
func (mr *MockBankKeeperMockRecorder) Params(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Params", reflect.TypeOf((*MockBankKeeper)(nil).Params), arg0, arg1)
|
|
}
|
|
|
|
// SendCoins mocks base method.
|
|
func (m *MockBankKeeper) SendCoins(ctx types.Context, fromAddr, toAddr types.AccAddress, amt types.Coins) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SendCoins", ctx, fromAddr, toAddr, amt)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SendCoins indicates an expected call of SendCoins.
|
|
func (mr *MockBankKeeperMockRecorder) SendCoins(ctx, fromAddr, toAddr, amt interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoins", reflect.TypeOf((*MockBankKeeper)(nil).SendCoins), ctx, fromAddr, toAddr, amt)
|
|
}
|
|
|
|
// SendCoinsFromAccountToModule mocks base method.
|
|
func (m *MockBankKeeper) SendCoinsFromAccountToModule(ctx types.Context, senderAddr types.AccAddress, recipientModule string, amt types.Coins) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SendCoinsFromAccountToModule", ctx, senderAddr, recipientModule, amt)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SendCoinsFromAccountToModule indicates an expected call of SendCoinsFromAccountToModule.
|
|
func (mr *MockBankKeeperMockRecorder) SendCoinsFromAccountToModule(ctx, senderAddr, recipientModule, amt interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromAccountToModule", reflect.TypeOf((*MockBankKeeper)(nil).SendCoinsFromAccountToModule), ctx, senderAddr, recipientModule, amt)
|
|
}
|
|
|
|
// SendCoinsFromModuleToAccount mocks base method.
|
|
func (m *MockBankKeeper) SendCoinsFromModuleToAccount(ctx types.Context, senderModule string, recipientAddr types.AccAddress, amt types.Coins) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SendCoinsFromModuleToAccount", ctx, senderModule, recipientAddr, amt)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SendCoinsFromModuleToAccount indicates an expected call of SendCoinsFromModuleToAccount.
|
|
func (mr *MockBankKeeperMockRecorder) SendCoinsFromModuleToAccount(ctx, senderModule, recipientAddr, amt interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromModuleToAccount", reflect.TypeOf((*MockBankKeeper)(nil).SendCoinsFromModuleToAccount), ctx, senderModule, recipientAddr, amt)
|
|
}
|
|
|
|
// SendCoinsFromModuleToModule mocks base method.
|
|
func (m *MockBankKeeper) SendCoinsFromModuleToModule(ctx types.Context, senderModule, recipientModule string, amt types.Coins) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SendCoinsFromModuleToModule", ctx, senderModule, recipientModule, amt)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SendCoinsFromModuleToModule indicates an expected call of SendCoinsFromModuleToModule.
|
|
func (mr *MockBankKeeperMockRecorder) SendCoinsFromModuleToModule(ctx, senderModule, recipientModule, amt interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromModuleToModule", reflect.TypeOf((*MockBankKeeper)(nil).SendCoinsFromModuleToModule), ctx, senderModule, recipientModule, amt)
|
|
}
|
|
|
|
// SendEnabled mocks base method.
|
|
func (m *MockBankKeeper) SendEnabled(arg0 context.Context, arg1 *types1.QuerySendEnabledRequest) (*types1.QuerySendEnabledResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SendEnabled", arg0, arg1)
|
|
ret0, _ := ret[0].(*types1.QuerySendEnabledResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SendEnabled indicates an expected call of SendEnabled.
|
|
func (mr *MockBankKeeperMockRecorder) SendEnabled(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendEnabled", reflect.TypeOf((*MockBankKeeper)(nil).SendEnabled), arg0, arg1)
|
|
}
|
|
|
|
// SetAllSendEnabled mocks base method.
|
|
func (m *MockBankKeeper) SetAllSendEnabled(ctx types.Context, sendEnableds []*types1.SendEnabled) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetAllSendEnabled", ctx, sendEnableds)
|
|
}
|
|
|
|
// SetAllSendEnabled indicates an expected call of SetAllSendEnabled.
|
|
func (mr *MockBankKeeperMockRecorder) SetAllSendEnabled(ctx, sendEnableds interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAllSendEnabled", reflect.TypeOf((*MockBankKeeper)(nil).SetAllSendEnabled), ctx, sendEnableds)
|
|
}
|
|
|
|
// SetDenomMetaData mocks base method.
|
|
func (m *MockBankKeeper) SetDenomMetaData(ctx types.Context, denomMetaData types1.Metadata) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetDenomMetaData", ctx, denomMetaData)
|
|
}
|
|
|
|
// SetDenomMetaData indicates an expected call of SetDenomMetaData.
|
|
func (mr *MockBankKeeperMockRecorder) SetDenomMetaData(ctx, denomMetaData interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDenomMetaData", reflect.TypeOf((*MockBankKeeper)(nil).SetDenomMetaData), ctx, denomMetaData)
|
|
}
|
|
|
|
// SetParams mocks base method.
|
|
func (m *MockBankKeeper) SetParams(ctx types.Context, params types1.Params) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetParams", ctx, params)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SetParams indicates an expected call of SetParams.
|
|
func (mr *MockBankKeeperMockRecorder) SetParams(ctx, params interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetParams", reflect.TypeOf((*MockBankKeeper)(nil).SetParams), ctx, params)
|
|
}
|
|
|
|
// SetSendEnabled mocks base method.
|
|
func (m *MockBankKeeper) SetSendEnabled(ctx types.Context, denom string, value bool) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetSendEnabled", ctx, denom, value)
|
|
}
|
|
|
|
// SetSendEnabled indicates an expected call of SetSendEnabled.
|
|
func (mr *MockBankKeeperMockRecorder) SetSendEnabled(ctx, denom, value interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSendEnabled", reflect.TypeOf((*MockBankKeeper)(nil).SetSendEnabled), ctx, denom, value)
|
|
}
|
|
|
|
// SpendableBalances mocks base method.
|
|
func (m *MockBankKeeper) SpendableBalances(arg0 context.Context, arg1 *types1.QuerySpendableBalancesRequest) (*types1.QuerySpendableBalancesResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SpendableBalances", arg0, arg1)
|
|
ret0, _ := ret[0].(*types1.QuerySpendableBalancesResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SpendableBalances indicates an expected call of SpendableBalances.
|
|
func (mr *MockBankKeeperMockRecorder) SpendableBalances(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpendableBalances", reflect.TypeOf((*MockBankKeeper)(nil).SpendableBalances), arg0, arg1)
|
|
}
|
|
|
|
// SpendableCoin mocks base method.
|
|
func (m *MockBankKeeper) SpendableCoin(ctx types.Context, addr types.AccAddress, denom string) types.Coin {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SpendableCoin", ctx, addr, denom)
|
|
ret0, _ := ret[0].(types.Coin)
|
|
return ret0
|
|
}
|
|
|
|
// SpendableCoin indicates an expected call of SpendableCoin.
|
|
func (mr *MockBankKeeperMockRecorder) SpendableCoin(ctx, addr, denom interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpendableCoin", reflect.TypeOf((*MockBankKeeper)(nil).SpendableCoin), ctx, addr, denom)
|
|
}
|
|
|
|
// SpendableCoins mocks base method.
|
|
func (m *MockBankKeeper) SpendableCoins(ctx types.Context, addr types.AccAddress) types.Coins {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SpendableCoins", ctx, addr)
|
|
ret0, _ := ret[0].(types.Coins)
|
|
return ret0
|
|
}
|
|
|
|
// SpendableCoins indicates an expected call of SpendableCoins.
|
|
func (mr *MockBankKeeperMockRecorder) SpendableCoins(ctx, addr interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpendableCoins", reflect.TypeOf((*MockBankKeeper)(nil).SpendableCoins), ctx, addr)
|
|
}
|
|
|
|
// SupplyOf mocks base method.
|
|
func (m *MockBankKeeper) SupplyOf(arg0 context.Context, arg1 *types1.QuerySupplyOfRequest) (*types1.QuerySupplyOfResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SupplyOf", arg0, arg1)
|
|
ret0, _ := ret[0].(*types1.QuerySupplyOfResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SupplyOf indicates an expected call of SupplyOf.
|
|
func (mr *MockBankKeeperMockRecorder) SupplyOf(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SupplyOf", reflect.TypeOf((*MockBankKeeper)(nil).SupplyOf), arg0, arg1)
|
|
}
|
|
|
|
// TotalSupply mocks base method.
|
|
func (m *MockBankKeeper) TotalSupply(arg0 context.Context, arg1 *types1.QueryTotalSupplyRequest) (*types1.QueryTotalSupplyResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TotalSupply", arg0, arg1)
|
|
ret0, _ := ret[0].(*types1.QueryTotalSupplyResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// TotalSupply indicates an expected call of TotalSupply.
|
|
func (mr *MockBankKeeperMockRecorder) TotalSupply(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TotalSupply", reflect.TypeOf((*MockBankKeeper)(nil).TotalSupply), arg0, arg1)
|
|
}
|
|
|
|
// UndelegateCoins mocks base method.
|
|
func (m *MockBankKeeper) UndelegateCoins(ctx types.Context, moduleAccAddr, delegatorAddr types.AccAddress, amt types.Coins) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UndelegateCoins", ctx, moduleAccAddr, delegatorAddr, amt)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UndelegateCoins indicates an expected call of UndelegateCoins.
|
|
func (mr *MockBankKeeperMockRecorder) UndelegateCoins(ctx, moduleAccAddr, delegatorAddr, amt interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UndelegateCoins", reflect.TypeOf((*MockBankKeeper)(nil).UndelegateCoins), ctx, moduleAccAddr, delegatorAddr, amt)
|
|
}
|
|
|
|
// UndelegateCoinsFromModuleToAccount mocks base method.
|
|
func (m *MockBankKeeper) UndelegateCoinsFromModuleToAccount(ctx types.Context, senderModule string, recipientAddr types.AccAddress, amt types.Coins) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UndelegateCoinsFromModuleToAccount", ctx, senderModule, recipientAddr, amt)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UndelegateCoinsFromModuleToAccount indicates an expected call of UndelegateCoinsFromModuleToAccount.
|
|
func (mr *MockBankKeeperMockRecorder) UndelegateCoinsFromModuleToAccount(ctx, senderModule, recipientAddr, amt interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UndelegateCoinsFromModuleToAccount", reflect.TypeOf((*MockBankKeeper)(nil).UndelegateCoinsFromModuleToAccount), ctx, senderModule, recipientAddr, amt)
|
|
}
|
|
|
|
// ValidateBalance mocks base method.
|
|
func (m *MockBankKeeper) ValidateBalance(ctx types.Context, addr types.AccAddress) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ValidateBalance", ctx, addr)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ValidateBalance indicates an expected call of ValidateBalance.
|
|
func (mr *MockBankKeeperMockRecorder) ValidateBalance(ctx, addr interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateBalance", reflect.TypeOf((*MockBankKeeper)(nil).ValidateBalance), ctx, addr)
|
|
}
|
|
|
|
// WithMintCoinsRestriction mocks base method.
|
|
func (m *MockBankKeeper) WithMintCoinsRestriction(arg0 keeper.MintingRestrictionFn) keeper.BaseKeeper {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WithMintCoinsRestriction", arg0)
|
|
ret0, _ := ret[0].(keeper.BaseKeeper)
|
|
return ret0
|
|
}
|
|
|
|
// WithMintCoinsRestriction indicates an expected call of WithMintCoinsRestriction.
|
|
func (mr *MockBankKeeperMockRecorder) WithMintCoinsRestriction(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithMintCoinsRestriction", reflect.TypeOf((*MockBankKeeper)(nil).WithMintCoinsRestriction), arg0)
|
|
}
|
|
|
|
// MockStakingKeeper is a mock of StakingKeeper interface.
|
|
type MockStakingKeeper struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockStakingKeeperMockRecorder
|
|
}
|
|
|
|
// MockStakingKeeperMockRecorder is the mock recorder for MockStakingKeeper.
|
|
type MockStakingKeeperMockRecorder struct {
|
|
mock *MockStakingKeeper
|
|
}
|
|
|
|
// NewMockStakingKeeper creates a new mock instance.
|
|
func NewMockStakingKeeper(ctrl *gomock.Controller) *MockStakingKeeper {
|
|
mock := &MockStakingKeeper{ctrl: ctrl}
|
|
mock.recorder = &MockStakingKeeperMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockStakingKeeper) EXPECT() *MockStakingKeeperMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// BondDenom mocks base method.
|
|
func (m *MockStakingKeeper) BondDenom(ctx types.Context) string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BondDenom", ctx)
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// BondDenom indicates an expected call of BondDenom.
|
|
func (mr *MockStakingKeeperMockRecorder) BondDenom(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BondDenom", reflect.TypeOf((*MockStakingKeeper)(nil).BondDenom), ctx)
|
|
}
|
|
|
|
// IterateBondedValidatorsByPower mocks base method.
|
|
func (m *MockStakingKeeper) IterateBondedValidatorsByPower(arg0 types.Context, arg1 func(int64, types2.ValidatorI) bool) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "IterateBondedValidatorsByPower", arg0, arg1)
|
|
}
|
|
|
|
// IterateBondedValidatorsByPower indicates an expected call of IterateBondedValidatorsByPower.
|
|
func (mr *MockStakingKeeperMockRecorder) IterateBondedValidatorsByPower(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateBondedValidatorsByPower", reflect.TypeOf((*MockStakingKeeper)(nil).IterateBondedValidatorsByPower), arg0, arg1)
|
|
}
|
|
|
|
// IterateDelegations mocks base method.
|
|
func (m *MockStakingKeeper) IterateDelegations(ctx types.Context, delegator types.AccAddress, fn func(int64, types2.DelegationI) bool) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "IterateDelegations", ctx, delegator, fn)
|
|
}
|
|
|
|
// IterateDelegations indicates an expected call of IterateDelegations.
|
|
func (mr *MockStakingKeeperMockRecorder) IterateDelegations(ctx, delegator, fn interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateDelegations", reflect.TypeOf((*MockStakingKeeper)(nil).IterateDelegations), ctx, delegator, fn)
|
|
}
|
|
|
|
// TokensFromConsensusPower mocks base method.
|
|
func (m *MockStakingKeeper) TokensFromConsensusPower(ctx types.Context, power int64) math.Int {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TokensFromConsensusPower", ctx, power)
|
|
ret0, _ := ret[0].(math.Int)
|
|
return ret0
|
|
}
|
|
|
|
// TokensFromConsensusPower indicates an expected call of TokensFromConsensusPower.
|
|
func (mr *MockStakingKeeperMockRecorder) TokensFromConsensusPower(ctx, power interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TokensFromConsensusPower", reflect.TypeOf((*MockStakingKeeper)(nil).TokensFromConsensusPower), ctx, power)
|
|
}
|
|
|
|
// TotalBondedTokens mocks base method.
|
|
func (m *MockStakingKeeper) TotalBondedTokens(arg0 types.Context) math.Int {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TotalBondedTokens", arg0)
|
|
ret0, _ := ret[0].(math.Int)
|
|
return ret0
|
|
}
|
|
|
|
// TotalBondedTokens indicates an expected call of TotalBondedTokens.
|
|
func (mr *MockStakingKeeperMockRecorder) TotalBondedTokens(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TotalBondedTokens", reflect.TypeOf((*MockStakingKeeper)(nil).TotalBondedTokens), arg0)
|
|
}
|