// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/ChainSafe/gossamer/dot/sync (interfaces: Telemetry,StorageState,TransactionState,BabeVerifier,FinalityGadget,BlockImportHandler,Network,WarpSyncProofProvider)
//
// Generated by this command:
//
//	mockgen -destination=mocks_test.go -package=sync . Telemetry,StorageState,TransactionState,BabeVerifier,FinalityGadget,BlockImportHandler,Network,WarpSyncProofProvider
//

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

import (
	json "encoding/json"
	reflect "reflect"
	time "time"

	network "github.com/ChainSafe/gossamer/dot/network"
	peerset "github.com/ChainSafe/gossamer/dot/peerset"
	types "github.com/ChainSafe/gossamer/dot/types"
	grandpa "github.com/ChainSafe/gossamer/internal/primitives/consensus/grandpa"
	common "github.com/ChainSafe/gossamer/lib/common"
	warpsync "github.com/ChainSafe/gossamer/lib/grandpa/warpsync"
	storage "github.com/ChainSafe/gossamer/lib/runtime/storage"
	peer "github.com/libp2p/go-libp2p/core/peer"
	gomock "go.uber.org/mock/gomock"
)

// MockTelemetry is a mock of Telemetry interface.
type MockTelemetry struct {
	ctrl     *gomock.Controller
	recorder *MockTelemetryMockRecorder
	isgomock struct{}
}

// MockTelemetryMockRecorder is the mock recorder for MockTelemetry.
type MockTelemetryMockRecorder struct {
	mock *MockTelemetry
}

// NewMockTelemetry creates a new mock instance.
func NewMockTelemetry(ctrl *gomock.Controller) *MockTelemetry {
	mock := &MockTelemetry{ctrl: ctrl}
	mock.recorder = &MockTelemetryMockRecorder{mock}
	return mock
}

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

// SendMessage mocks base method.
func (m *MockTelemetry) SendMessage(msg json.Marshaler) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendMessage", msg)
}

// SendMessage indicates an expected call of SendMessage.
func (mr *MockTelemetryMockRecorder) SendMessage(msg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockTelemetry)(nil).SendMessage), msg)
}

// MockStorageState is a mock of StorageState interface.
type MockStorageState struct {
	ctrl     *gomock.Controller
	recorder *MockStorageStateMockRecorder
	isgomock struct{}
}

// MockStorageStateMockRecorder is the mock recorder for MockStorageState.
type MockStorageStateMockRecorder struct {
	mock *MockStorageState
}

// NewMockStorageState creates a new mock instance.
func NewMockStorageState(ctrl *gomock.Controller) *MockStorageState {
	mock := &MockStorageState{ctrl: ctrl}
	mock.recorder = &MockStorageStateMockRecorder{mock}
	return mock
}

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

// LoadCodeHash mocks base method.
func (m *MockStorageState) LoadCodeHash(hash *common.Hash) (common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadCodeHash", hash)
	ret0, _ := ret[0].(common.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// StoreTrie mocks base method.
func (m *MockStorageState) StoreTrie(ts storage.TrieState, header *types.Header) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StoreTrie", ts, header)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// TrieState mocks base method.
func (m *MockStorageState) TrieState(root *common.Hash) (storage.TrieState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TrieState", root)
	ret0, _ := ret[0].(storage.TrieState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TrieState indicates an expected call of TrieState.
func (mr *MockStorageStateMockRecorder) TrieState(root any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TrieState", reflect.TypeOf((*MockStorageState)(nil).TrieState), root)
}

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

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

// MockTransactionState is a mock of TransactionState interface.
type MockTransactionState struct {
	ctrl     *gomock.Controller
	recorder *MockTransactionStateMockRecorder
	isgomock struct{}
}

// MockTransactionStateMockRecorder is the mock recorder for MockTransactionState.
type MockTransactionStateMockRecorder struct {
	mock *MockTransactionState
}

// NewMockTransactionState creates a new mock instance.
func NewMockTransactionState(ctrl *gomock.Controller) *MockTransactionState {
	mock := &MockTransactionState{ctrl: ctrl}
	mock.recorder = &MockTransactionStateMockRecorder{mock}
	return mock
}

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

// RemoveExtrinsic mocks base method.
func (m *MockTransactionState) RemoveExtrinsic(ext types.Extrinsic) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RemoveExtrinsic", ext)
}

// RemoveExtrinsic indicates an expected call of RemoveExtrinsic.
func (mr *MockTransactionStateMockRecorder) RemoveExtrinsic(ext any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveExtrinsic", reflect.TypeOf((*MockTransactionState)(nil).RemoveExtrinsic), ext)
}

// MockBabeVerifier is a mock of BabeVerifier interface.
type MockBabeVerifier struct {
	ctrl     *gomock.Controller
	recorder *MockBabeVerifierMockRecorder
	isgomock struct{}
}

// MockBabeVerifierMockRecorder is the mock recorder for MockBabeVerifier.
type MockBabeVerifierMockRecorder struct {
	mock *MockBabeVerifier
}

// NewMockBabeVerifier creates a new mock instance.
func NewMockBabeVerifier(ctrl *gomock.Controller) *MockBabeVerifier {
	mock := &MockBabeVerifier{ctrl: ctrl}
	mock.recorder = &MockBabeVerifierMockRecorder{mock}
	return mock
}

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

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

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

// MockFinalityGadget is a mock of FinalityGadget interface.
type MockFinalityGadget struct {
	ctrl     *gomock.Controller
	recorder *MockFinalityGadgetMockRecorder
	isgomock struct{}
}

// MockFinalityGadgetMockRecorder is the mock recorder for MockFinalityGadget.
type MockFinalityGadgetMockRecorder struct {
	mock *MockFinalityGadget
}

// NewMockFinalityGadget creates a new mock instance.
func NewMockFinalityGadget(ctrl *gomock.Controller) *MockFinalityGadget {
	mock := &MockFinalityGadget{ctrl: ctrl}
	mock.recorder = &MockFinalityGadgetMockRecorder{mock}
	return mock
}

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

// VerifyBlockJustification mocks base method.
func (m *MockFinalityGadget) VerifyBlockJustification(arg0 common.Hash, arg1 uint, arg2 []byte) (uint64, uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyBlockJustification", arg0, arg1, arg2)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(uint64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// VerifyBlockJustification indicates an expected call of VerifyBlockJustification.
func (mr *MockFinalityGadgetMockRecorder) VerifyBlockJustification(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyBlockJustification", reflect.TypeOf((*MockFinalityGadget)(nil).VerifyBlockJustification), arg0, arg1, arg2)
}

// MockBlockImportHandler is a mock of BlockImportHandler interface.
type MockBlockImportHandler struct {
	ctrl     *gomock.Controller
	recorder *MockBlockImportHandlerMockRecorder
	isgomock struct{}
}

// MockBlockImportHandlerMockRecorder is the mock recorder for MockBlockImportHandler.
type MockBlockImportHandlerMockRecorder struct {
	mock *MockBlockImportHandler
}

// NewMockBlockImportHandler creates a new mock instance.
func NewMockBlockImportHandler(ctrl *gomock.Controller) *MockBlockImportHandler {
	mock := &MockBlockImportHandler{ctrl: ctrl}
	mock.recorder = &MockBlockImportHandlerMockRecorder{mock}
	return mock
}

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

// HandleBlockImport mocks base method.
func (m *MockBlockImportHandler) HandleBlockImport(block *types.Block, state storage.TrieState, announce bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleBlockImport", block, state, announce)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleBlockImport indicates an expected call of HandleBlockImport.
func (mr *MockBlockImportHandlerMockRecorder) HandleBlockImport(block, state, announce any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleBlockImport", reflect.TypeOf((*MockBlockImportHandler)(nil).HandleBlockImport), block, state, announce)
}

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

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

// MockNetwork is a mock of Network interface.
type MockNetwork struct {
	ctrl     *gomock.Controller
	recorder *MockNetworkMockRecorder
	isgomock struct{}
}

// MockNetworkMockRecorder is the mock recorder for MockNetwork.
type MockNetworkMockRecorder struct {
	mock *MockNetwork
}

// NewMockNetwork creates a new mock instance.
func NewMockNetwork(ctrl *gomock.Controller) *MockNetwork {
	mock := &MockNetwork{ctrl: ctrl}
	mock.recorder = &MockNetworkMockRecorder{mock}
	return mock
}

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

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

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

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

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

// GetRequestResponseProtocol mocks base method.
func (m *MockNetwork) GetRequestResponseProtocol(subprotocol string, requestTimeout time.Duration, maxResponseSize uint64) *network.RequestResponseProtocol {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRequestResponseProtocol", subprotocol, requestTimeout, maxResponseSize)
	ret0, _ := ret[0].(*network.RequestResponseProtocol)
	return ret0
}

// GetRequestResponseProtocol indicates an expected call of GetRequestResponseProtocol.
func (mr *MockNetworkMockRecorder) GetRequestResponseProtocol(subprotocol, requestTimeout, maxResponseSize any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRequestResponseProtocol", reflect.TypeOf((*MockNetwork)(nil).GetRequestResponseProtocol), subprotocol, requestTimeout, maxResponseSize)
}

// GossipMessageExcluding mocks base method.
func (m *MockNetwork) GossipMessageExcluding(arg0 network.NotificationsMessage, arg1 peer.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "GossipMessageExcluding", arg0, arg1)
}

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

// ReportPeer mocks base method.
func (m *MockNetwork) ReportPeer(change peerset.ReputationChange, p peer.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReportPeer", change, p)
}

// ReportPeer indicates an expected call of ReportPeer.
func (mr *MockNetworkMockRecorder) ReportPeer(change, p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportPeer", reflect.TypeOf((*MockNetwork)(nil).ReportPeer), change, p)
}

// MockWarpSyncProofProvider is a mock of WarpSyncProofProvider interface.
type MockWarpSyncProofProvider struct {
	ctrl     *gomock.Controller
	recorder *MockWarpSyncProofProviderMockRecorder
	isgomock struct{}
}

// MockWarpSyncProofProviderMockRecorder is the mock recorder for MockWarpSyncProofProvider.
type MockWarpSyncProofProviderMockRecorder struct {
	mock *MockWarpSyncProofProvider
}

// NewMockWarpSyncProofProvider creates a new mock instance.
func NewMockWarpSyncProofProvider(ctrl *gomock.Controller) *MockWarpSyncProofProvider {
	mock := &MockWarpSyncProofProvider{ctrl: ctrl}
	mock.recorder = &MockWarpSyncProofProviderMockRecorder{mock}
	return mock
}

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

// CurrentAuthorities mocks base method.
func (m *MockWarpSyncProofProvider) CurrentAuthorities() (grandpa.AuthorityList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CurrentAuthorities")
	ret0, _ := ret[0].(grandpa.AuthorityList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Verify mocks base method.
func (m *MockWarpSyncProofProvider) Verify(encodedProof []byte, setId grandpa.SetID, authorities grandpa.AuthorityList) (*warpsync.WarpSyncVerificationResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Verify", encodedProof, setId, authorities)
	ret0, _ := ret[0].(*warpsync.WarpSyncVerificationResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Verify indicates an expected call of Verify.
func (mr *MockWarpSyncProofProviderMockRecorder) Verify(encodedProof, setId, authorities any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Verify", reflect.TypeOf((*MockWarpSyncProofProvider)(nil).Verify), encodedProof, setId, authorities)
}
