mocks.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ./interface.go

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

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

	gomock "github.com/golang/mock/gomock"
	types "github.com/spacemeshos/go-spacemesh/common/types"
	fetch "github.com/spacemeshos/go-spacemesh/fetch"
	p2p "github.com/spacemeshos/go-spacemesh/p2p"
)

// MocklayerTicker is a mock of layerTicker interface.
type MocklayerTicker struct {
	ctrl     *gomock.Controller
	recorder *MocklayerTickerMockRecorder
}

// MocklayerTickerMockRecorder is the mock recorder for MocklayerTicker.
type MocklayerTickerMockRecorder struct {
	mock *MocklayerTicker
}

// NewMocklayerTicker creates a new mock instance.
func NewMocklayerTicker(ctrl *gomock.Controller) *MocklayerTicker {
	mock := &MocklayerTicker{ctrl: ctrl}
	mock.recorder = &MocklayerTickerMockRecorder{mock}
	return mock
}

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

// CurrentLayer mocks base method.
func (m *MocklayerTicker) CurrentLayer() types.LayerID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CurrentLayer")
	ret0, _ := ret[0].(types.LayerID)
	return ret0
}

// CurrentLayer indicates an expected call of CurrentLayer.
func (mr *MocklayerTickerMockRecorder) CurrentLayer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentLayer", reflect.TypeOf((*MocklayerTicker)(nil).CurrentLayer))
}

// MockmeshProvider is a mock of meshProvider interface.
type MockmeshProvider struct {
	ctrl     *gomock.Controller
	recorder *MockmeshProviderMockRecorder
}

// MockmeshProviderMockRecorder is the mock recorder for MockmeshProvider.
type MockmeshProviderMockRecorder struct {
	mock *MockmeshProvider
}

// NewMockmeshProvider creates a new mock instance.
func NewMockmeshProvider(ctrl *gomock.Controller) *MockmeshProvider {
	mock := &MockmeshProvider{ctrl: ctrl}
	mock.recorder = &MockmeshProviderMockRecorder{mock}
	return mock
}

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

// SetZeroBlockLayer mocks base method.
func (m *MockmeshProvider) SetZeroBlockLayer(arg0 context.Context, arg1 types.LayerID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetZeroBlockLayer", arg0, arg1)
}

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

// MockactiveSetCache is a mock of activeSetCache interface.
type MockactiveSetCache struct {
	ctrl     *gomock.Controller
	recorder *MockactiveSetCacheMockRecorder
}

// MockactiveSetCacheMockRecorder is the mock recorder for MockactiveSetCache.
type MockactiveSetCacheMockRecorder struct {
	mock *MockactiveSetCache
}

// NewMockactiveSetCache creates a new mock instance.
func NewMockactiveSetCache(ctrl *gomock.Controller) *MockactiveSetCache {
	mock := &MockactiveSetCache{ctrl: ctrl}
	mock.recorder = &MockactiveSetCacheMockRecorder{mock}
	return mock
}

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

// GetMissingActiveSet mocks base method.
func (m *MockactiveSetCache) GetMissingActiveSet(arg0 types.EpochID, arg1 []types.ATXID) []types.ATXID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMissingActiveSet", arg0, arg1)
	ret0, _ := ret[0].([]types.ATXID)
	return ret0
}

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

// MockfetchLogic is a mock of fetchLogic interface.
type MockfetchLogic struct {
	ctrl     *gomock.Controller
	recorder *MockfetchLogicMockRecorder
}

// MockfetchLogicMockRecorder is the mock recorder for MockfetchLogic.
type MockfetchLogicMockRecorder struct {
	mock *MockfetchLogic
}

// NewMockfetchLogic creates a new mock instance.
func NewMockfetchLogic(ctrl *gomock.Controller) *MockfetchLogic {
	mock := &MockfetchLogic{ctrl: ctrl}
	mock.recorder = &MockfetchLogicMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// GetLayerData mocks base method.
func (m *MockfetchLogic) GetLayerData(arg0 context.Context, arg1 []p2p.Peer, arg2 types.LayerID, arg3 func([]byte, p2p.Peer), arg4 func(error, p2p.Peer)) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLayerData", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetLayerOpinions mocks base method.
func (m *MockfetchLogic) GetLayerOpinions(arg0 context.Context, arg1 []p2p.Peer, arg2 types.LayerID, arg3 func([]byte, p2p.Peer), arg4 func(error, p2p.Peer)) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLayerOpinions", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// GetMaliciousIDs mocks base method.
func (m *MockfetchLogic) GetMaliciousIDs(arg0 context.Context, arg1 []p2p.Peer, arg2 func([]byte, p2p.Peer), arg3 func(error, p2p.Peer)) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMaliciousIDs", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetPeers mocks base method.
func (m *MockfetchLogic) GetPeers() []p2p.Peer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPeers")
	ret0, _ := ret[0].([]p2p.Peer)
	return ret0
}

// GetPeers indicates an expected call of GetPeers.
func (mr *MockfetchLogicMockRecorder) GetPeers() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPeers", reflect.TypeOf((*MockfetchLogic)(nil).GetPeers))
}

// PeerEpochInfo mocks base method.
func (m *MockfetchLogic) PeerEpochInfo(arg0 context.Context, arg1 p2p.Peer, arg2 types.EpochID) (*fetch.EpochData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PeerEpochInfo", arg0, arg1, arg2)
	ret0, _ := ret[0].(*fetch.EpochData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PeerMeshHashes mocks base method.
func (m *MockfetchLogic) PeerMeshHashes(arg0 context.Context, arg1 p2p.Peer, arg2 *fetch.MeshHashRequest) (*fetch.MeshHashes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PeerMeshHashes", arg0, arg1, arg2)
	ret0, _ := ret[0].(*fetch.MeshHashes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PollLayerData mocks base method.
func (m *MockfetchLogic) PollLayerData(arg0 context.Context, arg1 types.LayerID, arg2 ...p2p.Peer) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PollLayerData", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// PollLayerData indicates an expected call of PollLayerData.
func (mr *MockfetchLogicMockRecorder) PollLayerData(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PollLayerData", reflect.TypeOf((*MockfetchLogic)(nil).PollLayerData), varargs...)
}

// PollLayerOpinions mocks base method.
func (m *MockfetchLogic) PollLayerOpinions(arg0 context.Context, arg1 types.LayerID) ([]*fetch.LayerOpinion, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PollLayerOpinions", arg0, arg1)
	ret0, _ := ret[0].([]*fetch.LayerOpinion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PollMaliciousProofs mocks base method.
func (m *MockfetchLogic) PollMaliciousProofs(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PollMaliciousProofs", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

// PollMaliciousProofs indicates an expected call of PollMaliciousProofs.
func (mr *MockfetchLogicMockRecorder) PollMaliciousProofs(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PollMaliciousProofs", reflect.TypeOf((*MockfetchLogic)(nil).PollMaliciousProofs), ctx)
}

// RegisterPeerHashes mocks base method.
func (m *MockfetchLogic) RegisterPeerHashes(peer p2p.Peer, hashes []types.Hash32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterPeerHashes", peer, hashes)
}

// RegisterPeerHashes indicates an expected call of RegisterPeerHashes.
func (mr *MockfetchLogicMockRecorder) RegisterPeerHashes(peer, hashes interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterPeerHashes", reflect.TypeOf((*MockfetchLogic)(nil).RegisterPeerHashes), peer, hashes)
}

// Mockfetcher is a mock of fetcher interface.
type Mockfetcher struct {
	ctrl     *gomock.Controller
	recorder *MockfetcherMockRecorder
}

// MockfetcherMockRecorder is the mock recorder for Mockfetcher.
type MockfetcherMockRecorder struct {
	mock *Mockfetcher
}

// NewMockfetcher creates a new mock instance.
func NewMockfetcher(ctrl *gomock.Controller) *Mockfetcher {
	mock := &Mockfetcher{ctrl: ctrl}
	mock.recorder = &MockfetcherMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// GetLayerData mocks base method.
func (m *Mockfetcher) GetLayerData(arg0 context.Context, arg1 []p2p.Peer, arg2 types.LayerID, arg3 func([]byte, p2p.Peer), arg4 func(error, p2p.Peer)) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLayerData", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetLayerOpinions mocks base method.
func (m *Mockfetcher) GetLayerOpinions(arg0 context.Context, arg1 []p2p.Peer, arg2 types.LayerID, arg3 func([]byte, p2p.Peer), arg4 func(error, p2p.Peer)) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLayerOpinions", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// GetMaliciousIDs mocks base method.
func (m *Mockfetcher) GetMaliciousIDs(arg0 context.Context, arg1 []p2p.Peer, arg2 func([]byte, p2p.Peer), arg3 func(error, p2p.Peer)) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMaliciousIDs", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetPeers mocks base method.
func (m *Mockfetcher) GetPeers() []p2p.Peer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPeers")
	ret0, _ := ret[0].([]p2p.Peer)
	return ret0
}

// GetPeers indicates an expected call of GetPeers.
func (mr *MockfetcherMockRecorder) GetPeers() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPeers", reflect.TypeOf((*Mockfetcher)(nil).GetPeers))
}

// PeerEpochInfo mocks base method.
func (m *Mockfetcher) PeerEpochInfo(arg0 context.Context, arg1 p2p.Peer, arg2 types.EpochID) (*fetch.EpochData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PeerEpochInfo", arg0, arg1, arg2)
	ret0, _ := ret[0].(*fetch.EpochData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PeerMeshHashes mocks base method.
func (m *Mockfetcher) PeerMeshHashes(arg0 context.Context, arg1 p2p.Peer, arg2 *fetch.MeshHashRequest) (*fetch.MeshHashes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PeerMeshHashes", arg0, arg1, arg2)
	ret0, _ := ret[0].(*fetch.MeshHashes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterPeerHashes mocks base method.
func (m *Mockfetcher) RegisterPeerHashes(peer p2p.Peer, hashes []types.Hash32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterPeerHashes", peer, hashes)
}

// RegisterPeerHashes indicates an expected call of RegisterPeerHashes.
func (mr *MockfetcherMockRecorder) RegisterPeerHashes(peer, hashes interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterPeerHashes", reflect.TypeOf((*Mockfetcher)(nil).RegisterPeerHashes), peer, hashes)
}

// MocklayerPatrol is a mock of layerPatrol interface.
type MocklayerPatrol struct {
	ctrl     *gomock.Controller
	recorder *MocklayerPatrolMockRecorder
}

// MocklayerPatrolMockRecorder is the mock recorder for MocklayerPatrol.
type MocklayerPatrolMockRecorder struct {
	mock *MocklayerPatrol
}

// NewMocklayerPatrol creates a new mock instance.
func NewMocklayerPatrol(ctrl *gomock.Controller) *MocklayerPatrol {
	mock := &MocklayerPatrol{ctrl: ctrl}
	mock.recorder = &MocklayerPatrolMockRecorder{mock}
	return mock
}

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

// IsHareInCharge mocks base method.
func (m *MocklayerPatrol) IsHareInCharge(arg0 types.LayerID) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsHareInCharge", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

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

// MockcertHandler is a mock of certHandler interface.
type MockcertHandler struct {
	ctrl     *gomock.Controller
	recorder *MockcertHandlerMockRecorder
}

// MockcertHandlerMockRecorder is the mock recorder for MockcertHandler.
type MockcertHandlerMockRecorder struct {
	mock *MockcertHandler
}

// NewMockcertHandler creates a new mock instance.
func NewMockcertHandler(ctrl *gomock.Controller) *MockcertHandler {
	mock := &MockcertHandler{ctrl: ctrl}
	mock.recorder = &MockcertHandlerMockRecorder{mock}
	return mock
}

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

// HandleSyncedCertificate mocks base method.
func (m *MockcertHandler) HandleSyncedCertificate(arg0 context.Context, arg1 types.LayerID, arg2 *types.Certificate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleSyncedCertificate", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockforkFinder is a mock of forkFinder interface.
type MockforkFinder struct {
	ctrl     *gomock.Controller
	recorder *MockforkFinderMockRecorder
}

// MockforkFinderMockRecorder is the mock recorder for MockforkFinder.
type MockforkFinderMockRecorder struct {
	mock *MockforkFinder
}

// NewMockforkFinder creates a new mock instance.
func NewMockforkFinder(ctrl *gomock.Controller) *MockforkFinder {
	mock := &MockforkFinder{ctrl: ctrl}
	mock.recorder = &MockforkFinderMockRecorder{mock}
	return mock
}

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

// AddResynced mocks base method.
func (m *MockforkFinder) AddResynced(arg0 types.LayerID, arg1 types.Hash32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddResynced", arg0, arg1)
}

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

// FindFork mocks base method.
func (m *MockforkFinder) FindFork(arg0 context.Context, arg1 p2p.Peer, arg2 types.LayerID, arg3 types.Hash32) (types.LayerID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindFork", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(types.LayerID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NeedResync mocks base method.
func (m *MockforkFinder) NeedResync(arg0 types.LayerID, arg1 types.Hash32) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NeedResync", arg0, arg1)
	ret0, _ := ret[0].(bool)
	return ret0
}

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

// Purge mocks base method.
func (m *MockforkFinder) Purge(arg0 bool, arg1 ...p2p.Peer) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Purge", varargs...)
}

// Purge indicates an expected call of Purge.
func (mr *MockforkFinderMockRecorder) Purge(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Purge", reflect.TypeOf((*MockforkFinder)(nil).Purge), varargs...)
}

// UpdateAgreement mocks base method.
func (m *MockforkFinder) UpdateAgreement(arg0 p2p.Peer, arg1 types.LayerID, arg2 types.Hash32, arg3 time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateAgreement", arg0, arg1, arg2, arg3)
}

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

// MockidProvider is a mock of idProvider interface.
type MockidProvider struct {
	ctrl     *gomock.Controller
	recorder *MockidProviderMockRecorder
}

// MockidProviderMockRecorder is the mock recorder for MockidProvider.
type MockidProviderMockRecorder struct {
	mock *MockidProvider
}

// NewMockidProvider creates a new mock instance.
func NewMockidProvider(ctrl *gomock.Controller) *MockidProvider {
	mock := &MockidProvider{ctrl: ctrl}
	mock.recorder = &MockidProviderMockRecorder{mock}
	return mock
}

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

// IdentityExists mocks base method.
func (m *MockidProvider) IdentityExists(id types.NodeID) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IdentityExists", id)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IdentityExists indicates an expected call of IdentityExists.
func (mr *MockidProviderMockRecorder) IdentityExists(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IdentityExists", reflect.TypeOf((*MockidProvider)(nil).IdentityExists), id)
}