// Code generated by MockGen. DO NOT EDIT.
// Source: interface.go
//
// Generated by this command:
//
//	mockgen -source=interface.go -package=blockproc -destination=interface_mock.go
//

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

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

	evmcore "github.com/0xsoniclabs/sonic/evmcore"
	inter "github.com/0xsoniclabs/sonic/inter"
	iblockproc "github.com/0xsoniclabs/sonic/inter/iblockproc"
	state "github.com/0xsoniclabs/sonic/inter/state"
	opera "github.com/0xsoniclabs/sonic/opera"
	idx "github.com/Fantom-foundation/lachesis-base/inter/idx"
	common "github.com/ethereum/go-ethereum/common"
	types "github.com/ethereum/go-ethereum/core/types"
	params "github.com/ethereum/go-ethereum/params"
	gomock "go.uber.org/mock/gomock"
)

// MockTxListener is a mock of TxListener interface.
type MockTxListener struct {
	ctrl     *gomock.Controller
	recorder *MockTxListenerMockRecorder
	isgomock struct{}
}

// MockTxListenerMockRecorder is the mock recorder for MockTxListener.
type MockTxListenerMockRecorder struct {
	mock *MockTxListener
}

// NewMockTxListener creates a new mock instance.
func NewMockTxListener(ctrl *gomock.Controller) *MockTxListener {
	mock := &MockTxListener{ctrl: ctrl}
	mock.recorder = &MockTxListenerMockRecorder{mock}
	return mock
}

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

// Finalize mocks base method.
func (m *MockTxListener) Finalize() iblockproc.BlockState {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Finalize")
	ret0, _ := ret[0].(iblockproc.BlockState)
	return ret0
}

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

// OnNewLog mocks base method.
func (m *MockTxListener) OnNewLog(arg0 *types.Log) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnNewLog", arg0)
}

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

// OnNewReceipt mocks base method.
func (m *MockTxListener) OnNewReceipt(tx *types.Transaction, r *types.Receipt, originator idx.ValidatorID, baseFee, blobBaseFee *big.Int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnNewReceipt", tx, r, originator, baseFee, blobBaseFee)
}

// OnNewReceipt indicates an expected call of OnNewReceipt.
func (mr *MockTxListenerMockRecorder) OnNewReceipt(tx, r, originator, baseFee, blobBaseFee any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnNewReceipt", reflect.TypeOf((*MockTxListener)(nil).OnNewReceipt), tx, r, originator, baseFee, blobBaseFee)
}

// Update mocks base method.
func (m *MockTxListener) Update(bs iblockproc.BlockState, es iblockproc.EpochState) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Update", bs, es)
}

// Update indicates an expected call of Update.
func (mr *MockTxListenerMockRecorder) Update(bs, es any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockTxListener)(nil).Update), bs, es)
}

// MockTxListenerModule is a mock of TxListenerModule interface.
type MockTxListenerModule struct {
	ctrl     *gomock.Controller
	recorder *MockTxListenerModuleMockRecorder
	isgomock struct{}
}

// MockTxListenerModuleMockRecorder is the mock recorder for MockTxListenerModule.
type MockTxListenerModuleMockRecorder struct {
	mock *MockTxListenerModule
}

// NewMockTxListenerModule creates a new mock instance.
func NewMockTxListenerModule(ctrl *gomock.Controller) *MockTxListenerModule {
	mock := &MockTxListenerModule{ctrl: ctrl}
	mock.recorder = &MockTxListenerModuleMockRecorder{mock}
	return mock
}

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

// Start mocks base method.
func (m *MockTxListenerModule) Start(block iblockproc.BlockCtx, bs iblockproc.BlockState, es iblockproc.EpochState, statedb state.StateDB) TxListener {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Start", block, bs, es, statedb)
	ret0, _ := ret[0].(TxListener)
	return ret0
}

// Start indicates an expected call of Start.
func (mr *MockTxListenerModuleMockRecorder) Start(block, bs, es, statedb any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockTxListenerModule)(nil).Start), block, bs, es, statedb)
}

// MockTxTransactor is a mock of TxTransactor interface.
type MockTxTransactor struct {
	ctrl     *gomock.Controller
	recorder *MockTxTransactorMockRecorder
	isgomock struct{}
}

// MockTxTransactorMockRecorder is the mock recorder for MockTxTransactor.
type MockTxTransactorMockRecorder struct {
	mock *MockTxTransactor
}

// NewMockTxTransactor creates a new mock instance.
func NewMockTxTransactor(ctrl *gomock.Controller) *MockTxTransactor {
	mock := &MockTxTransactor{ctrl: ctrl}
	mock.recorder = &MockTxTransactorMockRecorder{mock}
	return mock
}

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

// PopInternalTxs mocks base method.
func (m *MockTxTransactor) PopInternalTxs(block iblockproc.BlockCtx, bs iblockproc.BlockState, es iblockproc.EpochState, sealing bool, statedb state.StateDB) types.Transactions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PopInternalTxs", block, bs, es, sealing, statedb)
	ret0, _ := ret[0].(types.Transactions)
	return ret0
}

// PopInternalTxs indicates an expected call of PopInternalTxs.
func (mr *MockTxTransactorMockRecorder) PopInternalTxs(block, bs, es, sealing, statedb any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PopInternalTxs", reflect.TypeOf((*MockTxTransactor)(nil).PopInternalTxs), block, bs, es, sealing, statedb)
}

// MockSealerProcessor is a mock of SealerProcessor interface.
type MockSealerProcessor struct {
	ctrl     *gomock.Controller
	recorder *MockSealerProcessorMockRecorder
	isgomock struct{}
}

// MockSealerProcessorMockRecorder is the mock recorder for MockSealerProcessor.
type MockSealerProcessorMockRecorder struct {
	mock *MockSealerProcessor
}

// NewMockSealerProcessor creates a new mock instance.
func NewMockSealerProcessor(ctrl *gomock.Controller) *MockSealerProcessor {
	mock := &MockSealerProcessor{ctrl: ctrl}
	mock.recorder = &MockSealerProcessorMockRecorder{mock}
	return mock
}

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

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

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

// SealEpoch mocks base method.
func (m *MockSealerProcessor) SealEpoch() (iblockproc.BlockState, iblockproc.EpochState) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SealEpoch")
	ret0, _ := ret[0].(iblockproc.BlockState)
	ret1, _ := ret[1].(iblockproc.EpochState)
	return ret0, ret1
}

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

// Update mocks base method.
func (m *MockSealerProcessor) Update(bs iblockproc.BlockState, es iblockproc.EpochState) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Update", bs, es)
}

// Update indicates an expected call of Update.
func (mr *MockSealerProcessorMockRecorder) Update(bs, es any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockSealerProcessor)(nil).Update), bs, es)
}

// MockSealerModule is a mock of SealerModule interface.
type MockSealerModule struct {
	ctrl     *gomock.Controller
	recorder *MockSealerModuleMockRecorder
	isgomock struct{}
}

// MockSealerModuleMockRecorder is the mock recorder for MockSealerModule.
type MockSealerModuleMockRecorder struct {
	mock *MockSealerModule
}

// NewMockSealerModule creates a new mock instance.
func NewMockSealerModule(ctrl *gomock.Controller) *MockSealerModule {
	mock := &MockSealerModule{ctrl: ctrl}
	mock.recorder = &MockSealerModuleMockRecorder{mock}
	return mock
}

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

// Start mocks base method.
func (m *MockSealerModule) Start(block iblockproc.BlockCtx, bs iblockproc.BlockState, es iblockproc.EpochState) SealerProcessor {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Start", block, bs, es)
	ret0, _ := ret[0].(SealerProcessor)
	return ret0
}

// Start indicates an expected call of Start.
func (mr *MockSealerModuleMockRecorder) Start(block, bs, es any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockSealerModule)(nil).Start), block, bs, es)
}

// MockConfirmedEventsProcessor is a mock of ConfirmedEventsProcessor interface.
type MockConfirmedEventsProcessor struct {
	ctrl     *gomock.Controller
	recorder *MockConfirmedEventsProcessorMockRecorder
	isgomock struct{}
}

// MockConfirmedEventsProcessorMockRecorder is the mock recorder for MockConfirmedEventsProcessor.
type MockConfirmedEventsProcessorMockRecorder struct {
	mock *MockConfirmedEventsProcessor
}

// NewMockConfirmedEventsProcessor creates a new mock instance.
func NewMockConfirmedEventsProcessor(ctrl *gomock.Controller) *MockConfirmedEventsProcessor {
	mock := &MockConfirmedEventsProcessor{ctrl: ctrl}
	mock.recorder = &MockConfirmedEventsProcessorMockRecorder{mock}
	return mock
}

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

// Finalize mocks base method.
func (m *MockConfirmedEventsProcessor) Finalize(block iblockproc.BlockCtx, blockSkipped bool) iblockproc.BlockState {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Finalize", block, blockSkipped)
	ret0, _ := ret[0].(iblockproc.BlockState)
	return ret0
}

// Finalize indicates an expected call of Finalize.
func (mr *MockConfirmedEventsProcessorMockRecorder) Finalize(block, blockSkipped any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Finalize", reflect.TypeOf((*MockConfirmedEventsProcessor)(nil).Finalize), block, blockSkipped)
}

// ProcessConfirmedEvent mocks base method.
func (m *MockConfirmedEventsProcessor) ProcessConfirmedEvent(arg0 inter.EventI) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ProcessConfirmedEvent", arg0)
}

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

// MockConfirmedEventsModule is a mock of ConfirmedEventsModule interface.
type MockConfirmedEventsModule struct {
	ctrl     *gomock.Controller
	recorder *MockConfirmedEventsModuleMockRecorder
	isgomock struct{}
}

// MockConfirmedEventsModuleMockRecorder is the mock recorder for MockConfirmedEventsModule.
type MockConfirmedEventsModuleMockRecorder struct {
	mock *MockConfirmedEventsModule
}

// NewMockConfirmedEventsModule creates a new mock instance.
func NewMockConfirmedEventsModule(ctrl *gomock.Controller) *MockConfirmedEventsModule {
	mock := &MockConfirmedEventsModule{ctrl: ctrl}
	mock.recorder = &MockConfirmedEventsModuleMockRecorder{mock}
	return mock
}

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

// Start mocks base method.
func (m *MockConfirmedEventsModule) Start(bs iblockproc.BlockState, es iblockproc.EpochState) ConfirmedEventsProcessor {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Start", bs, es)
	ret0, _ := ret[0].(ConfirmedEventsProcessor)
	return ret0
}

// Start indicates an expected call of Start.
func (mr *MockConfirmedEventsModuleMockRecorder) Start(bs, es any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockConfirmedEventsModule)(nil).Start), bs, es)
}

// MockEVMProcessor is a mock of EVMProcessor interface.
type MockEVMProcessor struct {
	ctrl     *gomock.Controller
	recorder *MockEVMProcessorMockRecorder
	isgomock struct{}
}

// MockEVMProcessorMockRecorder is the mock recorder for MockEVMProcessor.
type MockEVMProcessorMockRecorder struct {
	mock *MockEVMProcessor
}

// NewMockEVMProcessor creates a new mock instance.
func NewMockEVMProcessor(ctrl *gomock.Controller) *MockEVMProcessor {
	mock := &MockEVMProcessor{ctrl: ctrl}
	mock.recorder = &MockEVMProcessorMockRecorder{mock}
	return mock
}

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

// Execute mocks base method.
func (m *MockEVMProcessor) Execute(txs types.Transactions, gasLimit uint64) []evmcore.ProcessedTransaction {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Execute", txs, gasLimit)
	ret0, _ := ret[0].([]evmcore.ProcessedTransaction)
	return ret0
}

// Execute indicates an expected call of Execute.
func (mr *MockEVMProcessorMockRecorder) Execute(txs, gasLimit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Execute", reflect.TypeOf((*MockEVMProcessor)(nil).Execute), txs, gasLimit)
}

// Finalize mocks base method.
func (m *MockEVMProcessor) Finalize() (*evmcore.EvmBlock, int, types.Receipts) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Finalize")
	ret0, _ := ret[0].(*evmcore.EvmBlock)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(types.Receipts)
	return ret0, ret1, ret2
}

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

// MockEVM is a mock of EVM interface.
type MockEVM struct {
	ctrl     *gomock.Controller
	recorder *MockEVMMockRecorder
	isgomock struct{}
}

// MockEVMMockRecorder is the mock recorder for MockEVM.
type MockEVMMockRecorder struct {
	mock *MockEVM
}

// NewMockEVM creates a new mock instance.
func NewMockEVM(ctrl *gomock.Controller) *MockEVM {
	mock := &MockEVM{ctrl: ctrl}
	mock.recorder = &MockEVMMockRecorder{mock}
	return mock
}

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

// Start mocks base method.
func (m *MockEVM) Start(block iblockproc.BlockCtx, statedb state.StateDB, reader evmcore.DummyChain, onNewLog func(*types.Log), net opera.Rules, evmCfg *params.ChainConfig, prevrandao common.Hash) EVMProcessor {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Start", block, statedb, reader, onNewLog, net, evmCfg, prevrandao)
	ret0, _ := ret[0].(EVMProcessor)
	return ret0
}

// Start indicates an expected call of Start.
func (mr *MockEVMMockRecorder) Start(block, statedb, reader, onNewLog, net, evmCfg, prevrandao any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockEVM)(nil).Start), block, statedb, reader, onNewLog, net, evmCfg, prevrandao)
}
