// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/ethereum/go-ethereum/internal/ethapi (interfaces: Backend)
//
// Generated by this command:
//
//	mockgen -destination=../../eth/filters/IBackend.go -package=filters . Backend
//

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

import (
	context "context"
	big "math/big"
	reflect "reflect"
	time "time"

	ethereum "github.com/ethereum/go-ethereum"
	accounts "github.com/ethereum/go-ethereum/accounts"
	common "github.com/ethereum/go-ethereum/common"
	consensus "github.com/ethereum/go-ethereum/consensus"
	core "github.com/ethereum/go-ethereum/core"
	filtermaps "github.com/ethereum/go-ethereum/core/filtermaps"
	state "github.com/ethereum/go-ethereum/core/state"
	stateless "github.com/ethereum/go-ethereum/core/stateless"
	types "github.com/ethereum/go-ethereum/core/types"
	vm "github.com/ethereum/go-ethereum/core/vm"
	ethdb "github.com/ethereum/go-ethereum/ethdb"
	event "github.com/ethereum/go-ethereum/event"
	params "github.com/ethereum/go-ethereum/params"
	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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// FeeHistory mocks base method.
func (m *MockBackend) FeeHistory(ctx context.Context, blockCount uint64, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (*big.Int, [][]*big.Int, []*big.Int, []float64, []*big.Int, []float64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FeeHistory", ctx, blockCount, lastBlock, rewardPercentiles)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].([][]*big.Int)
	ret2, _ := ret[2].([]*big.Int)
	ret3, _ := ret[3].([]float64)
	ret4, _ := ret[4].([]*big.Int)
	ret5, _ := ret[5].([]float64)
	ret6, _ := ret[6].(error)
	return ret0, ret1, ret2, ret3, ret4, ret5, ret6
}

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

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

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

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

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

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

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

// GetBorBlockTransaction mocks base method.
func (m *MockBackend) GetBorBlockTransaction(ctx context.Context, txHash common.Hash) (*types.Transaction, common.Hash, uint64, uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBorBlockTransaction", ctx, txHash)
	ret0, _ := ret[0].(*types.Transaction)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(uint64)
	ret3, _ := ret[3].(uint64)
	ret4, _ := ret[4].(error)
	return ret0, ret1, ret2, ret3, ret4
}

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

// GetBorBlockTransactionWithBlockHash mocks base method.
func (m *MockBackend) GetBorBlockTransactionWithBlockHash(ctx context.Context, txHash, blockHash common.Hash) (*types.Transaction, common.Hash, uint64, uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBorBlockTransactionWithBlockHash", ctx, txHash, blockHash)
	ret0, _ := ret[0].(*types.Transaction)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(uint64)
	ret3, _ := ret[3].(uint64)
	ret4, _ := ret[4].(error)
	return ret0, ret1, ret2, ret3, ret4
}

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

// GetEVM mocks base method.
func (m *MockBackend) GetEVM(ctx context.Context, arg1 *state.StateDB, header *types.Header, vmConfig *vm.Config, blockCtx *vm.BlockContext) *vm.EVM {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEVM", ctx, arg1, header, vmConfig, blockCtx)
	ret0, _ := ret[0].(*vm.EVM)
	return ret0
}

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

// GetLogs mocks base method.
func (m *MockBackend) GetLogs(ctx context.Context, blockHash common.Hash, number uint64) ([][]*types.Log, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogs", ctx, blockHash, number)
	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, number any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogs", reflect.TypeOf((*MockBackend)(nil).GetLogs), ctx, blockHash, number)
}

// GetPoolNonce mocks base method.
func (m *MockBackend) GetPoolNonce(ctx context.Context, addr common.Address) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPoolNonce", ctx, addr)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetPoolTransactions mocks base method.
func (m *MockBackend) GetPoolTransactions() (types.Transactions, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPoolTransactions")
	ret0, _ := ret[0].(types.Transactions)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetRootHash mocks base method.
func (m *MockBackend) GetRootHash(ctx context.Context, starBlockNr, endBlockNr uint64) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRootHash", ctx, starBlockNr, endBlockNr)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTd mocks base method.
func (m *MockBackend) GetTd(ctx context.Context, hash common.Hash) *big.Int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTd", ctx, hash)
	ret0, _ := ret[0].(*big.Int)
	return ret0
}

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

// GetTdByNumber mocks base method.
func (m *MockBackend) GetTdByNumber(ctx context.Context, blockNr rpc.BlockNumber) *big.Int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTdByNumber", ctx, blockNr)
	ret0, _ := ret[0].(*big.Int)
	return ret0
}

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

// GetTransaction mocks base method.
func (m *MockBackend) GetTransaction(txHash common.Hash) (bool, *types.Transaction, common.Hash, uint64, uint64) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransaction", txHash)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(*types.Transaction)
	ret2, _ := ret[2].(common.Hash)
	ret3, _ := ret[3].(uint64)
	ret4, _ := ret[4].(uint64)
	return ret0, ret1, ret2, ret3, ret4
}

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

// GetVoteOnHash mocks base method.
func (m *MockBackend) GetVoteOnHash(ctx context.Context, startBlockNumber, endBlockNumber uint64, hash, milestoneID string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVoteOnHash", ctx, startBlockNumber, endBlockNumber, hash, milestoneID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWhitelistedCheckpoint mocks base method.
func (m *MockBackend) GetWhitelistedCheckpoint() (bool, uint64, common.Hash) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWhitelistedCheckpoint")
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(uint64)
	ret2, _ := ret[2].(common.Hash)
	return ret0, ret1, ret2
}

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

// GetWhitelistedMilestone mocks base method.
func (m *MockBackend) GetWhitelistedMilestone() (bool, uint64, common.Hash) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWhitelistedMilestone")
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(uint64)
	ret2, _ := ret[2].(common.Hash)
	return ret0, ret1, ret2
}

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

// GetWitnesses mocks base method.
func (m *MockBackend) GetWitnesses(ctx context.Context, originBlock, totalBlocks uint64) ([]*stateless.Witness, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWitnesses", ctx, originBlock, totalBlocks)
	ret0, _ := ret[0].([]*stateless.Witness)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// Pending mocks base method.
func (m *MockBackend) Pending() (*types.Block, types.Receipts, *state.StateDB) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Pending")
	ret0, _ := ret[0].(*types.Block)
	ret1, _ := ret[1].(types.Receipts)
	ret2, _ := ret[2].(*state.StateDB)
	return ret0, ret1, ret2
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// SendTx mocks base method.
func (m *MockBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendTx", ctx, signedTx)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SetHead mocks base method.
func (m *MockBackend) SetHead(number uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetHead", number)
}

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

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

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

// StateAndHeaderByNumberOrHash mocks base method.
func (m *MockBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*state.StateDB, *types.Header, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StateAndHeaderByNumberOrHash", ctx, blockNrOrHash)
	ret0, _ := ret[0].(*state.StateDB)
	ret1, _ := ret[1].(*types.Header)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

// StoreWitness mocks base method.
func (m *MockBackend) StoreWitness(ctx context.Context, blockHash common.Hash, witness *stateless.Witness) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StoreWitness", ctx, blockHash, witness)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SuggestGasTipCap mocks base method.
func (m *MockBackend) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SuggestGasTipCap", ctx)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// WitnessByNumberOrHash mocks base method.
func (m *MockBackend) WitnessByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*stateless.Witness, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WitnessByNumberOrHash", ctx, blockNrOrHash)
	ret0, _ := ret[0].(*stateless.Witness)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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