gravity_queryclient.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/Gravity-Bridge/Gravity-Bridge/module/x/gravity/types (interfaces: QueryClient)

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

import (
	context "context"
	reflect "reflect"

	types "github.com/Gravity-Bridge/Gravity-Bridge/module/x/gravity/types"
	gomock "github.com/golang/mock/gomock"
	grpc "google.golang.org/grpc"
)

// MockQueryClient is a mock of QueryClient interface.
type MockQueryClient struct {
	ctrl     *gomock.Controller
	recorder *MockQueryClientMockRecorder
}

// MockQueryClientMockRecorder is the mock recorder for MockQueryClient.
type MockQueryClientMockRecorder struct {
	mock *MockQueryClient
}

// NewMockQueryClient creates a new mock instance.
func NewMockQueryClient(ctrl *gomock.Controller) *MockQueryClient {
	mock := &MockQueryClient{ctrl: ctrl}
	mock.recorder = &MockQueryClientMockRecorder{mock}
	return mock
}

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

// BatchConfirms mocks base method.
func (m *MockQueryClient) BatchConfirms(arg0 context.Context, arg1 *types.QueryBatchConfirmsRequest, arg2 ...grpc.CallOption) (*types.QueryBatchConfirmsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchConfirms", varargs...)
	ret0, _ := ret[0].(*types.QueryBatchConfirmsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchConfirms indicates an expected call of BatchConfirms.
func (mr *MockQueryClientMockRecorder) BatchConfirms(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, "BatchConfirms", reflect.TypeOf((*MockQueryClient)(nil).BatchConfirms), varargs...)
}

// BatchFees mocks base method.
func (m *MockQueryClient) BatchFees(arg0 context.Context, arg1 *types.QueryBatchFeeRequest, arg2 ...grpc.CallOption) (*types.QueryBatchFeeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchFees", varargs...)
	ret0, _ := ret[0].(*types.QueryBatchFeeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchFees indicates an expected call of BatchFees.
func (mr *MockQueryClientMockRecorder) BatchFees(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, "BatchFees", reflect.TypeOf((*MockQueryClient)(nil).BatchFees), varargs...)
}

// BatchRequestByNonce mocks base method.
func (m *MockQueryClient) BatchRequestByNonce(arg0 context.Context, arg1 *types.QueryBatchRequestByNonceRequest, arg2 ...grpc.CallOption) (*types.QueryBatchRequestByNonceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchRequestByNonce", varargs...)
	ret0, _ := ret[0].(*types.QueryBatchRequestByNonceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchRequestByNonce indicates an expected call of BatchRequestByNonce.
func (mr *MockQueryClientMockRecorder) BatchRequestByNonce(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, "BatchRequestByNonce", reflect.TypeOf((*MockQueryClient)(nil).BatchRequestByNonce), varargs...)
}

// CurrentValset mocks base method.
func (m *MockQueryClient) CurrentValset(arg0 context.Context, arg1 *types.QueryCurrentValsetRequest, arg2 ...grpc.CallOption) (*types.QueryCurrentValsetResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CurrentValset", varargs...)
	ret0, _ := ret[0].(*types.QueryCurrentValsetResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CurrentValset indicates an expected call of CurrentValset.
func (mr *MockQueryClientMockRecorder) CurrentValset(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, "CurrentValset", reflect.TypeOf((*MockQueryClient)(nil).CurrentValset), varargs...)
}

// DenomToERC20 mocks base method.
func (m *MockQueryClient) DenomToERC20(arg0 context.Context, arg1 *types.QueryDenomToERC20Request, arg2 ...grpc.CallOption) (*types.QueryDenomToERC20Response, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DenomToERC20", varargs...)
	ret0, _ := ret[0].(*types.QueryDenomToERC20Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DenomToERC20 indicates an expected call of DenomToERC20.
func (mr *MockQueryClientMockRecorder) DenomToERC20(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, "DenomToERC20", reflect.TypeOf((*MockQueryClient)(nil).DenomToERC20), varargs...)
}

// ERC20ToDenom mocks base method.
func (m *MockQueryClient) ERC20ToDenom(arg0 context.Context, arg1 *types.QueryERC20ToDenomRequest, arg2 ...grpc.CallOption) (*types.QueryERC20ToDenomResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ERC20ToDenom", varargs...)
	ret0, _ := ret[0].(*types.QueryERC20ToDenomResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ERC20ToDenom indicates an expected call of ERC20ToDenom.
func (mr *MockQueryClientMockRecorder) ERC20ToDenom(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, "ERC20ToDenom", reflect.TypeOf((*MockQueryClient)(nil).ERC20ToDenom), varargs...)
}

// GetAttestations mocks base method.
func (m *MockQueryClient) GetAttestations(arg0 context.Context, arg1 *types.QueryAttestationsRequest, arg2 ...grpc.CallOption) (*types.QueryAttestationsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAttestations", varargs...)
	ret0, _ := ret[0].(*types.QueryAttestationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAttestations indicates an expected call of GetAttestations.
func (mr *MockQueryClientMockRecorder) GetAttestations(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, "GetAttestations", reflect.TypeOf((*MockQueryClient)(nil).GetAttestations), varargs...)
}

// GetDelegateKeyByEth mocks base method.
func (m *MockQueryClient) GetDelegateKeyByEth(arg0 context.Context, arg1 *types.QueryDelegateKeysByEthAddress, arg2 ...grpc.CallOption) (*types.QueryDelegateKeysByEthAddressResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetDelegateKeyByEth", varargs...)
	ret0, _ := ret[0].(*types.QueryDelegateKeysByEthAddressResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDelegateKeyByEth indicates an expected call of GetDelegateKeyByEth.
func (mr *MockQueryClientMockRecorder) GetDelegateKeyByEth(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, "GetDelegateKeyByEth", reflect.TypeOf((*MockQueryClient)(nil).GetDelegateKeyByEth), varargs...)
}

// GetDelegateKeyByOrchestrator mocks base method.
func (m *MockQueryClient) GetDelegateKeyByOrchestrator(arg0 context.Context, arg1 *types.QueryDelegateKeysByOrchestratorAddress, arg2 ...grpc.CallOption) (*types.QueryDelegateKeysByOrchestratorAddressResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetDelegateKeyByOrchestrator", varargs...)
	ret0, _ := ret[0].(*types.QueryDelegateKeysByOrchestratorAddressResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDelegateKeyByOrchestrator indicates an expected call of GetDelegateKeyByOrchestrator.
func (mr *MockQueryClientMockRecorder) GetDelegateKeyByOrchestrator(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, "GetDelegateKeyByOrchestrator", reflect.TypeOf((*MockQueryClient)(nil).GetDelegateKeyByOrchestrator), varargs...)
}

// GetDelegateKeyByValidator mocks base method.
func (m *MockQueryClient) GetDelegateKeyByValidator(arg0 context.Context, arg1 *types.QueryDelegateKeysByValidatorAddress, arg2 ...grpc.CallOption) (*types.QueryDelegateKeysByValidatorAddressResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetDelegateKeyByValidator", varargs...)
	ret0, _ := ret[0].(*types.QueryDelegateKeysByValidatorAddressResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDelegateKeyByValidator indicates an expected call of GetDelegateKeyByValidator.
func (mr *MockQueryClientMockRecorder) GetDelegateKeyByValidator(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, "GetDelegateKeyByValidator", reflect.TypeOf((*MockQueryClient)(nil).GetDelegateKeyByValidator), varargs...)
}

// GetPendingIbcAutoForwards mocks base method.
func (m *MockQueryClient) GetPendingIbcAutoForwards(arg0 context.Context, arg1 *types.QueryPendingIbcAutoForwards, arg2 ...grpc.CallOption) (*types.QueryPendingIbcAutoForwardsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPendingIbcAutoForwards", varargs...)
	ret0, _ := ret[0].(*types.QueryPendingIbcAutoForwardsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPendingIbcAutoForwards indicates an expected call of GetPendingIbcAutoForwards.
func (mr *MockQueryClientMockRecorder) GetPendingIbcAutoForwards(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, "GetPendingIbcAutoForwards", reflect.TypeOf((*MockQueryClient)(nil).GetPendingIbcAutoForwards), varargs...)
}

// GetPendingSendToEth mocks base method.
func (m *MockQueryClient) GetPendingSendToEth(arg0 context.Context, arg1 *types.QueryPendingSendToEth, arg2 ...grpc.CallOption) (*types.QueryPendingSendToEthResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPendingSendToEth", varargs...)
	ret0, _ := ret[0].(*types.QueryPendingSendToEthResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPendingSendToEth indicates an expected call of GetPendingSendToEth.
func (mr *MockQueryClientMockRecorder) GetPendingSendToEth(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, "GetPendingSendToEth", reflect.TypeOf((*MockQueryClient)(nil).GetPendingSendToEth), varargs...)
}

// LastEventNonceByAddr mocks base method.
func (m *MockQueryClient) LastEventNonceByAddr(arg0 context.Context, arg1 *types.QueryLastEventNonceByAddrRequest, arg2 ...grpc.CallOption) (*types.QueryLastEventNonceByAddrResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LastEventNonceByAddr", varargs...)
	ret0, _ := ret[0].(*types.QueryLastEventNonceByAddrResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LastEventNonceByAddr indicates an expected call of LastEventNonceByAddr.
func (mr *MockQueryClientMockRecorder) LastEventNonceByAddr(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, "LastEventNonceByAddr", reflect.TypeOf((*MockQueryClient)(nil).LastEventNonceByAddr), varargs...)
}

// LastPendingBatchRequestByAddr mocks base method.
func (m *MockQueryClient) LastPendingBatchRequestByAddr(arg0 context.Context, arg1 *types.QueryLastPendingBatchRequestByAddrRequest, arg2 ...grpc.CallOption) (*types.QueryLastPendingBatchRequestByAddrResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LastPendingBatchRequestByAddr", varargs...)
	ret0, _ := ret[0].(*types.QueryLastPendingBatchRequestByAddrResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LastPendingBatchRequestByAddr indicates an expected call of LastPendingBatchRequestByAddr.
func (mr *MockQueryClientMockRecorder) LastPendingBatchRequestByAddr(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, "LastPendingBatchRequestByAddr", reflect.TypeOf((*MockQueryClient)(nil).LastPendingBatchRequestByAddr), varargs...)
}

// LastPendingLogicCallByAddr mocks base method.
func (m *MockQueryClient) LastPendingLogicCallByAddr(arg0 context.Context, arg1 *types.QueryLastPendingLogicCallByAddrRequest, arg2 ...grpc.CallOption) (*types.QueryLastPendingLogicCallByAddrResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LastPendingLogicCallByAddr", varargs...)
	ret0, _ := ret[0].(*types.QueryLastPendingLogicCallByAddrResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LastPendingLogicCallByAddr indicates an expected call of LastPendingLogicCallByAddr.
func (mr *MockQueryClientMockRecorder) LastPendingLogicCallByAddr(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, "LastPendingLogicCallByAddr", reflect.TypeOf((*MockQueryClient)(nil).LastPendingLogicCallByAddr), varargs...)
}

// LastPendingValsetRequestByAddr mocks base method.
func (m *MockQueryClient) LastPendingValsetRequestByAddr(arg0 context.Context, arg1 *types.QueryLastPendingValsetRequestByAddrRequest, arg2 ...grpc.CallOption) (*types.QueryLastPendingValsetRequestByAddrResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LastPendingValsetRequestByAddr", varargs...)
	ret0, _ := ret[0].(*types.QueryLastPendingValsetRequestByAddrResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LastPendingValsetRequestByAddr indicates an expected call of LastPendingValsetRequestByAddr.
func (mr *MockQueryClientMockRecorder) LastPendingValsetRequestByAddr(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, "LastPendingValsetRequestByAddr", reflect.TypeOf((*MockQueryClient)(nil).LastPendingValsetRequestByAddr), varargs...)
}

// LastValsetRequests mocks base method.
func (m *MockQueryClient) LastValsetRequests(arg0 context.Context, arg1 *types.QueryLastValsetRequestsRequest, arg2 ...grpc.CallOption) (*types.QueryLastValsetRequestsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LastValsetRequests", varargs...)
	ret0, _ := ret[0].(*types.QueryLastValsetRequestsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LastValsetRequests indicates an expected call of LastValsetRequests.
func (mr *MockQueryClientMockRecorder) LastValsetRequests(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, "LastValsetRequests", reflect.TypeOf((*MockQueryClient)(nil).LastValsetRequests), varargs...)
}

// LogicConfirms mocks base method.
func (m *MockQueryClient) LogicConfirms(arg0 context.Context, arg1 *types.QueryLogicConfirmsRequest, arg2 ...grpc.CallOption) (*types.QueryLogicConfirmsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LogicConfirms", varargs...)
	ret0, _ := ret[0].(*types.QueryLogicConfirmsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LogicConfirms indicates an expected call of LogicConfirms.
func (mr *MockQueryClientMockRecorder) LogicConfirms(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, "LogicConfirms", reflect.TypeOf((*MockQueryClient)(nil).LogicConfirms), varargs...)
}

// OutgoingLogicCalls mocks base method.
func (m *MockQueryClient) OutgoingLogicCalls(arg0 context.Context, arg1 *types.QueryOutgoingLogicCallsRequest, arg2 ...grpc.CallOption) (*types.QueryOutgoingLogicCallsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OutgoingLogicCalls", varargs...)
	ret0, _ := ret[0].(*types.QueryOutgoingLogicCallsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OutgoingLogicCalls indicates an expected call of OutgoingLogicCalls.
func (mr *MockQueryClientMockRecorder) OutgoingLogicCalls(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, "OutgoingLogicCalls", reflect.TypeOf((*MockQueryClient)(nil).OutgoingLogicCalls), varargs...)
}

// OutgoingTxBatches mocks base method.
func (m *MockQueryClient) OutgoingTxBatches(arg0 context.Context, arg1 *types.QueryOutgoingTxBatchesRequest, arg2 ...grpc.CallOption) (*types.QueryOutgoingTxBatchesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OutgoingTxBatches", varargs...)
	ret0, _ := ret[0].(*types.QueryOutgoingTxBatchesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OutgoingTxBatches indicates an expected call of OutgoingTxBatches.
func (mr *MockQueryClientMockRecorder) OutgoingTxBatches(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, "OutgoingTxBatches", reflect.TypeOf((*MockQueryClient)(nil).OutgoingTxBatches), varargs...)
}

// Params mocks base method.
func (m *MockQueryClient) Params(arg0 context.Context, arg1 *types.QueryParamsRequest, arg2 ...grpc.CallOption) (*types.QueryParamsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Params", varargs...)
	ret0, _ := ret[0].(*types.QueryParamsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Params indicates an expected call of Params.
func (mr *MockQueryClientMockRecorder) Params(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, "Params", reflect.TypeOf((*MockQueryClient)(nil).Params), varargs...)
}

// ValsetConfirm mocks base method.
func (m *MockQueryClient) ValsetConfirm(arg0 context.Context, arg1 *types.QueryValsetConfirmRequest, arg2 ...grpc.CallOption) (*types.QueryValsetConfirmResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ValsetConfirm", varargs...)
	ret0, _ := ret[0].(*types.QueryValsetConfirmResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValsetConfirm indicates an expected call of ValsetConfirm.
func (mr *MockQueryClientMockRecorder) ValsetConfirm(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, "ValsetConfirm", reflect.TypeOf((*MockQueryClient)(nil).ValsetConfirm), varargs...)
}

// ValsetConfirmsByNonce mocks base method.
func (m *MockQueryClient) ValsetConfirmsByNonce(arg0 context.Context, arg1 *types.QueryValsetConfirmsByNonceRequest, arg2 ...grpc.CallOption) (*types.QueryValsetConfirmsByNonceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ValsetConfirmsByNonce", varargs...)
	ret0, _ := ret[0].(*types.QueryValsetConfirmsByNonceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValsetConfirmsByNonce indicates an expected call of ValsetConfirmsByNonce.
func (mr *MockQueryClientMockRecorder) ValsetConfirmsByNonce(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, "ValsetConfirmsByNonce", reflect.TypeOf((*MockQueryClient)(nil).ValsetConfirmsByNonce), varargs...)
}

// ValsetRequest mocks base method.
func (m *MockQueryClient) ValsetRequest(arg0 context.Context, arg1 *types.QueryValsetRequestRequest, arg2 ...grpc.CallOption) (*types.QueryValsetRequestResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ValsetRequest", varargs...)
	ret0, _ := ret[0].(*types.QueryValsetRequestResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValsetRequest indicates an expected call of ValsetRequest.
func (mr *MockQueryClientMockRecorder) ValsetRequest(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, "ValsetRequest", reflect.TypeOf((*MockQueryClient)(nil).ValsetRequest), varargs...)
}