mocks.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ./interface.go
//
// Generated by this command:
//
//	mockgen -typed -package=mocks -destination=./mocks/mocks.go -source=./interface.go
//
// Package mocks is a generated GoMock package.
package mocks

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

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

// 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() *layerTickerCurrentLayerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentLayer", reflect.TypeOf((*MocklayerTicker)(nil).CurrentLayer))
	return &layerTickerCurrentLayerCall{Call: call}
}

// layerTickerCurrentLayerCall wrap *gomock.Call
type layerTickerCurrentLayerCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *layerTickerCurrentLayerCall) Return(arg0 types.LayerID) *layerTickerCurrentLayerCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *layerTickerCurrentLayerCall) Do(f func() types.LayerID) *layerTickerCurrentLayerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *layerTickerCurrentLayerCall) DoAndReturn(f func() types.LayerID) *layerTickerCurrentLayerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *meshProviderSetZeroBlockLayerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetZeroBlockLayer", reflect.TypeOf((*MockmeshProvider)(nil).SetZeroBlockLayer), arg0, arg1)
	return &meshProviderSetZeroBlockLayerCall{Call: call}
}

// meshProviderSetZeroBlockLayerCall wrap *gomock.Call
type meshProviderSetZeroBlockLayerCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *meshProviderSetZeroBlockLayerCall) Return() *meshProviderSetZeroBlockLayerCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *meshProviderSetZeroBlockLayerCall) Do(f func(context.Context, types.LayerID)) *meshProviderSetZeroBlockLayerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *meshProviderSetZeroBlockLayerCall) DoAndReturn(f func(context.Context, types.LayerID)) *meshProviderSetZeroBlockLayerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *activeSetCacheGetMissingActiveSetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMissingActiveSet", reflect.TypeOf((*MockactiveSetCache)(nil).GetMissingActiveSet), arg0, arg1)
	return &activeSetCacheGetMissingActiveSetCall{Call: call}
}

// activeSetCacheGetMissingActiveSetCall wrap *gomock.Call
type activeSetCacheGetMissingActiveSetCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *activeSetCacheGetMissingActiveSetCall) Return(arg0 []types.ATXID) *activeSetCacheGetMissingActiveSetCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *activeSetCacheGetMissingActiveSetCall) Do(f func(types.EpochID, []types.ATXID) []types.ATXID) *activeSetCacheGetMissingActiveSetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *activeSetCacheGetMissingActiveSetCall) DoAndReturn(f func(types.EpochID, []types.ATXID) []types.ATXID) *activeSetCacheGetMissingActiveSetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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, arg2 ...system.GetAtxOpt) error {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAtxs", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// fetchLogicGetAtxsCall wrap *gomock.Call
type fetchLogicGetAtxsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetchLogicGetAtxsCall) Return(arg0 error) *fetchLogicGetAtxsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetchLogicGetAtxsCall) Do(f func(context.Context, []types.ATXID, ...system.GetAtxOpt) error) *fetchLogicGetAtxsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetchLogicGetAtxsCall) DoAndReturn(f func(context.Context, []types.ATXID, ...system.GetAtxOpt) error) *fetchLogicGetAtxsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *fetchLogicGetBallotsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBallots", reflect.TypeOf((*MockfetchLogic)(nil).GetBallots), arg0, arg1)
	return &fetchLogicGetBallotsCall{Call: call}
}

// fetchLogicGetBallotsCall wrap *gomock.Call
type fetchLogicGetBallotsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetchLogicGetBallotsCall) Return(arg0 error) *fetchLogicGetBallotsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetchLogicGetBallotsCall) Do(f func(context.Context, []types.BallotID) error) *fetchLogicGetBallotsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetchLogicGetBallotsCall) DoAndReturn(f func(context.Context, []types.BallotID) error) *fetchLogicGetBallotsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *fetchLogicGetBlocksCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlocks", reflect.TypeOf((*MockfetchLogic)(nil).GetBlocks), arg0, arg1)
	return &fetchLogicGetBlocksCall{Call: call}
}

// fetchLogicGetBlocksCall wrap *gomock.Call
type fetchLogicGetBlocksCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetchLogicGetBlocksCall) Return(arg0 error) *fetchLogicGetBlocksCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetchLogicGetBlocksCall) Do(f func(context.Context, []types.BlockID) error) *fetchLogicGetBlocksCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetchLogicGetBlocksCall) DoAndReturn(f func(context.Context, []types.BlockID) error) *fetchLogicGetBlocksCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// GetCert indicates an expected call of GetCert.
func (mr *MockfetchLogicMockRecorder) GetCert(arg0, arg1, arg2, arg3 any) *fetchLogicGetCertCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCert", reflect.TypeOf((*MockfetchLogic)(nil).GetCert), arg0, arg1, arg2, arg3)
	return &fetchLogicGetCertCall{Call: call}
}

// fetchLogicGetCertCall wrap *gomock.Call
type fetchLogicGetCertCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetchLogicGetCertCall) Return(arg0 *types.Certificate, arg1 error) *fetchLogicGetCertCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetchLogicGetCertCall) Do(f func(context.Context, types.LayerID, types.BlockID, []p2p.Peer) (*types.Certificate, error)) *fetchLogicGetCertCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetchLogicGetCertCall) DoAndReturn(f func(context.Context, types.LayerID, types.BlockID, []p2p.Peer) (*types.Certificate, error)) *fetchLogicGetCertCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *fetchLogicGetEpochATXsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEpochATXs", reflect.TypeOf((*MockfetchLogic)(nil).GetEpochATXs), arg0, arg1)
	return &fetchLogicGetEpochATXsCall{Call: call}
}

// fetchLogicGetEpochATXsCall wrap *gomock.Call
type fetchLogicGetEpochATXsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetchLogicGetEpochATXsCall) Return(arg0 error) *fetchLogicGetEpochATXsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetchLogicGetEpochATXsCall) Do(f func(context.Context, types.EpochID) error) *fetchLogicGetEpochATXsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetchLogicGetEpochATXsCall) DoAndReturn(f func(context.Context, types.EpochID) error) *fetchLogicGetEpochATXsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// GetLayerData indicates an expected call of GetLayerData.
func (mr *MockfetchLogicMockRecorder) GetLayerData(arg0, arg1, arg2 any) *fetchLogicGetLayerDataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLayerData", reflect.TypeOf((*MockfetchLogic)(nil).GetLayerData), arg0, arg1, arg2)
	return &fetchLogicGetLayerDataCall{Call: call}
}

// fetchLogicGetLayerDataCall wrap *gomock.Call
type fetchLogicGetLayerDataCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetchLogicGetLayerDataCall) Return(arg0 []byte, arg1 error) *fetchLogicGetLayerDataCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetchLogicGetLayerDataCall) Do(f func(context.Context, p2p.Peer, types.LayerID) ([]byte, error)) *fetchLogicGetLayerDataCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetchLogicGetLayerDataCall) DoAndReturn(f func(context.Context, p2p.Peer, types.LayerID) ([]byte, error)) *fetchLogicGetLayerDataCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// GetLayerOpinions indicates an expected call of GetLayerOpinions.
func (mr *MockfetchLogicMockRecorder) GetLayerOpinions(arg0, arg1, arg2 any) *fetchLogicGetLayerOpinionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLayerOpinions", reflect.TypeOf((*MockfetchLogic)(nil).GetLayerOpinions), arg0, arg1, arg2)
	return &fetchLogicGetLayerOpinionsCall{Call: call}
}

// fetchLogicGetLayerOpinionsCall wrap *gomock.Call
type fetchLogicGetLayerOpinionsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetchLogicGetLayerOpinionsCall) Return(arg0 []byte, arg1 error) *fetchLogicGetLayerOpinionsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetchLogicGetLayerOpinionsCall) Do(f func(context.Context, p2p.Peer, types.LayerID) ([]byte, error)) *fetchLogicGetLayerOpinionsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetchLogicGetLayerOpinionsCall) DoAndReturn(f func(context.Context, p2p.Peer, types.LayerID) ([]byte, error)) *fetchLogicGetLayerOpinionsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *fetchLogicGetMalfeasanceProofsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMalfeasanceProofs", reflect.TypeOf((*MockfetchLogic)(nil).GetMalfeasanceProofs), arg0, arg1)
	return &fetchLogicGetMalfeasanceProofsCall{Call: call}
}

// fetchLogicGetMalfeasanceProofsCall wrap *gomock.Call
type fetchLogicGetMalfeasanceProofsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetchLogicGetMalfeasanceProofsCall) Return(arg0 error) *fetchLogicGetMalfeasanceProofsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetchLogicGetMalfeasanceProofsCall) Do(f func(context.Context, []types.NodeID) error) *fetchLogicGetMalfeasanceProofsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetchLogicGetMalfeasanceProofsCall) DoAndReturn(f func(context.Context, []types.NodeID) error) *fetchLogicGetMalfeasanceProofsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// GetMaliciousIDs indicates an expected call of GetMaliciousIDs.
func (mr *MockfetchLogicMockRecorder) GetMaliciousIDs(arg0, arg1 any) *fetchLogicGetMaliciousIDsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaliciousIDs", reflect.TypeOf((*MockfetchLogic)(nil).GetMaliciousIDs), arg0, arg1)
	return &fetchLogicGetMaliciousIDsCall{Call: call}
}

// fetchLogicGetMaliciousIDsCall wrap *gomock.Call
type fetchLogicGetMaliciousIDsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetchLogicGetMaliciousIDsCall) Return(arg0 []byte, arg1 error) *fetchLogicGetMaliciousIDsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetchLogicGetMaliciousIDsCall) Do(f func(context.Context, p2p.Peer) ([]byte, error)) *fetchLogicGetMaliciousIDsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetchLogicGetMaliciousIDsCall) DoAndReturn(f func(context.Context, p2p.Peer) ([]byte, error)) *fetchLogicGetMaliciousIDsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *fetchLogicPeerEpochInfoCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeerEpochInfo", reflect.TypeOf((*MockfetchLogic)(nil).PeerEpochInfo), arg0, arg1, arg2)
	return &fetchLogicPeerEpochInfoCall{Call: call}
}

// fetchLogicPeerEpochInfoCall wrap *gomock.Call
type fetchLogicPeerEpochInfoCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetchLogicPeerEpochInfoCall) Return(arg0 *fetch.EpochData, arg1 error) *fetchLogicPeerEpochInfoCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetchLogicPeerEpochInfoCall) Do(f func(context.Context, p2p.Peer, types.EpochID) (*fetch.EpochData, error)) *fetchLogicPeerEpochInfoCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetchLogicPeerEpochInfoCall) DoAndReturn(f func(context.Context, p2p.Peer, types.EpochID) (*fetch.EpochData, error)) *fetchLogicPeerEpochInfoCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *fetchLogicPeerMeshHashesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeerMeshHashes", reflect.TypeOf((*MockfetchLogic)(nil).PeerMeshHashes), arg0, arg1, arg2)
	return &fetchLogicPeerMeshHashesCall{Call: call}
}

// fetchLogicPeerMeshHashesCall wrap *gomock.Call
type fetchLogicPeerMeshHashesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetchLogicPeerMeshHashesCall) Return(arg0 *fetch.MeshHashes, arg1 error) *fetchLogicPeerMeshHashesCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetchLogicPeerMeshHashesCall) Do(f func(context.Context, p2p.Peer, *fetch.MeshHashRequest) (*fetch.MeshHashes, error)) *fetchLogicPeerMeshHashesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetchLogicPeerMeshHashesCall) DoAndReturn(f func(context.Context, p2p.Peer, *fetch.MeshHashRequest) (*fetch.MeshHashes, error)) *fetchLogicPeerMeshHashesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PollLayerData mocks base method.
func (m *MockfetchLogic) PollLayerData(arg0 context.Context, arg1 types.LayerID, arg2 ...p2p.Peer) error {
	m.ctrl.T.Helper()
	varargs := []any{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 any, arg2 ...any) *fetchLogicPollLayerDataCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0, arg1}, arg2...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PollLayerData", reflect.TypeOf((*MockfetchLogic)(nil).PollLayerData), varargs...)
	return &fetchLogicPollLayerDataCall{Call: call}
}

// fetchLogicPollLayerDataCall wrap *gomock.Call
type fetchLogicPollLayerDataCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetchLogicPollLayerDataCall) Return(arg0 error) *fetchLogicPollLayerDataCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetchLogicPollLayerDataCall) Do(f func(context.Context, types.LayerID, ...p2p.Peer) error) *fetchLogicPollLayerDataCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetchLogicPollLayerDataCall) DoAndReturn(f func(context.Context, types.LayerID, ...p2p.Peer) error) *fetchLogicPollLayerDataCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// PollLayerOpinions indicates an expected call of PollLayerOpinions.
func (mr *MockfetchLogicMockRecorder) PollLayerOpinions(arg0, arg1, arg2, arg3 any) *fetchLogicPollLayerOpinionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PollLayerOpinions", reflect.TypeOf((*MockfetchLogic)(nil).PollLayerOpinions), arg0, arg1, arg2, arg3)
	return &fetchLogicPollLayerOpinionsCall{Call: call}
}

// fetchLogicPollLayerOpinionsCall wrap *gomock.Call
type fetchLogicPollLayerOpinionsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetchLogicPollLayerOpinionsCall) Return(arg0 []*fetch.LayerOpinion, arg1 []*types.Certificate, arg2 error) *fetchLogicPollLayerOpinionsCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetchLogicPollLayerOpinionsCall) Do(f func(context.Context, types.LayerID, bool, []p2p.Peer) ([]*fetch.LayerOpinion, []*types.Certificate, error)) *fetchLogicPollLayerOpinionsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetchLogicPollLayerOpinionsCall) DoAndReturn(f func(context.Context, types.LayerID, bool, []p2p.Peer) ([]*fetch.LayerOpinion, []*types.Certificate, error)) *fetchLogicPollLayerOpinionsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *fetchLogicPollMaliciousProofsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PollMaliciousProofs", reflect.TypeOf((*MockfetchLogic)(nil).PollMaliciousProofs), ctx)
	return &fetchLogicPollMaliciousProofsCall{Call: call}
}

// fetchLogicPollMaliciousProofsCall wrap *gomock.Call
type fetchLogicPollMaliciousProofsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetchLogicPollMaliciousProofsCall) Return(arg0 error) *fetchLogicPollMaliciousProofsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetchLogicPollMaliciousProofsCall) Do(f func(context.Context) error) *fetchLogicPollMaliciousProofsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetchLogicPollMaliciousProofsCall) DoAndReturn(f func(context.Context) error) *fetchLogicPollMaliciousProofsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *fetchLogicRegisterPeerHashesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterPeerHashes", reflect.TypeOf((*MockfetchLogic)(nil).RegisterPeerHashes), peer, hashes)
	return &fetchLogicRegisterPeerHashesCall{Call: call}
}

// fetchLogicRegisterPeerHashesCall wrap *gomock.Call
type fetchLogicRegisterPeerHashesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetchLogicRegisterPeerHashesCall) Return() *fetchLogicRegisterPeerHashesCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetchLogicRegisterPeerHashesCall) Do(f func(p2p.Peer, []types.Hash32)) *fetchLogicRegisterPeerHashesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetchLogicRegisterPeerHashesCall) DoAndReturn(f func(p2p.Peer, []types.Hash32)) *fetchLogicRegisterPeerHashesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SelectBestShuffled indicates an expected call of SelectBestShuffled.
func (mr *MockfetchLogicMockRecorder) SelectBestShuffled(arg0 any) *fetchLogicSelectBestShuffledCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectBestShuffled", reflect.TypeOf((*MockfetchLogic)(nil).SelectBestShuffled), arg0)
	return &fetchLogicSelectBestShuffledCall{Call: call}
}

// fetchLogicSelectBestShuffledCall wrap *gomock.Call
type fetchLogicSelectBestShuffledCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetchLogicSelectBestShuffledCall) Return(arg0 []p2p.Peer) *fetchLogicSelectBestShuffledCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetchLogicSelectBestShuffledCall) Do(f func(int) []p2p.Peer) *fetchLogicSelectBestShuffledCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetchLogicSelectBestShuffledCall) DoAndReturn(f func(int) []p2p.Peer) *fetchLogicSelectBestShuffledCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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, arg2 ...system.GetAtxOpt) error {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAtxs", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetAtxs indicates an expected call of GetAtxs.
func (mr *MockfetcherMockRecorder) GetAtxs(arg0, arg1 any, arg2 ...any) *fetcherGetAtxsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0, arg1}, arg2...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAtxs", reflect.TypeOf((*Mockfetcher)(nil).GetAtxs), varargs...)
	return &fetcherGetAtxsCall{Call: call}
}

// fetcherGetAtxsCall wrap *gomock.Call
type fetcherGetAtxsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetcherGetAtxsCall) Return(arg0 error) *fetcherGetAtxsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetcherGetAtxsCall) Do(f func(context.Context, []types.ATXID, ...system.GetAtxOpt) error) *fetcherGetAtxsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetcherGetAtxsCall) DoAndReturn(f func(context.Context, []types.ATXID, ...system.GetAtxOpt) error) *fetcherGetAtxsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *fetcherGetBallotsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBallots", reflect.TypeOf((*Mockfetcher)(nil).GetBallots), arg0, arg1)
	return &fetcherGetBallotsCall{Call: call}
}

// fetcherGetBallotsCall wrap *gomock.Call
type fetcherGetBallotsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetcherGetBallotsCall) Return(arg0 error) *fetcherGetBallotsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetcherGetBallotsCall) Do(f func(context.Context, []types.BallotID) error) *fetcherGetBallotsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetcherGetBallotsCall) DoAndReturn(f func(context.Context, []types.BallotID) error) *fetcherGetBallotsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *fetcherGetBlocksCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlocks", reflect.TypeOf((*Mockfetcher)(nil).GetBlocks), arg0, arg1)
	return &fetcherGetBlocksCall{Call: call}
}

// fetcherGetBlocksCall wrap *gomock.Call
type fetcherGetBlocksCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetcherGetBlocksCall) Return(arg0 error) *fetcherGetBlocksCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetcherGetBlocksCall) Do(f func(context.Context, []types.BlockID) error) *fetcherGetBlocksCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetcherGetBlocksCall) DoAndReturn(f func(context.Context, []types.BlockID) error) *fetcherGetBlocksCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// GetCert indicates an expected call of GetCert.
func (mr *MockfetcherMockRecorder) GetCert(arg0, arg1, arg2, arg3 any) *fetcherGetCertCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCert", reflect.TypeOf((*Mockfetcher)(nil).GetCert), arg0, arg1, arg2, arg3)
	return &fetcherGetCertCall{Call: call}
}

// fetcherGetCertCall wrap *gomock.Call
type fetcherGetCertCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetcherGetCertCall) Return(arg0 *types.Certificate, arg1 error) *fetcherGetCertCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetcherGetCertCall) Do(f func(context.Context, types.LayerID, types.BlockID, []p2p.Peer) (*types.Certificate, error)) *fetcherGetCertCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetcherGetCertCall) DoAndReturn(f func(context.Context, types.LayerID, types.BlockID, []p2p.Peer) (*types.Certificate, error)) *fetcherGetCertCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// GetLayerData indicates an expected call of GetLayerData.
func (mr *MockfetcherMockRecorder) GetLayerData(arg0, arg1, arg2 any) *fetcherGetLayerDataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLayerData", reflect.TypeOf((*Mockfetcher)(nil).GetLayerData), arg0, arg1, arg2)
	return &fetcherGetLayerDataCall{Call: call}
}

// fetcherGetLayerDataCall wrap *gomock.Call
type fetcherGetLayerDataCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetcherGetLayerDataCall) Return(arg0 []byte, arg1 error) *fetcherGetLayerDataCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetcherGetLayerDataCall) Do(f func(context.Context, p2p.Peer, types.LayerID) ([]byte, error)) *fetcherGetLayerDataCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetcherGetLayerDataCall) DoAndReturn(f func(context.Context, p2p.Peer, types.LayerID) ([]byte, error)) *fetcherGetLayerDataCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// GetLayerOpinions indicates an expected call of GetLayerOpinions.
func (mr *MockfetcherMockRecorder) GetLayerOpinions(arg0, arg1, arg2 any) *fetcherGetLayerOpinionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLayerOpinions", reflect.TypeOf((*Mockfetcher)(nil).GetLayerOpinions), arg0, arg1, arg2)
	return &fetcherGetLayerOpinionsCall{Call: call}
}

// fetcherGetLayerOpinionsCall wrap *gomock.Call
type fetcherGetLayerOpinionsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetcherGetLayerOpinionsCall) Return(arg0 []byte, arg1 error) *fetcherGetLayerOpinionsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetcherGetLayerOpinionsCall) Do(f func(context.Context, p2p.Peer, types.LayerID) ([]byte, error)) *fetcherGetLayerOpinionsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetcherGetLayerOpinionsCall) DoAndReturn(f func(context.Context, p2p.Peer, types.LayerID) ([]byte, error)) *fetcherGetLayerOpinionsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *fetcherGetMalfeasanceProofsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMalfeasanceProofs", reflect.TypeOf((*Mockfetcher)(nil).GetMalfeasanceProofs), arg0, arg1)
	return &fetcherGetMalfeasanceProofsCall{Call: call}
}

// fetcherGetMalfeasanceProofsCall wrap *gomock.Call
type fetcherGetMalfeasanceProofsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetcherGetMalfeasanceProofsCall) Return(arg0 error) *fetcherGetMalfeasanceProofsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetcherGetMalfeasanceProofsCall) Do(f func(context.Context, []types.NodeID) error) *fetcherGetMalfeasanceProofsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetcherGetMalfeasanceProofsCall) DoAndReturn(f func(context.Context, []types.NodeID) error) *fetcherGetMalfeasanceProofsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// GetMaliciousIDs indicates an expected call of GetMaliciousIDs.
func (mr *MockfetcherMockRecorder) GetMaliciousIDs(arg0, arg1 any) *fetcherGetMaliciousIDsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaliciousIDs", reflect.TypeOf((*Mockfetcher)(nil).GetMaliciousIDs), arg0, arg1)
	return &fetcherGetMaliciousIDsCall{Call: call}
}

// fetcherGetMaliciousIDsCall wrap *gomock.Call
type fetcherGetMaliciousIDsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetcherGetMaliciousIDsCall) Return(arg0 []byte, arg1 error) *fetcherGetMaliciousIDsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetcherGetMaliciousIDsCall) Do(f func(context.Context, p2p.Peer) ([]byte, error)) *fetcherGetMaliciousIDsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetcherGetMaliciousIDsCall) DoAndReturn(f func(context.Context, p2p.Peer) ([]byte, error)) *fetcherGetMaliciousIDsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *fetcherPeerEpochInfoCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeerEpochInfo", reflect.TypeOf((*Mockfetcher)(nil).PeerEpochInfo), arg0, arg1, arg2)
	return &fetcherPeerEpochInfoCall{Call: call}
}

// fetcherPeerEpochInfoCall wrap *gomock.Call
type fetcherPeerEpochInfoCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetcherPeerEpochInfoCall) Return(arg0 *fetch.EpochData, arg1 error) *fetcherPeerEpochInfoCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetcherPeerEpochInfoCall) Do(f func(context.Context, p2p.Peer, types.EpochID) (*fetch.EpochData, error)) *fetcherPeerEpochInfoCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetcherPeerEpochInfoCall) DoAndReturn(f func(context.Context, p2p.Peer, types.EpochID) (*fetch.EpochData, error)) *fetcherPeerEpochInfoCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *fetcherPeerMeshHashesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeerMeshHashes", reflect.TypeOf((*Mockfetcher)(nil).PeerMeshHashes), arg0, arg1, arg2)
	return &fetcherPeerMeshHashesCall{Call: call}
}

// fetcherPeerMeshHashesCall wrap *gomock.Call
type fetcherPeerMeshHashesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetcherPeerMeshHashesCall) Return(arg0 *fetch.MeshHashes, arg1 error) *fetcherPeerMeshHashesCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetcherPeerMeshHashesCall) Do(f func(context.Context, p2p.Peer, *fetch.MeshHashRequest) (*fetch.MeshHashes, error)) *fetcherPeerMeshHashesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetcherPeerMeshHashesCall) DoAndReturn(f func(context.Context, p2p.Peer, *fetch.MeshHashRequest) (*fetch.MeshHashes, error)) *fetcherPeerMeshHashesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *fetcherRegisterPeerHashesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterPeerHashes", reflect.TypeOf((*Mockfetcher)(nil).RegisterPeerHashes), peer, hashes)
	return &fetcherRegisterPeerHashesCall{Call: call}
}

// fetcherRegisterPeerHashesCall wrap *gomock.Call
type fetcherRegisterPeerHashesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetcherRegisterPeerHashesCall) Return() *fetcherRegisterPeerHashesCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetcherRegisterPeerHashesCall) Do(f func(p2p.Peer, []types.Hash32)) *fetcherRegisterPeerHashesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetcherRegisterPeerHashesCall) DoAndReturn(f func(p2p.Peer, []types.Hash32)) *fetcherRegisterPeerHashesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SelectBestShuffled indicates an expected call of SelectBestShuffled.
func (mr *MockfetcherMockRecorder) SelectBestShuffled(arg0 any) *fetcherSelectBestShuffledCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectBestShuffled", reflect.TypeOf((*Mockfetcher)(nil).SelectBestShuffled), arg0)
	return &fetcherSelectBestShuffledCall{Call: call}
}

// fetcherSelectBestShuffledCall wrap *gomock.Call
type fetcherSelectBestShuffledCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *fetcherSelectBestShuffledCall) Return(arg0 []p2p.Peer) *fetcherSelectBestShuffledCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *fetcherSelectBestShuffledCall) Do(f func(int) []p2p.Peer) *fetcherSelectBestShuffledCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *fetcherSelectBestShuffledCall) DoAndReturn(f func(int) []p2p.Peer) *fetcherSelectBestShuffledCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *layerPatrolIsHareInChargeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsHareInCharge", reflect.TypeOf((*MocklayerPatrol)(nil).IsHareInCharge), arg0)
	return &layerPatrolIsHareInChargeCall{Call: call}
}

// layerPatrolIsHareInChargeCall wrap *gomock.Call
type layerPatrolIsHareInChargeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *layerPatrolIsHareInChargeCall) Return(arg0 bool) *layerPatrolIsHareInChargeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *layerPatrolIsHareInChargeCall) Do(f func(types.LayerID) bool) *layerPatrolIsHareInChargeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *layerPatrolIsHareInChargeCall) DoAndReturn(f func(types.LayerID) bool) *layerPatrolIsHareInChargeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *certHandlerHandleSyncedCertificateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleSyncedCertificate", reflect.TypeOf((*MockcertHandler)(nil).HandleSyncedCertificate), arg0, arg1, arg2)
	return &certHandlerHandleSyncedCertificateCall{Call: call}
}

// certHandlerHandleSyncedCertificateCall wrap *gomock.Call
type certHandlerHandleSyncedCertificateCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *certHandlerHandleSyncedCertificateCall) Return(arg0 error) *certHandlerHandleSyncedCertificateCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *certHandlerHandleSyncedCertificateCall) Do(f func(context.Context, types.LayerID, *types.Certificate) error) *certHandlerHandleSyncedCertificateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *certHandlerHandleSyncedCertificateCall) DoAndReturn(f func(context.Context, types.LayerID, *types.Certificate) error) *certHandlerHandleSyncedCertificateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *forkFinderAddResyncedCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddResynced", reflect.TypeOf((*MockforkFinder)(nil).AddResynced), arg0, arg1)
	return &forkFinderAddResyncedCall{Call: call}
}

// forkFinderAddResyncedCall wrap *gomock.Call
type forkFinderAddResyncedCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *forkFinderAddResyncedCall) Return() *forkFinderAddResyncedCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *forkFinderAddResyncedCall) Do(f func(types.LayerID, types.Hash32)) *forkFinderAddResyncedCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *forkFinderAddResyncedCall) DoAndReturn(f func(types.LayerID, types.Hash32)) *forkFinderAddResyncedCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *forkFinderFindForkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindFork", reflect.TypeOf((*MockforkFinder)(nil).FindFork), arg0, arg1, arg2, arg3)
	return &forkFinderFindForkCall{Call: call}
}

// forkFinderFindForkCall wrap *gomock.Call
type forkFinderFindForkCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *forkFinderFindForkCall) Return(arg0 types.LayerID, arg1 error) *forkFinderFindForkCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *forkFinderFindForkCall) Do(f func(context.Context, p2p.Peer, types.LayerID, types.Hash32) (types.LayerID, error)) *forkFinderFindForkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *forkFinderFindForkCall) DoAndReturn(f func(context.Context, p2p.Peer, types.LayerID, types.Hash32) (types.LayerID, error)) *forkFinderFindForkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *forkFinderNeedResyncCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NeedResync", reflect.TypeOf((*MockforkFinder)(nil).NeedResync), arg0, arg1)
	return &forkFinderNeedResyncCall{Call: call}
}

// forkFinderNeedResyncCall wrap *gomock.Call
type forkFinderNeedResyncCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *forkFinderNeedResyncCall) Return(arg0 bool) *forkFinderNeedResyncCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *forkFinderNeedResyncCall) Do(f func(types.LayerID, types.Hash32) bool) *forkFinderNeedResyncCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *forkFinderNeedResyncCall) DoAndReturn(f func(types.LayerID, types.Hash32) bool) *forkFinderNeedResyncCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Purge mocks base method.
func (m *MockforkFinder) Purge(arg0 bool, arg1 ...p2p.Peer) {
	m.ctrl.T.Helper()
	varargs := []any{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 any, arg1 ...any) *forkFinderPurgeCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Purge", reflect.TypeOf((*MockforkFinder)(nil).Purge), varargs...)
	return &forkFinderPurgeCall{Call: call}
}

// forkFinderPurgeCall wrap *gomock.Call
type forkFinderPurgeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *forkFinderPurgeCall) Return() *forkFinderPurgeCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *forkFinderPurgeCall) Do(f func(bool, ...p2p.Peer)) *forkFinderPurgeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *forkFinderPurgeCall) DoAndReturn(f func(bool, ...p2p.Peer)) *forkFinderPurgeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *forkFinderUpdateAgreementCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAgreement", reflect.TypeOf((*MockforkFinder)(nil).UpdateAgreement), arg0, arg1, arg2, arg3)
	return &forkFinderUpdateAgreementCall{Call: call}
}

// forkFinderUpdateAgreementCall wrap *gomock.Call
type forkFinderUpdateAgreementCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *forkFinderUpdateAgreementCall) Return() *forkFinderUpdateAgreementCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *forkFinderUpdateAgreementCall) Do(f func(p2p.Peer, types.LayerID, types.Hash32, time.Time)) *forkFinderUpdateAgreementCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *forkFinderUpdateAgreementCall) DoAndReturn(f func(p2p.Peer, types.LayerID, types.Hash32, time.Time)) *forkFinderUpdateAgreementCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// 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 any) *idProviderIdentityExistsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IdentityExists", reflect.TypeOf((*MockidProvider)(nil).IdentityExists), id)
	return &idProviderIdentityExistsCall{Call: call}
}

// idProviderIdentityExistsCall wrap *gomock.Call
type idProviderIdentityExistsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *idProviderIdentityExistsCall) Return(arg0 bool, arg1 error) *idProviderIdentityExistsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *idProviderIdentityExistsCall) Do(f func(types.NodeID) (bool, error)) *idProviderIdentityExistsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *idProviderIdentityExistsCall) DoAndReturn(f func(types.NodeID) (bool, error)) *idProviderIdentityExistsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}