code.vegaprotocol.io/vega@v0.79.0/datanode/service/mocks/mocks.go

// Code generated by MockGen. DO NOT EDIT.
// Source: code.vegaprotocol.io/vega/datanode/service (interfaces: OrderStore,ChainStore,MarketStore,MarketDataStore,PositionStore,AccountStore,BalanceStore,RewardStore,AMMStore,AssetStore)

// Package mocks is a generated GoMock package.
package mocks

import (
	context "context"
	reflect "reflect"
	time "time"

	entities "code.vegaprotocol.io/vega/datanode/entities"
	gomock "github.com/golang/mock/gomock"
)

// MockOrderStore is a mock of OrderStore interface.
type MockOrderStore struct {
	ctrl     *gomock.Controller
	recorder *MockOrderStoreMockRecorder
}

// MockOrderStoreMockRecorder is the mock recorder for MockOrderStore.
type MockOrderStoreMockRecorder struct {
	mock *MockOrderStore
}

// NewMockOrderStore creates a new mock instance.
func NewMockOrderStore(ctrl *gomock.Controller) *MockOrderStore {
	mock := &MockOrderStore{ctrl: ctrl}
	mock.recorder = &MockOrderStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockOrderStore) EXPECT() *MockOrderStoreMockRecorder {
	return m.recorder
}

// GetLiveOrders mocks base method.
func (m *MockOrderStore) GetLiveOrders(arg0 context.Context) ([]entities.Order, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLiveOrders", arg0)
	ret0, _ := ret[0].([]entities.Order)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLiveOrders indicates an expected call of GetLiveOrders.
func (mr *MockOrderStoreMockRecorder) GetLiveOrders(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLiveOrders", reflect.TypeOf((*MockOrderStore)(nil).GetLiveOrders), arg0)
}

// MockChainStore is a mock of ChainStore interface.
type MockChainStore struct {
	ctrl     *gomock.Controller
	recorder *MockChainStoreMockRecorder
}

// MockChainStoreMockRecorder is the mock recorder for MockChainStore.
type MockChainStoreMockRecorder struct {
	mock *MockChainStore
}

// NewMockChainStore creates a new mock instance.
func NewMockChainStore(ctrl *gomock.Controller) *MockChainStore {
	mock := &MockChainStore{ctrl: ctrl}
	mock.recorder = &MockChainStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockChainStore) EXPECT() *MockChainStoreMockRecorder {
	return m.recorder
}

// Get mocks base method.
func (m *MockChainStore) Get(arg0 context.Context) (entities.Chain, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", arg0)
	ret0, _ := ret[0].(entities.Chain)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockChainStoreMockRecorder) Get(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockChainStore)(nil).Get), arg0)
}

// Set mocks base method.
func (m *MockChainStore) Set(arg0 context.Context, arg1 entities.Chain) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Set", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Set indicates an expected call of Set.
func (mr *MockChainStoreMockRecorder) Set(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockChainStore)(nil).Set), arg0, arg1)
}

// MockMarketStore is a mock of MarketStore interface.
type MockMarketStore struct {
	ctrl     *gomock.Controller
	recorder *MockMarketStoreMockRecorder
}

// MockMarketStoreMockRecorder is the mock recorder for MockMarketStore.
type MockMarketStoreMockRecorder struct {
	mock *MockMarketStore
}

// NewMockMarketStore creates a new mock instance.
func NewMockMarketStore(ctrl *gomock.Controller) *MockMarketStore {
	mock := &MockMarketStore{ctrl: ctrl}
	mock.recorder = &MockMarketStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockMarketStore) EXPECT() *MockMarketStoreMockRecorder {
	return m.recorder
}

// GetAllFees mocks base method.
func (m *MockMarketStore) GetAllFees(arg0 context.Context) ([]entities.Market, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllFees", arg0)
	ret0, _ := ret[0].([]entities.Market)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllFees indicates an expected call of GetAllFees.
func (mr *MockMarketStoreMockRecorder) GetAllFees(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllFees", reflect.TypeOf((*MockMarketStore)(nil).GetAllFees), arg0)
}

// GetAllPaged mocks base method.
func (m *MockMarketStore) GetAllPaged(arg0 context.Context, arg1 string, arg2 entities.CursorPagination, arg3 bool) ([]entities.Market, entities.PageInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllPaged", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]entities.Market)
	ret1, _ := ret[1].(entities.PageInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetAllPaged indicates an expected call of GetAllPaged.
func (mr *MockMarketStoreMockRecorder) GetAllPaged(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllPaged", reflect.TypeOf((*MockMarketStore)(nil).GetAllPaged), arg0, arg1, arg2, arg3)
}

// GetByID mocks base method.
func (m *MockMarketStore) GetByID(arg0 context.Context, arg1 string) (entities.Market, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", arg0, arg1)
	ret0, _ := ret[0].(entities.Market)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByID indicates an expected call of GetByID.
func (mr *MockMarketStoreMockRecorder) GetByID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockMarketStore)(nil).GetByID), arg0, arg1)
}

// GetByIDs mocks base method.
func (m *MockMarketStore) GetByIDs(arg0 context.Context, arg1 []string) ([]entities.Market, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByIDs", arg0, arg1)
	ret0, _ := ret[0].([]entities.Market)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByIDs indicates an expected call of GetByIDs.
func (mr *MockMarketStoreMockRecorder) GetByIDs(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByIDs", reflect.TypeOf((*MockMarketStore)(nil).GetByIDs), arg0, arg1)
}

// GetByTxHash mocks base method.
func (m *MockMarketStore) GetByTxHash(arg0 context.Context, arg1 entities.TxHash) ([]entities.Market, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByTxHash", arg0, arg1)
	ret0, _ := ret[0].([]entities.Market)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByTxHash indicates an expected call of GetByTxHash.
func (mr *MockMarketStoreMockRecorder) GetByTxHash(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByTxHash", reflect.TypeOf((*MockMarketStore)(nil).GetByTxHash), arg0, arg1)
}

// ListSuccessorMarkets mocks base method.
func (m *MockMarketStore) ListSuccessorMarkets(arg0 context.Context, arg1 string, arg2 bool, arg3 entities.CursorPagination) ([]entities.SuccessorMarket, entities.PageInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSuccessorMarkets", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]entities.SuccessorMarket)
	ret1, _ := ret[1].(entities.PageInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListSuccessorMarkets indicates an expected call of ListSuccessorMarkets.
func (mr *MockMarketStoreMockRecorder) ListSuccessorMarkets(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSuccessorMarkets", reflect.TypeOf((*MockMarketStore)(nil).ListSuccessorMarkets), arg0, arg1, arg2, arg3)
}

// Upsert mocks base method.
func (m *MockMarketStore) Upsert(arg0 context.Context, arg1 *entities.Market) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Upsert", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Upsert indicates an expected call of Upsert.
func (mr *MockMarketStoreMockRecorder) Upsert(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upsert", reflect.TypeOf((*MockMarketStore)(nil).Upsert), arg0, arg1)
}

// MockMarketDataStore is a mock of MarketDataStore interface.
type MockMarketDataStore struct {
	ctrl     *gomock.Controller
	recorder *MockMarketDataStoreMockRecorder
}

// MockMarketDataStoreMockRecorder is the mock recorder for MockMarketDataStore.
type MockMarketDataStoreMockRecorder struct {
	mock *MockMarketDataStore
}

// NewMockMarketDataStore creates a new mock instance.
func NewMockMarketDataStore(ctrl *gomock.Controller) *MockMarketDataStore {
	mock := &MockMarketDataStore{ctrl: ctrl}
	mock.recorder = &MockMarketDataStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockMarketDataStore) EXPECT() *MockMarketDataStoreMockRecorder {
	return m.recorder
}

// Add mocks base method.
func (m *MockMarketDataStore) Add(arg0 *entities.MarketData) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Add", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Add indicates an expected call of Add.
func (mr *MockMarketDataStoreMockRecorder) Add(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockMarketDataStore)(nil).Add), arg0)
}

// Flush mocks base method.
func (m *MockMarketDataStore) Flush(arg0 context.Context) ([]*entities.MarketData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Flush", arg0)
	ret0, _ := ret[0].([]*entities.MarketData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Flush indicates an expected call of Flush.
func (mr *MockMarketDataStoreMockRecorder) Flush(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Flush", reflect.TypeOf((*MockMarketDataStore)(nil).Flush), arg0)
}

// GetHistoricMarketData mocks base method.
func (m *MockMarketDataStore) GetHistoricMarketData(arg0 context.Context, arg1 string, arg2, arg3 *time.Time, arg4 entities.Pagination) ([]entities.MarketData, entities.PageInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHistoricMarketData", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].([]entities.MarketData)
	ret1, _ := ret[1].(entities.PageInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetHistoricMarketData indicates an expected call of GetHistoricMarketData.
func (mr *MockMarketDataStoreMockRecorder) GetHistoricMarketData(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoricMarketData", reflect.TypeOf((*MockMarketDataStore)(nil).GetHistoricMarketData), arg0, arg1, arg2, arg3, arg4)
}

// GetMarketDataByID mocks base method.
func (m *MockMarketDataStore) GetMarketDataByID(arg0 context.Context, arg1 string) (entities.MarketData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMarketDataByID", arg0, arg1)
	ret0, _ := ret[0].(entities.MarketData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMarketDataByID indicates an expected call of GetMarketDataByID.
func (mr *MockMarketDataStoreMockRecorder) GetMarketDataByID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMarketDataByID", reflect.TypeOf((*MockMarketDataStore)(nil).GetMarketDataByID), arg0, arg1)
}

// GetMarketsData mocks base method.
func (m *MockMarketDataStore) GetMarketsData(arg0 context.Context) ([]entities.MarketData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMarketsData", arg0)
	ret0, _ := ret[0].([]entities.MarketData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMarketsData indicates an expected call of GetMarketsData.
func (mr *MockMarketDataStoreMockRecorder) GetMarketsData(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMarketsData", reflect.TypeOf((*MockMarketDataStore)(nil).GetMarketsData), arg0)
}

// MockPositionStore is a mock of PositionStore interface.
type MockPositionStore struct {
	ctrl     *gomock.Controller
	recorder *MockPositionStoreMockRecorder
}

// MockPositionStoreMockRecorder is the mock recorder for MockPositionStore.
type MockPositionStoreMockRecorder struct {
	mock *MockPositionStore
}

// NewMockPositionStore creates a new mock instance.
func NewMockPositionStore(ctrl *gomock.Controller) *MockPositionStore {
	mock := &MockPositionStore{ctrl: ctrl}
	mock.recorder = &MockPositionStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockPositionStore) EXPECT() *MockPositionStoreMockRecorder {
	return m.recorder
}

// Add mocks base method.
func (m *MockPositionStore) Add(arg0 context.Context, arg1 entities.Position) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Add", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Add indicates an expected call of Add.
func (mr *MockPositionStoreMockRecorder) Add(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockPositionStore)(nil).Add), arg0, arg1)
}

// Flush mocks base method.
func (m *MockPositionStore) Flush(arg0 context.Context) ([]entities.Position, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Flush", arg0)
	ret0, _ := ret[0].([]entities.Position)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Flush indicates an expected call of Flush.
func (mr *MockPositionStoreMockRecorder) Flush(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Flush", reflect.TypeOf((*MockPositionStore)(nil).Flush), arg0)
}

// GetAll mocks base method.
func (m *MockPositionStore) GetAll(arg0 context.Context) ([]entities.Position, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAll", arg0)
	ret0, _ := ret[0].([]entities.Position)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAll indicates an expected call of GetAll.
func (mr *MockPositionStoreMockRecorder) GetAll(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAll", reflect.TypeOf((*MockPositionStore)(nil).GetAll), arg0)
}

// GetByMarket mocks base method.
func (m *MockPositionStore) GetByMarket(arg0 context.Context, arg1 string) ([]entities.Position, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByMarket", arg0, arg1)
	ret0, _ := ret[0].([]entities.Position)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByMarket indicates an expected call of GetByMarket.
func (mr *MockPositionStoreMockRecorder) GetByMarket(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByMarket", reflect.TypeOf((*MockPositionStore)(nil).GetByMarket), arg0, arg1)
}

// GetByMarketAndParties mocks base method.
func (m *MockPositionStore) GetByMarketAndParties(arg0 context.Context, arg1 string, arg2 []string) ([]entities.Position, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByMarketAndParties", arg0, arg1, arg2)
	ret0, _ := ret[0].([]entities.Position)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByMarketAndParties indicates an expected call of GetByMarketAndParties.
func (mr *MockPositionStoreMockRecorder) GetByMarketAndParties(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByMarketAndParties", reflect.TypeOf((*MockPositionStore)(nil).GetByMarketAndParties), arg0, arg1, arg2)
}

// GetByMarketAndParty mocks base method.
func (m *MockPositionStore) GetByMarketAndParty(arg0 context.Context, arg1, arg2 string) (entities.Position, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByMarketAndParty", arg0, arg1, arg2)
	ret0, _ := ret[0].(entities.Position)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByMarketAndParty indicates an expected call of GetByMarketAndParty.
func (mr *MockPositionStoreMockRecorder) GetByMarketAndParty(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByMarketAndParty", reflect.TypeOf((*MockPositionStore)(nil).GetByMarketAndParty), arg0, arg1, arg2)
}

// GetByParty mocks base method.
func (m *MockPositionStore) GetByParty(arg0 context.Context, arg1 string) ([]entities.Position, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByParty", arg0, arg1)
	ret0, _ := ret[0].([]entities.Position)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByParty indicates an expected call of GetByParty.
func (mr *MockPositionStoreMockRecorder) GetByParty(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByParty", reflect.TypeOf((*MockPositionStore)(nil).GetByParty), arg0, arg1)
}

// GetByPartyConnection mocks base method.
func (m *MockPositionStore) GetByPartyConnection(arg0 context.Context, arg1, arg2 []string, arg3 entities.CursorPagination) ([]entities.Position, entities.PageInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByPartyConnection", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]entities.Position)
	ret1, _ := ret[1].(entities.PageInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByPartyConnection indicates an expected call of GetByPartyConnection.
func (mr *MockPositionStoreMockRecorder) GetByPartyConnection(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByPartyConnection", reflect.TypeOf((*MockPositionStore)(nil).GetByPartyConnection), arg0, arg1, arg2, arg3)
}

// GetByTxHash mocks base method.
func (m *MockPositionStore) GetByTxHash(arg0 context.Context, arg1 entities.TxHash) ([]entities.Position, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByTxHash", arg0, arg1)
	ret0, _ := ret[0].([]entities.Position)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByTxHash indicates an expected call of GetByTxHash.
func (mr *MockPositionStoreMockRecorder) GetByTxHash(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByTxHash", reflect.TypeOf((*MockPositionStore)(nil).GetByTxHash), arg0, arg1)
}

// MockAccountStore is a mock of AccountStore interface.
type MockAccountStore struct {
	ctrl     *gomock.Controller
	recorder *MockAccountStoreMockRecorder
}

// MockAccountStoreMockRecorder is the mock recorder for MockAccountStore.
type MockAccountStoreMockRecorder struct {
	mock *MockAccountStore
}

// NewMockAccountStore creates a new mock instance.
func NewMockAccountStore(ctrl *gomock.Controller) *MockAccountStore {
	mock := &MockAccountStore{ctrl: ctrl}
	mock.recorder = &MockAccountStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAccountStore) EXPECT() *MockAccountStoreMockRecorder {
	return m.recorder
}

// GetAll mocks base method.
func (m *MockAccountStore) GetAll(arg0 context.Context) ([]entities.Account, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAll", arg0)
	ret0, _ := ret[0].([]entities.Account)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAll indicates an expected call of GetAll.
func (mr *MockAccountStoreMockRecorder) GetAll(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAll", reflect.TypeOf((*MockAccountStore)(nil).GetAll), arg0)
}

// GetBalancesByTxHash mocks base method.
func (m *MockAccountStore) GetBalancesByTxHash(arg0 context.Context, arg1 entities.TxHash) ([]entities.AccountBalance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBalancesByTxHash", arg0, arg1)
	ret0, _ := ret[0].([]entities.AccountBalance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBalancesByTxHash indicates an expected call of GetBalancesByTxHash.
func (mr *MockAccountStoreMockRecorder) GetBalancesByTxHash(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBalancesByTxHash", reflect.TypeOf((*MockAccountStore)(nil).GetBalancesByTxHash), arg0, arg1)
}

// GetByRawID mocks base method.
func (m *MockAccountStore) GetByRawID(arg0 context.Context, arg1 string) (entities.Account, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByRawID", arg0, arg1)
	ret0, _ := ret[0].(entities.Account)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByRawID indicates an expected call of GetByRawID.
func (mr *MockAccountStoreMockRecorder) GetByRawID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByRawID", reflect.TypeOf((*MockAccountStore)(nil).GetByRawID), arg0, arg1)
}

// GetByTxHash mocks base method.
func (m *MockAccountStore) GetByTxHash(arg0 context.Context, arg1 entities.TxHash) ([]entities.Account, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByTxHash", arg0, arg1)
	ret0, _ := ret[0].([]entities.Account)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByTxHash indicates an expected call of GetByTxHash.
func (mr *MockAccountStoreMockRecorder) GetByTxHash(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByTxHash", reflect.TypeOf((*MockAccountStore)(nil).GetByTxHash), arg0, arg1)
}

// Obtain mocks base method.
func (m *MockAccountStore) Obtain(arg0 context.Context, arg1 *entities.Account) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Obtain", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Obtain indicates an expected call of Obtain.
func (mr *MockAccountStoreMockRecorder) Obtain(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Obtain", reflect.TypeOf((*MockAccountStore)(nil).Obtain), arg0, arg1)
}

// Query mocks base method.
func (m *MockAccountStore) Query(arg0 context.Context, arg1 entities.AccountFilter) ([]entities.Account, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Query", arg0, arg1)
	ret0, _ := ret[0].([]entities.Account)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Query indicates an expected call of Query.
func (mr *MockAccountStoreMockRecorder) Query(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockAccountStore)(nil).Query), arg0, arg1)
}

// QueryBalances mocks base method.
func (m *MockAccountStore) QueryBalances(arg0 context.Context, arg1 entities.AccountFilter, arg2 entities.CursorPagination) ([]entities.AccountBalance, entities.PageInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryBalances", arg0, arg1, arg2)
	ret0, _ := ret[0].([]entities.AccountBalance)
	ret1, _ := ret[1].(entities.PageInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// QueryBalances indicates an expected call of QueryBalances.
func (mr *MockAccountStoreMockRecorder) QueryBalances(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBalances", reflect.TypeOf((*MockAccountStore)(nil).QueryBalances), arg0, arg1, arg2)
}

// MockBalanceStore is a mock of BalanceStore interface.
type MockBalanceStore struct {
	ctrl     *gomock.Controller
	recorder *MockBalanceStoreMockRecorder
}

// MockBalanceStoreMockRecorder is the mock recorder for MockBalanceStore.
type MockBalanceStoreMockRecorder struct {
	mock *MockBalanceStore
}

// NewMockBalanceStore creates a new mock instance.
func NewMockBalanceStore(ctrl *gomock.Controller) *MockBalanceStore {
	mock := &MockBalanceStore{ctrl: ctrl}
	mock.recorder = &MockBalanceStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBalanceStore) EXPECT() *MockBalanceStoreMockRecorder {
	return m.recorder
}

// Add mocks base method.
func (m *MockBalanceStore) Add(arg0 entities.AccountBalance) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Add", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Add indicates an expected call of Add.
func (mr *MockBalanceStoreMockRecorder) Add(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockBalanceStore)(nil).Add), arg0)
}

// Flush mocks base method.
func (m *MockBalanceStore) Flush(arg0 context.Context) ([]entities.AccountBalance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Flush", arg0)
	ret0, _ := ret[0].([]entities.AccountBalance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Flush indicates an expected call of Flush.
func (mr *MockBalanceStoreMockRecorder) Flush(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Flush", reflect.TypeOf((*MockBalanceStore)(nil).Flush), arg0)
}

// Query mocks base method.
func (m *MockBalanceStore) Query(arg0 context.Context, arg1 entities.AccountFilter, arg2 entities.DateRange, arg3 entities.CursorPagination) (*[]entities.AggregatedBalance, entities.PageInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Query", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*[]entities.AggregatedBalance)
	ret1, _ := ret[1].(entities.PageInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Query indicates an expected call of Query.
func (mr *MockBalanceStoreMockRecorder) Query(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockBalanceStore)(nil).Query), arg0, arg1, arg2, arg3)
}

// MockRewardStore is a mock of RewardStore interface.
type MockRewardStore struct {
	ctrl     *gomock.Controller
	recorder *MockRewardStoreMockRecorder
}

// MockRewardStoreMockRecorder is the mock recorder for MockRewardStore.
type MockRewardStoreMockRecorder struct {
	mock *MockRewardStore
}

// NewMockRewardStore creates a new mock instance.
func NewMockRewardStore(ctrl *gomock.Controller) *MockRewardStore {
	mock := &MockRewardStore{ctrl: ctrl}
	mock.recorder = &MockRewardStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRewardStore) EXPECT() *MockRewardStoreMockRecorder {
	return m.recorder
}

// Add mocks base method.
func (m *MockRewardStore) Add(arg0 context.Context, arg1 entities.Reward) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Add", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Add indicates an expected call of Add.
func (mr *MockRewardStoreMockRecorder) Add(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockRewardStore)(nil).Add), arg0, arg1)
}

// GetAll mocks base method.
func (m *MockRewardStore) GetAll(arg0 context.Context) ([]entities.Reward, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAll", arg0)
	ret0, _ := ret[0].([]entities.Reward)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAll indicates an expected call of GetAll.
func (mr *MockRewardStoreMockRecorder) GetAll(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAll", reflect.TypeOf((*MockRewardStore)(nil).GetAll), arg0)
}

// GetByCursor mocks base method.
func (m *MockRewardStore) GetByCursor(arg0 context.Context, arg1 []string, arg2 *string, arg3, arg4 *uint64, arg5 entities.CursorPagination, arg6, arg7, arg8 *string) ([]entities.Reward, entities.PageInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByCursor", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
	ret0, _ := ret[0].([]entities.Reward)
	ret1, _ := ret[1].(entities.PageInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByCursor indicates an expected call of GetByCursor.
func (mr *MockRewardStoreMockRecorder) GetByCursor(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByCursor", reflect.TypeOf((*MockRewardStore)(nil).GetByCursor), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
}

// GetByTxHash mocks base method.
func (m *MockRewardStore) GetByTxHash(arg0 context.Context, arg1 entities.TxHash) ([]entities.Reward, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByTxHash", arg0, arg1)
	ret0, _ := ret[0].([]entities.Reward)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByTxHash indicates an expected call of GetByTxHash.
func (mr *MockRewardStoreMockRecorder) GetByTxHash(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByTxHash", reflect.TypeOf((*MockRewardStore)(nil).GetByTxHash), arg0, arg1)
}

// GetEpochSummaries mocks base method.
func (m *MockRewardStore) GetEpochSummaries(arg0 context.Context, arg1 entities.RewardSummaryFilter, arg2 entities.CursorPagination) ([]entities.EpochRewardSummary, entities.PageInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEpochSummaries", arg0, arg1, arg2)
	ret0, _ := ret[0].([]entities.EpochRewardSummary)
	ret1, _ := ret[1].(entities.PageInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetEpochSummaries indicates an expected call of GetEpochSummaries.
func (mr *MockRewardStoreMockRecorder) GetEpochSummaries(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEpochSummaries", reflect.TypeOf((*MockRewardStore)(nil).GetEpochSummaries), arg0, arg1, arg2)
}

// GetSummaries mocks base method.
func (m *MockRewardStore) GetSummaries(arg0 context.Context, arg1 []string, arg2 *string) ([]entities.RewardSummary, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSummaries", arg0, arg1, arg2)
	ret0, _ := ret[0].([]entities.RewardSummary)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSummaries indicates an expected call of GetSummaries.
func (mr *MockRewardStoreMockRecorder) GetSummaries(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSummaries", reflect.TypeOf((*MockRewardStore)(nil).GetSummaries), arg0, arg1, arg2)
}

// MockAMMStore is a mock of AMMStore interface.
type MockAMMStore struct {
	ctrl     *gomock.Controller
	recorder *MockAMMStoreMockRecorder
}

// MockAMMStoreMockRecorder is the mock recorder for MockAMMStore.
type MockAMMStoreMockRecorder struct {
	mock *MockAMMStore
}

// NewMockAMMStore creates a new mock instance.
func NewMockAMMStore(ctrl *gomock.Controller) *MockAMMStore {
	mock := &MockAMMStore{ctrl: ctrl}
	mock.recorder = &MockAMMStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAMMStore) EXPECT() *MockAMMStoreMockRecorder {
	return m.recorder
}

// ListActive mocks base method.
func (m *MockAMMStore) ListActive(arg0 context.Context) ([]entities.AMMPool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListActive", arg0)
	ret0, _ := ret[0].([]entities.AMMPool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListActive indicates an expected call of ListActive.
func (mr *MockAMMStoreMockRecorder) ListActive(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListActive", reflect.TypeOf((*MockAMMStore)(nil).ListActive), arg0)
}

// MockAssetStore is a mock of AssetStore interface.
type MockAssetStore struct {
	ctrl     *gomock.Controller
	recorder *MockAssetStoreMockRecorder
}

// MockAssetStoreMockRecorder is the mock recorder for MockAssetStore.
type MockAssetStoreMockRecorder struct {
	mock *MockAssetStore
}

// NewMockAssetStore creates a new mock instance.
func NewMockAssetStore(ctrl *gomock.Controller) *MockAssetStore {
	mock := &MockAssetStore{ctrl: ctrl}
	mock.recorder = &MockAssetStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAssetStore) EXPECT() *MockAssetStoreMockRecorder {
	return m.recorder
}

// GetByID mocks base method.
func (m *MockAssetStore) GetByID(arg0 context.Context, arg1 string) (entities.Asset, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", arg0, arg1)
	ret0, _ := ret[0].(entities.Asset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByID indicates an expected call of GetByID.
func (mr *MockAssetStoreMockRecorder) GetByID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockAssetStore)(nil).GetByID), arg0, arg1)
}