mirror of
https://github.com/status-im/status-go.git
synced 2025-01-18 02:31:47 +00:00
9a59d6a459
This commit adds support for centralized metrics. There are two providers as of now, and we haven't quite decided which one to go for, so for the time being both are supported. It also introduces a new endpoint InitializeApplication that replaces OpenAccounts
918 lines
35 KiB
Go
918 lines
35 KiB
Go
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: rpc/chain/client.go
|
|
|
|
// Package mock_client is a generated GoMock package.
|
|
package mock_client
|
|
|
|
import (
|
|
context "context"
|
|
big "math/big"
|
|
reflect "reflect"
|
|
|
|
gomock "github.com/golang/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"
|
|
chain "github.com/status-im/status-go/rpc/chain"
|
|
)
|
|
|
|
// 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 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCallContext", reflect.TypeOf((*MockBatchCallClient)(nil).BatchCallContext), ctx, b)
|
|
}
|
|
|
|
// MockChainInterface is a mock of ChainInterface interface.
|
|
type MockChainInterface struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockChainInterfaceMockRecorder
|
|
}
|
|
|
|
// MockChainInterfaceMockRecorder is the mock recorder for MockChainInterface.
|
|
type MockChainInterfaceMockRecorder struct {
|
|
mock *MockChainInterface
|
|
}
|
|
|
|
// NewMockChainInterface creates a new mock instance.
|
|
func NewMockChainInterface(ctrl *gomock.Controller) *MockChainInterface {
|
|
mock := &MockChainInterface{ctrl: ctrl}
|
|
mock.recorder = &MockChainInterfaceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockChainInterface) EXPECT() *MockChainInterfaceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// BalanceAt mocks base method.
|
|
func (m *MockChainInterface) 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 *MockChainInterfaceMockRecorder) BalanceAt(ctx, account, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BalanceAt", reflect.TypeOf((*MockChainInterface)(nil).BalanceAt), ctx, account, blockNumber)
|
|
}
|
|
|
|
// BatchCallContext mocks base method.
|
|
func (m *MockChainInterface) 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 *MockChainInterfaceMockRecorder) BatchCallContext(ctx, b interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCallContext", reflect.TypeOf((*MockChainInterface)(nil).BatchCallContext), ctx, b)
|
|
}
|
|
|
|
// BlockByHash mocks base method.
|
|
func (m *MockChainInterface) 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 *MockChainInterfaceMockRecorder) BlockByHash(ctx, hash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHash", reflect.TypeOf((*MockChainInterface)(nil).BlockByHash), ctx, hash)
|
|
}
|
|
|
|
// BlockByNumber mocks base method.
|
|
func (m *MockChainInterface) 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 *MockChainInterfaceMockRecorder) BlockByNumber(ctx, number interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByNumber", reflect.TypeOf((*MockChainInterface)(nil).BlockByNumber), ctx, number)
|
|
}
|
|
|
|
// BlockNumber mocks base method.
|
|
func (m *MockChainInterface) 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 *MockChainInterfaceMockRecorder) BlockNumber(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockNumber", reflect.TypeOf((*MockChainInterface)(nil).BlockNumber), ctx)
|
|
}
|
|
|
|
// CallBlockHashByTransaction mocks base method.
|
|
func (m *MockChainInterface) CallBlockHashByTransaction(ctx context.Context, blockNumber *big.Int, index uint) (common.Hash, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CallBlockHashByTransaction", ctx, blockNumber, index)
|
|
ret0, _ := ret[0].(common.Hash)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CallBlockHashByTransaction indicates an expected call of CallBlockHashByTransaction.
|
|
func (mr *MockChainInterfaceMockRecorder) CallBlockHashByTransaction(ctx, blockNumber, index interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallBlockHashByTransaction", reflect.TypeOf((*MockChainInterface)(nil).CallBlockHashByTransaction), ctx, blockNumber, index)
|
|
}
|
|
|
|
// CallContext mocks base method.
|
|
func (m *MockChainInterface) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{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 *MockChainInterfaceMockRecorder) CallContext(ctx, result, method interface{}, args ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, result, method}, args...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContext", reflect.TypeOf((*MockChainInterface)(nil).CallContext), varargs...)
|
|
}
|
|
|
|
// CallContract mocks base method.
|
|
func (m *MockChainInterface) 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 *MockChainInterfaceMockRecorder) CallContract(ctx, call, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContract", reflect.TypeOf((*MockChainInterface)(nil).CallContract), ctx, call, blockNumber)
|
|
}
|
|
|
|
// CodeAt mocks base method.
|
|
func (m *MockChainInterface) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CodeAt", ctx, contract, blockNumber)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CodeAt indicates an expected call of CodeAt.
|
|
func (mr *MockChainInterfaceMockRecorder) CodeAt(ctx, contract, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CodeAt", reflect.TypeOf((*MockChainInterface)(nil).CodeAt), ctx, contract, blockNumber)
|
|
}
|
|
|
|
// FilterLogs mocks base method.
|
|
func (m *MockChainInterface) 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 *MockChainInterfaceMockRecorder) FilterLogs(ctx, q interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterLogs", reflect.TypeOf((*MockChainInterface)(nil).FilterLogs), ctx, q)
|
|
}
|
|
|
|
// GetBaseFeeFromBlock mocks base method.
|
|
func (m *MockChainInterface) 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 *MockChainInterfaceMockRecorder) GetBaseFeeFromBlock(ctx, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBaseFeeFromBlock", reflect.TypeOf((*MockChainInterface)(nil).GetBaseFeeFromBlock), ctx, blockNumber)
|
|
}
|
|
|
|
// HeaderByHash mocks base method.
|
|
func (m *MockChainInterface) 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 *MockChainInterfaceMockRecorder) HeaderByHash(ctx, hash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockChainInterface)(nil).HeaderByHash), ctx, hash)
|
|
}
|
|
|
|
// HeaderByNumber mocks base method.
|
|
func (m *MockChainInterface) 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 *MockChainInterfaceMockRecorder) HeaderByNumber(ctx, number interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockChainInterface)(nil).HeaderByNumber), ctx, number)
|
|
}
|
|
|
|
// NetworkID mocks base method.
|
|
func (m *MockChainInterface) NetworkID() uint64 {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "NetworkID")
|
|
ret0, _ := ret[0].(uint64)
|
|
return ret0
|
|
}
|
|
|
|
// NetworkID indicates an expected call of NetworkID.
|
|
func (mr *MockChainInterfaceMockRecorder) NetworkID() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkID", reflect.TypeOf((*MockChainInterface)(nil).NetworkID))
|
|
}
|
|
|
|
// NonceAt mocks base method.
|
|
func (m *MockChainInterface) 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 *MockChainInterfaceMockRecorder) NonceAt(ctx, account, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NonceAt", reflect.TypeOf((*MockChainInterface)(nil).NonceAt), ctx, account, blockNumber)
|
|
}
|
|
|
|
// ToBigInt mocks base method.
|
|
func (m *MockChainInterface) ToBigInt() *big.Int {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ToBigInt")
|
|
ret0, _ := ret[0].(*big.Int)
|
|
return ret0
|
|
}
|
|
|
|
// ToBigInt indicates an expected call of ToBigInt.
|
|
func (mr *MockChainInterfaceMockRecorder) ToBigInt() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToBigInt", reflect.TypeOf((*MockChainInterface)(nil).ToBigInt))
|
|
}
|
|
|
|
// TransactionByHash mocks base method.
|
|
func (m *MockChainInterface) TransactionByHash(ctx context.Context, hash common.Hash) (*types.Transaction, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TransactionByHash", ctx, hash)
|
|
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 *MockChainInterfaceMockRecorder) TransactionByHash(ctx, hash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByHash", reflect.TypeOf((*MockChainInterface)(nil).TransactionByHash), ctx, hash)
|
|
}
|
|
|
|
// TransactionReceipt mocks base method.
|
|
func (m *MockChainInterface) 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 *MockChainInterfaceMockRecorder) TransactionReceipt(ctx, txHash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionReceipt", reflect.TypeOf((*MockChainInterface)(nil).TransactionReceipt), ctx, txHash)
|
|
}
|
|
|
|
// MockClientInterface is a mock of ClientInterface interface.
|
|
type MockClientInterface struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockClientInterfaceMockRecorder
|
|
}
|
|
|
|
// MockClientInterfaceMockRecorder is the mock recorder for MockClientInterface.
|
|
type MockClientInterfaceMockRecorder struct {
|
|
mock *MockClientInterface
|
|
}
|
|
|
|
// NewMockClientInterface creates a new mock instance.
|
|
func NewMockClientInterface(ctrl *gomock.Controller) *MockClientInterface {
|
|
mock := &MockClientInterface{ctrl: ctrl}
|
|
mock.recorder = &MockClientInterfaceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockClientInterface) EXPECT() *MockClientInterfaceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// BalanceAt mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) BalanceAt(ctx, account, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BalanceAt", reflect.TypeOf((*MockClientInterface)(nil).BalanceAt), ctx, account, blockNumber)
|
|
}
|
|
|
|
// BatchCallContext mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) BatchCallContext(ctx, b interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCallContext", reflect.TypeOf((*MockClientInterface)(nil).BatchCallContext), ctx, b)
|
|
}
|
|
|
|
// BlockByHash mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) BlockByHash(ctx, hash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHash", reflect.TypeOf((*MockClientInterface)(nil).BlockByHash), ctx, hash)
|
|
}
|
|
|
|
// BlockByNumber mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) BlockByNumber(ctx, number interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByNumber", reflect.TypeOf((*MockClientInterface)(nil).BlockByNumber), ctx, number)
|
|
}
|
|
|
|
// BlockNumber mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) BlockNumber(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockNumber", reflect.TypeOf((*MockClientInterface)(nil).BlockNumber), ctx)
|
|
}
|
|
|
|
// CallBlockHashByTransaction mocks base method.
|
|
func (m *MockClientInterface) CallBlockHashByTransaction(ctx context.Context, blockNumber *big.Int, index uint) (common.Hash, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CallBlockHashByTransaction", ctx, blockNumber, index)
|
|
ret0, _ := ret[0].(common.Hash)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CallBlockHashByTransaction indicates an expected call of CallBlockHashByTransaction.
|
|
func (mr *MockClientInterfaceMockRecorder) CallBlockHashByTransaction(ctx, blockNumber, index interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallBlockHashByTransaction", reflect.TypeOf((*MockClientInterface)(nil).CallBlockHashByTransaction), ctx, blockNumber, index)
|
|
}
|
|
|
|
// CallContext mocks base method.
|
|
func (m *MockClientInterface) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{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 *MockClientInterfaceMockRecorder) CallContext(ctx, result, method interface{}, args ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, result, method}, args...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContext", reflect.TypeOf((*MockClientInterface)(nil).CallContext), varargs...)
|
|
}
|
|
|
|
// CallContract mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) CallContract(ctx, call, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContract", reflect.TypeOf((*MockClientInterface)(nil).CallContract), ctx, call, blockNumber)
|
|
}
|
|
|
|
// CodeAt mocks base method.
|
|
func (m *MockClientInterface) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CodeAt", ctx, contract, blockNumber)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CodeAt indicates an expected call of CodeAt.
|
|
func (mr *MockClientInterfaceMockRecorder) CodeAt(ctx, contract, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CodeAt", reflect.TypeOf((*MockClientInterface)(nil).CodeAt), ctx, contract, blockNumber)
|
|
}
|
|
|
|
// EstimateGas mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) EstimateGas(ctx, call interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateGas", reflect.TypeOf((*MockClientInterface)(nil).EstimateGas), ctx, call)
|
|
}
|
|
|
|
// FilterLogs mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) FilterLogs(ctx, q interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterLogs", reflect.TypeOf((*MockClientInterface)(nil).FilterLogs), ctx, q)
|
|
}
|
|
|
|
// GetBaseFeeFromBlock mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) GetBaseFeeFromBlock(ctx, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBaseFeeFromBlock", reflect.TypeOf((*MockClientInterface)(nil).GetBaseFeeFromBlock), ctx, blockNumber)
|
|
}
|
|
|
|
// GetLimiter mocks base method.
|
|
func (m *MockClientInterface) GetLimiter() chain.RequestLimiter {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetLimiter")
|
|
ret0, _ := ret[0].(chain.RequestLimiter)
|
|
return ret0
|
|
}
|
|
|
|
// GetLimiter indicates an expected call of GetLimiter.
|
|
func (mr *MockClientInterfaceMockRecorder) GetLimiter() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLimiter", reflect.TypeOf((*MockClientInterface)(nil).GetLimiter))
|
|
}
|
|
|
|
// GetWalletNotifier mocks base method.
|
|
func (m *MockClientInterface) GetWalletNotifier() func(uint64, string) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWalletNotifier")
|
|
ret0, _ := ret[0].(func(uint64, string))
|
|
return ret0
|
|
}
|
|
|
|
// GetWalletNotifier indicates an expected call of GetWalletNotifier.
|
|
func (mr *MockClientInterfaceMockRecorder) GetWalletNotifier() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWalletNotifier", reflect.TypeOf((*MockClientInterface)(nil).GetWalletNotifier))
|
|
}
|
|
|
|
// HeaderByHash mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) HeaderByHash(ctx, hash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockClientInterface)(nil).HeaderByHash), ctx, hash)
|
|
}
|
|
|
|
// HeaderByNumber mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) HeaderByNumber(ctx, number interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockClientInterface)(nil).HeaderByNumber), ctx, number)
|
|
}
|
|
|
|
// IsConnected mocks base method.
|
|
func (m *MockClientInterface) IsConnected() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsConnected")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsConnected indicates an expected call of IsConnected.
|
|
func (mr *MockClientInterfaceMockRecorder) IsConnected() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsConnected", reflect.TypeOf((*MockClientInterface)(nil).IsConnected))
|
|
}
|
|
|
|
// NetworkID mocks base method.
|
|
func (m *MockClientInterface) NetworkID() uint64 {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "NetworkID")
|
|
ret0, _ := ret[0].(uint64)
|
|
return ret0
|
|
}
|
|
|
|
// NetworkID indicates an expected call of NetworkID.
|
|
func (mr *MockClientInterfaceMockRecorder) NetworkID() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkID", reflect.TypeOf((*MockClientInterface)(nil).NetworkID))
|
|
}
|
|
|
|
// NonceAt mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) NonceAt(ctx, account, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NonceAt", reflect.TypeOf((*MockClientInterface)(nil).NonceAt), ctx, account, blockNumber)
|
|
}
|
|
|
|
// PendingCodeAt mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) PendingCodeAt(ctx, account interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingCodeAt", reflect.TypeOf((*MockClientInterface)(nil).PendingCodeAt), ctx, account)
|
|
}
|
|
|
|
// PendingNonceAt mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) PendingNonceAt(ctx, account interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingNonceAt", reflect.TypeOf((*MockClientInterface)(nil).PendingNonceAt), ctx, account)
|
|
}
|
|
|
|
// SendTransaction mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) SendTransaction(ctx, tx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTransaction", reflect.TypeOf((*MockClientInterface)(nil).SendTransaction), ctx, tx)
|
|
}
|
|
|
|
// SetIsConnected mocks base method.
|
|
func (m *MockClientInterface) SetIsConnected(arg0 bool) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetIsConnected", arg0)
|
|
}
|
|
|
|
// SetIsConnected indicates an expected call of SetIsConnected.
|
|
func (mr *MockClientInterfaceMockRecorder) SetIsConnected(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIsConnected", reflect.TypeOf((*MockClientInterface)(nil).SetIsConnected), arg0)
|
|
}
|
|
|
|
// SetLimiter mocks base method.
|
|
func (m *MockClientInterface) SetLimiter(arg0 chain.RequestLimiter) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetLimiter", arg0)
|
|
}
|
|
|
|
// SetLimiter indicates an expected call of SetLimiter.
|
|
func (mr *MockClientInterfaceMockRecorder) SetLimiter(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLimiter", reflect.TypeOf((*MockClientInterface)(nil).SetLimiter), arg0)
|
|
}
|
|
|
|
// SetWalletNotifier mocks base method.
|
|
func (m *MockClientInterface) SetWalletNotifier(notifier func(uint64, string)) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetWalletNotifier", notifier)
|
|
}
|
|
|
|
// SetWalletNotifier indicates an expected call of SetWalletNotifier.
|
|
func (mr *MockClientInterfaceMockRecorder) SetWalletNotifier(notifier interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWalletNotifier", reflect.TypeOf((*MockClientInterface)(nil).SetWalletNotifier), notifier)
|
|
}
|
|
|
|
// SubscribeFilterLogs mocks base method.
|
|
func (m *MockClientInterface) SubscribeFilterLogs(ctx context.Context, query ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SubscribeFilterLogs", ctx, query, ch)
|
|
ret0, _ := ret[0].(ethereum.Subscription)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SubscribeFilterLogs indicates an expected call of SubscribeFilterLogs.
|
|
func (mr *MockClientInterfaceMockRecorder) SubscribeFilterLogs(ctx, query, ch interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeFilterLogs", reflect.TypeOf((*MockClientInterface)(nil).SubscribeFilterLogs), ctx, query, ch)
|
|
}
|
|
|
|
// SuggestGasPrice mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) SuggestGasPrice(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuggestGasPrice", reflect.TypeOf((*MockClientInterface)(nil).SuggestGasPrice), ctx)
|
|
}
|
|
|
|
// SuggestGasTipCap mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) SuggestGasTipCap(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuggestGasTipCap", reflect.TypeOf((*MockClientInterface)(nil).SuggestGasTipCap), ctx)
|
|
}
|
|
|
|
// ToBigInt mocks base method.
|
|
func (m *MockClientInterface) ToBigInt() *big.Int {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ToBigInt")
|
|
ret0, _ := ret[0].(*big.Int)
|
|
return ret0
|
|
}
|
|
|
|
// ToBigInt indicates an expected call of ToBigInt.
|
|
func (mr *MockClientInterfaceMockRecorder) ToBigInt() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToBigInt", reflect.TypeOf((*MockClientInterface)(nil).ToBigInt))
|
|
}
|
|
|
|
// TransactionByHash mocks base method.
|
|
func (m *MockClientInterface) TransactionByHash(ctx context.Context, hash common.Hash) (*types.Transaction, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TransactionByHash", ctx, hash)
|
|
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 *MockClientInterfaceMockRecorder) TransactionByHash(ctx, hash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByHash", reflect.TypeOf((*MockClientInterface)(nil).TransactionByHash), ctx, hash)
|
|
}
|
|
|
|
// TransactionReceipt mocks base method.
|
|
func (m *MockClientInterface) 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 *MockClientInterfaceMockRecorder) TransactionReceipt(ctx, txHash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionReceipt", reflect.TypeOf((*MockClientInterface)(nil).TransactionReceipt), ctx, txHash)
|
|
}
|
|
|
|
// MockTagger is a mock of Tagger interface.
|
|
type MockTagger struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockTaggerMockRecorder
|
|
}
|
|
|
|
// MockTaggerMockRecorder is the mock recorder for MockTagger.
|
|
type MockTaggerMockRecorder struct {
|
|
mock *MockTagger
|
|
}
|
|
|
|
// NewMockTagger creates a new mock instance.
|
|
func NewMockTagger(ctrl *gomock.Controller) *MockTagger {
|
|
mock := &MockTagger{ctrl: ctrl}
|
|
mock.recorder = &MockTaggerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockTagger) EXPECT() *MockTaggerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// DeepCopyTag mocks base method.
|
|
func (m *MockTagger) DeepCopyTag() chain.Tagger {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeepCopyTag")
|
|
ret0, _ := ret[0].(chain.Tagger)
|
|
return ret0
|
|
}
|
|
|
|
// DeepCopyTag indicates an expected call of DeepCopyTag.
|
|
func (mr *MockTaggerMockRecorder) DeepCopyTag() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeepCopyTag", reflect.TypeOf((*MockTagger)(nil).DeepCopyTag))
|
|
}
|
|
|
|
// GroupTag mocks base method.
|
|
func (m *MockTagger) GroupTag() string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GroupTag")
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// GroupTag indicates an expected call of GroupTag.
|
|
func (mr *MockTaggerMockRecorder) GroupTag() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GroupTag", reflect.TypeOf((*MockTagger)(nil).GroupTag))
|
|
}
|
|
|
|
// SetGroupTag mocks base method.
|
|
func (m *MockTagger) SetGroupTag(tag string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetGroupTag", tag)
|
|
}
|
|
|
|
// SetGroupTag indicates an expected call of SetGroupTag.
|
|
func (mr *MockTaggerMockRecorder) SetGroupTag(tag interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGroupTag", reflect.TypeOf((*MockTagger)(nil).SetGroupTag), tag)
|
|
}
|
|
|
|
// SetTag mocks base method.
|
|
func (m *MockTagger) SetTag(tag string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetTag", tag)
|
|
}
|
|
|
|
// SetTag indicates an expected call of SetTag.
|
|
func (mr *MockTaggerMockRecorder) SetTag(tag interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTag", reflect.TypeOf((*MockTagger)(nil).SetTag), tag)
|
|
}
|
|
|
|
// Tag mocks base method.
|
|
func (m *MockTagger) Tag() string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Tag")
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// Tag indicates an expected call of Tag.
|
|
func (mr *MockTaggerMockRecorder) Tag() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tag", reflect.TypeOf((*MockTagger)(nil).Tag))
|
|
}
|