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

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

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

	accounts "github.com/luxfi/geth/accounts"
	consensus "github.com/luxfi/evm/consensus"
	core "github.com/luxfi/evm/core"
	bloombits "github.com/luxfi/evm/core/bloombits"
	state "github.com/luxfi/evm/core/state"
	types "github.com/luxfi/evm/core/types"
	vm "github.com/luxfi/evm/core/vm"
	params "github.com/luxfi/evm/params"
	rpc "github.com/luxfi/geth/rpc"
	common "github.com/luxfi/geth/common"
	ethdb "github.com/luxfi/geth/ethdb"
	event "github.com/luxfi/geth/event"
	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))
}

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

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

// 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)
}

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

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

// 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))
}

// 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))
}

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

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

// 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, 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].(error)
	return ret0, ret1, ret2, ret3, ret4
}

// 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)
}

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

// GetEVM indicates an expected call of GetEVM.
func (mr *MockBackendMockRecorder) GetEVM(ctx, msg, state, 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, msg, state, 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)
}

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

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

// 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)
}

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

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

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

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

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

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

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

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

// 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))
}

// 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)
}

// ServiceFilter mocks base method.
func (m *MockBackend) ServiceFilter(ctx context.Context, session *bloombits.MatcherSession) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ServiceFilter", ctx, session)
}

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

// 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))
}

// 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)
}

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

// SubscribeChainSideEvent indicates an expected call of SubscribeChainSideEvent.
func (mr *MockBackendMockRecorder) SubscribeChainSideEvent(ch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeChainSideEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeChainSideEvent), 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)
}

// 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)
}

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

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

// 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(tx *types.Transaction) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnprotectedAllowed", tx)
	ret0, _ := ret[0].(bool)
	return ret0
}

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