// Copyright 2025 Sonic Operations Ltd
// This file is part of the Sonic Client
//
// Sonic is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Sonic is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Sonic. If not, see <http://www.gnu.org/licenses/>.

// Code generated by MockGen. DO NOT EDIT.
// Source: world.go
//
// Generated by this command:
//
//	mockgen -source=world.go -destination=world_mock.go -package=emitter External,TxPool,TxSigner,Signer
//

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

import (
	big "math/big"
	reflect "reflect"

	evmcore "github.com/0xsoniclabs/sonic/evmcore"
	inter "github.com/0xsoniclabs/sonic/inter"
	state "github.com/0xsoniclabs/sonic/inter/state"
	opera "github.com/0xsoniclabs/sonic/opera"
	vecmt "github.com/0xsoniclabs/sonic/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"
	gomock "go.uber.org/mock/gomock"
)

// MockExternal is a mock of External interface.
type MockExternal struct {
	ctrl     *gomock.Controller
	recorder *MockExternalMockRecorder
	isgomock struct{}
}

// MockExternalMockRecorder is the mock recorder for MockExternal.
type MockExternalMockRecorder struct {
	mock *MockExternal
}

// NewMockExternal creates a new mock instance.
func NewMockExternal(ctrl *gomock.Controller) *MockExternal {
	mock := &MockExternal{ctrl: ctrl}
	mock.recorder = &MockExternalMockRecorder{mock}
	return mock
}

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

// Broadcast mocks base method.
func (m *MockExternal) Broadcast(arg0 *inter.EventPayload) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Broadcast", arg0)
}

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

// Build mocks base method.
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
}

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

// Check mocks base method.
func (m *MockExternal) Check(e *inter.EventPayload, parents inter.Events) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Check", e, parents)
	ret0, _ := ret[0].(error)
	return ret0
}

// Check indicates an expected call of Check.
func (mr *MockExternalMockRecorder) Check(e, parents any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Check", reflect.TypeOf((*MockExternal)(nil).Check), e, parents)
}

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

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

// GetEpochValidators mocks base method.
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
}

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

// GetEvent mocks base method.
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
}

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

// GetEventPayload mocks base method.
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
}

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

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

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

// GetHeader mocks base method.
func (m *MockExternal) GetHeader(arg0 common.Hash, arg1 uint64) *evmcore.EvmHeader {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHeader", arg0, arg1)
	ret0, _ := ret[0].(*evmcore.EvmHeader)
	return ret0
}

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

// GetHeads mocks base method.
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
}

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

// GetLastEvent mocks base method.
func (m *MockExternal) GetLastEvent(epoch idx.Epoch, from idx.ValidatorID) *hash.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLastEvent", epoch, from)
	ret0, _ := ret[0].(*hash.Event)
	return ret0
}

// GetLastEvent indicates an expected call of GetLastEvent.
func (mr *MockExternalMockRecorder) GetLastEvent(epoch, from any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastEvent", reflect.TypeOf((*MockExternal)(nil).GetLastEvent), epoch, from)
}

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

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

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

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

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

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

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

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

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

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

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

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

// Lock indicates an expected call of 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))
}

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

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

// Process mocks base method.
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
}

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

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

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

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

// Unlock indicates an expected call of 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))
}

// MockTxSigner is a mock of TxSigner interface.
type MockTxSigner struct {
	ctrl     *gomock.Controller
	recorder *MockTxSignerMockRecorder
	isgomock struct{}
}

// MockTxSignerMockRecorder is the mock recorder for MockTxSigner.
type MockTxSignerMockRecorder struct {
	mock *MockTxSigner
}

// NewMockTxSigner creates a new mock instance.
func NewMockTxSigner(ctrl *gomock.Controller) *MockTxSigner {
	mock := &MockTxSigner{ctrl: ctrl}
	mock.recorder = &MockTxSignerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// Hash indicates an expected call of Hash.
func (mr *MockTxSignerMockRecorder) Hash(tx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Hash", reflect.TypeOf((*MockTxSigner)(nil).Hash), tx)
}

// Sender mocks base method.
func (m *MockTxSigner) Sender(tx *types.Transaction) (common.Address, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Sender", tx)
	ret0, _ := ret[0].(common.Address)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Sender indicates an expected call of Sender.
func (mr *MockTxSignerMockRecorder) Sender(tx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sender", reflect.TypeOf((*MockTxSigner)(nil).Sender), tx)
}

// SignatureValues mocks base method.
func (m *MockTxSigner) SignatureValues(tx *types.Transaction, sig []byte) (*big.Int, *big.Int, *big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignatureValues", tx, sig)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(*big.Int)
	ret2, _ := ret[2].(*big.Int)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// SignatureValues indicates an expected call of SignatureValues.
func (mr *MockTxSignerMockRecorder) SignatureValues(tx, sig any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignatureValues", reflect.TypeOf((*MockTxSigner)(nil).SignatureValues), tx, sig)
}

// MockReader is a mock of Reader interface.
type MockReader struct {
	ctrl     *gomock.Controller
	recorder *MockReaderMockRecorder
	isgomock struct{}
}

// MockReaderMockRecorder is the mock recorder for MockReader.
type MockReaderMockRecorder struct {
	mock *MockReader
}

// NewMockReader creates a new mock instance.
func NewMockReader(ctrl *gomock.Controller) *MockReader {
	mock := &MockReader{ctrl: ctrl}
	mock.recorder = &MockReaderMockRecorder{mock}
	return mock
}

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

// GetEpochValidators mocks base method.
func (m *MockReader) 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
}

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

// GetEvent mocks base method.
func (m *MockReader) GetEvent(arg0 hash.Event) *inter.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEvent", arg0)
	ret0, _ := ret[0].(*inter.Event)
	return ret0
}

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

// GetEventPayload mocks base method.
func (m *MockReader) GetEventPayload(arg0 hash.Event) *inter.EventPayload {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEventPayload", arg0)
	ret0, _ := ret[0].(*inter.EventPayload)
	return ret0
}

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

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

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

// GetHeads mocks base method.
func (m *MockReader) GetHeads(arg0 idx.Epoch) hash.Events {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHeads", arg0)
	ret0, _ := ret[0].(hash.Events)
	return ret0
}

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

// GetLastEvent mocks base method.
func (m *MockReader) GetLastEvent(epoch idx.Epoch, from idx.ValidatorID) *hash.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLastEvent", epoch, from)
	ret0, _ := ret[0].(*hash.Event)
	return ret0
}

// GetLastEvent indicates an expected call of GetLastEvent.
func (mr *MockReaderMockRecorder) GetLastEvent(epoch, from any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastEvent", reflect.TypeOf((*MockReader)(nil).GetLastEvent), epoch, from)
}

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

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

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

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

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

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

// MockTxPool is a mock of TxPool interface.
type MockTxPool struct {
	ctrl     *gomock.Controller
	recorder *MockTxPoolMockRecorder
	isgomock struct{}
}

// MockTxPoolMockRecorder is the mock recorder for MockTxPool.
type MockTxPoolMockRecorder struct {
	mock *MockTxPool
}

// NewMockTxPool creates a new mock instance.
func NewMockTxPool(ctrl *gomock.Controller) *MockTxPool {
	mock := &MockTxPool{ctrl: ctrl}
	mock.recorder = &MockTxPoolMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Pending mocks base method.
func (m *MockTxPool) Pending(enforceTips bool) (map[common.Address]types.Transactions, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Pending", enforceTips)
	ret0, _ := ret[0].(map[common.Address]types.Transactions)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Pending indicates an expected call of Pending.
func (mr *MockTxPoolMockRecorder) Pending(enforceTips any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pending", reflect.TypeOf((*MockTxPool)(nil).Pending), enforceTips)
}
