// Code generated by mockery v2.51.1. DO NOT EDIT.

package mocks

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

	common "github.com/ethereum/go-ethereum/common"

	ethereum "github.com/ethereum/go-ethereum"

	mock "github.com/stretchr/testify/mock"

	rpc "github.com/ethereum/go-ethereum/rpc"

	types "github.com/ethereum/go-ethereum/core/types"
)

// EthereumClient is an autogenerated mock type for the EthereumClient type
type EthereumClient struct {
	mock.Mock
}

type EthereumClient_Expecter struct {
	mock *mock.Mock
}

func (_m *EthereumClient) EXPECT() *EthereumClient_Expecter {
	return &EthereumClient_Expecter{mock: &_m.Mock}
}

// BalanceAt provides a mock function with given fields: ctx, account, blockNumber
func (_m *EthereumClient) BalanceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (*big.Int, error) {
	ret := _m.Called(ctx, account, blockNumber)

	if len(ret) == 0 {
		panic("no return value specified for BalanceAt")
	}

	var r0 *big.Int
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Address, *big.Int) (*big.Int, error)); ok {
		return rf(ctx, account, blockNumber)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Address, *big.Int) *big.Int); ok {
		r0 = rf(ctx, account, blockNumber)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*big.Int)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Address, *big.Int) error); ok {
		r1 = rf(ctx, account, blockNumber)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_BalanceAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BalanceAt'
type EthereumClient_BalanceAt_Call struct {
	*mock.Call
}

// BalanceAt is a helper method to define mock.On call
//   - ctx context.Context
//   - account common.Address
//   - blockNumber *big.Int
func (_e *EthereumClient_Expecter) BalanceAt(ctx interface{}, account interface{}, blockNumber interface{}) *EthereumClient_BalanceAt_Call {
	return &EthereumClient_BalanceAt_Call{Call: _e.mock.On("BalanceAt", ctx, account, blockNumber)}
}

func (_c *EthereumClient_BalanceAt_Call) Run(run func(ctx context.Context, account common.Address, blockNumber *big.Int)) *EthereumClient_BalanceAt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Address), args[2].(*big.Int))
	})
	return _c
}

func (_c *EthereumClient_BalanceAt_Call) Return(_a0 *big.Int, _a1 error) *EthereumClient_BalanceAt_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_BalanceAt_Call) RunAndReturn(run func(context.Context, common.Address, *big.Int) (*big.Int, error)) *EthereumClient_BalanceAt_Call {
	_c.Call.Return(run)
	return _c
}

// BlockByHash provides a mock function with given fields: ctx, hash
func (_m *EthereumClient) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
	ret := _m.Called(ctx, hash)

	if len(ret) == 0 {
		panic("no return value specified for BlockByHash")
	}

	var r0 *types.Block
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash) (*types.Block, error)); ok {
		return rf(ctx, hash)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash) *types.Block); ok {
		r0 = rf(ctx, hash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Block)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Hash) error); ok {
		r1 = rf(ctx, hash)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_BlockByHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockByHash'
type EthereumClient_BlockByHash_Call struct {
	*mock.Call
}

// BlockByHash is a helper method to define mock.On call
//   - ctx context.Context
//   - hash common.Hash
func (_e *EthereumClient_Expecter) BlockByHash(ctx interface{}, hash interface{}) *EthereumClient_BlockByHash_Call {
	return &EthereumClient_BlockByHash_Call{Call: _e.mock.On("BlockByHash", ctx, hash)}
}

func (_c *EthereumClient_BlockByHash_Call) Run(run func(ctx context.Context, hash common.Hash)) *EthereumClient_BlockByHash_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Hash))
	})
	return _c
}

func (_c *EthereumClient_BlockByHash_Call) Return(_a0 *types.Block, _a1 error) *EthereumClient_BlockByHash_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_BlockByHash_Call) RunAndReturn(run func(context.Context, common.Hash) (*types.Block, error)) *EthereumClient_BlockByHash_Call {
	_c.Call.Return(run)
	return _c
}

// BlockByNumber provides a mock function with given fields: ctx, number
func (_m *EthereumClient) BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error) {
	ret := _m.Called(ctx, number)

	if len(ret) == 0 {
		panic("no return value specified for BlockByNumber")
	}

	var r0 *types.Block
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *big.Int) (*types.Block, error)); ok {
		return rf(ctx, number)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *big.Int) *types.Block); ok {
		r0 = rf(ctx, number)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Block)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *big.Int) error); ok {
		r1 = rf(ctx, number)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_BlockByNumber_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockByNumber'
type EthereumClient_BlockByNumber_Call struct {
	*mock.Call
}

// BlockByNumber is a helper method to define mock.On call
//   - ctx context.Context
//   - number *big.Int
func (_e *EthereumClient_Expecter) BlockByNumber(ctx interface{}, number interface{}) *EthereumClient_BlockByNumber_Call {
	return &EthereumClient_BlockByNumber_Call{Call: _e.mock.On("BlockByNumber", ctx, number)}
}

func (_c *EthereumClient_BlockByNumber_Call) Run(run func(ctx context.Context, number *big.Int)) *EthereumClient_BlockByNumber_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*big.Int))
	})
	return _c
}

func (_c *EthereumClient_BlockByNumber_Call) Return(_a0 *types.Block, _a1 error) *EthereumClient_BlockByNumber_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_BlockByNumber_Call) RunAndReturn(run func(context.Context, *big.Int) (*types.Block, error)) *EthereumClient_BlockByNumber_Call {
	_c.Call.Return(run)
	return _c
}

// CallContract provides a mock function with given fields: ctx, call, blockNumber
func (_m *EthereumClient) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
	ret := _m.Called(ctx, call, blockNumber)

	if len(ret) == 0 {
		panic("no return value specified for CallContract")
	}

	var r0 []byte
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ethereum.CallMsg, *big.Int) ([]byte, error)); ok {
		return rf(ctx, call, blockNumber)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ethereum.CallMsg, *big.Int) []byte); ok {
		r0 = rf(ctx, call, blockNumber)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ethereum.CallMsg, *big.Int) error); ok {
		r1 = rf(ctx, call, blockNumber)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_CallContract_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CallContract'
type EthereumClient_CallContract_Call struct {
	*mock.Call
}

// CallContract is a helper method to define mock.On call
//   - ctx context.Context
//   - call ethereum.CallMsg
//   - blockNumber *big.Int
func (_e *EthereumClient_Expecter) CallContract(ctx interface{}, call interface{}, blockNumber interface{}) *EthereumClient_CallContract_Call {
	return &EthereumClient_CallContract_Call{Call: _e.mock.On("CallContract", ctx, call, blockNumber)}
}

func (_c *EthereumClient_CallContract_Call) Run(run func(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int)) *EthereumClient_CallContract_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ethereum.CallMsg), args[2].(*big.Int))
	})
	return _c
}

func (_c *EthereumClient_CallContract_Call) Return(_a0 []byte, _a1 error) *EthereumClient_CallContract_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_CallContract_Call) RunAndReturn(run func(context.Context, ethereum.CallMsg, *big.Int) ([]byte, error)) *EthereumClient_CallContract_Call {
	_c.Call.Return(run)
	return _c
}

// ChainID provides a mock function with given fields: ctx
func (_m *EthereumClient) ChainID(ctx context.Context) (*big.Int, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ChainID")
	}

	var r0 *big.Int
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (*big.Int, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) *big.Int); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*big.Int)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_ChainID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChainID'
type EthereumClient_ChainID_Call struct {
	*mock.Call
}

// ChainID is a helper method to define mock.On call
//   - ctx context.Context
func (_e *EthereumClient_Expecter) ChainID(ctx interface{}) *EthereumClient_ChainID_Call {
	return &EthereumClient_ChainID_Call{Call: _e.mock.On("ChainID", ctx)}
}

func (_c *EthereumClient_ChainID_Call) Run(run func(ctx context.Context)) *EthereumClient_ChainID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *EthereumClient_ChainID_Call) Return(_a0 *big.Int, _a1 error) *EthereumClient_ChainID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_ChainID_Call) RunAndReturn(run func(context.Context) (*big.Int, error)) *EthereumClient_ChainID_Call {
	_c.Call.Return(run)
	return _c
}

// Client provides a mock function with no fields
func (_m *EthereumClient) Client() *rpc.Client {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Client")
	}

	var r0 *rpc.Client
	if rf, ok := ret.Get(0).(func() *rpc.Client); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rpc.Client)
		}
	}

	return r0
}

// EthereumClient_Client_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Client'
type EthereumClient_Client_Call struct {
	*mock.Call
}

// Client is a helper method to define mock.On call
func (_e *EthereumClient_Expecter) Client() *EthereumClient_Client_Call {
	return &EthereumClient_Client_Call{Call: _e.mock.On("Client")}
}

func (_c *EthereumClient_Client_Call) Run(run func()) *EthereumClient_Client_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *EthereumClient_Client_Call) Return(_a0 *rpc.Client) *EthereumClient_Client_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *EthereumClient_Client_Call) RunAndReturn(run func() *rpc.Client) *EthereumClient_Client_Call {
	_c.Call.Return(run)
	return _c
}

// CodeAt provides a mock function with given fields: ctx, account, blockNumber
func (_m *EthereumClient) CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error) {
	ret := _m.Called(ctx, account, blockNumber)

	if len(ret) == 0 {
		panic("no return value specified for CodeAt")
	}

	var r0 []byte
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Address, *big.Int) ([]byte, error)); ok {
		return rf(ctx, account, blockNumber)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Address, *big.Int) []byte); ok {
		r0 = rf(ctx, account, blockNumber)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Address, *big.Int) error); ok {
		r1 = rf(ctx, account, blockNumber)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_CodeAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CodeAt'
type EthereumClient_CodeAt_Call struct {
	*mock.Call
}

// CodeAt is a helper method to define mock.On call
//   - ctx context.Context
//   - account common.Address
//   - blockNumber *big.Int
func (_e *EthereumClient_Expecter) CodeAt(ctx interface{}, account interface{}, blockNumber interface{}) *EthereumClient_CodeAt_Call {
	return &EthereumClient_CodeAt_Call{Call: _e.mock.On("CodeAt", ctx, account, blockNumber)}
}

func (_c *EthereumClient_CodeAt_Call) Run(run func(ctx context.Context, account common.Address, blockNumber *big.Int)) *EthereumClient_CodeAt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Address), args[2].(*big.Int))
	})
	return _c
}

func (_c *EthereumClient_CodeAt_Call) Return(_a0 []byte, _a1 error) *EthereumClient_CodeAt_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_CodeAt_Call) RunAndReturn(run func(context.Context, common.Address, *big.Int) ([]byte, error)) *EthereumClient_CodeAt_Call {
	_c.Call.Return(run)
	return _c
}

// EstimateGas provides a mock function with given fields: ctx, call
func (_m *EthereumClient) EstimateGas(ctx context.Context, call ethereum.CallMsg) (uint64, error) {
	ret := _m.Called(ctx, call)

	if len(ret) == 0 {
		panic("no return value specified for EstimateGas")
	}

	var r0 uint64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ethereum.CallMsg) (uint64, error)); ok {
		return rf(ctx, call)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ethereum.CallMsg) uint64); ok {
		r0 = rf(ctx, call)
	} else {
		r0 = ret.Get(0).(uint64)
	}

	if rf, ok := ret.Get(1).(func(context.Context, ethereum.CallMsg) error); ok {
		r1 = rf(ctx, call)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_EstimateGas_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimateGas'
type EthereumClient_EstimateGas_Call struct {
	*mock.Call
}

// EstimateGas is a helper method to define mock.On call
//   - ctx context.Context
//   - call ethereum.CallMsg
func (_e *EthereumClient_Expecter) EstimateGas(ctx interface{}, call interface{}) *EthereumClient_EstimateGas_Call {
	return &EthereumClient_EstimateGas_Call{Call: _e.mock.On("EstimateGas", ctx, call)}
}

func (_c *EthereumClient_EstimateGas_Call) Run(run func(ctx context.Context, call ethereum.CallMsg)) *EthereumClient_EstimateGas_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ethereum.CallMsg))
	})
	return _c
}

func (_c *EthereumClient_EstimateGas_Call) Return(_a0 uint64, _a1 error) *EthereumClient_EstimateGas_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_EstimateGas_Call) RunAndReturn(run func(context.Context, ethereum.CallMsg) (uint64, error)) *EthereumClient_EstimateGas_Call {
	_c.Call.Return(run)
	return _c
}

// HeaderByHash provides a mock function with given fields: ctx, hash
func (_m *EthereumClient) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
	ret := _m.Called(ctx, hash)

	if len(ret) == 0 {
		panic("no return value specified for HeaderByHash")
	}

	var r0 *types.Header
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash) (*types.Header, error)); ok {
		return rf(ctx, hash)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash) *types.Header); ok {
		r0 = rf(ctx, hash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Header)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Hash) error); ok {
		r1 = rf(ctx, hash)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_HeaderByHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeaderByHash'
type EthereumClient_HeaderByHash_Call struct {
	*mock.Call
}

// HeaderByHash is a helper method to define mock.On call
//   - ctx context.Context
//   - hash common.Hash
func (_e *EthereumClient_Expecter) HeaderByHash(ctx interface{}, hash interface{}) *EthereumClient_HeaderByHash_Call {
	return &EthereumClient_HeaderByHash_Call{Call: _e.mock.On("HeaderByHash", ctx, hash)}
}

func (_c *EthereumClient_HeaderByHash_Call) Run(run func(ctx context.Context, hash common.Hash)) *EthereumClient_HeaderByHash_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Hash))
	})
	return _c
}

func (_c *EthereumClient_HeaderByHash_Call) Return(_a0 *types.Header, _a1 error) *EthereumClient_HeaderByHash_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_HeaderByHash_Call) RunAndReturn(run func(context.Context, common.Hash) (*types.Header, error)) *EthereumClient_HeaderByHash_Call {
	_c.Call.Return(run)
	return _c
}

// HeaderByNumber provides a mock function with given fields: ctx, number
func (_m *EthereumClient) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
	ret := _m.Called(ctx, number)

	if len(ret) == 0 {
		panic("no return value specified for HeaderByNumber")
	}

	var r0 *types.Header
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *big.Int) (*types.Header, error)); ok {
		return rf(ctx, number)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *big.Int) *types.Header); ok {
		r0 = rf(ctx, number)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Header)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *big.Int) error); ok {
		r1 = rf(ctx, number)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_HeaderByNumber_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeaderByNumber'
type EthereumClient_HeaderByNumber_Call struct {
	*mock.Call
}

// HeaderByNumber is a helper method to define mock.On call
//   - ctx context.Context
//   - number *big.Int
func (_e *EthereumClient_Expecter) HeaderByNumber(ctx interface{}, number interface{}) *EthereumClient_HeaderByNumber_Call {
	return &EthereumClient_HeaderByNumber_Call{Call: _e.mock.On("HeaderByNumber", ctx, number)}
}

func (_c *EthereumClient_HeaderByNumber_Call) Run(run func(ctx context.Context, number *big.Int)) *EthereumClient_HeaderByNumber_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*big.Int))
	})
	return _c
}

func (_c *EthereumClient_HeaderByNumber_Call) Return(_a0 *types.Header, _a1 error) *EthereumClient_HeaderByNumber_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_HeaderByNumber_Call) RunAndReturn(run func(context.Context, *big.Int) (*types.Header, error)) *EthereumClient_HeaderByNumber_Call {
	_c.Call.Return(run)
	return _c
}

// NonceAt provides a mock function with given fields: ctx, account, blockNumber
func (_m *EthereumClient) NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error) {
	ret := _m.Called(ctx, account, blockNumber)

	if len(ret) == 0 {
		panic("no return value specified for NonceAt")
	}

	var r0 uint64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Address, *big.Int) (uint64, error)); ok {
		return rf(ctx, account, blockNumber)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Address, *big.Int) uint64); ok {
		r0 = rf(ctx, account, blockNumber)
	} else {
		r0 = ret.Get(0).(uint64)
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Address, *big.Int) error); ok {
		r1 = rf(ctx, account, blockNumber)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_NonceAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NonceAt'
type EthereumClient_NonceAt_Call struct {
	*mock.Call
}

// NonceAt is a helper method to define mock.On call
//   - ctx context.Context
//   - account common.Address
//   - blockNumber *big.Int
func (_e *EthereumClient_Expecter) NonceAt(ctx interface{}, account interface{}, blockNumber interface{}) *EthereumClient_NonceAt_Call {
	return &EthereumClient_NonceAt_Call{Call: _e.mock.On("NonceAt", ctx, account, blockNumber)}
}

func (_c *EthereumClient_NonceAt_Call) Run(run func(ctx context.Context, account common.Address, blockNumber *big.Int)) *EthereumClient_NonceAt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Address), args[2].(*big.Int))
	})
	return _c
}

func (_c *EthereumClient_NonceAt_Call) Return(_a0 uint64, _a1 error) *EthereumClient_NonceAt_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_NonceAt_Call) RunAndReturn(run func(context.Context, common.Address, *big.Int) (uint64, error)) *EthereumClient_NonceAt_Call {
	_c.Call.Return(run)
	return _c
}

// PendingBalanceAt provides a mock function with given fields: ctx, account
func (_m *EthereumClient) PendingBalanceAt(ctx context.Context, account common.Address) (*big.Int, error) {
	ret := _m.Called(ctx, account)

	if len(ret) == 0 {
		panic("no return value specified for PendingBalanceAt")
	}

	var r0 *big.Int
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Address) (*big.Int, error)); ok {
		return rf(ctx, account)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Address) *big.Int); ok {
		r0 = rf(ctx, account)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*big.Int)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Address) error); ok {
		r1 = rf(ctx, account)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_PendingBalanceAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PendingBalanceAt'
type EthereumClient_PendingBalanceAt_Call struct {
	*mock.Call
}

// PendingBalanceAt is a helper method to define mock.On call
//   - ctx context.Context
//   - account common.Address
func (_e *EthereumClient_Expecter) PendingBalanceAt(ctx interface{}, account interface{}) *EthereumClient_PendingBalanceAt_Call {
	return &EthereumClient_PendingBalanceAt_Call{Call: _e.mock.On("PendingBalanceAt", ctx, account)}
}

func (_c *EthereumClient_PendingBalanceAt_Call) Run(run func(ctx context.Context, account common.Address)) *EthereumClient_PendingBalanceAt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Address))
	})
	return _c
}

func (_c *EthereumClient_PendingBalanceAt_Call) Return(_a0 *big.Int, _a1 error) *EthereumClient_PendingBalanceAt_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_PendingBalanceAt_Call) RunAndReturn(run func(context.Context, common.Address) (*big.Int, error)) *EthereumClient_PendingBalanceAt_Call {
	_c.Call.Return(run)
	return _c
}

// PendingCodeAt provides a mock function with given fields: ctx, account
func (_m *EthereumClient) PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error) {
	ret := _m.Called(ctx, account)

	if len(ret) == 0 {
		panic("no return value specified for PendingCodeAt")
	}

	var r0 []byte
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Address) ([]byte, error)); ok {
		return rf(ctx, account)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Address) []byte); ok {
		r0 = rf(ctx, account)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Address) error); ok {
		r1 = rf(ctx, account)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_PendingCodeAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PendingCodeAt'
type EthereumClient_PendingCodeAt_Call struct {
	*mock.Call
}

// PendingCodeAt is a helper method to define mock.On call
//   - ctx context.Context
//   - account common.Address
func (_e *EthereumClient_Expecter) PendingCodeAt(ctx interface{}, account interface{}) *EthereumClient_PendingCodeAt_Call {
	return &EthereumClient_PendingCodeAt_Call{Call: _e.mock.On("PendingCodeAt", ctx, account)}
}

func (_c *EthereumClient_PendingCodeAt_Call) Run(run func(ctx context.Context, account common.Address)) *EthereumClient_PendingCodeAt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Address))
	})
	return _c
}

func (_c *EthereumClient_PendingCodeAt_Call) Return(_a0 []byte, _a1 error) *EthereumClient_PendingCodeAt_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_PendingCodeAt_Call) RunAndReturn(run func(context.Context, common.Address) ([]byte, error)) *EthereumClient_PendingCodeAt_Call {
	_c.Call.Return(run)
	return _c
}

// PendingNonceAt provides a mock function with given fields: ctx, account
func (_m *EthereumClient) PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) {
	ret := _m.Called(ctx, account)

	if len(ret) == 0 {
		panic("no return value specified for PendingNonceAt")
	}

	var r0 uint64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Address) (uint64, error)); ok {
		return rf(ctx, account)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Address) uint64); ok {
		r0 = rf(ctx, account)
	} else {
		r0 = ret.Get(0).(uint64)
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Address) error); ok {
		r1 = rf(ctx, account)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_PendingNonceAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PendingNonceAt'
type EthereumClient_PendingNonceAt_Call struct {
	*mock.Call
}

// PendingNonceAt is a helper method to define mock.On call
//   - ctx context.Context
//   - account common.Address
func (_e *EthereumClient_Expecter) PendingNonceAt(ctx interface{}, account interface{}) *EthereumClient_PendingNonceAt_Call {
	return &EthereumClient_PendingNonceAt_Call{Call: _e.mock.On("PendingNonceAt", ctx, account)}
}

func (_c *EthereumClient_PendingNonceAt_Call) Run(run func(ctx context.Context, account common.Address)) *EthereumClient_PendingNonceAt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Address))
	})
	return _c
}

func (_c *EthereumClient_PendingNonceAt_Call) Return(_a0 uint64, _a1 error) *EthereumClient_PendingNonceAt_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_PendingNonceAt_Call) RunAndReturn(run func(context.Context, common.Address) (uint64, error)) *EthereumClient_PendingNonceAt_Call {
	_c.Call.Return(run)
	return _c
}

// PendingStorageAt provides a mock function with given fields: ctx, account, key
func (_m *EthereumClient) PendingStorageAt(ctx context.Context, account common.Address, key common.Hash) ([]byte, error) {
	ret := _m.Called(ctx, account, key)

	if len(ret) == 0 {
		panic("no return value specified for PendingStorageAt")
	}

	var r0 []byte
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Address, common.Hash) ([]byte, error)); ok {
		return rf(ctx, account, key)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Address, common.Hash) []byte); ok {
		r0 = rf(ctx, account, key)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Address, common.Hash) error); ok {
		r1 = rf(ctx, account, key)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_PendingStorageAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PendingStorageAt'
type EthereumClient_PendingStorageAt_Call struct {
	*mock.Call
}

// PendingStorageAt is a helper method to define mock.On call
//   - ctx context.Context
//   - account common.Address
//   - key common.Hash
func (_e *EthereumClient_Expecter) PendingStorageAt(ctx interface{}, account interface{}, key interface{}) *EthereumClient_PendingStorageAt_Call {
	return &EthereumClient_PendingStorageAt_Call{Call: _e.mock.On("PendingStorageAt", ctx, account, key)}
}

func (_c *EthereumClient_PendingStorageAt_Call) Run(run func(ctx context.Context, account common.Address, key common.Hash)) *EthereumClient_PendingStorageAt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Address), args[2].(common.Hash))
	})
	return _c
}

func (_c *EthereumClient_PendingStorageAt_Call) Return(_a0 []byte, _a1 error) *EthereumClient_PendingStorageAt_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_PendingStorageAt_Call) RunAndReturn(run func(context.Context, common.Address, common.Hash) ([]byte, error)) *EthereumClient_PendingStorageAt_Call {
	_c.Call.Return(run)
	return _c
}

// PendingTransactionCount provides a mock function with given fields: ctx
func (_m *EthereumClient) PendingTransactionCount(ctx context.Context) (uint, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for PendingTransactionCount")
	}

	var r0 uint
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (uint, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) uint); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(uint)
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_PendingTransactionCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PendingTransactionCount'
type EthereumClient_PendingTransactionCount_Call struct {
	*mock.Call
}

// PendingTransactionCount is a helper method to define mock.On call
//   - ctx context.Context
func (_e *EthereumClient_Expecter) PendingTransactionCount(ctx interface{}) *EthereumClient_PendingTransactionCount_Call {
	return &EthereumClient_PendingTransactionCount_Call{Call: _e.mock.On("PendingTransactionCount", ctx)}
}

func (_c *EthereumClient_PendingTransactionCount_Call) Run(run func(ctx context.Context)) *EthereumClient_PendingTransactionCount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *EthereumClient_PendingTransactionCount_Call) Return(_a0 uint, _a1 error) *EthereumClient_PendingTransactionCount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_PendingTransactionCount_Call) RunAndReturn(run func(context.Context) (uint, error)) *EthereumClient_PendingTransactionCount_Call {
	_c.Call.Return(run)
	return _c
}

// SendTransaction provides a mock function with given fields: ctx, tx
func (_m *EthereumClient) SendTransaction(ctx context.Context, tx *types.Transaction) error {
	ret := _m.Called(ctx, tx)

	if len(ret) == 0 {
		panic("no return value specified for SendTransaction")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.Transaction) error); ok {
		r0 = rf(ctx, tx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// EthereumClient_SendTransaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendTransaction'
type EthereumClient_SendTransaction_Call struct {
	*mock.Call
}

// SendTransaction is a helper method to define mock.On call
//   - ctx context.Context
//   - tx *types.Transaction
func (_e *EthereumClient_Expecter) SendTransaction(ctx interface{}, tx interface{}) *EthereumClient_SendTransaction_Call {
	return &EthereumClient_SendTransaction_Call{Call: _e.mock.On("SendTransaction", ctx, tx)}
}

func (_c *EthereumClient_SendTransaction_Call) Run(run func(ctx context.Context, tx *types.Transaction)) *EthereumClient_SendTransaction_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.Transaction))
	})
	return _c
}

func (_c *EthereumClient_SendTransaction_Call) Return(_a0 error) *EthereumClient_SendTransaction_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *EthereumClient_SendTransaction_Call) RunAndReturn(run func(context.Context, *types.Transaction) error) *EthereumClient_SendTransaction_Call {
	_c.Call.Return(run)
	return _c
}

// StorageAt provides a mock function with given fields: ctx, account, key, blockNumber
func (_m *EthereumClient) StorageAt(ctx context.Context, account common.Address, key common.Hash, blockNumber *big.Int) ([]byte, error) {
	ret := _m.Called(ctx, account, key, blockNumber)

	if len(ret) == 0 {
		panic("no return value specified for StorageAt")
	}

	var r0 []byte
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Address, common.Hash, *big.Int) ([]byte, error)); ok {
		return rf(ctx, account, key, blockNumber)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Address, common.Hash, *big.Int) []byte); ok {
		r0 = rf(ctx, account, key, blockNumber)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Address, common.Hash, *big.Int) error); ok {
		r1 = rf(ctx, account, key, blockNumber)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_StorageAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StorageAt'
type EthereumClient_StorageAt_Call struct {
	*mock.Call
}

// StorageAt is a helper method to define mock.On call
//   - ctx context.Context
//   - account common.Address
//   - key common.Hash
//   - blockNumber *big.Int
func (_e *EthereumClient_Expecter) StorageAt(ctx interface{}, account interface{}, key interface{}, blockNumber interface{}) *EthereumClient_StorageAt_Call {
	return &EthereumClient_StorageAt_Call{Call: _e.mock.On("StorageAt", ctx, account, key, blockNumber)}
}

func (_c *EthereumClient_StorageAt_Call) Run(run func(ctx context.Context, account common.Address, key common.Hash, blockNumber *big.Int)) *EthereumClient_StorageAt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Address), args[2].(common.Hash), args[3].(*big.Int))
	})
	return _c
}

func (_c *EthereumClient_StorageAt_Call) Return(_a0 []byte, _a1 error) *EthereumClient_StorageAt_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_StorageAt_Call) RunAndReturn(run func(context.Context, common.Address, common.Hash, *big.Int) ([]byte, error)) *EthereumClient_StorageAt_Call {
	_c.Call.Return(run)
	return _c
}

// SubscribeNewHead provides a mock function with given fields: ctx, ch
func (_m *EthereumClient) SubscribeNewHead(ctx context.Context, ch chan<- *types.Header) (ethereum.Subscription, error) {
	ret := _m.Called(ctx, ch)

	if len(ret) == 0 {
		panic("no return value specified for SubscribeNewHead")
	}

	var r0 ethereum.Subscription
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, chan<- *types.Header) (ethereum.Subscription, error)); ok {
		return rf(ctx, ch)
	}
	if rf, ok := ret.Get(0).(func(context.Context, chan<- *types.Header) ethereum.Subscription); ok {
		r0 = rf(ctx, ch)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ethereum.Subscription)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, chan<- *types.Header) error); ok {
		r1 = rf(ctx, ch)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_SubscribeNewHead_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribeNewHead'
type EthereumClient_SubscribeNewHead_Call struct {
	*mock.Call
}

// SubscribeNewHead is a helper method to define mock.On call
//   - ctx context.Context
//   - ch chan<- *types.Header
func (_e *EthereumClient_Expecter) SubscribeNewHead(ctx interface{}, ch interface{}) *EthereumClient_SubscribeNewHead_Call {
	return &EthereumClient_SubscribeNewHead_Call{Call: _e.mock.On("SubscribeNewHead", ctx, ch)}
}

func (_c *EthereumClient_SubscribeNewHead_Call) Run(run func(ctx context.Context, ch chan<- *types.Header)) *EthereumClient_SubscribeNewHead_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(chan<- *types.Header))
	})
	return _c
}

func (_c *EthereumClient_SubscribeNewHead_Call) Return(_a0 ethereum.Subscription, _a1 error) *EthereumClient_SubscribeNewHead_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_SubscribeNewHead_Call) RunAndReturn(run func(context.Context, chan<- *types.Header) (ethereum.Subscription, error)) *EthereumClient_SubscribeNewHead_Call {
	_c.Call.Return(run)
	return _c
}

// SuggestGasPrice provides a mock function with given fields: ctx
func (_m *EthereumClient) SuggestGasPrice(ctx context.Context) (*big.Int, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for SuggestGasPrice")
	}

	var r0 *big.Int
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (*big.Int, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) *big.Int); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*big.Int)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_SuggestGasPrice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuggestGasPrice'
type EthereumClient_SuggestGasPrice_Call struct {
	*mock.Call
}

// SuggestGasPrice is a helper method to define mock.On call
//   - ctx context.Context
func (_e *EthereumClient_Expecter) SuggestGasPrice(ctx interface{}) *EthereumClient_SuggestGasPrice_Call {
	return &EthereumClient_SuggestGasPrice_Call{Call: _e.mock.On("SuggestGasPrice", ctx)}
}

func (_c *EthereumClient_SuggestGasPrice_Call) Run(run func(ctx context.Context)) *EthereumClient_SuggestGasPrice_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *EthereumClient_SuggestGasPrice_Call) Return(_a0 *big.Int, _a1 error) *EthereumClient_SuggestGasPrice_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_SuggestGasPrice_Call) RunAndReturn(run func(context.Context) (*big.Int, error)) *EthereumClient_SuggestGasPrice_Call {
	_c.Call.Return(run)
	return _c
}

// SuggestGasTipCap provides a mock function with given fields: ctx
func (_m *EthereumClient) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for SuggestGasTipCap")
	}

	var r0 *big.Int
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (*big.Int, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) *big.Int); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*big.Int)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_SuggestGasTipCap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuggestGasTipCap'
type EthereumClient_SuggestGasTipCap_Call struct {
	*mock.Call
}

// SuggestGasTipCap is a helper method to define mock.On call
//   - ctx context.Context
func (_e *EthereumClient_Expecter) SuggestGasTipCap(ctx interface{}) *EthereumClient_SuggestGasTipCap_Call {
	return &EthereumClient_SuggestGasTipCap_Call{Call: _e.mock.On("SuggestGasTipCap", ctx)}
}

func (_c *EthereumClient_SuggestGasTipCap_Call) Run(run func(ctx context.Context)) *EthereumClient_SuggestGasTipCap_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *EthereumClient_SuggestGasTipCap_Call) Return(_a0 *big.Int, _a1 error) *EthereumClient_SuggestGasTipCap_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_SuggestGasTipCap_Call) RunAndReturn(run func(context.Context) (*big.Int, error)) *EthereumClient_SuggestGasTipCap_Call {
	_c.Call.Return(run)
	return _c
}

// TransactionByHash provides a mock function with given fields: ctx, txHash
func (_m *EthereumClient) TransactionByHash(ctx context.Context, txHash common.Hash) (*types.Transaction, bool, error) {
	ret := _m.Called(ctx, txHash)

	if len(ret) == 0 {
		panic("no return value specified for TransactionByHash")
	}

	var r0 *types.Transaction
	var r1 bool
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash) (*types.Transaction, bool, error)); ok {
		return rf(ctx, txHash)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash) *types.Transaction); ok {
		r0 = rf(ctx, txHash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Transaction)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Hash) bool); ok {
		r1 = rf(ctx, txHash)
	} else {
		r1 = ret.Get(1).(bool)
	}

	if rf, ok := ret.Get(2).(func(context.Context, common.Hash) error); ok {
		r2 = rf(ctx, txHash)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// EthereumClient_TransactionByHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransactionByHash'
type EthereumClient_TransactionByHash_Call struct {
	*mock.Call
}

// TransactionByHash is a helper method to define mock.On call
//   - ctx context.Context
//   - txHash common.Hash
func (_e *EthereumClient_Expecter) TransactionByHash(ctx interface{}, txHash interface{}) *EthereumClient_TransactionByHash_Call {
	return &EthereumClient_TransactionByHash_Call{Call: _e.mock.On("TransactionByHash", ctx, txHash)}
}

func (_c *EthereumClient_TransactionByHash_Call) Run(run func(ctx context.Context, txHash common.Hash)) *EthereumClient_TransactionByHash_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Hash))
	})
	return _c
}

func (_c *EthereumClient_TransactionByHash_Call) Return(tx *types.Transaction, isPending bool, err error) *EthereumClient_TransactionByHash_Call {
	_c.Call.Return(tx, isPending, err)
	return _c
}

func (_c *EthereumClient_TransactionByHash_Call) RunAndReturn(run func(context.Context, common.Hash) (*types.Transaction, bool, error)) *EthereumClient_TransactionByHash_Call {
	_c.Call.Return(run)
	return _c
}

// TransactionCount provides a mock function with given fields: ctx, blockHash
func (_m *EthereumClient) TransactionCount(ctx context.Context, blockHash common.Hash) (uint, error) {
	ret := _m.Called(ctx, blockHash)

	if len(ret) == 0 {
		panic("no return value specified for TransactionCount")
	}

	var r0 uint
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash) (uint, error)); ok {
		return rf(ctx, blockHash)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash) uint); ok {
		r0 = rf(ctx, blockHash)
	} else {
		r0 = ret.Get(0).(uint)
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Hash) error); ok {
		r1 = rf(ctx, blockHash)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_TransactionCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransactionCount'
type EthereumClient_TransactionCount_Call struct {
	*mock.Call
}

// TransactionCount is a helper method to define mock.On call
//   - ctx context.Context
//   - blockHash common.Hash
func (_e *EthereumClient_Expecter) TransactionCount(ctx interface{}, blockHash interface{}) *EthereumClient_TransactionCount_Call {
	return &EthereumClient_TransactionCount_Call{Call: _e.mock.On("TransactionCount", ctx, blockHash)}
}

func (_c *EthereumClient_TransactionCount_Call) Run(run func(ctx context.Context, blockHash common.Hash)) *EthereumClient_TransactionCount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Hash))
	})
	return _c
}

func (_c *EthereumClient_TransactionCount_Call) Return(_a0 uint, _a1 error) *EthereumClient_TransactionCount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_TransactionCount_Call) RunAndReturn(run func(context.Context, common.Hash) (uint, error)) *EthereumClient_TransactionCount_Call {
	_c.Call.Return(run)
	return _c
}

// TransactionInBlock provides a mock function with given fields: ctx, blockHash, index
func (_m *EthereumClient) TransactionInBlock(ctx context.Context, blockHash common.Hash, index uint) (*types.Transaction, error) {
	ret := _m.Called(ctx, blockHash, index)

	if len(ret) == 0 {
		panic("no return value specified for TransactionInBlock")
	}

	var r0 *types.Transaction
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash, uint) (*types.Transaction, error)); ok {
		return rf(ctx, blockHash, index)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash, uint) *types.Transaction); ok {
		r0 = rf(ctx, blockHash, index)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Transaction)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Hash, uint) error); ok {
		r1 = rf(ctx, blockHash, index)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_TransactionInBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransactionInBlock'
type EthereumClient_TransactionInBlock_Call struct {
	*mock.Call
}

// TransactionInBlock is a helper method to define mock.On call
//   - ctx context.Context
//   - blockHash common.Hash
//   - index uint
func (_e *EthereumClient_Expecter) TransactionInBlock(ctx interface{}, blockHash interface{}, index interface{}) *EthereumClient_TransactionInBlock_Call {
	return &EthereumClient_TransactionInBlock_Call{Call: _e.mock.On("TransactionInBlock", ctx, blockHash, index)}
}

func (_c *EthereumClient_TransactionInBlock_Call) Run(run func(ctx context.Context, blockHash common.Hash, index uint)) *EthereumClient_TransactionInBlock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Hash), args[2].(uint))
	})
	return _c
}

func (_c *EthereumClient_TransactionInBlock_Call) Return(_a0 *types.Transaction, _a1 error) *EthereumClient_TransactionInBlock_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_TransactionInBlock_Call) RunAndReturn(run func(context.Context, common.Hash, uint) (*types.Transaction, error)) *EthereumClient_TransactionInBlock_Call {
	_c.Call.Return(run)
	return _c
}

// TransactionReceipt provides a mock function with given fields: ctx, txHash
func (_m *EthereumClient) TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) {
	ret := _m.Called(ctx, txHash)

	if len(ret) == 0 {
		panic("no return value specified for TransactionReceipt")
	}

	var r0 *types.Receipt
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash) (*types.Receipt, error)); ok {
		return rf(ctx, txHash)
	}
	if rf, ok := ret.Get(0).(func(context.Context, common.Hash) *types.Receipt); ok {
		r0 = rf(ctx, txHash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Receipt)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, common.Hash) error); ok {
		r1 = rf(ctx, txHash)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EthereumClient_TransactionReceipt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransactionReceipt'
type EthereumClient_TransactionReceipt_Call struct {
	*mock.Call
}

// TransactionReceipt is a helper method to define mock.On call
//   - ctx context.Context
//   - txHash common.Hash
func (_e *EthereumClient_Expecter) TransactionReceipt(ctx interface{}, txHash interface{}) *EthereumClient_TransactionReceipt_Call {
	return &EthereumClient_TransactionReceipt_Call{Call: _e.mock.On("TransactionReceipt", ctx, txHash)}
}

func (_c *EthereumClient_TransactionReceipt_Call) Run(run func(ctx context.Context, txHash common.Hash)) *EthereumClient_TransactionReceipt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(common.Hash))
	})
	return _c
}

func (_c *EthereumClient_TransactionReceipt_Call) Return(_a0 *types.Receipt, _a1 error) *EthereumClient_TransactionReceipt_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EthereumClient_TransactionReceipt_Call) RunAndReturn(run func(context.Context, common.Hash) (*types.Receipt, error)) *EthereumClient_TransactionReceipt_Call {
	_c.Call.Return(run)
	return _c
}

// NewEthereumClient creates a new instance of EthereumClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewEthereumClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *EthereumClient {
	mock := &EthereumClient{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}
