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

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

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

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

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

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

// LayerToTime indicates an expected call of LayerToTime.
func (mr *MocklayerTickerMockRecorder) LayerToTime(arg0 any) *MocklayerTickerLayerToTimeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LayerToTime", reflect.TypeOf((*MocklayerTicker)(nil).LayerToTime), arg0)
	return &MocklayerTickerLayerToTimeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MocklayerTickerLayerToTimeCall) Return(arg0 time.Time) *MocklayerTickerLayerToTimeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocklayerTickerLayerToTimeCall) DoAndReturn(f func(types.LayerID) time.Time) *MocklayerTickerLayerToTimeCall {
	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) *MockmeshProviderSetZeroBlockLayerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetZeroBlockLayer", reflect.TypeOf((*MockmeshProvider)(nil).SetZeroBlockLayer), arg0, arg1)
	return &MockmeshProviderSetZeroBlockLayerCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockmeshProviderSetZeroBlockLayerCall) DoAndReturn(f func(context.Context, types.LayerID)) *MockmeshProviderSetZeroBlockLayerCall {
	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) *MockfetchLogicGetAtxsCall {
	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 &MockfetchLogicGetAtxsCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetchLogicGetAtxsCall) DoAndReturn(f func(context.Context, []types.ATXID, ...system.GetAtxOpt) error) *MockfetchLogicGetAtxsCall {
	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) *MockfetchLogicGetBallotsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBallots", reflect.TypeOf((*MockfetchLogic)(nil).GetBallots), arg0, arg1)
	return &MockfetchLogicGetBallotsCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetchLogicGetBallotsCall) DoAndReturn(f func(context.Context, []types.BallotID) error) *MockfetchLogicGetBallotsCall {
	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) *MockfetchLogicGetBlocksCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlocks", reflect.TypeOf((*MockfetchLogic)(nil).GetBlocks), arg0, arg1)
	return &MockfetchLogicGetBlocksCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetchLogicGetBlocksCall) DoAndReturn(f func(context.Context, []types.BlockID) error) *MockfetchLogicGetBlocksCall {
	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) *MockfetchLogicGetCertCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCert", reflect.TypeOf((*MockfetchLogic)(nil).GetCert), arg0, arg1, arg2, arg3)
	return &MockfetchLogicGetCertCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetchLogicGetCertCall) DoAndReturn(f func(context.Context, types.LayerID, types.BlockID, []p2p.Peer) (*types.Certificate, error)) *MockfetchLogicGetCertCall {
	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) *MockfetchLogicGetLayerDataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLayerData", reflect.TypeOf((*MockfetchLogic)(nil).GetLayerData), arg0, arg1, arg2)
	return &MockfetchLogicGetLayerDataCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetchLogicGetLayerDataCall) DoAndReturn(f func(context.Context, p2p.Peer, types.LayerID) ([]byte, error)) *MockfetchLogicGetLayerDataCall {
	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) *MockfetchLogicGetLayerOpinionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLayerOpinions", reflect.TypeOf((*MockfetchLogic)(nil).GetLayerOpinions), arg0, arg1, arg2)
	return &MockfetchLogicGetLayerOpinionsCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetchLogicGetLayerOpinionsCall) DoAndReturn(f func(context.Context, p2p.Peer, types.LayerID) ([]byte, error)) *MockfetchLogicGetLayerOpinionsCall {
	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) *MockfetchLogicGetMalfeasanceProofsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMalfeasanceProofs", reflect.TypeOf((*MockfetchLogic)(nil).GetMalfeasanceProofs), arg0, arg1)
	return &MockfetchLogicGetMalfeasanceProofsCall{Call: call}
}

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

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

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

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

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

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

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetchLogicGetMaliciousIDsCall) DoAndReturn(f func(context.Context, p2p.Peer) ([]types.NodeID, error)) *MockfetchLogicGetMaliciousIDsCall {
	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) *MockfetchLogicPeerEpochInfoCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeerEpochInfo", reflect.TypeOf((*MockfetchLogic)(nil).PeerEpochInfo), arg0, arg1, arg2)
	return &MockfetchLogicPeerEpochInfoCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetchLogicPeerEpochInfoCall) DoAndReturn(f func(context.Context, p2p.Peer, types.EpochID) (*fetch.EpochData, error)) *MockfetchLogicPeerEpochInfoCall {
	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) *MockfetchLogicPeerMeshHashesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeerMeshHashes", reflect.TypeOf((*MockfetchLogic)(nil).PeerMeshHashes), arg0, arg1, arg2)
	return &MockfetchLogicPeerMeshHashesCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetchLogicPeerMeshHashesCall) DoAndReturn(f func(context.Context, p2p.Peer, *fetch.MeshHashRequest) (*fetch.MeshHashes, error)) *MockfetchLogicPeerMeshHashesCall {
	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) *MockfetchLogicPollLayerDataCall {
	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 &MockfetchLogicPollLayerDataCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetchLogicPollLayerDataCall) DoAndReturn(f func(context.Context, types.LayerID, ...p2p.Peer) error) *MockfetchLogicPollLayerDataCall {
	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) *MockfetchLogicPollLayerOpinionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PollLayerOpinions", reflect.TypeOf((*MockfetchLogic)(nil).PollLayerOpinions), arg0, arg1, arg2, arg3)
	return &MockfetchLogicPollLayerOpinionsCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetchLogicPollLayerOpinionsCall) DoAndReturn(f func(context.Context, types.LayerID, bool, []p2p.Peer) ([]*fetch.LayerOpinion, []*types.Certificate, error)) *MockfetchLogicPollLayerOpinionsCall {
	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) *MockfetchLogicRegisterPeerHashesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterPeerHashes", reflect.TypeOf((*MockfetchLogic)(nil).RegisterPeerHashes), peer, hashes)
	return &MockfetchLogicRegisterPeerHashesCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetchLogicRegisterPeerHashesCall) DoAndReturn(f func(p2p.Peer, []types.Hash32)) *MockfetchLogicRegisterPeerHashesCall {
	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) *MockfetchLogicSelectBestShuffledCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectBestShuffled", reflect.TypeOf((*MockfetchLogic)(nil).SelectBestShuffled), arg0)
	return &MockfetchLogicSelectBestShuffledCall{Call: call}
}

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

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

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

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

// MockatxSyncer is a mock of atxSyncer interface.
type MockatxSyncer struct {
	ctrl     *gomock.Controller
	recorder *MockatxSyncerMockRecorder
}

// MockatxSyncerMockRecorder is the mock recorder for MockatxSyncer.
type MockatxSyncerMockRecorder struct {
	mock *MockatxSyncer
}

// NewMockatxSyncer creates a new mock instance.
func NewMockatxSyncer(ctrl *gomock.Controller) *MockatxSyncer {
	mock := &MockatxSyncer{ctrl: ctrl}
	mock.recorder = &MockatxSyncerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// MockmalSyncer is a mock of malSyncer interface.
type MockmalSyncer struct {
	ctrl     *gomock.Controller
	recorder *MockmalSyncerMockRecorder
}

// MockmalSyncerMockRecorder is the mock recorder for MockmalSyncer.
type MockmalSyncerMockRecorder struct {
	mock *MockmalSyncer
}

// NewMockmalSyncer creates a new mock instance.
func NewMockmalSyncer(ctrl *gomock.Controller) *MockmalSyncer {
	mock := &MockmalSyncer{ctrl: ctrl}
	mock.recorder = &MockmalSyncerMockRecorder{mock}
	return mock
}

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

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

// DownloadLoop indicates an expected call of DownloadLoop.
func (mr *MockmalSyncerMockRecorder) DownloadLoop(parent any) *MockmalSyncerDownloadLoopCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadLoop", reflect.TypeOf((*MockmalSyncer)(nil).DownloadLoop), parent)
	return &MockmalSyncerDownloadLoopCall{Call: call}
}

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

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

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

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

// EnsureInSync mocks base method.
func (m *MockmalSyncer) EnsureInSync(parent context.Context, epochStart, epochEnd time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnsureInSync", parent, epochStart, epochEnd)
	ret0, _ := ret[0].(error)
	return ret0
}

// EnsureInSync indicates an expected call of EnsureInSync.
func (mr *MockmalSyncerMockRecorder) EnsureInSync(parent, epochStart, epochEnd any) *MockmalSyncerEnsureInSyncCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureInSync", reflect.TypeOf((*MockmalSyncer)(nil).EnsureInSync), parent, epochStart, epochEnd)
	return &MockmalSyncerEnsureInSyncCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockmalSyncerEnsureInSyncCall) Do(f func(context.Context, time.Time, time.Time) error) *MockmalSyncerEnsureInSyncCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockmalSyncerEnsureInSyncCall) DoAndReturn(f func(context.Context, time.Time, time.Time) error) *MockmalSyncerEnsureInSyncCall {
	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) *MockfetcherGetAtxsCall {
	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 &MockfetcherGetAtxsCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetcherGetAtxsCall) DoAndReturn(f func(context.Context, []types.ATXID, ...system.GetAtxOpt) error) *MockfetcherGetAtxsCall {
	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) *MockfetcherGetBallotsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBallots", reflect.TypeOf((*Mockfetcher)(nil).GetBallots), arg0, arg1)
	return &MockfetcherGetBallotsCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetcherGetBallotsCall) DoAndReturn(f func(context.Context, []types.BallotID) error) *MockfetcherGetBallotsCall {
	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) *MockfetcherGetBlocksCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlocks", reflect.TypeOf((*Mockfetcher)(nil).GetBlocks), arg0, arg1)
	return &MockfetcherGetBlocksCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetcherGetBlocksCall) DoAndReturn(f func(context.Context, []types.BlockID) error) *MockfetcherGetBlocksCall {
	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) *MockfetcherGetCertCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCert", reflect.TypeOf((*Mockfetcher)(nil).GetCert), arg0, arg1, arg2, arg3)
	return &MockfetcherGetCertCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetcherGetCertCall) DoAndReturn(f func(context.Context, types.LayerID, types.BlockID, []p2p.Peer) (*types.Certificate, error)) *MockfetcherGetCertCall {
	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) *MockfetcherGetLayerDataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLayerData", reflect.TypeOf((*Mockfetcher)(nil).GetLayerData), arg0, arg1, arg2)
	return &MockfetcherGetLayerDataCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetcherGetLayerDataCall) DoAndReturn(f func(context.Context, p2p.Peer, types.LayerID) ([]byte, error)) *MockfetcherGetLayerDataCall {
	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) *MockfetcherGetLayerOpinionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLayerOpinions", reflect.TypeOf((*Mockfetcher)(nil).GetLayerOpinions), arg0, arg1, arg2)
	return &MockfetcherGetLayerOpinionsCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetcherGetLayerOpinionsCall) DoAndReturn(f func(context.Context, p2p.Peer, types.LayerID) ([]byte, error)) *MockfetcherGetLayerOpinionsCall {
	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) *MockfetcherGetMalfeasanceProofsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMalfeasanceProofs", reflect.TypeOf((*Mockfetcher)(nil).GetMalfeasanceProofs), arg0, arg1)
	return &MockfetcherGetMalfeasanceProofsCall{Call: call}
}

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

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

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

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

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

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

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetcherGetMaliciousIDsCall) DoAndReturn(f func(context.Context, p2p.Peer) ([]types.NodeID, error)) *MockfetcherGetMaliciousIDsCall {
	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) *MockfetcherPeerEpochInfoCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeerEpochInfo", reflect.TypeOf((*Mockfetcher)(nil).PeerEpochInfo), arg0, arg1, arg2)
	return &MockfetcherPeerEpochInfoCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetcherPeerEpochInfoCall) DoAndReturn(f func(context.Context, p2p.Peer, types.EpochID) (*fetch.EpochData, error)) *MockfetcherPeerEpochInfoCall {
	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) *MockfetcherPeerMeshHashesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeerMeshHashes", reflect.TypeOf((*Mockfetcher)(nil).PeerMeshHashes), arg0, arg1, arg2)
	return &MockfetcherPeerMeshHashesCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetcherPeerMeshHashesCall) DoAndReturn(f func(context.Context, p2p.Peer, *fetch.MeshHashRequest) (*fetch.MeshHashes, error)) *MockfetcherPeerMeshHashesCall {
	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) *MockfetcherRegisterPeerHashesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterPeerHashes", reflect.TypeOf((*Mockfetcher)(nil).RegisterPeerHashes), peer, hashes)
	return &MockfetcherRegisterPeerHashesCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetcherRegisterPeerHashesCall) DoAndReturn(f func(p2p.Peer, []types.Hash32)) *MockfetcherRegisterPeerHashesCall {
	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) *MockfetcherSelectBestShuffledCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectBestShuffled", reflect.TypeOf((*Mockfetcher)(nil).SelectBestShuffled), arg0)
	return &MockfetcherSelectBestShuffledCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockfetcherSelectBestShuffledCall) DoAndReturn(f func(int) []p2p.Peer) *MockfetcherSelectBestShuffledCall {
	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) *MocklayerPatrolIsHareInChargeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsHareInCharge", reflect.TypeOf((*MocklayerPatrol)(nil).IsHareInCharge), arg0)
	return &MocklayerPatrolIsHareInChargeCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocklayerPatrolIsHareInChargeCall) DoAndReturn(f func(types.LayerID) bool) *MocklayerPatrolIsHareInChargeCall {
	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) *MockcertHandlerHandleSyncedCertificateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleSyncedCertificate", reflect.TypeOf((*MockcertHandler)(nil).HandleSyncedCertificate), arg0, arg1, arg2)
	return &MockcertHandlerHandleSyncedCertificateCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockcertHandlerHandleSyncedCertificateCall) DoAndReturn(f func(context.Context, types.LayerID, *types.Certificate) error) *MockcertHandlerHandleSyncedCertificateCall {
	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) *MockforkFinderAddResyncedCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddResynced", reflect.TypeOf((*MockforkFinder)(nil).AddResynced), arg0, arg1)
	return &MockforkFinderAddResyncedCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockforkFinderAddResyncedCall) DoAndReturn(f func(types.LayerID, types.Hash32)) *MockforkFinderAddResyncedCall {
	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) *MockforkFinderFindForkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindFork", reflect.TypeOf((*MockforkFinder)(nil).FindFork), arg0, arg1, arg2, arg3)
	return &MockforkFinderFindForkCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockforkFinderFindForkCall) DoAndReturn(f func(context.Context, p2p.Peer, types.LayerID, types.Hash32) (types.LayerID, error)) *MockforkFinderFindForkCall {
	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) *MockforkFinderNeedResyncCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NeedResync", reflect.TypeOf((*MockforkFinder)(nil).NeedResync), arg0, arg1)
	return &MockforkFinderNeedResyncCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockforkFinderNeedResyncCall) DoAndReturn(f func(types.LayerID, types.Hash32) bool) *MockforkFinderNeedResyncCall {
	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) *MockforkFinderPurgeCall {
	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 &MockforkFinderPurgeCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockforkFinderPurgeCall) DoAndReturn(f func(bool, ...p2p.Peer)) *MockforkFinderPurgeCall {
	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) *MockforkFinderUpdateAgreementCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAgreement", reflect.TypeOf((*MockforkFinder)(nil).UpdateAgreement), arg0, arg1, arg2, arg3)
	return &MockforkFinderUpdateAgreementCall{Call: call}
}

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

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

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

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