func (mr *MockTxPoolMockRecorder) SubscribeNewTxsNotify(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeNewTxsNotify", reflect.TypeOf((*MockTxPool)(nil).SubscribeNewTxsNotify), arg0)
}
SubscribeNewTxsNotify indicates an expected call of SubscribeNewTxsNotify
package mock
import (
	evmcore "github.com/Fantom-foundation/go-opera/evmcore"
	inter "github.com/Fantom-foundation/go-opera/inter"
	validatorpk "github.com/Fantom-foundation/go-opera/inter/validatorpk"
	opera "github.com/Fantom-foundation/go-opera/opera"
	vecmt "github.com/Fantom-foundation/go-opera/vecmt"
	hash "github.com/Fantom-foundation/lachesis-base/hash"
	idx "github.com/Fantom-foundation/lachesis-base/inter/idx"
	pos "github.com/Fantom-foundation/lachesis-base/inter/pos"
	common "github.com/ethereum/go-ethereum/common"
	types "github.com/ethereum/go-ethereum/core/types"
	event "github.com/ethereum/go-ethereum/event"
	gomock "github.com/golang/mock/gomock"
	big "math/big"
	reflect "reflect"
)
type MockExternal struct {
	ctrl     *gomock.Controller
	recorder *MockExternalMockRecorder
}
type MockExternalMockRecorder struct {
	mock *MockExternal
}
func NewMockExternal(ctrl *gomock.Controller) *MockExternal {
	mock := &MockExternal{ctrl: ctrl}
	mock.recorder = &MockExternalMockRecorder{mock}
	return mock
}
func (m *MockExternal) EXPECT() *MockExternalMockRecorder {
	return m.recorder
}
func (m *MockExternal) Broadcast(arg0 *inter.EventPayload) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Broadcast", arg0)
}
func (mr *MockExternalMockRecorder) Broadcast(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Broadcast", reflect.TypeOf((*MockExternal)(nil).Broadcast), arg0)
}
func (m *MockExternal) Build(arg0 *inter.MutableEventPayload, arg1 func()) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Build", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExternalMockRecorder) Build(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Build", reflect.TypeOf((*MockExternal)(nil).Build), arg0, arg1)
}
func (m *MockExternal) Check(arg0 *inter.EventPayload, arg1 inter.Events) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Check", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExternalMockRecorder) Check(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Check", reflect.TypeOf((*MockExternal)(nil).Check), arg0, arg1)
}
func (m *MockExternal) DagIndex() *vecmt.Index {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DagIndex")
	ret0, _ := ret[0].(*vecmt.Index)
	return ret0
}
func (mr *MockExternalMockRecorder) DagIndex() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DagIndex", reflect.TypeOf((*MockExternal)(nil).DagIndex))
}
func (m *MockExternal) GetEpochValidators() (*pos.Validators, idx.Epoch) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEpochValidators")
	ret0, _ := ret[0].(*pos.Validators)
	ret1, _ := ret[1].(idx.Epoch)
	return ret0, ret1
}
func (mr *MockExternalMockRecorder) GetEpochValidators() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEpochValidators", reflect.TypeOf((*MockExternal)(nil).GetEpochValidators))
}
func (m *MockExternal) GetEvent(arg0 hash.Event) *inter.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEvent", arg0)
	ret0, _ := ret[0].(*inter.Event)
	return ret0
}
func (mr *MockExternalMockRecorder) GetEvent(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEvent", reflect.TypeOf((*MockExternal)(nil).GetEvent), arg0)
}
func (m *MockExternal) GetEventPayload(arg0 hash.Event) *inter.EventPayload {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEventPayload", arg0)
	ret0, _ := ret[0].(*inter.EventPayload)
	return ret0
}
func (mr *MockExternalMockRecorder) GetEventPayload(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventPayload", reflect.TypeOf((*MockExternal)(nil).GetEventPayload), arg0)
}
func (m *MockExternal) GetGenesisTime() inter.Timestamp {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGenesisTime")
	ret0, _ := ret[0].(inter.Timestamp)
	return ret0
}
func (mr *MockExternalMockRecorder) GetGenesisTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGenesisTime", reflect.TypeOf((*MockExternal)(nil).GetGenesisTime))
}
func (m *MockExternal) GetHeads(arg0 idx.Epoch) hash.Events {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHeads", arg0)
	ret0, _ := ret[0].(hash.Events)
	return ret0
}
func (mr *MockExternalMockRecorder) GetHeads(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHeads", reflect.TypeOf((*MockExternal)(nil).GetHeads), arg0)
}
func (m *MockExternal) GetLastEvent(arg0 idx.Epoch, arg1 idx.ValidatorID) *hash.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLastEvent", arg0, arg1)
	ret0, _ := ret[0].(*hash.Event)
	return ret0
}
func (mr *MockExternalMockRecorder) GetLastEvent(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastEvent", reflect.TypeOf((*MockExternal)(nil).GetLastEvent), arg0, arg1)
}
func (m *MockExternal) GetLatestBlockIndex() idx.Block {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestBlockIndex")
	ret0, _ := ret[0].(idx.Block)
	return ret0
}
func (mr *MockExternalMockRecorder) GetLatestBlockIndex() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestBlockIndex", reflect.TypeOf((*MockExternal)(nil).GetLatestBlockIndex))
}
func (m *MockExternal) GetRecommendedGasPrice() *big.Int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRecommendedGasPrice")
	ret0, _ := ret[0].(*big.Int)
	return ret0
}
func (mr *MockExternalMockRecorder) GetRecommendedGasPrice() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecommendedGasPrice", reflect.TypeOf((*MockExternal)(nil).GetRecommendedGasPrice))
}
func (m *MockExternal) GetRules() opera.Rules {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRules")
	ret0, _ := ret[0].(opera.Rules)
	return ret0
}
func (mr *MockExternalMockRecorder) GetRules() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRules", reflect.TypeOf((*MockExternal)(nil).GetRules))
}
func (m *MockExternal) IsBusy() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsBusy")
	ret0, _ := ret[0].(bool)
	return ret0
}
func (mr *MockExternalMockRecorder) IsBusy() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsBusy", reflect.TypeOf((*MockExternal)(nil).IsBusy))
}
func (m *MockExternal) IsSynced() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsSynced")
	ret0, _ := ret[0].(bool)
	return ret0
}
func (mr *MockExternalMockRecorder) IsSynced() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSynced", reflect.TypeOf((*MockExternal)(nil).IsSynced))
}
func (m *MockExternal) Lock() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Lock")
}
func (mr *MockExternalMockRecorder) Lock() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lock", reflect.TypeOf((*MockExternal)(nil).Lock))
}
func (m *MockExternal) PeersNum() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PeersNum")
	ret0, _ := ret[0].(int)
	return ret0
}
func (mr *MockExternalMockRecorder) PeersNum() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeersNum", reflect.TypeOf((*MockExternal)(nil).PeersNum))
}
func (m *MockExternal) Process(arg0 *inter.EventPayload) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Process", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExternalMockRecorder) Process(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Process", reflect.TypeOf((*MockExternal)(nil).Process), arg0)
}
func (m *MockExternal) Unlock() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Unlock")
}
func (mr *MockExternalMockRecorder) Unlock() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlock", reflect.TypeOf((*MockExternal)(nil).Unlock))
}
type MockTxPool struct {
	ctrl     *gomock.Controller
	recorder *MockTxPoolMockRecorder
}
type MockTxPoolMockRecorder struct {
	mock *MockTxPool
}
func NewMockTxPool(ctrl *gomock.Controller) *MockTxPool {
	mock := &MockTxPool{ctrl: ctrl}
	mock.recorder = &MockTxPoolMockRecorder{mock}
	return mock
}
func (m *MockTxPool) EXPECT() *MockTxPoolMockRecorder {
	return m.recorder
}
func (m *MockTxPool) Count() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Count")
	ret0, _ := ret[0].(int)
	return ret0
}
func (mr *MockTxPoolMockRecorder) Count() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockTxPool)(nil).Count))
}
func (m *MockTxPool) Has(arg0 common.Hash) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Has", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}
func (mr *MockTxPoolMockRecorder) Has(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockTxPool)(nil).Has), arg0)
}
func (m *MockTxPool) Pending() (map[common.Address]types.Transactions, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Pending")
	ret0, _ := ret[0].(map[common.Address]types.Transactions)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockTxPoolMockRecorder) Pending() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pending", reflect.TypeOf((*MockTxPool)(nil).Pending))
}
func (m *MockTxPool) SubscribeNewTxsNotify(arg0 chan<- evmcore.NewTxsNotify) event.Subscription {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeNewTxsNotify", arg0)
	ret0, _ := ret[0].(event.Subscription)
	return ret0
}