1155 lines
46 KiB
Go
1155 lines
46 KiB
Go
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: rpc/chain/ethclient/eth_client.go
|
|
//
|
|
// Generated by this command:
|
|
//
|
|
// mockgen -package=mock_ethclient -destination=rpc/chain/mock/client/ethclient/eth_client.go -source=rpc/chain/ethclient/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"
|
|
)
|
|
|
|
// MockChainReader is a mock of ChainReader interface.
|
|
type MockChainReader struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockChainReaderMockRecorder
|
|
}
|
|
|
|
// MockChainReaderMockRecorder is the mock recorder for MockChainReader.
|
|
type MockChainReaderMockRecorder struct {
|
|
mock *MockChainReader
|
|
}
|
|
|
|
// NewMockChainReader creates a new mock instance.
|
|
func NewMockChainReader(ctrl *gomock.Controller) *MockChainReader {
|
|
mock := &MockChainReader{ctrl: ctrl}
|
|
mock.recorder = &MockChainReaderMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockChainReader) EXPECT() *MockChainReaderMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// BlockByHash mocks base method.
|
|
func (m *MockChainReader) 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 *MockChainReaderMockRecorder) BlockByHash(ctx, hash any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHash", reflect.TypeOf((*MockChainReader)(nil).BlockByHash), ctx, hash)
|
|
}
|
|
|
|
// BlockByNumber mocks base method.
|
|
func (m *MockChainReader) 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 *MockChainReaderMockRecorder) BlockByNumber(ctx, number any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByNumber", reflect.TypeOf((*MockChainReader)(nil).BlockByNumber), ctx, number)
|
|
}
|
|
|
|
// HeaderByHash mocks base method.
|
|
func (m *MockChainReader) 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 *MockChainReaderMockRecorder) HeaderByHash(ctx, hash any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockChainReader)(nil).HeaderByHash), ctx, hash)
|
|
}
|
|
|
|
// HeaderByNumber mocks base method.
|
|
func (m *MockChainReader) 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 *MockChainReaderMockRecorder) HeaderByNumber(ctx, number any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockChainReader)(nil).HeaderByNumber), ctx, number)
|
|
}
|
|
|
|
// MockCallClient is a mock of CallClient interface.
|
|
type MockCallClient struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockCallClientMockRecorder
|
|
}
|
|
|
|
// MockCallClientMockRecorder is the mock recorder for MockCallClient.
|
|
type MockCallClientMockRecorder struct {
|
|
mock *MockCallClient
|
|
}
|
|
|
|
// NewMockCallClient creates a new mock instance.
|
|
func NewMockCallClient(ctrl *gomock.Controller) *MockCallClient {
|
|
mock := &MockCallClient{ctrl: ctrl}
|
|
mock.recorder = &MockCallClientMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockCallClient) EXPECT() *MockCallClientMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// CallContext mocks base method.
|
|
func (m *MockCallClient) 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 *MockCallClientMockRecorder) 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((*MockCallClient)(nil).CallContext), varargs...)
|
|
}
|
|
|
|
// MockBatchCallClient is a mock of BatchCallClient interface.
|
|
type MockBatchCallClient struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockBatchCallClientMockRecorder
|
|
}
|
|
|
|
// MockBatchCallClientMockRecorder is the mock recorder for MockBatchCallClient.
|
|
type MockBatchCallClientMockRecorder struct {
|
|
mock *MockBatchCallClient
|
|
}
|
|
|
|
// NewMockBatchCallClient creates a new mock instance.
|
|
func NewMockBatchCallClient(ctrl *gomock.Controller) *MockBatchCallClient {
|
|
mock := &MockBatchCallClient{ctrl: ctrl}
|
|
mock.recorder = &MockBatchCallClientMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockBatchCallClient) EXPECT() *MockBatchCallClientMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// BatchCallContext mocks base method.
|
|
func (m *MockBatchCallClient) 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 *MockBatchCallClientMockRecorder) BatchCallContext(ctx, b any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCallContext", reflect.TypeOf((*MockBatchCallClient)(nil).BatchCallContext), ctx, b)
|
|
}
|
|
|
|
// MockRPCClientInterface is a mock of RPCClientInterface interface.
|
|
type MockRPCClientInterface struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockRPCClientInterfaceMockRecorder
|
|
}
|
|
|
|
// MockRPCClientInterfaceMockRecorder is the mock recorder for MockRPCClientInterface.
|
|
type MockRPCClientInterfaceMockRecorder struct {
|
|
mock *MockRPCClientInterface
|
|
}
|
|
|
|
// NewMockRPCClientInterface creates a new mock instance.
|
|
func NewMockRPCClientInterface(ctrl *gomock.Controller) *MockRPCClientInterface {
|
|
mock := &MockRPCClientInterface{ctrl: ctrl}
|
|
mock.recorder = &MockRPCClientInterfaceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockRPCClientInterface) EXPECT() *MockRPCClientInterfaceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// BatchCallContext mocks base method.
|
|
func (m *MockRPCClientInterface) 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 *MockRPCClientInterfaceMockRecorder) BatchCallContext(ctx, b any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCallContext", reflect.TypeOf((*MockRPCClientInterface)(nil).BatchCallContext), ctx, b)
|
|
}
|
|
|
|
// CallContext mocks base method.
|
|
func (m *MockRPCClientInterface) 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 *MockRPCClientInterfaceMockRecorder) 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((*MockRPCClientInterface)(nil).CallContext), varargs...)
|
|
}
|
|
|
|
// MockBaseEthClientInterface is a mock of BaseEthClientInterface interface.
|
|
type MockBaseEthClientInterface struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockBaseEthClientInterfaceMockRecorder
|
|
}
|
|
|
|
// MockBaseEthClientInterfaceMockRecorder is the mock recorder for MockBaseEthClientInterface.
|
|
type MockBaseEthClientInterfaceMockRecorder struct {
|
|
mock *MockBaseEthClientInterface
|
|
}
|
|
|
|
// NewMockBaseEthClientInterface creates a new mock instance.
|
|
func NewMockBaseEthClientInterface(ctrl *gomock.Controller) *MockBaseEthClientInterface {
|
|
mock := &MockBaseEthClientInterface{ctrl: ctrl}
|
|
mock.recorder = &MockBaseEthClientInterfaceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockBaseEthClientInterface) EXPECT() *MockBaseEthClientInterfaceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// BalanceAt mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) BalanceAt(ctx, account, blockNumber any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BalanceAt", reflect.TypeOf((*MockBaseEthClientInterface)(nil).BalanceAt), ctx, account, blockNumber)
|
|
}
|
|
|
|
// BlockByHash mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) BlockByHash(ctx, hash any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHash", reflect.TypeOf((*MockBaseEthClientInterface)(nil).BlockByHash), ctx, hash)
|
|
}
|
|
|
|
// BlockByNumber mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) BlockByNumber(ctx, number any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByNumber", reflect.TypeOf((*MockBaseEthClientInterface)(nil).BlockByNumber), ctx, number)
|
|
}
|
|
|
|
// BlockNumber mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) BlockNumber(ctx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockNumber", reflect.TypeOf((*MockBaseEthClientInterface)(nil).BlockNumber), ctx)
|
|
}
|
|
|
|
// CallContract mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) CallContract(ctx, call, blockNumber any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContract", reflect.TypeOf((*MockBaseEthClientInterface)(nil).CallContract), ctx, call, blockNumber)
|
|
}
|
|
|
|
// Close mocks base method.
|
|
func (m *MockBaseEthClientInterface) Close() {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "Close")
|
|
}
|
|
|
|
// Close indicates an expected call of Close.
|
|
func (mr *MockBaseEthClientInterfaceMockRecorder) Close() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockBaseEthClientInterface)(nil).Close))
|
|
}
|
|
|
|
// CodeAt mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) CodeAt(ctx, account, blockNumber any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CodeAt", reflect.TypeOf((*MockBaseEthClientInterface)(nil).CodeAt), ctx, account, blockNumber)
|
|
}
|
|
|
|
// EstimateGas mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) EstimateGas(ctx, call any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateGas", reflect.TypeOf((*MockBaseEthClientInterface)(nil).EstimateGas), ctx, call)
|
|
}
|
|
|
|
// FeeHistory mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) FeeHistory(ctx, blockCount, lastBlock, rewardPercentiles any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeeHistory", reflect.TypeOf((*MockBaseEthClientInterface)(nil).FeeHistory), ctx, blockCount, lastBlock, rewardPercentiles)
|
|
}
|
|
|
|
// FilterLogs mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) FilterLogs(ctx, q any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterLogs", reflect.TypeOf((*MockBaseEthClientInterface)(nil).FilterLogs), ctx, q)
|
|
}
|
|
|
|
// HeaderByHash mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) HeaderByHash(ctx, hash any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockBaseEthClientInterface)(nil).HeaderByHash), ctx, hash)
|
|
}
|
|
|
|
// HeaderByNumber mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) HeaderByNumber(ctx, number any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockBaseEthClientInterface)(nil).HeaderByNumber), ctx, number)
|
|
}
|
|
|
|
// NonceAt mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) NonceAt(ctx, account, blockNumber any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NonceAt", reflect.TypeOf((*MockBaseEthClientInterface)(nil).NonceAt), ctx, account, blockNumber)
|
|
}
|
|
|
|
// PendingBalanceAt mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) PendingBalanceAt(ctx, account any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingBalanceAt", reflect.TypeOf((*MockBaseEthClientInterface)(nil).PendingBalanceAt), ctx, account)
|
|
}
|
|
|
|
// PendingCallContract mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) PendingCallContract(ctx, call any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingCallContract", reflect.TypeOf((*MockBaseEthClientInterface)(nil).PendingCallContract), ctx, call)
|
|
}
|
|
|
|
// PendingCodeAt mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) PendingCodeAt(ctx, account any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingCodeAt", reflect.TypeOf((*MockBaseEthClientInterface)(nil).PendingCodeAt), ctx, account)
|
|
}
|
|
|
|
// PendingNonceAt mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) PendingNonceAt(ctx, account any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingNonceAt", reflect.TypeOf((*MockBaseEthClientInterface)(nil).PendingNonceAt), ctx, account)
|
|
}
|
|
|
|
// PendingStorageAt mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) PendingStorageAt(ctx, account, key any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingStorageAt", reflect.TypeOf((*MockBaseEthClientInterface)(nil).PendingStorageAt), ctx, account, key)
|
|
}
|
|
|
|
// PendingTransactionCount mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) PendingTransactionCount(ctx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingTransactionCount", reflect.TypeOf((*MockBaseEthClientInterface)(nil).PendingTransactionCount), ctx)
|
|
}
|
|
|
|
// SendTransaction mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) SendTransaction(ctx, tx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTransaction", reflect.TypeOf((*MockBaseEthClientInterface)(nil).SendTransaction), ctx, tx)
|
|
}
|
|
|
|
// StorageAt mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) StorageAt(ctx, account, key, blockNumber any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageAt", reflect.TypeOf((*MockBaseEthClientInterface)(nil).StorageAt), ctx, account, key, blockNumber)
|
|
}
|
|
|
|
// SubscribeFilterLogs mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) SubscribeFilterLogs(ctx, q, ch any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeFilterLogs", reflect.TypeOf((*MockBaseEthClientInterface)(nil).SubscribeFilterLogs), ctx, q, ch)
|
|
}
|
|
|
|
// SuggestGasPrice mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) SuggestGasPrice(ctx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuggestGasPrice", reflect.TypeOf((*MockBaseEthClientInterface)(nil).SuggestGasPrice), ctx)
|
|
}
|
|
|
|
// SyncProgress mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) SyncProgress(ctx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncProgress", reflect.TypeOf((*MockBaseEthClientInterface)(nil).SyncProgress), ctx)
|
|
}
|
|
|
|
// TransactionByHash mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) TransactionByHash(ctx, txHash any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByHash", reflect.TypeOf((*MockBaseEthClientInterface)(nil).TransactionByHash), ctx, txHash)
|
|
}
|
|
|
|
// TransactionReceipt mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) TransactionReceipt(ctx, txHash any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionReceipt", reflect.TypeOf((*MockBaseEthClientInterface)(nil).TransactionReceipt), ctx, txHash)
|
|
}
|
|
|
|
// TransactionSender mocks base method.
|
|
func (m *MockBaseEthClientInterface) 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 *MockBaseEthClientInterfaceMockRecorder) TransactionSender(ctx, tx, block, index any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionSender", reflect.TypeOf((*MockBaseEthClientInterface)(nil).TransactionSender), ctx, tx, block, index)
|
|
}
|
|
|
|
// MockEthClientInterface is a mock of EthClientInterface interface.
|
|
type MockEthClientInterface struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockEthClientInterfaceMockRecorder
|
|
}
|
|
|
|
// MockEthClientInterfaceMockRecorder is the mock recorder for MockEthClientInterface.
|
|
type MockEthClientInterfaceMockRecorder struct {
|
|
mock *MockEthClientInterface
|
|
}
|
|
|
|
// NewMockEthClientInterface creates a new mock instance.
|
|
func NewMockEthClientInterface(ctrl *gomock.Controller) *MockEthClientInterface {
|
|
mock := &MockEthClientInterface{ctrl: ctrl}
|
|
mock.recorder = &MockEthClientInterfaceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockEthClientInterface) EXPECT() *MockEthClientInterfaceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// BalanceAt mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) BalanceAt(ctx, account, blockNumber any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BalanceAt", reflect.TypeOf((*MockEthClientInterface)(nil).BalanceAt), ctx, account, blockNumber)
|
|
}
|
|
|
|
// BatchCallContext mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) BatchCallContext(ctx, b any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCallContext", reflect.TypeOf((*MockEthClientInterface)(nil).BatchCallContext), ctx, b)
|
|
}
|
|
|
|
// BlockByHash mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) BlockByHash(ctx, hash any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHash", reflect.TypeOf((*MockEthClientInterface)(nil).BlockByHash), ctx, hash)
|
|
}
|
|
|
|
// BlockByNumber mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) BlockByNumber(ctx, number any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByNumber", reflect.TypeOf((*MockEthClientInterface)(nil).BlockByNumber), ctx, number)
|
|
}
|
|
|
|
// BlockNumber mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) BlockNumber(ctx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockNumber", reflect.TypeOf((*MockEthClientInterface)(nil).BlockNumber), ctx)
|
|
}
|
|
|
|
// CallContext mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) 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((*MockEthClientInterface)(nil).CallContext), varargs...)
|
|
}
|
|
|
|
// CallContract mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) CallContract(ctx, call, blockNumber any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContract", reflect.TypeOf((*MockEthClientInterface)(nil).CallContract), ctx, call, blockNumber)
|
|
}
|
|
|
|
// Close mocks base method.
|
|
func (m *MockEthClientInterface) Close() {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "Close")
|
|
}
|
|
|
|
// Close indicates an expected call of Close.
|
|
func (mr *MockEthClientInterfaceMockRecorder) Close() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockEthClientInterface)(nil).Close))
|
|
}
|
|
|
|
// CodeAt mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) CodeAt(ctx, account, blockNumber any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CodeAt", reflect.TypeOf((*MockEthClientInterface)(nil).CodeAt), ctx, account, blockNumber)
|
|
}
|
|
|
|
// EstimateGas mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) EstimateGas(ctx, call any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateGas", reflect.TypeOf((*MockEthClientInterface)(nil).EstimateGas), ctx, call)
|
|
}
|
|
|
|
// FeeHistory mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) FeeHistory(ctx, blockCount, lastBlock, rewardPercentiles any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeeHistory", reflect.TypeOf((*MockEthClientInterface)(nil).FeeHistory), ctx, blockCount, lastBlock, rewardPercentiles)
|
|
}
|
|
|
|
// FilterLogs mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) FilterLogs(ctx, q any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterLogs", reflect.TypeOf((*MockEthClientInterface)(nil).FilterLogs), ctx, q)
|
|
}
|
|
|
|
// GetBaseFeeFromBlock mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) GetBaseFeeFromBlock(ctx, blockNumber any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBaseFeeFromBlock", reflect.TypeOf((*MockEthClientInterface)(nil).GetBaseFeeFromBlock), ctx, blockNumber)
|
|
}
|
|
|
|
// HeaderByHash mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) HeaderByHash(ctx, hash any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockEthClientInterface)(nil).HeaderByHash), ctx, hash)
|
|
}
|
|
|
|
// HeaderByNumber mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) HeaderByNumber(ctx, number any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockEthClientInterface)(nil).HeaderByNumber), ctx, number)
|
|
}
|
|
|
|
// NonceAt mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) NonceAt(ctx, account, blockNumber any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NonceAt", reflect.TypeOf((*MockEthClientInterface)(nil).NonceAt), ctx, account, blockNumber)
|
|
}
|
|
|
|
// PendingBalanceAt mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) PendingBalanceAt(ctx, account any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingBalanceAt", reflect.TypeOf((*MockEthClientInterface)(nil).PendingBalanceAt), ctx, account)
|
|
}
|
|
|
|
// PendingCallContract mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) PendingCallContract(ctx, call any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingCallContract", reflect.TypeOf((*MockEthClientInterface)(nil).PendingCallContract), ctx, call)
|
|
}
|
|
|
|
// PendingCodeAt mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) PendingCodeAt(ctx, account any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingCodeAt", reflect.TypeOf((*MockEthClientInterface)(nil).PendingCodeAt), ctx, account)
|
|
}
|
|
|
|
// PendingNonceAt mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) PendingNonceAt(ctx, account any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingNonceAt", reflect.TypeOf((*MockEthClientInterface)(nil).PendingNonceAt), ctx, account)
|
|
}
|
|
|
|
// PendingStorageAt mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) PendingStorageAt(ctx, account, key any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingStorageAt", reflect.TypeOf((*MockEthClientInterface)(nil).PendingStorageAt), ctx, account, key)
|
|
}
|
|
|
|
// PendingTransactionCount mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) PendingTransactionCount(ctx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingTransactionCount", reflect.TypeOf((*MockEthClientInterface)(nil).PendingTransactionCount), ctx)
|
|
}
|
|
|
|
// SendTransaction mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) SendTransaction(ctx, tx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTransaction", reflect.TypeOf((*MockEthClientInterface)(nil).SendTransaction), ctx, tx)
|
|
}
|
|
|
|
// StorageAt mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) StorageAt(ctx, account, key, blockNumber any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageAt", reflect.TypeOf((*MockEthClientInterface)(nil).StorageAt), ctx, account, key, blockNumber)
|
|
}
|
|
|
|
// SubscribeFilterLogs mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) SubscribeFilterLogs(ctx, q, ch any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeFilterLogs", reflect.TypeOf((*MockEthClientInterface)(nil).SubscribeFilterLogs), ctx, q, ch)
|
|
}
|
|
|
|
// SuggestGasPrice mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) SuggestGasPrice(ctx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuggestGasPrice", reflect.TypeOf((*MockEthClientInterface)(nil).SuggestGasPrice), ctx)
|
|
}
|
|
|
|
// SuggestGasTipCap mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) SuggestGasTipCap(ctx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuggestGasTipCap", reflect.TypeOf((*MockEthClientInterface)(nil).SuggestGasTipCap), ctx)
|
|
}
|
|
|
|
// SyncProgress mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) SyncProgress(ctx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncProgress", reflect.TypeOf((*MockEthClientInterface)(nil).SyncProgress), ctx)
|
|
}
|
|
|
|
// TransactionByHash mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) TransactionByHash(ctx, txHash any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByHash", reflect.TypeOf((*MockEthClientInterface)(nil).TransactionByHash), ctx, txHash)
|
|
}
|
|
|
|
// TransactionReceipt mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) TransactionReceipt(ctx, txHash any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionReceipt", reflect.TypeOf((*MockEthClientInterface)(nil).TransactionReceipt), ctx, txHash)
|
|
}
|
|
|
|
// TransactionSender mocks base method.
|
|
func (m *MockEthClientInterface) 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 *MockEthClientInterfaceMockRecorder) TransactionSender(ctx, tx, block, index any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionSender", reflect.TypeOf((*MockEthClientInterface)(nil).TransactionSender), ctx, tx, block, index)
|
|
}
|