// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/ChainSafe/gossamer/dot/core (interfaces: TransactionState,Network,CodeSubstitutedState,Telemetry,BlockImportDigestHandler,GrandpaState)
//
// Generated by this command:
//
//	mockgen -destination=mocks_test.go -package core . TransactionState,Network,CodeSubstitutedState,Telemetry,BlockImportDigestHandler,GrandpaState
//

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

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

	network "github.com/ChainSafe/gossamer/dot/network"
	peerset "github.com/ChainSafe/gossamer/dot/peerset"
	types "github.com/ChainSafe/gossamer/dot/types"
	common "github.com/ChainSafe/gossamer/lib/common"
	transaction "github.com/ChainSafe/gossamer/lib/transaction"
	peer "github.com/libp2p/go-libp2p/core/peer"
	gomock "go.uber.org/mock/gomock"
)

// 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
}

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

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

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

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

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

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

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

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

// 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)
}

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

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

// 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
}

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

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

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

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

// 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)
}

// MockCodeSubstitutedState is a mock of CodeSubstitutedState interface.
type MockCodeSubstitutedState struct {
	ctrl     *gomock.Controller
	recorder *MockCodeSubstitutedStateMockRecorder
	isgomock struct{}
}

// MockCodeSubstitutedStateMockRecorder is the mock recorder for MockCodeSubstitutedState.
type MockCodeSubstitutedStateMockRecorder struct {
	mock *MockCodeSubstitutedState
}

// NewMockCodeSubstitutedState creates a new mock instance.
func NewMockCodeSubstitutedState(ctrl *gomock.Controller) *MockCodeSubstitutedState {
	mock := &MockCodeSubstitutedState{ctrl: ctrl}
	mock.recorder = &MockCodeSubstitutedStateMockRecorder{mock}
	return mock
}

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

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

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

// 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)
}

// MockBlockImportDigestHandler is a mock of BlockImportDigestHandler interface.
type MockBlockImportDigestHandler struct {
	ctrl     *gomock.Controller
	recorder *MockBlockImportDigestHandlerMockRecorder
	isgomock struct{}
}

// MockBlockImportDigestHandlerMockRecorder is the mock recorder for MockBlockImportDigestHandler.
type MockBlockImportDigestHandlerMockRecorder struct {
	mock *MockBlockImportDigestHandler
}

// NewMockBlockImportDigestHandler creates a new mock instance.
func NewMockBlockImportDigestHandler(ctrl *gomock.Controller) *MockBlockImportDigestHandler {
	mock := &MockBlockImportDigestHandler{ctrl: ctrl}
	mock.recorder = &MockBlockImportDigestHandlerMockRecorder{mock}
	return mock
}

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

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

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

// MockGrandpaState is a mock of GrandpaState interface.
type MockGrandpaState struct {
	ctrl     *gomock.Controller
	recorder *MockGrandpaStateMockRecorder
	isgomock struct{}
}

// MockGrandpaStateMockRecorder is the mock recorder for MockGrandpaState.
type MockGrandpaStateMockRecorder struct {
	mock *MockGrandpaState
}

// NewMockGrandpaState creates a new mock instance.
func NewMockGrandpaState(ctrl *gomock.Controller) *MockGrandpaState {
	mock := &MockGrandpaState{ctrl: ctrl}
	mock.recorder = &MockGrandpaStateMockRecorder{mock}
	return mock
}

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

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

// ApplyForcedChanges indicates an expected call of ApplyForcedChanges.
func (mr *MockGrandpaStateMockRecorder) ApplyForcedChanges(importedHeader any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyForcedChanges", reflect.TypeOf((*MockGrandpaState)(nil).ApplyForcedChanges), importedHeader)
}
