// Copyright 2014 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library 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.
//
// The go-ethereum library 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 the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

// Code generated by MockGen. DO NOT EDIT.
// Source: filter.go
//
// Generated by this command:
//
//	mockgen -source=filter.go -package=filters -destination=filter_mock.go
//

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

import (
	context "context"
	reflect "reflect"

	evmcore "github.com/0xsoniclabs/sonic/evmcore"
	evmstore "github.com/0xsoniclabs/sonic/gossip/evmstore"
	topicsdb "github.com/0xsoniclabs/sonic/topicsdb"
	common "github.com/ethereum/go-ethereum/common"
	types "github.com/ethereum/go-ethereum/core/types"
	event "github.com/ethereum/go-ethereum/event"
	rpc "github.com/ethereum/go-ethereum/rpc"
	gomock "go.uber.org/mock/gomock"
)

// MockBackend is a mock of Backend interface.
type MockBackend struct {
	ctrl     *gomock.Controller
	recorder *MockBackendMockRecorder
	isgomock struct{}
}

// MockBackendMockRecorder is the mock recorder for MockBackend.
type MockBackendMockRecorder struct {
	mock *MockBackend
}

// NewMockBackend creates a new mock instance.
func NewMockBackend(ctrl *gomock.Controller) *MockBackend {
	mock := &MockBackend{ctrl: ctrl}
	mock.recorder = &MockBackendMockRecorder{mock}
	return mock
}

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

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

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

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

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

// GetLogs mocks base method.
func (m *MockBackend) GetLogs(ctx context.Context, blockHash common.Hash) ([][]*types.Log, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogs", ctx, blockHash)
	ret0, _ := ret[0].([][]*types.Log)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogs indicates an expected call of GetLogs.
func (mr *MockBackendMockRecorder) GetLogs(ctx, blockHash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogs", reflect.TypeOf((*MockBackend)(nil).GetLogs), ctx, blockHash)
}

// GetReceipts mocks base method.
func (m *MockBackend) GetReceipts(ctx context.Context, blockHash common.Hash) (types.Receipts, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReceipts", ctx, blockHash)
	ret0, _ := ret[0].(types.Receipts)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReceipts indicates an expected call of GetReceipts.
func (mr *MockBackendMockRecorder) GetReceipts(ctx, blockHash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReceipts", reflect.TypeOf((*MockBackend)(nil).GetReceipts), ctx, blockHash)
}

// GetReceiptsByNumber mocks base method.
func (m *MockBackend) GetReceiptsByNumber(ctx context.Context, number rpc.BlockNumber) (types.Receipts, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReceiptsByNumber", ctx, number)
	ret0, _ := ret[0].(types.Receipts)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReceiptsByNumber indicates an expected call of GetReceiptsByNumber.
func (mr *MockBackendMockRecorder) GetReceiptsByNumber(ctx, number any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReceiptsByNumber", reflect.TypeOf((*MockBackend)(nil).GetReceiptsByNumber), ctx, number)
}

// GetTxPosition mocks base method.
func (m *MockBackend) GetTxPosition(txid common.Hash) *evmstore.TxPosition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTxPosition", txid)
	ret0, _ := ret[0].(*evmstore.TxPosition)
	return ret0
}

// GetTxPosition indicates an expected call of GetTxPosition.
func (mr *MockBackendMockRecorder) GetTxPosition(txid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTxPosition", reflect.TypeOf((*MockBackend)(nil).GetTxPosition), txid)
}

// HeaderByHash mocks base method.
func (m *MockBackend) HeaderByHash(ctx context.Context, blockHash common.Hash) (*evmcore.EvmHeader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HeaderByHash", ctx, blockHash)
	ret0, _ := ret[0].(*evmcore.EvmHeader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HeaderByHash indicates an expected call of HeaderByHash.
func (mr *MockBackendMockRecorder) HeaderByHash(ctx, blockHash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockBackend)(nil).HeaderByHash), ctx, blockHash)
}

// HeaderByNumber mocks base method.
func (m *MockBackend) HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*evmcore.EvmHeader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HeaderByNumber", ctx, blockNr)
	ret0, _ := ret[0].(*evmcore.EvmHeader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HeaderByNumber indicates an expected call of HeaderByNumber.
func (mr *MockBackendMockRecorder) HeaderByNumber(ctx, blockNr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockBackend)(nil).HeaderByNumber), ctx, blockNr)
}

// SubscribeLogsNotify mocks base method.
func (m *MockBackend) SubscribeLogsNotify(ch chan<- []*types.Log) event.Subscription {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeLogsNotify", ch)
	ret0, _ := ret[0].(event.Subscription)
	return ret0
}

// SubscribeLogsNotify indicates an expected call of SubscribeLogsNotify.
func (mr *MockBackendMockRecorder) SubscribeLogsNotify(ch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeLogsNotify", reflect.TypeOf((*MockBackend)(nil).SubscribeLogsNotify), ch)
}

// SubscribeNewBlockNotify mocks base method.
func (m *MockBackend) SubscribeNewBlockNotify(ch chan<- evmcore.ChainHeadNotify) event.Subscription {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeNewBlockNotify", ch)
	ret0, _ := ret[0].(event.Subscription)
	return ret0
}

// SubscribeNewBlockNotify indicates an expected call of SubscribeNewBlockNotify.
func (mr *MockBackendMockRecorder) SubscribeNewBlockNotify(ch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeNewBlockNotify", reflect.TypeOf((*MockBackend)(nil).SubscribeNewBlockNotify), ch)
}

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

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