cmd/aergocli/cmd/mock_types/mock_types.go
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/aergoio/aergo/v2/types (interfaces: AergoRPCServiceClient)
// Package mock_types is a generated GoMock package.
package mock_types
import (
context "context"
reflect "reflect"
types "github.com/aergoio/aergo/v2/types"
gomock "github.com/golang/mock/gomock"
grpc "google.golang.org/grpc"
)
// MockAergoRPCServiceClient is a mock of AergoRPCServiceClient interface
type MockAergoRPCServiceClient struct {
ctrl *gomock.Controller
recorder *MockAergoRPCServiceClientMockRecorder
}
// MockAergoRPCServiceClientMockRecorder is the mock recorder for MockAergoRPCServiceClient
type MockAergoRPCServiceClientMockRecorder struct {
mock *MockAergoRPCServiceClient
}
// NewMockAergoRPCServiceClient creates a new mock instance
func NewMockAergoRPCServiceClient(ctrl *gomock.Controller) *MockAergoRPCServiceClient {
mock := &MockAergoRPCServiceClient{ctrl: ctrl}
mock.recorder = &MockAergoRPCServiceClientMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockAergoRPCServiceClient) EXPECT() *MockAergoRPCServiceClientMockRecorder {
return m.recorder
}
// Blockchain mocks base method
func (m *MockAergoRPCServiceClient) Blockchain(arg0 context.Context, arg1 *types.Empty, arg2 ...grpc.CallOption) (*types.BlockchainStatus, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Blockchain", varargs...)
ret0, _ := ret[0].(*types.BlockchainStatus)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Blockchain indicates an expected call of Blockchain
func (mr *MockAergoRPCServiceClientMockRecorder) Blockchain(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Blockchain", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).Blockchain), varargs...)
}
// ChainStat mocks base method
func (m *MockAergoRPCServiceClient) ChainStat(arg0 context.Context, arg1 *types.Empty, arg2 ...grpc.CallOption) (*types.ChainStats, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ChainStat", varargs...)
ret0, _ := ret[0].(*types.ChainStats)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ChainStat indicates an expected call of ChainStat
func (mr *MockAergoRPCServiceClientMockRecorder) ChainStat(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainStat", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).ChainStat), varargs...)
}
// ChangeMembership mocks base method
func (m *MockAergoRPCServiceClient) ChangeMembership(arg0 context.Context, arg1 *types.MembershipChange, arg2 ...grpc.CallOption) (*types.MembershipChangeReply, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ChangeMembership", varargs...)
ret0, _ := ret[0].(*types.MembershipChangeReply)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ChangeMembership indicates an expected call of ChangeMembership
func (mr *MockAergoRPCServiceClientMockRecorder) ChangeMembership(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMembership", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).ChangeMembership), varargs...)
}
// CommitTX mocks base method
func (m *MockAergoRPCServiceClient) CommitTX(arg0 context.Context, arg1 *types.TxList, arg2 ...grpc.CallOption) (*types.CommitResultList, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "CommitTX", varargs...)
ret0, _ := ret[0].(*types.CommitResultList)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CommitTX indicates an expected call of CommitTX
func (mr *MockAergoRPCServiceClientMockRecorder) CommitTX(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitTX", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).CommitTX), varargs...)
}
// CreateAccount mocks base method
func (m *MockAergoRPCServiceClient) CreateAccount(arg0 context.Context, arg1 *types.Personal, arg2 ...grpc.CallOption) (*types.Account, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "CreateAccount", varargs...)
ret0, _ := ret[0].(*types.Account)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CreateAccount indicates an expected call of CreateAccount
func (mr *MockAergoRPCServiceClientMockRecorder) CreateAccount(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAccount", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).CreateAccount), varargs...)
}
// ExportAccount mocks base method
func (m *MockAergoRPCServiceClient) ExportAccount(arg0 context.Context, arg1 *types.Personal, arg2 ...grpc.CallOption) (*types.SingleBytes, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ExportAccount", varargs...)
ret0, _ := ret[0].(*types.SingleBytes)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ExportAccount indicates an expected call of ExportAccount
func (mr *MockAergoRPCServiceClientMockRecorder) ExportAccount(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportAccount", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).ExportAccount), varargs...)
}
// ExportAccountKeystore mocks base method
func (m *MockAergoRPCServiceClient) ExportAccountKeystore(arg0 context.Context, arg1 *types.Personal, arg2 ...grpc.CallOption) (*types.SingleBytes, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ExportAccountKeystore", varargs...)
ret0, _ := ret[0].(*types.SingleBytes)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ExportAccountKeystore indicates an expected call of ExportAccountKeystore
func (mr *MockAergoRPCServiceClientMockRecorder) ExportAccountKeystore(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportAccountKeystore", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).ExportAccountKeystore), varargs...)
}
// GetABI mocks base method
func (m *MockAergoRPCServiceClient) GetABI(arg0 context.Context, arg1 *types.SingleBytes, arg2 ...grpc.CallOption) (*types.ABI, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetABI", varargs...)
ret0, _ := ret[0].(*types.ABI)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetABI indicates an expected call of GetABI
func (mr *MockAergoRPCServiceClientMockRecorder) GetABI(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetABI", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetABI), varargs...)
}
// GetAccountVotes mocks base method
func (m *MockAergoRPCServiceClient) GetAccountVotes(arg0 context.Context, arg1 *types.AccountAddress, arg2 ...grpc.CallOption) (*types.AccountVoteInfo, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetAccountVotes", varargs...)
ret0, _ := ret[0].(*types.AccountVoteInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetAccountVotes indicates an expected call of GetAccountVotes
func (mr *MockAergoRPCServiceClientMockRecorder) GetAccountVotes(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountVotes", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetAccountVotes), varargs...)
}
// GetAccounts mocks base method
func (m *MockAergoRPCServiceClient) GetAccounts(arg0 context.Context, arg1 *types.Empty, arg2 ...grpc.CallOption) (*types.AccountList, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetAccounts", varargs...)
ret0, _ := ret[0].(*types.AccountList)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetAccounts indicates an expected call of GetAccounts
func (mr *MockAergoRPCServiceClientMockRecorder) GetAccounts(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccounts", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetAccounts), varargs...)
}
// GetBlock mocks base method
func (m *MockAergoRPCServiceClient) GetBlock(arg0 context.Context, arg1 *types.SingleBytes, arg2 ...grpc.CallOption) (*types.Block, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetBlock", varargs...)
ret0, _ := ret[0].(*types.Block)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetBlock indicates an expected call of GetBlock
func (mr *MockAergoRPCServiceClientMockRecorder) GetBlock(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlock", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetBlock), varargs...)
}
// GetBlockBody mocks base method
func (m *MockAergoRPCServiceClient) GetBlockBody(arg0 context.Context, arg1 *types.BlockBodyParams, arg2 ...grpc.CallOption) (*types.BlockBodyPaged, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetBlockBody", varargs...)
ret0, _ := ret[0].(*types.BlockBodyPaged)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetBlockBody indicates an expected call of GetBlockBody
func (mr *MockAergoRPCServiceClientMockRecorder) GetBlockBody(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockBody", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetBlockBody), varargs...)
}
// GetBlockMetadata mocks base method
func (m *MockAergoRPCServiceClient) GetBlockMetadata(arg0 context.Context, arg1 *types.SingleBytes, arg2 ...grpc.CallOption) (*types.BlockMetadata, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetBlockMetadata", varargs...)
ret0, _ := ret[0].(*types.BlockMetadata)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetBlockMetadata indicates an expected call of GetBlockMetadata
func (mr *MockAergoRPCServiceClientMockRecorder) GetBlockMetadata(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockMetadata", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetBlockMetadata), varargs...)
}
// GetBlockTX mocks base method
func (m *MockAergoRPCServiceClient) GetBlockTX(arg0 context.Context, arg1 *types.SingleBytes, arg2 ...grpc.CallOption) (*types.TxInBlock, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetBlockTX", varargs...)
ret0, _ := ret[0].(*types.TxInBlock)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetBlockTX indicates an expected call of GetBlockTX
func (mr *MockAergoRPCServiceClientMockRecorder) GetBlockTX(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockTX", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetBlockTX), varargs...)
}
// GetChainInfo mocks base method
func (m *MockAergoRPCServiceClient) GetChainInfo(arg0 context.Context, arg1 *types.Empty, arg2 ...grpc.CallOption) (*types.ChainInfo, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetChainInfo", varargs...)
ret0, _ := ret[0].(*types.ChainInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetChainInfo indicates an expected call of GetChainInfo
func (mr *MockAergoRPCServiceClientMockRecorder) GetChainInfo(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChainInfo", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetChainInfo), varargs...)
}
// GetConfChangeProgress mocks base method
func (m *MockAergoRPCServiceClient) GetConfChangeProgress(arg0 context.Context, arg1 *types.SingleBytes, arg2 ...grpc.CallOption) (*types.ConfChangeProgress, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetConfChangeProgress", varargs...)
ret0, _ := ret[0].(*types.ConfChangeProgress)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetConfChangeProgress indicates an expected call of GetConfChangeProgress
func (mr *MockAergoRPCServiceClientMockRecorder) GetConfChangeProgress(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfChangeProgress", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetConfChangeProgress), varargs...)
}
// GetConsensusInfo mocks base method
func (m *MockAergoRPCServiceClient) GetConsensusInfo(arg0 context.Context, arg1 *types.Empty, arg2 ...grpc.CallOption) (*types.ConsensusInfo, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetConsensusInfo", varargs...)
ret0, _ := ret[0].(*types.ConsensusInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetConsensusInfo indicates an expected call of GetConsensusInfo
func (mr *MockAergoRPCServiceClientMockRecorder) GetConsensusInfo(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsensusInfo", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetConsensusInfo), varargs...)
}
// GetEnterpriseConfig mocks base method
func (m *MockAergoRPCServiceClient) GetEnterpriseConfig(arg0 context.Context, arg1 *types.EnterpriseConfigKey, arg2 ...grpc.CallOption) (*types.EnterpriseConfig, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetEnterpriseConfig", varargs...)
ret0, _ := ret[0].(*types.EnterpriseConfig)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetEnterpriseConfig indicates an expected call of GetEnterpriseConfig
func (mr *MockAergoRPCServiceClientMockRecorder) GetEnterpriseConfig(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEnterpriseConfig", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetEnterpriseConfig), varargs...)
}
// GetNameInfo mocks base method
func (m *MockAergoRPCServiceClient) GetNameInfo(arg0 context.Context, arg1 *types.Name, arg2 ...grpc.CallOption) (*types.NameInfo, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetNameInfo", varargs...)
ret0, _ := ret[0].(*types.NameInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetNameInfo indicates an expected call of GetNameInfo
func (mr *MockAergoRPCServiceClientMockRecorder) GetNameInfo(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNameInfo", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetNameInfo), varargs...)
}
// GetPeers mocks base method
func (m *MockAergoRPCServiceClient) GetPeers(arg0 context.Context, arg1 *types.PeersParams, arg2 ...grpc.CallOption) (*types.PeerList, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetPeers", varargs...)
ret0, _ := ret[0].(*types.PeerList)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPeers indicates an expected call of GetPeers
func (mr *MockAergoRPCServiceClientMockRecorder) GetPeers(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPeers", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetPeers), varargs...)
}
// GetReceipt mocks base method
func (m *MockAergoRPCServiceClient) GetReceipt(arg0 context.Context, arg1 *types.SingleBytes, arg2 ...grpc.CallOption) (*types.Receipt, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetReceipt", varargs...)
ret0, _ := ret[0].(*types.Receipt)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetReceipt indicates an expected call of GetReceipt
func (mr *MockAergoRPCServiceClientMockRecorder) GetReceipt(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReceipt", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetReceipt), varargs...)
}
// GetServerInfo mocks base method
func (m *MockAergoRPCServiceClient) GetServerInfo(arg0 context.Context, arg1 *types.KeyParams, arg2 ...grpc.CallOption) (*types.ServerInfo, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetServerInfo", varargs...)
ret0, _ := ret[0].(*types.ServerInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetServerInfo indicates an expected call of GetServerInfo
func (mr *MockAergoRPCServiceClientMockRecorder) GetServerInfo(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerInfo", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetServerInfo), varargs...)
}
// GetStaking mocks base method
func (m *MockAergoRPCServiceClient) GetStaking(arg0 context.Context, arg1 *types.AccountAddress, arg2 ...grpc.CallOption) (*types.Staking, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetStaking", varargs...)
ret0, _ := ret[0].(*types.Staking)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetStaking indicates an expected call of GetStaking
func (mr *MockAergoRPCServiceClientMockRecorder) GetStaking(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStaking", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetStaking), varargs...)
}
// GetState mocks base method
func (m *MockAergoRPCServiceClient) GetState(arg0 context.Context, arg1 *types.SingleBytes, arg2 ...grpc.CallOption) (*types.State, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetState", varargs...)
ret0, _ := ret[0].(*types.State)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetState indicates an expected call of GetState
func (mr *MockAergoRPCServiceClientMockRecorder) GetState(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetState", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetState), varargs...)
}
// GetStateAndProof mocks base method
func (m *MockAergoRPCServiceClient) GetStateAndProof(arg0 context.Context, arg1 *types.AccountAndRoot, arg2 ...grpc.CallOption) (*types.AccountProof, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetStateAndProof", varargs...)
ret0, _ := ret[0].(*types.AccountProof)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetStateAndProof indicates an expected call of GetStateAndProof
func (mr *MockAergoRPCServiceClientMockRecorder) GetStateAndProof(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStateAndProof", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetStateAndProof), varargs...)
}
// GetTX mocks base method
func (m *MockAergoRPCServiceClient) GetTX(arg0 context.Context, arg1 *types.SingleBytes, arg2 ...grpc.CallOption) (*types.Tx, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetTX", varargs...)
ret0, _ := ret[0].(*types.Tx)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetTX indicates an expected call of GetTX
func (mr *MockAergoRPCServiceClientMockRecorder) GetTX(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTX", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetTX), varargs...)
}
// GetVotes mocks base method
func (m *MockAergoRPCServiceClient) GetVotes(arg0 context.Context, arg1 *types.VoteParams, arg2 ...grpc.CallOption) (*types.VoteList, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetVotes", varargs...)
ret0, _ := ret[0].(*types.VoteList)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetVotes indicates an expected call of GetVotes
func (mr *MockAergoRPCServiceClientMockRecorder) GetVotes(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVotes", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).GetVotes), varargs...)
}
// ImportAccount mocks base method
func (m *MockAergoRPCServiceClient) ImportAccount(arg0 context.Context, arg1 *types.ImportFormat, arg2 ...grpc.CallOption) (*types.Account, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ImportAccount", varargs...)
ret0, _ := ret[0].(*types.Account)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ImportAccount indicates an expected call of ImportAccount
func (mr *MockAergoRPCServiceClientMockRecorder) ImportAccount(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportAccount", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).ImportAccount), varargs...)
}
// ListBlockHeaders mocks base method
func (m *MockAergoRPCServiceClient) ListBlockHeaders(arg0 context.Context, arg1 *types.ListParams, arg2 ...grpc.CallOption) (*types.BlockHeaderList, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListBlockHeaders", varargs...)
ret0, _ := ret[0].(*types.BlockHeaderList)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListBlockHeaders indicates an expected call of ListBlockHeaders
func (mr *MockAergoRPCServiceClientMockRecorder) ListBlockHeaders(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBlockHeaders", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).ListBlockHeaders), varargs...)
}
// ListBlockMetadata mocks base method
func (m *MockAergoRPCServiceClient) ListBlockMetadata(arg0 context.Context, arg1 *types.ListParams, arg2 ...grpc.CallOption) (*types.BlockMetadataList, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListBlockMetadata", varargs...)
ret0, _ := ret[0].(*types.BlockMetadataList)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListBlockMetadata indicates an expected call of ListBlockMetadata
func (mr *MockAergoRPCServiceClientMockRecorder) ListBlockMetadata(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBlockMetadata", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).ListBlockMetadata), varargs...)
}
// ListBlockMetadataStream mocks base method
func (m *MockAergoRPCServiceClient) ListBlockMetadataStream(arg0 context.Context, arg1 *types.Empty, arg2 ...grpc.CallOption) (types.AergoRPCService_ListBlockMetadataStreamClient, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListBlockMetadataStream", varargs...)
ret0, _ := ret[0].(types.AergoRPCService_ListBlockMetadataStreamClient)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListBlockMetadataStream indicates an expected call of ListBlockMetadataStream
func (mr *MockAergoRPCServiceClientMockRecorder) ListBlockMetadataStream(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBlockMetadataStream", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).ListBlockMetadataStream), varargs...)
}
// ListBlockStream mocks base method
func (m *MockAergoRPCServiceClient) ListBlockStream(arg0 context.Context, arg1 *types.Empty, arg2 ...grpc.CallOption) (types.AergoRPCService_ListBlockStreamClient, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListBlockStream", varargs...)
ret0, _ := ret[0].(types.AergoRPCService_ListBlockStreamClient)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListBlockStream indicates an expected call of ListBlockStream
func (mr *MockAergoRPCServiceClientMockRecorder) ListBlockStream(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBlockStream", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).ListBlockStream), varargs...)
}
// ListEventStream mocks base method
func (m *MockAergoRPCServiceClient) ListEventStream(arg0 context.Context, arg1 *types.FilterInfo, arg2 ...grpc.CallOption) (types.AergoRPCService_ListEventStreamClient, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListEventStream", varargs...)
ret0, _ := ret[0].(types.AergoRPCService_ListEventStreamClient)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListEventStream indicates an expected call of ListEventStream
func (mr *MockAergoRPCServiceClientMockRecorder) ListEventStream(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEventStream", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).ListEventStream), varargs...)
}
// ListEvents mocks base method
func (m *MockAergoRPCServiceClient) ListEvents(arg0 context.Context, arg1 *types.FilterInfo, arg2 ...grpc.CallOption) (*types.EventList, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListEvents", varargs...)
ret0, _ := ret[0].(*types.EventList)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListEvents indicates an expected call of ListEvents
func (mr *MockAergoRPCServiceClientMockRecorder) ListEvents(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEvents", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).ListEvents), varargs...)
}
// LockAccount mocks base method
func (m *MockAergoRPCServiceClient) LockAccount(arg0 context.Context, arg1 *types.Personal, arg2 ...grpc.CallOption) (*types.Account, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "LockAccount", varargs...)
ret0, _ := ret[0].(*types.Account)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// LockAccount indicates an expected call of LockAccount
func (mr *MockAergoRPCServiceClientMockRecorder) LockAccount(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockAccount", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).LockAccount), varargs...)
}
// Metric mocks base method
func (m *MockAergoRPCServiceClient) Metric(arg0 context.Context, arg1 *types.MetricsRequest, arg2 ...grpc.CallOption) (*types.Metrics, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Metric", varargs...)
ret0, _ := ret[0].(*types.Metrics)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Metric indicates an expected call of Metric
func (mr *MockAergoRPCServiceClientMockRecorder) Metric(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Metric", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).Metric), varargs...)
}
// NodeState mocks base method
func (m *MockAergoRPCServiceClient) NodeState(arg0 context.Context, arg1 *types.NodeReq, arg2 ...grpc.CallOption) (*types.SingleBytes, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "NodeState", varargs...)
ret0, _ := ret[0].(*types.SingleBytes)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// NodeState indicates an expected call of NodeState
func (mr *MockAergoRPCServiceClientMockRecorder) NodeState(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeState", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).NodeState), varargs...)
}
// QueryContract mocks base method
func (m *MockAergoRPCServiceClient) QueryContract(arg0 context.Context, arg1 *types.Query, arg2 ...grpc.CallOption) (*types.SingleBytes, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "QueryContract", varargs...)
ret0, _ := ret[0].(*types.SingleBytes)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// QueryContract indicates an expected call of QueryContract
func (mr *MockAergoRPCServiceClientMockRecorder) QueryContract(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryContract", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).QueryContract), varargs...)
}
// QueryContractState mocks base method
func (m *MockAergoRPCServiceClient) QueryContractState(arg0 context.Context, arg1 *types.StateQuery, arg2 ...grpc.CallOption) (*types.StateQueryProof, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "QueryContractState", varargs...)
ret0, _ := ret[0].(*types.StateQueryProof)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// QueryContractState indicates an expected call of QueryContractState
func (mr *MockAergoRPCServiceClientMockRecorder) QueryContractState(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryContractState", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).QueryContractState), varargs...)
}
// SendTX mocks base method
func (m *MockAergoRPCServiceClient) SendTX(arg0 context.Context, arg1 *types.Tx, arg2 ...grpc.CallOption) (*types.CommitResult, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "SendTX", varargs...)
ret0, _ := ret[0].(*types.CommitResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// SendTX indicates an expected call of SendTX
func (mr *MockAergoRPCServiceClientMockRecorder) SendTX(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTX", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).SendTX), varargs...)
}
// SignTX mocks base method
func (m *MockAergoRPCServiceClient) SignTX(arg0 context.Context, arg1 *types.Tx, arg2 ...grpc.CallOption) (*types.Tx, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "SignTX", varargs...)
ret0, _ := ret[0].(*types.Tx)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// SignTX indicates an expected call of SignTX
func (mr *MockAergoRPCServiceClientMockRecorder) SignTX(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignTX", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).SignTX), varargs...)
}
// UnlockAccount mocks base method
func (m *MockAergoRPCServiceClient) UnlockAccount(arg0 context.Context, arg1 *types.Personal, arg2 ...grpc.CallOption) (*types.Account, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "UnlockAccount", varargs...)
ret0, _ := ret[0].(*types.Account)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// UnlockAccount indicates an expected call of UnlockAccount
func (mr *MockAergoRPCServiceClientMockRecorder) UnlockAccount(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockAccount", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).UnlockAccount), varargs...)
}
// VerifyTX mocks base method
func (m *MockAergoRPCServiceClient) VerifyTX(arg0 context.Context, arg1 *types.Tx, arg2 ...grpc.CallOption) (*types.VerifyResult, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "VerifyTX", varargs...)
ret0, _ := ret[0].(*types.VerifyResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// VerifyTX indicates an expected call of VerifyTX
func (mr *MockAergoRPCServiceClientMockRecorder) VerifyTX(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyTX", reflect.TypeOf((*MockAergoRPCServiceClient)(nil).VerifyTX), varargs...)
}