status-im/status-go

// Code generated by MockGen. DO NOT EDIT.
// Source: rpc/chain/ethclient/rps_limited_eth_client.go
//
// Generated by this command:
//
//    mockgen -package=mock_ethclient -destination=rpc/chain/mock/client/ethclient/rps_limited_eth_client.go -source=rpc/chain/ethclient/rps_limited_eth_client.go
//

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

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

    gomock "go.uber.org/mock/gomock"

    ethereum "github.com/ethereum/go-ethereum"
    common "github.com/ethereum/go-ethereum/common"
    types "github.com/ethereum/go-ethereum/core/types"
    rpc "github.com/ethereum/go-ethereum/rpc"
    ethclient "github.com/status-im/status-go/rpc/chain/ethclient"
    rpclimiter "github.com/status-im/status-go/rpc/chain/rpclimiter"
)

// MockRPSLimitedEthClientInterface is a mock of RPSLimitedEthClientInterface interface.
type MockRPSLimitedEthClientInterface struct {
    ctrl     *gomock.Controller
    recorder *MockRPSLimitedEthClientInterfaceMockRecorder
}

// MockRPSLimitedEthClientInterfaceMockRecorder is the mock recorder for MockRPSLimitedEthClientInterface.
type MockRPSLimitedEthClientInterfaceMockRecorder struct {
    mock *MockRPSLimitedEthClientInterface
}

// NewMockRPSLimitedEthClientInterface creates a new mock instance.
func NewMockRPSLimitedEthClientInterface(ctrl *gomock.Controller) *MockRPSLimitedEthClientInterface {
    mock := &MockRPSLimitedEthClientInterface{ctrl: ctrl}
    mock.recorder = &MockRPSLimitedEthClientInterfaceMockRecorder{mock}
    return mock
}

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

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

// BalanceAt indicates an expected call of BalanceAt.
func (mr *MockRPSLimitedEthClientInterfaceMockRecorder) BalanceAt(ctx, account, blockNumber any) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BalanceAt", reflect.TypeOf((*MockRPSLimitedEthClientInterface)(nil).BalanceAt), ctx, account, blockNumber)
}

// BatchCallContext mocks base method.
func (m *MockRPSLimitedEthClientInterface) BatchCallContext(ctx context.Context, b []rpc.BatchElem) error {
    m.ctrl.T.Helper()
    ret := m.ctrl.Call(m, "BatchCallContext", ctx, b)
    ret0, _ := ret[0].(error)
    return ret0
}

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

// BlockByHash mocks base method.
func (m *MockRPSLimitedEthClientInterface) 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 *MockRPSLimitedEthClientInterfaceMockRecorder) BlockByHash(ctx, hash any) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHash", reflect.TypeOf((*MockRPSLimitedEthClientInterface)(nil).BlockByHash), ctx, hash)
}

// BlockByNumber mocks base method.
func (m *MockRPSLimitedEthClientInterface) BlockByNumber(ctx context.Context, number *big.Int) (*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 *MockRPSLimitedEthClientInterfaceMockRecorder) BlockByNumber(ctx, number any) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByNumber", reflect.TypeOf((*MockRPSLimitedEthClientInterface)(nil).BlockByNumber), ctx, number)
}

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

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

// CallContext mocks base method.
func (m *MockRPSLimitedEthClientInterface) CallContext(ctx context.Context, result any, method string, args ...any) error {
    m.ctrl.T.Helper()
    varargs := []any{ctx, result, method}
    for _, a := range args {
        varargs = append(varargs, a)
    }
    ret := m.ctrl.Call(m, "CallContext", varargs...)
    ret0, _ := ret[0].(error)
    return ret0
}

// CallContext indicates an expected call of CallContext.
func (mr *MockRPSLimitedEthClientInterfaceMockRecorder) CallContext(ctx, result, method any, args ...any) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    varargs := append([]any{ctx, result, method}, args...)
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContext", reflect.TypeOf((*MockRPSLimitedEthClientInterface)(nil).CallContext), varargs...)
}

// CallContract mocks base method.
func (m *MockRPSLimitedEthClientInterface) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
    m.ctrl.T.Helper()
    ret := m.ctrl.Call(m, "CallContract", ctx, call, blockNumber)
    ret0, _ := ret[0].([]byte)
    ret1, _ := ret[1].(error)
    return ret0, ret1
}

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

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

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

// CodeAt mocks base method.
func (m *MockRPSLimitedEthClientInterface) CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error) {
    m.ctrl.T.Helper()
    ret := m.ctrl.Call(m, "CodeAt", ctx, account, blockNumber)
    ret0, _ := ret[0].([]byte)
    ret1, _ := ret[1].(error)
    return ret0, ret1
}

// CodeAt indicates an expected call of CodeAt.
func (mr *MockRPSLimitedEthClientInterfaceMockRecorder) CodeAt(ctx, account, blockNumber any) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CodeAt", reflect.TypeOf((*MockRPSLimitedEthClientInterface)(nil).CodeAt), ctx, account, blockNumber)
}

// CopyWithName mocks base method.
func (m *MockRPSLimitedEthClientInterface) CopyWithName(name string) ethclient.RPSLimitedEthClientInterface {
    m.ctrl.T.Helper()
    ret := m.ctrl.Call(m, "CopyWithName", name)
    ret0, _ := ret[0].(ethclient.RPSLimitedEthClientInterface)
    return ret0
}

// CopyWithName indicates an expected call of CopyWithName.
func (mr *MockRPSLimitedEthClientInterfaceMockRecorder) CopyWithName(name any) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyWithName", reflect.TypeOf((*MockRPSLimitedEthClientInterface)(nil).CopyWithName), name)
}

// EstimateGas mocks base method.
func (m *MockRPSLimitedEthClientInterface) EstimateGas(ctx context.Context, call ethereum.CallMsg) (uint64, error) {
    m.ctrl.T.Helper()
    ret := m.ctrl.Call(m, "EstimateGas", ctx, call)
    ret0, _ := ret[0].(uint64)
    ret1, _ := ret[1].(error)
    return ret0, ret1
}

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

// FeeHistory mocks base method.
func (m *MockRPSLimitedEthClientInterface) FeeHistory(ctx context.Context, blockCount uint64, lastBlock *big.Int, rewardPercentiles []float64) (*ethereum.FeeHistory, error) {
    m.ctrl.T.Helper()
    ret := m.ctrl.Call(m, "FeeHistory", ctx, blockCount, lastBlock, rewardPercentiles)
    ret0, _ := ret[0].(*ethereum.FeeHistory)
    ret1, _ := ret[1].(error)
    return ret0, ret1
}

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

// FilterLogs mocks base method.
func (m *MockRPSLimitedEthClientInterface) FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]types.Log, error) {
    m.ctrl.T.Helper()
    ret := m.ctrl.Call(m, "FilterLogs", ctx, q)
    ret0, _ := ret[0].([]types.Log)
    ret1, _ := ret[1].(error)
    return ret0, ret1
}

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

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

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

// GetLimiter mocks base method.
func (m *MockRPSLimitedEthClientInterface) GetLimiter() *rpclimiter.RPCRpsLimiter {
    m.ctrl.T.Helper()
    ret := m.ctrl.Call(m, "GetLimiter")
    ret0, _ := ret[0].(*rpclimiter.RPCRpsLimiter)
    return ret0
}

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

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

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

// HeaderByHash mocks base method.
func (m *MockRPSLimitedEthClientInterface) 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 *MockRPSLimitedEthClientInterfaceMockRecorder) HeaderByHash(ctx, hash any) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockRPSLimitedEthClientInterface)(nil).HeaderByHash), ctx, hash)
}

// HeaderByNumber mocks base method.
func (m *MockRPSLimitedEthClientInterface) HeaderByNumber(ctx context.Context, number *big.Int) (*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 *MockRPSLimitedEthClientInterfaceMockRecorder) HeaderByNumber(ctx, number any) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockRPSLimitedEthClientInterface)(nil).HeaderByNumber), ctx, number)
}

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

// NonceAt indicates an expected call of NonceAt.
func (mr *MockRPSLimitedEthClientInterfaceMockRecorder) NonceAt(ctx, account, blockNumber any) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NonceAt", reflect.TypeOf((*MockRPSLimitedEthClientInterface)(nil).NonceAt), ctx, account, blockNumber)
}

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

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

// PendingCallContract mocks base method.
func (m *MockRPSLimitedEthClientInterface) PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error) {
    m.ctrl.T.Helper()
    ret := m.ctrl.Call(m, "PendingCallContract", ctx, call)
    ret0, _ := ret[0].([]byte)
    ret1, _ := ret[1].(error)
    return ret0, ret1
}

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

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

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

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

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

// PendingStorageAt mocks base method.
func (m *MockRPSLimitedEthClientInterface) PendingStorageAt(ctx context.Context, account common.Address, key common.Hash) ([]byte, error) {
    m.ctrl.T.Helper()
    ret := m.ctrl.Call(m, "PendingStorageAt", ctx, account, key)
    ret0, _ := ret[0].([]byte)
    ret1, _ := ret[1].(error)
    return ret0, ret1
}

// PendingStorageAt indicates an expected call of PendingStorageAt.
func (mr *MockRPSLimitedEthClientInterfaceMockRecorder) PendingStorageAt(ctx, account, key any) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingStorageAt", reflect.TypeOf((*MockRPSLimitedEthClientInterface)(nil).PendingStorageAt), ctx, account, key)
}

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

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

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

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

// StorageAt mocks base method.
func (m *MockRPSLimitedEthClientInterface) StorageAt(ctx context.Context, account common.Address, key common.Hash, blockNumber *big.Int) ([]byte, error) {
    m.ctrl.T.Helper()
    ret := m.ctrl.Call(m, "StorageAt", ctx, account, key, blockNumber)
    ret0, _ := ret[0].([]byte)
    ret1, _ := ret[1].(error)
    return ret0, ret1
}

// StorageAt indicates an expected call of StorageAt.
func (mr *MockRPSLimitedEthClientInterfaceMockRecorder) StorageAt(ctx, account, key, blockNumber any) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageAt", reflect.TypeOf((*MockRPSLimitedEthClientInterface)(nil).StorageAt), ctx, account, key, blockNumber)
}

// SubscribeFilterLogs mocks base method.
func (m *MockRPSLimitedEthClientInterface) SubscribeFilterLogs(ctx context.Context, q ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error) {
    m.ctrl.T.Helper()
    ret := m.ctrl.Call(m, "SubscribeFilterLogs", ctx, q, ch)
    ret0, _ := ret[0].(ethereum.Subscription)
    ret1, _ := ret[1].(error)
    return ret0, ret1
}

// SubscribeFilterLogs indicates an expected call of SubscribeFilterLogs.
func (mr *MockRPSLimitedEthClientInterfaceMockRecorder) SubscribeFilterLogs(ctx, q, ch any) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeFilterLogs", reflect.TypeOf((*MockRPSLimitedEthClientInterface)(nil).SubscribeFilterLogs), ctx, q, ch)
}

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

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

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

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

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

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

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

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

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

// TransactionSender mocks base method.
func (m *MockRPSLimitedEthClientInterface) TransactionSender(ctx context.Context, tx *types.Transaction, block common.Hash, index uint) (common.Address, error) {
    m.ctrl.T.Helper()
    ret := m.ctrl.Call(m, "TransactionSender", ctx, tx, block, index)
    ret0, _ := ret[0].(common.Address)
    ret1, _ := ret[1].(error)
    return ret0, ret1
}

// TransactionSender indicates an expected call of TransactionSender.
func (mr *MockRPSLimitedEthClientInterfaceMockRecorder) TransactionSender(ctx, tx, block, index any) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionSender", reflect.TypeOf((*MockRPSLimitedEthClientInterface)(nil).TransactionSender), ctx, tx, block, index)
}