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

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

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

	gomock "github.com/golang/mock/gomock"
	common "github.com/simcord-llc/bitbon-system-blockchain/common"
	enode "github.com/simcord-llc/bitbon-system-blockchain/p2p/enode"
	snapshot "github.com/simcord-llc/bitbon-system-blockchain/quorum/snapshot"
)

// MockContractService is a mock of ContractService interface.
type MockContractService struct {
	ctrl     *gomock.Controller
	recorder *MockContractServiceMockRecorder
}

// MockContractServiceMockRecorder is the mock recorder for MockContractService.
type MockContractServiceMockRecorder struct {
	mock *MockContractService
}

// NewMockContractService creates a new mock instance.
func NewMockContractService(ctrl *gomock.Controller) *MockContractService {
	mock := &MockContractService{ctrl: ctrl}
	mock.recorder = &MockContractServiceMockRecorder{mock}
	return mock
}

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

// GetCurrentDistribution mocks base method.
func (m *MockContractService) GetCurrentDistribution(ctx context.Context) (map[common.Address]uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentDistribution", ctx)
	ret0, _ := ret[0].(map[common.Address]uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockP2PServer is a mock of P2PServer interface.
type MockP2PServer struct {
	ctrl     *gomock.Controller
	recorder *MockP2PServerMockRecorder
}

// MockP2PServerMockRecorder is the mock recorder for MockP2PServer.
type MockP2PServerMockRecorder struct {
	mock *MockP2PServer
}

// NewMockP2PServer creates a new mock instance.
func NewMockP2PServer(ctrl *gomock.Controller) *MockP2PServer {
	mock := &MockP2PServer{ctrl: ctrl}
	mock.recorder = &MockP2PServerMockRecorder{mock}
	return mock
}

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

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

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

// MockPeerListService is a mock of PeerListService interface.
type MockPeerListService struct {
	ctrl     *gomock.Controller
	recorder *MockPeerListServiceMockRecorder
}

// MockPeerListServiceMockRecorder is the mock recorder for MockPeerListService.
type MockPeerListServiceMockRecorder struct {
	mock *MockPeerListService
}

// NewMockPeerListService creates a new mock instance.
func NewMockPeerListService(ctrl *gomock.Controller) *MockPeerListService {
	mock := &MockPeerListService{ctrl: ctrl}
	mock.recorder = &MockPeerListServiceMockRecorder{mock}
	return mock
}

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

// AddPeer mocks base method.
func (m *MockPeerListService) AddPeer(p *Peer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddPeer", p)
}

// AddPeer indicates an expected call of AddPeer.
func (mr *MockPeerListServiceMockRecorder) AddPeer(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPeer", reflect.TypeOf((*MockPeerListService)(nil).AddPeer), p)
}

// GetSnapshotNodes mocks base method.
func (m *MockPeerListService) GetSnapshotNodes() ([]*snapshot.Node, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSnapshotNodes")
	ret0, _ := ret[0].([]*snapshot.Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MarkSelfIsMinerCandidate mocks base method.
func (m *MockPeerListService) MarkSelfIsMinerCandidate(in bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "MarkSelfIsMinerCandidate", in)
}

// MarkSelfIsMinerCandidate indicates an expected call of MarkSelfIsMinerCandidate.
func (mr *MockPeerListServiceMockRecorder) MarkSelfIsMinerCandidate(in interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkSelfIsMinerCandidate", reflect.TypeOf((*MockPeerListService)(nil).MarkSelfIsMinerCandidate), in)
}

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

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

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

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

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

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

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

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

// RemovePeer mocks base method.
func (m *MockPeerListService) RemovePeer(peerID enode.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RemovePeer", peerID)
}

// RemovePeer indicates an expected call of RemovePeer.
func (mr *MockPeerListServiceMockRecorder) RemovePeer(peerID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePeer", reflect.TypeOf((*MockPeerListService)(nil).RemovePeer), peerID)
}

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

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

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

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

// MockSnapshotService is a mock of SnapshotService interface.
type MockSnapshotService struct {
	ctrl     *gomock.Controller
	recorder *MockSnapshotServiceMockRecorder
}

// MockSnapshotServiceMockRecorder is the mock recorder for MockSnapshotService.
type MockSnapshotServiceMockRecorder struct {
	mock *MockSnapshotService
}

// NewMockSnapshotService creates a new mock instance.
func NewMockSnapshotService(ctrl *gomock.Controller) *MockSnapshotService {
	mock := &MockSnapshotService{ctrl: ctrl}
	mock.recorder = &MockSnapshotServiceMockRecorder{mock}
	return mock
}

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

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

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

// GetSnapshot mocks base method.
func (m *MockSnapshotService) GetSnapshot(epoch uint64) *snapshot.Snapshot {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSnapshot", epoch)
	ret0, _ := ret[0].(*snapshot.Snapshot)
	return ret0
}

// GetSnapshot indicates an expected call of GetSnapshot.
func (mr *MockSnapshotServiceMockRecorder) GetSnapshot(epoch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshot", reflect.TypeOf((*MockSnapshotService)(nil).GetSnapshot), epoch)
}

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

// MinerListAtEpoch indicates an expected call of MinerListAtEpoch.
func (mr *MockSnapshotServiceMockRecorder) MinerListAtEpoch(epoch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MinerListAtEpoch", reflect.TypeOf((*MockSnapshotService)(nil).MinerListAtEpoch), epoch)
}

// PrepareSnapshot mocks base method.
func (m *MockSnapshotService) PrepareSnapshot(epoch uint64) (*snapshot.Snapshot, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PrepareSnapshot", epoch)
	ret0, _ := ret[0].(*snapshot.Snapshot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PrepareSnapshot indicates an expected call of PrepareSnapshot.
func (mr *MockSnapshotServiceMockRecorder) PrepareSnapshot(epoch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareSnapshot", reflect.TypeOf((*MockSnapshotService)(nil).PrepareSnapshot), epoch)
}

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

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

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

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

// MockHandlers is a mock of Handlers interface.
type MockHandlers struct {
	ctrl     *gomock.Controller
	recorder *MockHandlersMockRecorder
}

// MockHandlersMockRecorder is the mock recorder for MockHandlers.
type MockHandlersMockRecorder struct {
	mock *MockHandlers
}

// NewMockHandlers creates a new mock instance.
func NewMockHandlers(ctrl *gomock.Controller) *MockHandlers {
	mock := &MockHandlers{ctrl: ctrl}
	mock.recorder = &MockHandlersMockRecorder{mock}
	return mock
}

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

// HandleMinersMsg mocks base method.
func (m *MockHandlers) HandleMinersMsg(msg *MinersMsg, peer *Peer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "HandleMinersMsg", msg, peer)
}

// HandleMinersMsg indicates an expected call of HandleMinersMsg.
func (mr *MockHandlersMockRecorder) HandleMinersMsg(msg, peer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMinersMsg", reflect.TypeOf((*MockHandlers)(nil).HandleMinersMsg), msg, peer)
}

// HandleNodeCandidateListMsg mocks base method.
func (m *MockHandlers) HandleNodeCandidateListMsg(msg *NodeCandidateListMsg, peer *Peer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "HandleNodeCandidateListMsg", msg, peer)
}

// HandleNodeCandidateListMsg indicates an expected call of HandleNodeCandidateListMsg.
func (mr *MockHandlersMockRecorder) HandleNodeCandidateListMsg(msg, peer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleNodeCandidateListMsg", reflect.TypeOf((*MockHandlers)(nil).HandleNodeCandidateListMsg), msg, peer)
}

// HandleVoteMinerAddMsg mocks base method.
func (m *MockHandlers) HandleVoteMinerAddMsg(peer *Peer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "HandleVoteMinerAddMsg", peer)
}

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

// HandleVoteMinerDelMsg mocks base method.
func (m *MockHandlers) HandleVoteMinerDelMsg(peer *Peer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "HandleVoteMinerDelMsg", peer)
}

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

// MockPingPeerService is a mock of PingPeerService interface.
type MockPingPeerService struct {
	ctrl     *gomock.Controller
	recorder *MockPingPeerServiceMockRecorder
}

// MockPingPeerServiceMockRecorder is the mock recorder for MockPingPeerService.
type MockPingPeerServiceMockRecorder struct {
	mock *MockPingPeerService
}

// NewMockPingPeerService creates a new mock instance.
func NewMockPingPeerService(ctrl *gomock.Controller) *MockPingPeerService {
	mock := &MockPingPeerService{ctrl: ctrl}
	mock.recorder = &MockPingPeerServiceMockRecorder{mock}
	return mock
}

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

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

// PingPong indicates an expected call of PingPong.
func (mr *MockPingPeerServiceMockRecorder) PingPong(timeout interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PingPong", reflect.TypeOf((*MockPingPeerService)(nil).PingPong), timeout)
}

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

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