// Code generated by MockGen. DO NOT EDIT.
// Source: consensus/consensus.go
//
// Generated by this command:
//
//	mockgen -source=consensus/consensus.go -package=consensus -destination=consensus/consensus_mock.go
//

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

import (
	context "context"
	big "math/big"
	reflect "reflect"

	common "github.com/autonity/autonity/common"
	fixsizecache "github.com/autonity/autonity/common/fixsizecache"
	state "github.com/autonity/autonity/core/state"
	types "github.com/autonity/autonity/core/types"
	p2p "github.com/autonity/autonity/p2p"
	enode "github.com/autonity/autonity/p2p/enode"
	params "github.com/autonity/autonity/params"
	rpc "github.com/autonity/autonity/rpc"
	gomock "go.uber.org/mock/gomock"
)

// MockChainHeaderReader is a mock of ChainHeaderReader interface.
type MockChainHeaderReader struct {
	ctrl     *gomock.Controller
	recorder *MockChainHeaderReaderMockRecorder
	isgomock struct{}
}

// MockChainHeaderReaderMockRecorder is the mock recorder for MockChainHeaderReader.
type MockChainHeaderReaderMockRecorder struct {
	mock *MockChainHeaderReader
}

// NewMockChainHeaderReader creates a new mock instance.
func NewMockChainHeaderReader(ctrl *gomock.Controller) *MockChainHeaderReader {
	mock := &MockChainHeaderReader{ctrl: ctrl}
	mock.recorder = &MockChainHeaderReaderMockRecorder{mock}
	return mock
}

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

// Config mocks base method.
func (m *MockChainHeaderReader) Config() *params.ChainConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Config")
	ret0, _ := ret[0].(*params.ChainConfig)
	return ret0
}

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

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

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

// EpochByHeight mocks base method.
func (m *MockChainHeaderReader) EpochByHeight(height uint64) (*types.EpochInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EpochByHeight", height)
	ret0, _ := ret[0].(*types.EpochInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EpochByHeight indicates an expected call of EpochByHeight.
func (mr *MockChainHeaderReaderMockRecorder) EpochByHeight(height any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EpochByHeight", reflect.TypeOf((*MockChainHeaderReader)(nil).EpochByHeight), height)
}

// GetHeader mocks base method.
func (m *MockChainHeaderReader) GetHeader(hash common.Hash, number uint64) *types.Header {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHeader", hash, number)
	ret0, _ := ret[0].(*types.Header)
	return ret0
}

// GetHeader indicates an expected call of GetHeader.
func (mr *MockChainHeaderReaderMockRecorder) GetHeader(hash, number any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHeader", reflect.TypeOf((*MockChainHeaderReader)(nil).GetHeader), hash, number)
}

// GetHeaderByHash mocks base method.
func (m *MockChainHeaderReader) GetHeaderByHash(hash common.Hash) *types.Header {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHeaderByHash", hash)
	ret0, _ := ret[0].(*types.Header)
	return ret0
}

// GetHeaderByHash indicates an expected call of GetHeaderByHash.
func (mr *MockChainHeaderReaderMockRecorder) GetHeaderByHash(hash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHeaderByHash", reflect.TypeOf((*MockChainHeaderReader)(nil).GetHeaderByHash), hash)
}

// GetHeaderByNumber mocks base method.
func (m *MockChainHeaderReader) GetHeaderByNumber(number uint64) *types.Header {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHeaderByNumber", number)
	ret0, _ := ret[0].(*types.Header)
	return ret0
}

// GetHeaderByNumber indicates an expected call of GetHeaderByNumber.
func (mr *MockChainHeaderReaderMockRecorder) GetHeaderByNumber(number any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHeaderByNumber", reflect.TypeOf((*MockChainHeaderReader)(nil).GetHeaderByNumber), number)
}

// GetTd mocks base method.
func (m *MockChainHeaderReader) GetTd(hash common.Hash, number uint64) *big.Int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTd", hash, number)
	ret0, _ := ret[0].(*big.Int)
	return ret0
}

// GetTd indicates an expected call of GetTd.
func (mr *MockChainHeaderReaderMockRecorder) GetTd(hash, number any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTd", reflect.TypeOf((*MockChainHeaderReader)(nil).GetTd), hash, number)
}

// MockChainReader is a mock of ChainReader interface.
type MockChainReader struct {
	ctrl     *gomock.Controller
	recorder *MockChainReaderMockRecorder
	isgomock struct{}
}

// MockChainReaderMockRecorder is the mock recorder for MockChainReader.
type MockChainReaderMockRecorder struct {
	mock *MockChainReader
}

// NewMockChainReader creates a new mock instance.
func NewMockChainReader(ctrl *gomock.Controller) *MockChainReader {
	mock := &MockChainReader{ctrl: ctrl}
	mock.recorder = &MockChainReaderMockRecorder{mock}
	return mock
}

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

// Config mocks base method.
func (m *MockChainReader) Config() *params.ChainConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Config")
	ret0, _ := ret[0].(*params.ChainConfig)
	return ret0
}

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

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

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

// Eip1559ParamsByHeight mocks base method.
func (m *MockChainReader) Eip1559ParamsByHeight(height uint64) (*types.Eip1559Params, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Eip1559ParamsByHeight", height)
	ret0, _ := ret[0].(*types.Eip1559Params)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Eip1559ParamsByHeight indicates an expected call of Eip1559ParamsByHeight.
func (mr *MockChainReaderMockRecorder) Eip1559ParamsByHeight(height any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eip1559ParamsByHeight", reflect.TypeOf((*MockChainReader)(nil).Eip1559ParamsByHeight), height)
}

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

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

// EpochByHeight mocks base method.
func (m *MockChainReader) EpochByHeight(height uint64) (*types.EpochInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EpochByHeight", height)
	ret0, _ := ret[0].(*types.EpochInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EpochByHeight indicates an expected call of EpochByHeight.
func (mr *MockChainReaderMockRecorder) EpochByHeight(height any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EpochByHeight", reflect.TypeOf((*MockChainReader)(nil).EpochByHeight), height)
}

// GetBlock mocks base method.
func (m *MockChainReader) GetBlock(hash common.Hash, number uint64) *types.Block {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlock", hash, number)
	ret0, _ := ret[0].(*types.Block)
	return ret0
}

// GetBlock indicates an expected call of GetBlock.
func (mr *MockChainReaderMockRecorder) GetBlock(hash, number any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlock", reflect.TypeOf((*MockChainReader)(nil).GetBlock), hash, number)
}

// GetHeader mocks base method.
func (m *MockChainReader) GetHeader(hash common.Hash, number uint64) *types.Header {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHeader", hash, number)
	ret0, _ := ret[0].(*types.Header)
	return ret0
}

// GetHeader indicates an expected call of GetHeader.
func (mr *MockChainReaderMockRecorder) GetHeader(hash, number any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHeader", reflect.TypeOf((*MockChainReader)(nil).GetHeader), hash, number)
}

// GetHeaderByHash mocks base method.
func (m *MockChainReader) GetHeaderByHash(hash common.Hash) *types.Header {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHeaderByHash", hash)
	ret0, _ := ret[0].(*types.Header)
	return ret0
}

// GetHeaderByHash indicates an expected call of GetHeaderByHash.
func (mr *MockChainReaderMockRecorder) GetHeaderByHash(hash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHeaderByHash", reflect.TypeOf((*MockChainReader)(nil).GetHeaderByHash), hash)
}

// GetHeaderByNumber mocks base method.
func (m *MockChainReader) GetHeaderByNumber(number uint64) *types.Header {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHeaderByNumber", number)
	ret0, _ := ret[0].(*types.Header)
	return ret0
}

// GetHeaderByNumber indicates an expected call of GetHeaderByNumber.
func (mr *MockChainReaderMockRecorder) GetHeaderByNumber(number any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHeaderByNumber", reflect.TypeOf((*MockChainReader)(nil).GetHeaderByNumber), number)
}

// GetTd mocks base method.
func (m *MockChainReader) GetTd(hash common.Hash, number uint64) *big.Int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTd", hash, number)
	ret0, _ := ret[0].(*big.Int)
	return ret0
}

// GetTd indicates an expected call of GetTd.
func (mr *MockChainReaderMockRecorder) GetTd(hash, number any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTd", reflect.TypeOf((*MockChainReader)(nil).GetTd), hash, number)
}

// MockEngine is a mock of Engine interface.
type MockEngine struct {
	ctrl     *gomock.Controller
	recorder *MockEngineMockRecorder
	isgomock struct{}
}

// MockEngineMockRecorder is the mock recorder for MockEngine.
type MockEngineMockRecorder struct {
	mock *MockEngine
}

// NewMockEngine creates a new mock instance.
func NewMockEngine(ctrl *gomock.Controller) *MockEngine {
	mock := &MockEngine{ctrl: ctrl}
	mock.recorder = &MockEngineMockRecorder{mock}
	return mock
}

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

// APIs mocks base method.
func (m *MockEngine) APIs(chain ChainReader) []rpc.API {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "APIs", chain)
	ret0, _ := ret[0].([]rpc.API)
	return ret0
}

// APIs indicates an expected call of APIs.
func (mr *MockEngineMockRecorder) APIs(chain any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "APIs", reflect.TypeOf((*MockEngine)(nil).APIs), chain)
}

// Author mocks base method.
func (m *MockEngine) Author(header *types.Header) (common.Address, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Author", header)
	ret0, _ := ret[0].(common.Address)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Author indicates an expected call of Author.
func (mr *MockEngineMockRecorder) Author(header any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Author", reflect.TypeOf((*MockEngine)(nil).Author), header)
}

// CalcDifficulty mocks base method.
func (m *MockEngine) CalcDifficulty(chain ChainHeaderReader, time uint64, parent *types.Header) *big.Int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcDifficulty", chain, time, parent)
	ret0, _ := ret[0].(*big.Int)
	return ret0
}

// CalcDifficulty indicates an expected call of CalcDifficulty.
func (mr *MockEngineMockRecorder) CalcDifficulty(chain, time, parent any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcDifficulty", reflect.TypeOf((*MockEngine)(nil).CalcDifficulty), chain, time, parent)
}

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

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

// Finalize mocks base method.
func (m *MockEngine) Finalize(chain ChainReader, header *types.Header, arg2 *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Receipt, *types.Epoch, *types.ContractsConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Finalize", chain, header, arg2, txs, uncles, receipts)
	ret0, _ := ret[0].(*types.Receipt)
	ret1, _ := ret[1].(*types.Epoch)
	ret2, _ := ret[2].(*types.ContractsConfig)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// Finalize indicates an expected call of Finalize.
func (mr *MockEngineMockRecorder) Finalize(chain, header, arg2, txs, uncles, receipts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Finalize", reflect.TypeOf((*MockEngine)(nil).Finalize), chain, header, arg2, txs, uncles, receipts)
}

// FinalizeAndAssemble mocks base method.
func (m *MockEngine) FinalizeAndAssemble(chain ChainReader, header *types.Header, arg2 *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts *[]*types.Receipt) (*types.Block, *types.ContractsConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizeAndAssemble", chain, header, arg2, txs, uncles, receipts)
	ret0, _ := ret[0].(*types.Block)
	ret1, _ := ret[1].(*types.ContractsConfig)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FinalizeAndAssemble indicates an expected call of FinalizeAndAssemble.
func (mr *MockEngineMockRecorder) FinalizeAndAssemble(chain, header, arg2, txs, uncles, receipts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeAndAssemble", reflect.TypeOf((*MockEngine)(nil).FinalizeAndAssemble), chain, header, arg2, txs, uncles, receipts)
}

// Prepare mocks base method.
func (m *MockEngine) Prepare(chain ChainHeaderReader, parentHeader, header *types.Header, parentState *state.StateDB) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Prepare", chain, parentHeader, header, parentState)
	ret0, _ := ret[0].(error)
	return ret0
}

// Prepare indicates an expected call of Prepare.
func (mr *MockEngineMockRecorder) Prepare(chain, parentHeader, header, parentState any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prepare", reflect.TypeOf((*MockEngine)(nil).Prepare), chain, parentHeader, header, parentState)
}

// Seal mocks base method.
func (m *MockEngine) Seal(parent *types.Header, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Seal", parent, block, results, stop)
	ret0, _ := ret[0].(error)
	return ret0
}

// Seal indicates an expected call of Seal.
func (mr *MockEngineMockRecorder) Seal(parent, block, results, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seal", reflect.TypeOf((*MockEngine)(nil).Seal), parent, block, results, stop)
}

// SealHash mocks base method.
func (m *MockEngine) SealHash(header *types.Header) common.Hash {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SealHash", header)
	ret0, _ := ret[0].(common.Hash)
	return ret0
}

// SealHash indicates an expected call of SealHash.
func (mr *MockEngineMockRecorder) SealHash(header any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SealHash", reflect.TypeOf((*MockEngine)(nil).SealHash), header)
}

// SetProposalVerifiedEventChan mocks base method.
func (m *MockEngine) SetProposalVerifiedEventChan(proposalVerifiedEventCh chan<- *types.Block) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetProposalVerifiedEventChan", proposalVerifiedEventCh)
}

// SetProposalVerifiedEventChan indicates an expected call of SetProposalVerifiedEventChan.
func (mr *MockEngineMockRecorder) SetProposalVerifiedEventChan(proposalVerifiedEventCh any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetProposalVerifiedEventChan", reflect.TypeOf((*MockEngine)(nil).SetProposalVerifiedEventChan), proposalVerifiedEventCh)
}

// SetResultChan mocks base method.
func (m *MockEngine) SetResultChan(results chan<- *types.Block) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetResultChan", results)
}

// SetResultChan indicates an expected call of SetResultChan.
func (mr *MockEngineMockRecorder) SetResultChan(results any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetResultChan", reflect.TypeOf((*MockEngine)(nil).SetResultChan), results)
}

// VerifyHeader mocks base method.
func (m *MockEngine) VerifyHeader(chain ChainHeaderReader, header *types.Header, seal bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyHeader", chain, header, seal)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyHeader indicates an expected call of VerifyHeader.
func (mr *MockEngineMockRecorder) VerifyHeader(chain, header, seal any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyHeader", reflect.TypeOf((*MockEngine)(nil).VerifyHeader), chain, header, seal)
}

// VerifyHeaders mocks base method.
func (m *MockEngine) VerifyHeaders(chain ChainHeaderReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyHeaders", chain, headers, seals)
	ret0, _ := ret[0].(chan<- struct{})
	ret1, _ := ret[1].(<-chan error)
	return ret0, ret1
}

// VerifyHeaders indicates an expected call of VerifyHeaders.
func (mr *MockEngineMockRecorder) VerifyHeaders(chain, headers, seals any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyHeaders", reflect.TypeOf((*MockEngine)(nil).VerifyHeaders), chain, headers, seals)
}

// VerifyUncles mocks base method.
func (m *MockEngine) VerifyUncles(chain ChainReader, block *types.Block) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyUncles", chain, block)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyUncles indicates an expected call of VerifyUncles.
func (mr *MockEngineMockRecorder) VerifyUncles(chain, block any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyUncles", reflect.TypeOf((*MockEngine)(nil).VerifyUncles), chain, block)
}

// MockHandler is a mock of Handler interface.
type MockHandler struct {
	ctrl     *gomock.Controller
	recorder *MockHandlerMockRecorder
	isgomock struct{}
}

// MockHandlerMockRecorder is the mock recorder for MockHandler.
type MockHandlerMockRecorder struct {
	mock *MockHandler
}

// NewMockHandler creates a new mock instance.
func NewMockHandler(ctrl *gomock.Controller) *MockHandler {
	mock := &MockHandler{ctrl: ctrl}
	mock.recorder = &MockHandlerMockRecorder{mock}
	return mock
}

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

// HandleMsg mocks base method.
func (m *MockHandler) HandleMsg(address common.Address, data p2p.Msg, errCh chan<- error) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleMsg", address, data, errCh)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleMsg indicates an expected call of HandleMsg.
func (mr *MockHandlerMockRecorder) HandleMsg(address, data, errCh any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMsg", reflect.TypeOf((*MockHandler)(nil).HandleMsg), address, data, errCh)
}

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

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

// SetBroadcaster mocks base method.
func (m *MockHandler) SetBroadcaster(arg0 Broadcaster) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBroadcaster", arg0)
}

// SetBroadcaster indicates an expected call of SetBroadcaster.
func (mr *MockHandlerMockRecorder) SetBroadcaster(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBroadcaster", reflect.TypeOf((*MockHandler)(nil).SetBroadcaster), arg0)
}

// SetEnqueuer mocks base method.
func (m *MockHandler) SetEnqueuer(arg0 Enqueuer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetEnqueuer", arg0)
}

// SetEnqueuer indicates an expected call of SetEnqueuer.
func (mr *MockHandlerMockRecorder) SetEnqueuer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEnqueuer", reflect.TypeOf((*MockHandler)(nil).SetEnqueuer), arg0)
}

// MockPoW is a mock of PoW interface.
type MockPoW struct {
	ctrl     *gomock.Controller
	recorder *MockPoWMockRecorder
	isgomock struct{}
}

// MockPoWMockRecorder is the mock recorder for MockPoW.
type MockPoWMockRecorder struct {
	mock *MockPoW
}

// NewMockPoW creates a new mock instance.
func NewMockPoW(ctrl *gomock.Controller) *MockPoW {
	mock := &MockPoW{ctrl: ctrl}
	mock.recorder = &MockPoWMockRecorder{mock}
	return mock
}

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

// APIs mocks base method.
func (m *MockPoW) APIs(chain ChainReader) []rpc.API {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "APIs", chain)
	ret0, _ := ret[0].([]rpc.API)
	return ret0
}

// APIs indicates an expected call of APIs.
func (mr *MockPoWMockRecorder) APIs(chain any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "APIs", reflect.TypeOf((*MockPoW)(nil).APIs), chain)
}

// Author mocks base method.
func (m *MockPoW) Author(header *types.Header) (common.Address, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Author", header)
	ret0, _ := ret[0].(common.Address)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Author indicates an expected call of Author.
func (mr *MockPoWMockRecorder) Author(header any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Author", reflect.TypeOf((*MockPoW)(nil).Author), header)
}

// CalcDifficulty mocks base method.
func (m *MockPoW) CalcDifficulty(chain ChainHeaderReader, time uint64, parent *types.Header) *big.Int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcDifficulty", chain, time, parent)
	ret0, _ := ret[0].(*big.Int)
	return ret0
}

// CalcDifficulty indicates an expected call of CalcDifficulty.
func (mr *MockPoWMockRecorder) CalcDifficulty(chain, time, parent any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcDifficulty", reflect.TypeOf((*MockPoW)(nil).CalcDifficulty), chain, time, parent)
}

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

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

// Finalize mocks base method.
func (m *MockPoW) Finalize(chain ChainReader, header *types.Header, arg2 *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Receipt, *types.Epoch, *types.ContractsConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Finalize", chain, header, arg2, txs, uncles, receipts)
	ret0, _ := ret[0].(*types.Receipt)
	ret1, _ := ret[1].(*types.Epoch)
	ret2, _ := ret[2].(*types.ContractsConfig)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// Finalize indicates an expected call of Finalize.
func (mr *MockPoWMockRecorder) Finalize(chain, header, arg2, txs, uncles, receipts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Finalize", reflect.TypeOf((*MockPoW)(nil).Finalize), chain, header, arg2, txs, uncles, receipts)
}

// FinalizeAndAssemble mocks base method.
func (m *MockPoW) FinalizeAndAssemble(chain ChainReader, header *types.Header, arg2 *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts *[]*types.Receipt) (*types.Block, *types.ContractsConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizeAndAssemble", chain, header, arg2, txs, uncles, receipts)
	ret0, _ := ret[0].(*types.Block)
	ret1, _ := ret[1].(*types.ContractsConfig)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FinalizeAndAssemble indicates an expected call of FinalizeAndAssemble.
func (mr *MockPoWMockRecorder) FinalizeAndAssemble(chain, header, arg2, txs, uncles, receipts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeAndAssemble", reflect.TypeOf((*MockPoW)(nil).FinalizeAndAssemble), chain, header, arg2, txs, uncles, receipts)
}

// Hashrate mocks base method.
func (m *MockPoW) Hashrate() float64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Hashrate")
	ret0, _ := ret[0].(float64)
	return ret0
}

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

// Prepare mocks base method.
func (m *MockPoW) Prepare(chain ChainHeaderReader, parentHeader, header *types.Header, parentState *state.StateDB) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Prepare", chain, parentHeader, header, parentState)
	ret0, _ := ret[0].(error)
	return ret0
}

// Prepare indicates an expected call of Prepare.
func (mr *MockPoWMockRecorder) Prepare(chain, parentHeader, header, parentState any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prepare", reflect.TypeOf((*MockPoW)(nil).Prepare), chain, parentHeader, header, parentState)
}

// Seal mocks base method.
func (m *MockPoW) Seal(parent *types.Header, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Seal", parent, block, results, stop)
	ret0, _ := ret[0].(error)
	return ret0
}

// Seal indicates an expected call of Seal.
func (mr *MockPoWMockRecorder) Seal(parent, block, results, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seal", reflect.TypeOf((*MockPoW)(nil).Seal), parent, block, results, stop)
}

// SealHash mocks base method.
func (m *MockPoW) SealHash(header *types.Header) common.Hash {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SealHash", header)
	ret0, _ := ret[0].(common.Hash)
	return ret0
}

// SealHash indicates an expected call of SealHash.
func (mr *MockPoWMockRecorder) SealHash(header any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SealHash", reflect.TypeOf((*MockPoW)(nil).SealHash), header)
}

// SetProposalVerifiedEventChan mocks base method.
func (m *MockPoW) SetProposalVerifiedEventChan(proposalVerifiedEventCh chan<- *types.Block) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetProposalVerifiedEventChan", proposalVerifiedEventCh)
}

// SetProposalVerifiedEventChan indicates an expected call of SetProposalVerifiedEventChan.
func (mr *MockPoWMockRecorder) SetProposalVerifiedEventChan(proposalVerifiedEventCh any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetProposalVerifiedEventChan", reflect.TypeOf((*MockPoW)(nil).SetProposalVerifiedEventChan), proposalVerifiedEventCh)
}

// SetResultChan mocks base method.
func (m *MockPoW) SetResultChan(results chan<- *types.Block) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetResultChan", results)
}

// SetResultChan indicates an expected call of SetResultChan.
func (mr *MockPoWMockRecorder) SetResultChan(results any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetResultChan", reflect.TypeOf((*MockPoW)(nil).SetResultChan), results)
}

// VerifyHeader mocks base method.
func (m *MockPoW) VerifyHeader(chain ChainHeaderReader, header *types.Header, seal bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyHeader", chain, header, seal)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyHeader indicates an expected call of VerifyHeader.
func (mr *MockPoWMockRecorder) VerifyHeader(chain, header, seal any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyHeader", reflect.TypeOf((*MockPoW)(nil).VerifyHeader), chain, header, seal)
}

// VerifyHeaders mocks base method.
func (m *MockPoW) VerifyHeaders(chain ChainHeaderReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyHeaders", chain, headers, seals)
	ret0, _ := ret[0].(chan<- struct{})
	ret1, _ := ret[1].(<-chan error)
	return ret0, ret1
}

// VerifyHeaders indicates an expected call of VerifyHeaders.
func (mr *MockPoWMockRecorder) VerifyHeaders(chain, headers, seals any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyHeaders", reflect.TypeOf((*MockPoW)(nil).VerifyHeaders), chain, headers, seals)
}

// VerifyUncles mocks base method.
func (m *MockPoW) VerifyUncles(chain ChainReader, block *types.Block) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyUncles", chain, block)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyUncles indicates an expected call of VerifyUncles.
func (mr *MockPoWMockRecorder) VerifyUncles(chain, block any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyUncles", reflect.TypeOf((*MockPoW)(nil).VerifyUncles), chain, block)
}

// MockBFT is a mock of BFT interface.
type MockBFT struct {
	ctrl     *gomock.Controller
	recorder *MockBFTMockRecorder
	isgomock struct{}
}

// MockBFTMockRecorder is the mock recorder for MockBFT.
type MockBFTMockRecorder struct {
	mock *MockBFT
}

// NewMockBFT creates a new mock instance.
func NewMockBFT(ctrl *gomock.Controller) *MockBFT {
	mock := &MockBFT{ctrl: ctrl}
	mock.recorder = &MockBFTMockRecorder{mock}
	return mock
}

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

// APIs mocks base method.
func (m *MockBFT) APIs(chain ChainReader) []rpc.API {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "APIs", chain)
	ret0, _ := ret[0].([]rpc.API)
	return ret0
}

// APIs indicates an expected call of APIs.
func (mr *MockBFTMockRecorder) APIs(chain any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "APIs", reflect.TypeOf((*MockBFT)(nil).APIs), chain)
}

// Author mocks base method.
func (m *MockBFT) Author(header *types.Header) (common.Address, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Author", header)
	ret0, _ := ret[0].(common.Address)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Author indicates an expected call of Author.
func (mr *MockBFTMockRecorder) Author(header any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Author", reflect.TypeOf((*MockBFT)(nil).Author), header)
}

// CalcDifficulty mocks base method.
func (m *MockBFT) CalcDifficulty(chain ChainHeaderReader, time uint64, parent *types.Header) *big.Int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcDifficulty", chain, time, parent)
	ret0, _ := ret[0].(*big.Int)
	return ret0
}

// CalcDifficulty indicates an expected call of CalcDifficulty.
func (mr *MockBFTMockRecorder) CalcDifficulty(chain, time, parent any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcDifficulty", reflect.TypeOf((*MockBFT)(nil).CalcDifficulty), chain, time, parent)
}

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

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

// Finalize mocks base method.
func (m *MockBFT) Finalize(chain ChainReader, header *types.Header, arg2 *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Receipt, *types.Epoch, *types.ContractsConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Finalize", chain, header, arg2, txs, uncles, receipts)
	ret0, _ := ret[0].(*types.Receipt)
	ret1, _ := ret[1].(*types.Epoch)
	ret2, _ := ret[2].(*types.ContractsConfig)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// Finalize indicates an expected call of Finalize.
func (mr *MockBFTMockRecorder) Finalize(chain, header, arg2, txs, uncles, receipts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Finalize", reflect.TypeOf((*MockBFT)(nil).Finalize), chain, header, arg2, txs, uncles, receipts)
}

// FinalizeAndAssemble mocks base method.
func (m *MockBFT) FinalizeAndAssemble(chain ChainReader, header *types.Header, arg2 *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts *[]*types.Receipt) (*types.Block, *types.ContractsConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizeAndAssemble", chain, header, arg2, txs, uncles, receipts)
	ret0, _ := ret[0].(*types.Block)
	ret1, _ := ret[1].(*types.ContractsConfig)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FinalizeAndAssemble indicates an expected call of FinalizeAndAssemble.
func (mr *MockBFTMockRecorder) FinalizeAndAssemble(chain, header, arg2, txs, uncles, receipts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeAndAssemble", reflect.TypeOf((*MockBFT)(nil).FinalizeAndAssemble), chain, header, arg2, txs, uncles, receipts)
}

// Prepare mocks base method.
func (m *MockBFT) Prepare(chain ChainHeaderReader, parentHeader, header *types.Header, parentState *state.StateDB) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Prepare", chain, parentHeader, header, parentState)
	ret0, _ := ret[0].(error)
	return ret0
}

// Prepare indicates an expected call of Prepare.
func (mr *MockBFTMockRecorder) Prepare(chain, parentHeader, header, parentState any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prepare", reflect.TypeOf((*MockBFT)(nil).Prepare), chain, parentHeader, header, parentState)
}

// Seal mocks base method.
func (m *MockBFT) Seal(parent *types.Header, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Seal", parent, block, results, stop)
	ret0, _ := ret[0].(error)
	return ret0
}

// Seal indicates an expected call of Seal.
func (mr *MockBFTMockRecorder) Seal(parent, block, results, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seal", reflect.TypeOf((*MockBFT)(nil).Seal), parent, block, results, stop)
}

// SealHash mocks base method.
func (m *MockBFT) SealHash(header *types.Header) common.Hash {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SealHash", header)
	ret0, _ := ret[0].(common.Hash)
	return ret0
}

// SealHash indicates an expected call of SealHash.
func (mr *MockBFTMockRecorder) SealHash(header any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SealHash", reflect.TypeOf((*MockBFT)(nil).SealHash), header)
}

// SetProposalVerifiedEventChan mocks base method.
func (m *MockBFT) SetProposalVerifiedEventChan(proposalVerifiedEventCh chan<- *types.Block) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetProposalVerifiedEventChan", proposalVerifiedEventCh)
}

// SetProposalVerifiedEventChan indicates an expected call of SetProposalVerifiedEventChan.
func (mr *MockBFTMockRecorder) SetProposalVerifiedEventChan(proposalVerifiedEventCh any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetProposalVerifiedEventChan", reflect.TypeOf((*MockBFT)(nil).SetProposalVerifiedEventChan), proposalVerifiedEventCh)
}

// SetResultChan mocks base method.
func (m *MockBFT) SetResultChan(results chan<- *types.Block) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetResultChan", results)
}

// SetResultChan indicates an expected call of SetResultChan.
func (mr *MockBFTMockRecorder) SetResultChan(results any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetResultChan", reflect.TypeOf((*MockBFT)(nil).SetResultChan), results)
}

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

// Start indicates an expected call of Start.
func (mr *MockBFTMockRecorder) Start(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockBFT)(nil).Start), ctx)
}

// VerifyHeader mocks base method.
func (m *MockBFT) VerifyHeader(chain ChainHeaderReader, header *types.Header, seal bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyHeader", chain, header, seal)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyHeader indicates an expected call of VerifyHeader.
func (mr *MockBFTMockRecorder) VerifyHeader(chain, header, seal any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyHeader", reflect.TypeOf((*MockBFT)(nil).VerifyHeader), chain, header, seal)
}

// VerifyHeaders mocks base method.
func (m *MockBFT) VerifyHeaders(chain ChainHeaderReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyHeaders", chain, headers, seals)
	ret0, _ := ret[0].(chan<- struct{})
	ret1, _ := ret[1].(<-chan error)
	return ret0, ret1
}

// VerifyHeaders indicates an expected call of VerifyHeaders.
func (mr *MockBFTMockRecorder) VerifyHeaders(chain, headers, seals any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyHeaders", reflect.TypeOf((*MockBFT)(nil).VerifyHeaders), chain, headers, seals)
}

// VerifyUncles mocks base method.
func (m *MockBFT) VerifyUncles(chain ChainReader, block *types.Block) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyUncles", chain, block)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyUncles indicates an expected call of VerifyUncles.
func (mr *MockBFTMockRecorder) VerifyUncles(chain, block any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyUncles", reflect.TypeOf((*MockBFT)(nil).VerifyUncles), chain, block)
}

// MockSyncer is a mock of Syncer interface.
type MockSyncer struct {
	ctrl     *gomock.Controller
	recorder *MockSyncerMockRecorder
	isgomock struct{}
}

// MockSyncerMockRecorder is the mock recorder for MockSyncer.
type MockSyncerMockRecorder struct {
	mock *MockSyncer
}

// NewMockSyncer creates a new mock instance.
func NewMockSyncer(ctrl *gomock.Controller) *MockSyncer {
	mock := &MockSyncer{ctrl: ctrl}
	mock.recorder = &MockSyncerMockRecorder{mock}
	return mock
}

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

// SyncPeer mocks base method.
func (m *MockSyncer) SyncPeer(address common.Address) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SyncPeer", address)
}

// SyncPeer indicates an expected call of SyncPeer.
func (mr *MockSyncerMockRecorder) SyncPeer(address any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncPeer", reflect.TypeOf((*MockSyncer)(nil).SyncPeer), address)
}

// MockEnqueuer is a mock of Enqueuer interface.
type MockEnqueuer struct {
	ctrl     *gomock.Controller
	recorder *MockEnqueuerMockRecorder
	isgomock struct{}
}

// MockEnqueuerMockRecorder is the mock recorder for MockEnqueuer.
type MockEnqueuerMockRecorder struct {
	mock *MockEnqueuer
}

// NewMockEnqueuer creates a new mock instance.
func NewMockEnqueuer(ctrl *gomock.Controller) *MockEnqueuer {
	mock := &MockEnqueuer{ctrl: ctrl}
	mock.recorder = &MockEnqueuerMockRecorder{mock}
	return mock
}

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

// Enqueue mocks base method.
func (m *MockEnqueuer) Enqueue(id string, block *types.Block) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Enqueue", id, block)
}

// Enqueue indicates an expected call of Enqueue.
func (mr *MockEnqueuerMockRecorder) Enqueue(id, block any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Enqueue", reflect.TypeOf((*MockEnqueuer)(nil).Enqueue), id, block)
}

// MockBroadcaster is a mock of Broadcaster interface.
type MockBroadcaster struct {
	ctrl     *gomock.Controller
	recorder *MockBroadcasterMockRecorder
	isgomock struct{}
}

// MockBroadcasterMockRecorder is the mock recorder for MockBroadcaster.
type MockBroadcasterMockRecorder struct {
	mock *MockBroadcaster
}

// NewMockBroadcaster creates a new mock instance.
func NewMockBroadcaster(ctrl *gomock.Controller) *MockBroadcaster {
	mock := &MockBroadcaster{ctrl: ctrl}
	mock.recorder = &MockBroadcasterMockRecorder{mock}
	return mock
}

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

// CommitteeEnodes mocks base method.
func (m *MockBroadcaster) CommitteeEnodes() []*enode.Node {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CommitteeEnodes")
	ret0, _ := ret[0].([]*enode.Node)
	return ret0
}

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

// FindPeer mocks base method.
func (m *MockBroadcaster) FindPeer(arg0 common.Address) (Peer, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindPeer", arg0)
	ret0, _ := ret[0].(Peer)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// FindPeer indicates an expected call of FindPeer.
func (mr *MockBroadcasterMockRecorder) FindPeer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindPeer", reflect.TypeOf((*MockBroadcaster)(nil).FindPeer), arg0)
}

// FindPeers mocks base method.
func (m *MockBroadcaster) FindPeers(arg0 []common.Address) map[common.Address]Peer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindPeers", arg0)
	ret0, _ := ret[0].(map[common.Address]Peer)
	return ret0
}

// FindPeers indicates an expected call of FindPeers.
func (mr *MockBroadcasterMockRecorder) FindPeers(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindPeers", reflect.TypeOf((*MockBroadcaster)(nil).FindPeers), arg0)
}

// MockPeer is a mock of Peer interface.
type MockPeer struct {
	ctrl     *gomock.Controller
	recorder *MockPeerMockRecorder
	isgomock struct{}
}

// MockPeerMockRecorder is the mock recorder for MockPeer.
type MockPeerMockRecorder struct {
	mock *MockPeer
}

// NewMockPeer creates a new mock instance.
func NewMockPeer(ctrl *gomock.Controller) *MockPeer {
	mock := &MockPeer{ctrl: ctrl}
	mock.recorder = &MockPeerMockRecorder{mock}
	return mock
}

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

// Cache mocks base method.
func (m *MockPeer) Cache() *fixsizecache.Cache[common.Hash, bool] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Cache")
	ret0, _ := ret[0].(*fixsizecache.Cache[common.Hash, bool])
	return ret0
}

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

// Send mocks base method.
func (m *MockPeer) Send(msgcode uint64, data any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", msgcode, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockPeerMockRecorder) Send(msgcode, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockPeer)(nil).Send), msgcode, data)
}

// SendRaw mocks base method.
func (m *MockPeer) SendRaw(msgcode uint64, data []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendRaw", msgcode, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendRaw indicates an expected call of SendRaw.
func (mr *MockPeerMockRecorder) SendRaw(msgcode, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendRaw", reflect.TypeOf((*MockPeer)(nil).SendRaw), msgcode, data)
}
