// Code generated by MockGen. DO NOT EDIT.
// Source: consensus/tendermint/core/interfaces/core_backend.go
//
// Generated by this command:
//
//	mockgen -source=consensus/tendermint/core/interfaces/core_backend.go -package=interfaces -destination=consensus/tendermint/core/interfaces/core_backend_mock.go
//

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

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

	abi "github.com/autonity/autonity/accounts/abi"
	autonity "github.com/autonity/autonity/autonity"
	common "github.com/autonity/autonity/common"
	message "github.com/autonity/autonity/consensus/tendermint/core/message"
	events "github.com/autonity/autonity/consensus/tendermint/events"
	interfaces "github.com/autonity/autonity/consensus/tendermint/router/interfaces"
	ping "github.com/autonity/autonity/consensus/tendermint/router/ping"
	core "github.com/autonity/autonity/core"
	types "github.com/autonity/autonity/core/types"
	blst "github.com/autonity/autonity/crypto/blst"
	event "github.com/autonity/autonity/event"
	log "github.com/autonity/autonity/log"
	gomock "go.uber.org/mock/gomock"
)

// MockBackend is a mock of Backend interface.
type MockBackend struct {
	ctrl     *gomock.Controller
	recorder *MockBackendMockRecorder
	isgomock struct{}
}

// MockBackendMockRecorder is the mock recorder for MockBackend.
type MockBackendMockRecorder struct {
	mock *MockBackend
}

// NewMockBackend creates a new mock instance.
func NewMockBackend(ctrl *gomock.Controller) *MockBackend {
	mock := &MockBackend{ctrl: ctrl}
	mock.recorder = &MockBackendMockRecorder{mock}
	return mock
}

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

// AddSeal mocks base method.
func (m *MockBackend) AddSeal(block *types.Block) (*types.Block, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddSeal", block)
	ret0, _ := ret[0].(*types.Block)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// AskSync mocks base method.
func (m *MockBackend) AskSync(committee *types.Committee, syncMsg *message.AskSyncMsg) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AskSync", committee, syncMsg)
	ret0, _ := ret[0].(error)
	return ret0
}

// AskSync indicates an expected call of AskSync.
func (mr *MockBackendMockRecorder) AskSync(committee, syncMsg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AskSync", reflect.TypeOf((*MockBackend)(nil).AskSync), committee, syncMsg)
}

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

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

// Broadcast mocks base method.
func (m *MockBackend) Broadcast(committee *types.Committee, arg1 message.Msg) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Broadcast", committee, arg1)
}

// Broadcast indicates an expected call of Broadcast.
func (mr *MockBackendMockRecorder) Broadcast(committee, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Broadcast", reflect.TypeOf((*MockBackend)(nil).Broadcast), committee, arg1)
}

// Commit mocks base method.
func (m *MockBackend) Commit(proposalBlock *types.Block, round int64, quorumCertificate *types.AggregateSignature) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Commit", proposalBlock, round, quorumCertificate)
	ret0, _ := ret[0].(error)
	return ret0
}

// Commit indicates an expected call of Commit.
func (mr *MockBackendMockRecorder) Commit(proposalBlock, round, quorumCertificate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockBackend)(nil).Commit), proposalBlock, round, quorumCertificate)
}

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

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

// DispatchToCore mocks base method.
func (m *MockBackend) DispatchToCore(ev any) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DispatchToCore", ev)
}

// DispatchToCore indicates an expected call of DispatchToCore.
func (mr *MockBackendMockRecorder) DispatchToCore(ev any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DispatchToCore", reflect.TypeOf((*MockBackend)(nil).DispatchToCore), ev)
}

// DispatchToFD mocks base method.
func (m *MockBackend) DispatchToFD(ev any) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DispatchToFD", ev)
}

// DispatchToFD indicates an expected call of DispatchToFD.
func (mr *MockBackendMockRecorder) DispatchToFD(ev any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DispatchToFD", reflect.TypeOf((*MockBackend)(nil).DispatchToFD), ev)
}

// EpochByHeight mocks base method.
func (m *MockBackend) 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 *MockBackendMockRecorder) EpochByHeight(height any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EpochByHeight", reflect.TypeOf((*MockBackend)(nil).EpochByHeight), height)
}

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

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

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

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

// Gossip mocks base method.
func (m *MockBackend) Gossip(committee *types.Committee, arg1 message.Msg, sender common.Address) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Gossip", committee, arg1, sender)
}

// Gossip indicates an expected call of Gossip.
func (mr *MockBackendMockRecorder) Gossip(committee, arg1, sender any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Gossip", reflect.TypeOf((*MockBackend)(nil).Gossip), committee, arg1, sender)
}

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

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

// HandleUnhandledMsgs mocks base method.
func (m *MockBackend) HandleUnhandledMsgs(ctx context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "HandleUnhandledMsgs", ctx)
}

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

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

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

// IsJailed mocks base method.
func (m *MockBackend) IsJailed(address common.Address) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsJailed", address)
	ret0, _ := ret[0].(bool)
	return ret0
}

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

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

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

// Jail mocks base method.
func (m *MockBackend) Jail(offender common.Address) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Jail", offender)
}

// Jail indicates an expected call of Jail.
func (mr *MockBackendMockRecorder) Jail(offender any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Jail", reflect.TypeOf((*MockBackend)(nil).Jail), offender)
}

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

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

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

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

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

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

// MessageCh mocks base method.
func (m *MockBackend) MessageCh() <-chan events.UnverifiedMessageEvent {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MessageCh")
	ret0, _ := ret[0].(<-chan events.UnverifiedMessageEvent)
	return ret0
}

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

// MinNonExpiredHeight mocks base method.
func (m *MockBackend) MinNonExpiredHeight(coreHeight uint64) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MinNonExpiredHeight", coreHeight)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MinNonExpiredHeight indicates an expected call of MinNonExpiredHeight.
func (mr *MockBackendMockRecorder) MinNonExpiredHeight(coreHeight any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MinNonExpiredHeight", reflect.TypeOf((*MockBackend)(nil).MinNonExpiredHeight), coreHeight)
}

// Post mocks base method.
func (m *MockBackend) Post(ev any) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Post", ev)
}

// Post indicates an expected call of Post.
func (mr *MockBackendMockRecorder) Post(ev any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Post", reflect.TypeOf((*MockBackend)(nil).Post), ev)
}

// ProcessFutureMsgs mocks base method.
func (m *MockBackend) ProcessFutureMsgs(height uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ProcessFutureMsgs", height)
}

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

// ProposalVerified mocks base method.
func (m *MockBackend) ProposalVerified(block *types.Block) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ProposalVerified", block)
}

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

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

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

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

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

// SetBlockchain mocks base method.
func (m *MockBackend) SetBlockchain(bc *core.BlockChain) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBlockchain", bc)
}

// SetBlockchain indicates an expected call of SetBlockchain.
func (mr *MockBackendMockRecorder) SetBlockchain(bc any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBlockchain", reflect.TypeOf((*MockBackend)(nil).SetBlockchain), bc)
}

// SetProposedBlockHash mocks base method.
func (m *MockBackend) SetProposedBlockHash(hash common.Hash) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetProposedBlockHash", hash)
}

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

// Sign mocks base method.
func (m *MockBackend) Sign(hash common.Hash) blst.Signature {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Sign", hash)
	ret0, _ := ret[0].(blst.Signature)
	return ret0
}

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

// SlowGossip mocks base method.
func (m *MockBackend) SlowGossip(committee *types.Committee, arg1 message.Msg, sender common.Address) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SlowGossip", committee, arg1, sender)
}

// SlowGossip indicates an expected call of SlowGossip.
func (mr *MockBackendMockRecorder) SlowGossip(committee, arg1, sender any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlowGossip", reflect.TypeOf((*MockBackend)(nil).SlowGossip), committee, arg1, sender)
}

// Subscribe mocks base method.
func (m *MockBackend) Subscribe(arg0 ...any) *event.TypeMuxSubscription {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Subscribe", varargs...)
	ret0, _ := ret[0].(*event.TypeMuxSubscription)
	return ret0
}

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

// VerifyProposal mocks base method.
func (m *MockBackend) VerifyProposal(arg0 *types.Block) (time.Duration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyProposal", arg0)
	ret0, _ := ret[0].(time.Duration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockCore is a mock of Core interface.
type MockCore struct {
	ctrl     *gomock.Controller
	recorder *MockCoreMockRecorder
	isgomock struct{}
}

// MockCoreMockRecorder is the mock recorder for MockCore.
type MockCoreMockRecorder struct {
	mock *MockCore
}

// NewMockCore creates a new mock instance.
func NewMockCore(ctrl *gomock.Controller) *MockCore {
	mock := &MockCore{ctrl: ctrl}
	mock.recorder = &MockCoreMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Start mocks base method.
func (m *MockCore) Start(ctx context.Context, contract *autonity.ProtocolContracts) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Start", ctx, contract)
}

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

// Stop mocks base method.
func (m *MockCore) Stop() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Stop")
}

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

// MockRouter is a mock of Router interface.
type MockRouter struct {
	ctrl     *gomock.Controller
	recorder *MockRouterMockRecorder
	isgomock struct{}
}

// MockRouterMockRecorder is the mock recorder for MockRouter.
type MockRouterMockRecorder struct {
	mock *MockRouter
}

// NewMockRouter creates a new mock instance.
func NewMockRouter(ctrl *gomock.Controller) *MockRouter {
	mock := &MockRouter{ctrl: ctrl}
	mock.recorder = &MockRouterMockRecorder{mock}
	return mock
}

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

// Forward mocks base method.
func (m_2 *MockRouter) Forward(committee *types.Committee, m message.Msg, sender common.Address, recipients []common.Address) {
	m_2.ctrl.T.Helper()
	m_2.ctrl.Call(m_2, "Forward", committee, m, sender, recipients)
}

// Forward indicates an expected call of Forward.
func (mr *MockRouterMockRecorder) Forward(committee, m, sender, recipients any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Forward", reflect.TypeOf((*MockRouter)(nil).Forward), committee, m, sender, recipients)
}

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

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

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

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

// SetBroadcaster mocks base method.
func (m *MockRouter) SetBroadcaster(broadcaster interfaces.PeerFinder) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBroadcaster", broadcaster)
}

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

// SetPinger mocks base method.
func (m *MockRouter) SetPinger(arg0 ping.Pinger) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPinger", arg0)
}

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

// SetSelector mocks base method.
func (m *MockRouter) SetSelector(arg0 interfaces.PeerSelector) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSelector", arg0)
}

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

// Start mocks base method.
func (m *MockRouter) Start(ctx context.Context, chain interfaces.BlockChainProvider) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Start", ctx, chain)
}

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

// Stop mocks base method.
func (m *MockRouter) Stop() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Stop")
}

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

// MockEventDispatcher is a mock of EventDispatcher interface.
type MockEventDispatcher struct {
	ctrl     *gomock.Controller
	recorder *MockEventDispatcherMockRecorder
	isgomock struct{}
}

// MockEventDispatcherMockRecorder is the mock recorder for MockEventDispatcher.
type MockEventDispatcherMockRecorder struct {
	mock *MockEventDispatcher
}

// NewMockEventDispatcher creates a new mock instance.
func NewMockEventDispatcher(ctrl *gomock.Controller) *MockEventDispatcher {
	mock := &MockEventDispatcher{ctrl: ctrl}
	mock.recorder = &MockEventDispatcherMockRecorder{mock}
	return mock
}

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

// Post mocks base method.
func (m *MockEventDispatcher) Post(ev any) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Post", ev)
}

// Post indicates an expected call of Post.
func (mr *MockEventDispatcherMockRecorder) Post(ev any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Post", reflect.TypeOf((*MockEventDispatcher)(nil).Post), ev)
}
