1831 lines
96 KiB
Dart
1831 lines
96 KiB
Dart
//
|
|
// Generated code. Do not modify.
|
|
// source: grpc.proto
|
|
//
|
|
// @dart = 2.12
|
|
|
|
// ignore_for_file: annotate_overrides, camel_case_types, comment_references
|
|
// ignore_for_file: constant_identifier_names, library_prefixes
|
|
// ignore_for_file: non_constant_identifier_names, prefer_final_fields
|
|
// ignore_for_file: unnecessary_import, unnecessary_this, unused_import
|
|
|
|
import 'dart:async' as $async;
|
|
import 'dart:core' as $core;
|
|
|
|
import 'package:grpc/service_api.dart' as $grpc;
|
|
import 'package:protobuf/protobuf.dart' as $pb;
|
|
|
|
import 'grpc.pb.dart' as $0;
|
|
|
|
export 'grpc.pb.dart';
|
|
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.Help')
|
|
class HelpClient extends $grpc.Client {
|
|
static final _$getMethodHelp = $grpc.ClientMethod<$0.GetMethodHelpRequest, $0.GetMethodHelpReply>(
|
|
'/io.haveno.protobuffer.Help/GetMethodHelp',
|
|
($0.GetMethodHelpRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetMethodHelpReply.fromBuffer(value));
|
|
|
|
HelpClient($grpc.ClientChannel channel,
|
|
{$grpc.CallOptions? options,
|
|
$core.Iterable<$grpc.ClientInterceptor>? interceptors})
|
|
: super(channel, options: options,
|
|
interceptors: interceptors);
|
|
|
|
$grpc.ResponseFuture<$0.GetMethodHelpReply> getMethodHelp($0.GetMethodHelpRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getMethodHelp, request, options: options);
|
|
}
|
|
}
|
|
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.Help')
|
|
abstract class HelpServiceBase extends $grpc.Service {
|
|
$core.String get $name => 'io.haveno.protobuffer.Help';
|
|
|
|
HelpServiceBase() {
|
|
$addMethod($grpc.ServiceMethod<$0.GetMethodHelpRequest, $0.GetMethodHelpReply>(
|
|
'GetMethodHelp',
|
|
getMethodHelp_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetMethodHelpRequest.fromBuffer(value),
|
|
($0.GetMethodHelpReply value) => value.writeToBuffer()));
|
|
}
|
|
|
|
$async.Future<$0.GetMethodHelpReply> getMethodHelp_Pre($grpc.ServiceCall call, $async.Future<$0.GetMethodHelpRequest> request) async {
|
|
return getMethodHelp(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetMethodHelpReply> getMethodHelp($grpc.ServiceCall call, $0.GetMethodHelpRequest request);
|
|
}
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.GetVersion')
|
|
class GetVersionClient extends $grpc.Client {
|
|
static final _$getVersion = $grpc.ClientMethod<$0.GetVersionRequest, $0.GetVersionReply>(
|
|
'/io.haveno.protobuffer.GetVersion/GetVersion',
|
|
($0.GetVersionRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetVersionReply.fromBuffer(value));
|
|
|
|
GetVersionClient($grpc.ClientChannel channel,
|
|
{$grpc.CallOptions? options,
|
|
$core.Iterable<$grpc.ClientInterceptor>? interceptors})
|
|
: super(channel, options: options,
|
|
interceptors: interceptors);
|
|
|
|
$grpc.ResponseFuture<$0.GetVersionReply> getVersion($0.GetVersionRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getVersion, request, options: options);
|
|
}
|
|
}
|
|
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.GetVersion')
|
|
abstract class GetVersionServiceBase extends $grpc.Service {
|
|
$core.String get $name => 'io.haveno.protobuffer.GetVersion';
|
|
|
|
GetVersionServiceBase() {
|
|
$addMethod($grpc.ServiceMethod<$0.GetVersionRequest, $0.GetVersionReply>(
|
|
'GetVersion',
|
|
getVersion_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetVersionRequest.fromBuffer(value),
|
|
($0.GetVersionReply value) => value.writeToBuffer()));
|
|
}
|
|
|
|
$async.Future<$0.GetVersionReply> getVersion_Pre($grpc.ServiceCall call, $async.Future<$0.GetVersionRequest> request) async {
|
|
return getVersion(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetVersionReply> getVersion($grpc.ServiceCall call, $0.GetVersionRequest request);
|
|
}
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.Account')
|
|
class AccountClient extends $grpc.Client {
|
|
static final _$accountExists = $grpc.ClientMethod<$0.AccountExistsRequest, $0.AccountExistsReply>(
|
|
'/io.haveno.protobuffer.Account/AccountExists',
|
|
($0.AccountExistsRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.AccountExistsReply.fromBuffer(value));
|
|
static final _$isAccountOpen = $grpc.ClientMethod<$0.IsAccountOpenRequest, $0.IsAccountOpenReply>(
|
|
'/io.haveno.protobuffer.Account/IsAccountOpen',
|
|
($0.IsAccountOpenRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.IsAccountOpenReply.fromBuffer(value));
|
|
static final _$createAccount = $grpc.ClientMethod<$0.CreateAccountRequest, $0.CreateAccountReply>(
|
|
'/io.haveno.protobuffer.Account/CreateAccount',
|
|
($0.CreateAccountRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.CreateAccountReply.fromBuffer(value));
|
|
static final _$openAccount = $grpc.ClientMethod<$0.OpenAccountRequest, $0.OpenAccountReply>(
|
|
'/io.haveno.protobuffer.Account/OpenAccount',
|
|
($0.OpenAccountRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.OpenAccountReply.fromBuffer(value));
|
|
static final _$isAppInitialized = $grpc.ClientMethod<$0.IsAppInitializedRequest, $0.IsAppInitializedReply>(
|
|
'/io.haveno.protobuffer.Account/IsAppInitialized',
|
|
($0.IsAppInitializedRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.IsAppInitializedReply.fromBuffer(value));
|
|
static final _$changePassword = $grpc.ClientMethod<$0.ChangePasswordRequest, $0.ChangePasswordReply>(
|
|
'/io.haveno.protobuffer.Account/ChangePassword',
|
|
($0.ChangePasswordRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.ChangePasswordReply.fromBuffer(value));
|
|
static final _$closeAccount = $grpc.ClientMethod<$0.CloseAccountRequest, $0.CloseAccountReply>(
|
|
'/io.haveno.protobuffer.Account/CloseAccount',
|
|
($0.CloseAccountRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.CloseAccountReply.fromBuffer(value));
|
|
static final _$deleteAccount = $grpc.ClientMethod<$0.DeleteAccountRequest, $0.DeleteAccountReply>(
|
|
'/io.haveno.protobuffer.Account/DeleteAccount',
|
|
($0.DeleteAccountRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.DeleteAccountReply.fromBuffer(value));
|
|
static final _$backupAccount = $grpc.ClientMethod<$0.BackupAccountRequest, $0.BackupAccountReply>(
|
|
'/io.haveno.protobuffer.Account/BackupAccount',
|
|
($0.BackupAccountRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.BackupAccountReply.fromBuffer(value));
|
|
static final _$restoreAccount = $grpc.ClientMethod<$0.RestoreAccountRequest, $0.RestoreAccountReply>(
|
|
'/io.haveno.protobuffer.Account/RestoreAccount',
|
|
($0.RestoreAccountRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.RestoreAccountReply.fromBuffer(value));
|
|
|
|
AccountClient($grpc.ClientChannel channel,
|
|
{$grpc.CallOptions? options,
|
|
$core.Iterable<$grpc.ClientInterceptor>? interceptors})
|
|
: super(channel, options: options,
|
|
interceptors: interceptors);
|
|
|
|
$grpc.ResponseFuture<$0.AccountExistsReply> accountExists($0.AccountExistsRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$accountExists, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.IsAccountOpenReply> isAccountOpen($0.IsAccountOpenRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$isAccountOpen, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.CreateAccountReply> createAccount($0.CreateAccountRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$createAccount, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.OpenAccountReply> openAccount($0.OpenAccountRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$openAccount, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.IsAppInitializedReply> isAppInitialized($0.IsAppInitializedRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$isAppInitialized, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.ChangePasswordReply> changePassword($0.ChangePasswordRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$changePassword, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.CloseAccountReply> closeAccount($0.CloseAccountRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$closeAccount, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.DeleteAccountReply> deleteAccount($0.DeleteAccountRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$deleteAccount, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseStream<$0.BackupAccountReply> backupAccount($0.BackupAccountRequest request, {$grpc.CallOptions? options}) {
|
|
return $createStreamingCall(_$backupAccount, $async.Stream.fromIterable([request]), options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.RestoreAccountReply> restoreAccount($0.RestoreAccountRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$restoreAccount, request, options: options);
|
|
}
|
|
}
|
|
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.Account')
|
|
abstract class AccountServiceBase extends $grpc.Service {
|
|
$core.String get $name => 'io.haveno.protobuffer.Account';
|
|
|
|
AccountServiceBase() {
|
|
$addMethod($grpc.ServiceMethod<$0.AccountExistsRequest, $0.AccountExistsReply>(
|
|
'AccountExists',
|
|
accountExists_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.AccountExistsRequest.fromBuffer(value),
|
|
($0.AccountExistsReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.IsAccountOpenRequest, $0.IsAccountOpenReply>(
|
|
'IsAccountOpen',
|
|
isAccountOpen_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.IsAccountOpenRequest.fromBuffer(value),
|
|
($0.IsAccountOpenReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.CreateAccountRequest, $0.CreateAccountReply>(
|
|
'CreateAccount',
|
|
createAccount_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.CreateAccountRequest.fromBuffer(value),
|
|
($0.CreateAccountReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.OpenAccountRequest, $0.OpenAccountReply>(
|
|
'OpenAccount',
|
|
openAccount_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.OpenAccountRequest.fromBuffer(value),
|
|
($0.OpenAccountReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.IsAppInitializedRequest, $0.IsAppInitializedReply>(
|
|
'IsAppInitialized',
|
|
isAppInitialized_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.IsAppInitializedRequest.fromBuffer(value),
|
|
($0.IsAppInitializedReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.ChangePasswordRequest, $0.ChangePasswordReply>(
|
|
'ChangePassword',
|
|
changePassword_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.ChangePasswordRequest.fromBuffer(value),
|
|
($0.ChangePasswordReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.CloseAccountRequest, $0.CloseAccountReply>(
|
|
'CloseAccount',
|
|
closeAccount_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.CloseAccountRequest.fromBuffer(value),
|
|
($0.CloseAccountReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.DeleteAccountRequest, $0.DeleteAccountReply>(
|
|
'DeleteAccount',
|
|
deleteAccount_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.DeleteAccountRequest.fromBuffer(value),
|
|
($0.DeleteAccountReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.BackupAccountRequest, $0.BackupAccountReply>(
|
|
'BackupAccount',
|
|
backupAccount_Pre,
|
|
false,
|
|
true,
|
|
($core.List<$core.int> value) => $0.BackupAccountRequest.fromBuffer(value),
|
|
($0.BackupAccountReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.RestoreAccountRequest, $0.RestoreAccountReply>(
|
|
'RestoreAccount',
|
|
restoreAccount_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.RestoreAccountRequest.fromBuffer(value),
|
|
($0.RestoreAccountReply value) => value.writeToBuffer()));
|
|
}
|
|
|
|
$async.Future<$0.AccountExistsReply> accountExists_Pre($grpc.ServiceCall call, $async.Future<$0.AccountExistsRequest> request) async {
|
|
return accountExists(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.IsAccountOpenReply> isAccountOpen_Pre($grpc.ServiceCall call, $async.Future<$0.IsAccountOpenRequest> request) async {
|
|
return isAccountOpen(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.CreateAccountReply> createAccount_Pre($grpc.ServiceCall call, $async.Future<$0.CreateAccountRequest> request) async {
|
|
return createAccount(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.OpenAccountReply> openAccount_Pre($grpc.ServiceCall call, $async.Future<$0.OpenAccountRequest> request) async {
|
|
return openAccount(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.IsAppInitializedReply> isAppInitialized_Pre($grpc.ServiceCall call, $async.Future<$0.IsAppInitializedRequest> request) async {
|
|
return isAppInitialized(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.ChangePasswordReply> changePassword_Pre($grpc.ServiceCall call, $async.Future<$0.ChangePasswordRequest> request) async {
|
|
return changePassword(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.CloseAccountReply> closeAccount_Pre($grpc.ServiceCall call, $async.Future<$0.CloseAccountRequest> request) async {
|
|
return closeAccount(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.DeleteAccountReply> deleteAccount_Pre($grpc.ServiceCall call, $async.Future<$0.DeleteAccountRequest> request) async {
|
|
return deleteAccount(call, await request);
|
|
}
|
|
|
|
$async.Stream<$0.BackupAccountReply> backupAccount_Pre($grpc.ServiceCall call, $async.Future<$0.BackupAccountRequest> request) async* {
|
|
yield* backupAccount(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.RestoreAccountReply> restoreAccount_Pre($grpc.ServiceCall call, $async.Future<$0.RestoreAccountRequest> request) async {
|
|
return restoreAccount(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.AccountExistsReply> accountExists($grpc.ServiceCall call, $0.AccountExistsRequest request);
|
|
$async.Future<$0.IsAccountOpenReply> isAccountOpen($grpc.ServiceCall call, $0.IsAccountOpenRequest request);
|
|
$async.Future<$0.CreateAccountReply> createAccount($grpc.ServiceCall call, $0.CreateAccountRequest request);
|
|
$async.Future<$0.OpenAccountReply> openAccount($grpc.ServiceCall call, $0.OpenAccountRequest request);
|
|
$async.Future<$0.IsAppInitializedReply> isAppInitialized($grpc.ServiceCall call, $0.IsAppInitializedRequest request);
|
|
$async.Future<$0.ChangePasswordReply> changePassword($grpc.ServiceCall call, $0.ChangePasswordRequest request);
|
|
$async.Future<$0.CloseAccountReply> closeAccount($grpc.ServiceCall call, $0.CloseAccountRequest request);
|
|
$async.Future<$0.DeleteAccountReply> deleteAccount($grpc.ServiceCall call, $0.DeleteAccountRequest request);
|
|
$async.Stream<$0.BackupAccountReply> backupAccount($grpc.ServiceCall call, $0.BackupAccountRequest request);
|
|
$async.Future<$0.RestoreAccountReply> restoreAccount($grpc.ServiceCall call, $0.RestoreAccountRequest request);
|
|
}
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.Disputes')
|
|
class DisputesClient extends $grpc.Client {
|
|
static final _$getDispute = $grpc.ClientMethod<$0.GetDisputeRequest, $0.GetDisputeReply>(
|
|
'/io.haveno.protobuffer.Disputes/GetDispute',
|
|
($0.GetDisputeRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetDisputeReply.fromBuffer(value));
|
|
static final _$getDisputes = $grpc.ClientMethod<$0.GetDisputesRequest, $0.GetDisputesReply>(
|
|
'/io.haveno.protobuffer.Disputes/GetDisputes',
|
|
($0.GetDisputesRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetDisputesReply.fromBuffer(value));
|
|
static final _$openDispute = $grpc.ClientMethod<$0.OpenDisputeRequest, $0.OpenDisputeReply>(
|
|
'/io.haveno.protobuffer.Disputes/OpenDispute',
|
|
($0.OpenDisputeRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.OpenDisputeReply.fromBuffer(value));
|
|
static final _$resolveDispute = $grpc.ClientMethod<$0.ResolveDisputeRequest, $0.ResolveDisputeReply>(
|
|
'/io.haveno.protobuffer.Disputes/ResolveDispute',
|
|
($0.ResolveDisputeRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.ResolveDisputeReply.fromBuffer(value));
|
|
static final _$sendDisputeChatMessage = $grpc.ClientMethod<$0.SendDisputeChatMessageRequest, $0.SendDisputeChatMessageReply>(
|
|
'/io.haveno.protobuffer.Disputes/SendDisputeChatMessage',
|
|
($0.SendDisputeChatMessageRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.SendDisputeChatMessageReply.fromBuffer(value));
|
|
|
|
DisputesClient($grpc.ClientChannel channel,
|
|
{$grpc.CallOptions? options,
|
|
$core.Iterable<$grpc.ClientInterceptor>? interceptors})
|
|
: super(channel, options: options,
|
|
interceptors: interceptors);
|
|
|
|
$grpc.ResponseFuture<$0.GetDisputeReply> getDispute($0.GetDisputeRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getDispute, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetDisputesReply> getDisputes($0.GetDisputesRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getDisputes, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.OpenDisputeReply> openDispute($0.OpenDisputeRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$openDispute, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.ResolveDisputeReply> resolveDispute($0.ResolveDisputeRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$resolveDispute, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.SendDisputeChatMessageReply> sendDisputeChatMessage($0.SendDisputeChatMessageRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$sendDisputeChatMessage, request, options: options);
|
|
}
|
|
}
|
|
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.Disputes')
|
|
abstract class DisputesServiceBase extends $grpc.Service {
|
|
$core.String get $name => 'io.haveno.protobuffer.Disputes';
|
|
|
|
DisputesServiceBase() {
|
|
$addMethod($grpc.ServiceMethod<$0.GetDisputeRequest, $0.GetDisputeReply>(
|
|
'GetDispute',
|
|
getDispute_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetDisputeRequest.fromBuffer(value),
|
|
($0.GetDisputeReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetDisputesRequest, $0.GetDisputesReply>(
|
|
'GetDisputes',
|
|
getDisputes_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetDisputesRequest.fromBuffer(value),
|
|
($0.GetDisputesReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.OpenDisputeRequest, $0.OpenDisputeReply>(
|
|
'OpenDispute',
|
|
openDispute_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.OpenDisputeRequest.fromBuffer(value),
|
|
($0.OpenDisputeReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.ResolveDisputeRequest, $0.ResolveDisputeReply>(
|
|
'ResolveDispute',
|
|
resolveDispute_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.ResolveDisputeRequest.fromBuffer(value),
|
|
($0.ResolveDisputeReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.SendDisputeChatMessageRequest, $0.SendDisputeChatMessageReply>(
|
|
'SendDisputeChatMessage',
|
|
sendDisputeChatMessage_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.SendDisputeChatMessageRequest.fromBuffer(value),
|
|
($0.SendDisputeChatMessageReply value) => value.writeToBuffer()));
|
|
}
|
|
|
|
$async.Future<$0.GetDisputeReply> getDispute_Pre($grpc.ServiceCall call, $async.Future<$0.GetDisputeRequest> request) async {
|
|
return getDispute(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetDisputesReply> getDisputes_Pre($grpc.ServiceCall call, $async.Future<$0.GetDisputesRequest> request) async {
|
|
return getDisputes(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.OpenDisputeReply> openDispute_Pre($grpc.ServiceCall call, $async.Future<$0.OpenDisputeRequest> request) async {
|
|
return openDispute(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.ResolveDisputeReply> resolveDispute_Pre($grpc.ServiceCall call, $async.Future<$0.ResolveDisputeRequest> request) async {
|
|
return resolveDispute(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.SendDisputeChatMessageReply> sendDisputeChatMessage_Pre($grpc.ServiceCall call, $async.Future<$0.SendDisputeChatMessageRequest> request) async {
|
|
return sendDisputeChatMessage(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetDisputeReply> getDispute($grpc.ServiceCall call, $0.GetDisputeRequest request);
|
|
$async.Future<$0.GetDisputesReply> getDisputes($grpc.ServiceCall call, $0.GetDisputesRequest request);
|
|
$async.Future<$0.OpenDisputeReply> openDispute($grpc.ServiceCall call, $0.OpenDisputeRequest request);
|
|
$async.Future<$0.ResolveDisputeReply> resolveDispute($grpc.ServiceCall call, $0.ResolveDisputeRequest request);
|
|
$async.Future<$0.SendDisputeChatMessageReply> sendDisputeChatMessage($grpc.ServiceCall call, $0.SendDisputeChatMessageRequest request);
|
|
}
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.DisputeAgents')
|
|
class DisputeAgentsClient extends $grpc.Client {
|
|
static final _$registerDisputeAgent = $grpc.ClientMethod<$0.RegisterDisputeAgentRequest, $0.RegisterDisputeAgentReply>(
|
|
'/io.haveno.protobuffer.DisputeAgents/RegisterDisputeAgent',
|
|
($0.RegisterDisputeAgentRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.RegisterDisputeAgentReply.fromBuffer(value));
|
|
static final _$unregisterDisputeAgent = $grpc.ClientMethod<$0.UnregisterDisputeAgentRequest, $0.UnregisterDisputeAgentReply>(
|
|
'/io.haveno.protobuffer.DisputeAgents/UnregisterDisputeAgent',
|
|
($0.UnregisterDisputeAgentRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.UnregisterDisputeAgentReply.fromBuffer(value));
|
|
|
|
DisputeAgentsClient($grpc.ClientChannel channel,
|
|
{$grpc.CallOptions? options,
|
|
$core.Iterable<$grpc.ClientInterceptor>? interceptors})
|
|
: super(channel, options: options,
|
|
interceptors: interceptors);
|
|
|
|
$grpc.ResponseFuture<$0.RegisterDisputeAgentReply> registerDisputeAgent($0.RegisterDisputeAgentRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$registerDisputeAgent, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.UnregisterDisputeAgentReply> unregisterDisputeAgent($0.UnregisterDisputeAgentRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$unregisterDisputeAgent, request, options: options);
|
|
}
|
|
}
|
|
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.DisputeAgents')
|
|
abstract class DisputeAgentsServiceBase extends $grpc.Service {
|
|
$core.String get $name => 'io.haveno.protobuffer.DisputeAgents';
|
|
|
|
DisputeAgentsServiceBase() {
|
|
$addMethod($grpc.ServiceMethod<$0.RegisterDisputeAgentRequest, $0.RegisterDisputeAgentReply>(
|
|
'RegisterDisputeAgent',
|
|
registerDisputeAgent_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.RegisterDisputeAgentRequest.fromBuffer(value),
|
|
($0.RegisterDisputeAgentReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.UnregisterDisputeAgentRequest, $0.UnregisterDisputeAgentReply>(
|
|
'UnregisterDisputeAgent',
|
|
unregisterDisputeAgent_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.UnregisterDisputeAgentRequest.fromBuffer(value),
|
|
($0.UnregisterDisputeAgentReply value) => value.writeToBuffer()));
|
|
}
|
|
|
|
$async.Future<$0.RegisterDisputeAgentReply> registerDisputeAgent_Pre($grpc.ServiceCall call, $async.Future<$0.RegisterDisputeAgentRequest> request) async {
|
|
return registerDisputeAgent(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.UnregisterDisputeAgentReply> unregisterDisputeAgent_Pre($grpc.ServiceCall call, $async.Future<$0.UnregisterDisputeAgentRequest> request) async {
|
|
return unregisterDisputeAgent(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.RegisterDisputeAgentReply> registerDisputeAgent($grpc.ServiceCall call, $0.RegisterDisputeAgentRequest request);
|
|
$async.Future<$0.UnregisterDisputeAgentReply> unregisterDisputeAgent($grpc.ServiceCall call, $0.UnregisterDisputeAgentRequest request);
|
|
}
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.Notifications')
|
|
class NotificationsClient extends $grpc.Client {
|
|
static final _$registerNotificationListener = $grpc.ClientMethod<$0.RegisterNotificationListenerRequest, $0.NotificationMessage>(
|
|
'/io.haveno.protobuffer.Notifications/RegisterNotificationListener',
|
|
($0.RegisterNotificationListenerRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.NotificationMessage.fromBuffer(value));
|
|
static final _$sendNotification = $grpc.ClientMethod<$0.SendNotificationRequest, $0.SendNotificationReply>(
|
|
'/io.haveno.protobuffer.Notifications/SendNotification',
|
|
($0.SendNotificationRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.SendNotificationReply.fromBuffer(value));
|
|
|
|
NotificationsClient($grpc.ClientChannel channel,
|
|
{$grpc.CallOptions? options,
|
|
$core.Iterable<$grpc.ClientInterceptor>? interceptors})
|
|
: super(channel, options: options,
|
|
interceptors: interceptors);
|
|
|
|
$grpc.ResponseStream<$0.NotificationMessage> registerNotificationListener($0.RegisterNotificationListenerRequest request, {$grpc.CallOptions? options}) {
|
|
return $createStreamingCall(_$registerNotificationListener, $async.Stream.fromIterable([request]), options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.SendNotificationReply> sendNotification($0.SendNotificationRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$sendNotification, request, options: options);
|
|
}
|
|
}
|
|
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.Notifications')
|
|
abstract class NotificationsServiceBase extends $grpc.Service {
|
|
$core.String get $name => 'io.haveno.protobuffer.Notifications';
|
|
|
|
NotificationsServiceBase() {
|
|
$addMethod($grpc.ServiceMethod<$0.RegisterNotificationListenerRequest, $0.NotificationMessage>(
|
|
'RegisterNotificationListener',
|
|
registerNotificationListener_Pre,
|
|
false,
|
|
true,
|
|
($core.List<$core.int> value) => $0.RegisterNotificationListenerRequest.fromBuffer(value),
|
|
($0.NotificationMessage value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.SendNotificationRequest, $0.SendNotificationReply>(
|
|
'SendNotification',
|
|
sendNotification_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.SendNotificationRequest.fromBuffer(value),
|
|
($0.SendNotificationReply value) => value.writeToBuffer()));
|
|
}
|
|
|
|
$async.Stream<$0.NotificationMessage> registerNotificationListener_Pre($grpc.ServiceCall call, $async.Future<$0.RegisterNotificationListenerRequest> request) async* {
|
|
yield* registerNotificationListener(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.SendNotificationReply> sendNotification_Pre($grpc.ServiceCall call, $async.Future<$0.SendNotificationRequest> request) async {
|
|
return sendNotification(call, await request);
|
|
}
|
|
|
|
$async.Stream<$0.NotificationMessage> registerNotificationListener($grpc.ServiceCall call, $0.RegisterNotificationListenerRequest request);
|
|
$async.Future<$0.SendNotificationReply> sendNotification($grpc.ServiceCall call, $0.SendNotificationRequest request);
|
|
}
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.XmrConnections')
|
|
class XmrConnectionsClient extends $grpc.Client {
|
|
static final _$addConnection = $grpc.ClientMethod<$0.AddConnectionRequest, $0.AddConnectionReply>(
|
|
'/io.haveno.protobuffer.XmrConnections/AddConnection',
|
|
($0.AddConnectionRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.AddConnectionReply.fromBuffer(value));
|
|
static final _$removeConnection = $grpc.ClientMethod<$0.RemoveConnectionRequest, $0.RemoveConnectionReply>(
|
|
'/io.haveno.protobuffer.XmrConnections/RemoveConnection',
|
|
($0.RemoveConnectionRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.RemoveConnectionReply.fromBuffer(value));
|
|
static final _$getConnection = $grpc.ClientMethod<$0.GetConnectionRequest, $0.GetConnectionReply>(
|
|
'/io.haveno.protobuffer.XmrConnections/GetConnection',
|
|
($0.GetConnectionRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetConnectionReply.fromBuffer(value));
|
|
static final _$getConnections = $grpc.ClientMethod<$0.GetConnectionsRequest, $0.GetConnectionsReply>(
|
|
'/io.haveno.protobuffer.XmrConnections/GetConnections',
|
|
($0.GetConnectionsRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetConnectionsReply.fromBuffer(value));
|
|
static final _$setConnection = $grpc.ClientMethod<$0.SetConnectionRequest, $0.SetConnectionReply>(
|
|
'/io.haveno.protobuffer.XmrConnections/SetConnection',
|
|
($0.SetConnectionRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.SetConnectionReply.fromBuffer(value));
|
|
static final _$checkConnection = $grpc.ClientMethod<$0.CheckConnectionRequest, $0.CheckConnectionReply>(
|
|
'/io.haveno.protobuffer.XmrConnections/CheckConnection',
|
|
($0.CheckConnectionRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.CheckConnectionReply.fromBuffer(value));
|
|
static final _$checkConnections = $grpc.ClientMethod<$0.CheckConnectionsRequest, $0.CheckConnectionsReply>(
|
|
'/io.haveno.protobuffer.XmrConnections/CheckConnections',
|
|
($0.CheckConnectionsRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.CheckConnectionsReply.fromBuffer(value));
|
|
static final _$startCheckingConnection = $grpc.ClientMethod<$0.StartCheckingConnectionRequest, $0.StartCheckingConnectionReply>(
|
|
'/io.haveno.protobuffer.XmrConnections/StartCheckingConnection',
|
|
($0.StartCheckingConnectionRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.StartCheckingConnectionReply.fromBuffer(value));
|
|
static final _$stopCheckingConnection = $grpc.ClientMethod<$0.StopCheckingConnectionRequest, $0.StopCheckingConnectionReply>(
|
|
'/io.haveno.protobuffer.XmrConnections/StopCheckingConnection',
|
|
($0.StopCheckingConnectionRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.StopCheckingConnectionReply.fromBuffer(value));
|
|
static final _$getBestAvailableConnection = $grpc.ClientMethod<$0.GetBestAvailableConnectionRequest, $0.GetBestAvailableConnectionReply>(
|
|
'/io.haveno.protobuffer.XmrConnections/GetBestAvailableConnection',
|
|
($0.GetBestAvailableConnectionRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetBestAvailableConnectionReply.fromBuffer(value));
|
|
static final _$setAutoSwitch = $grpc.ClientMethod<$0.SetAutoSwitchRequest, $0.SetAutoSwitchReply>(
|
|
'/io.haveno.protobuffer.XmrConnections/SetAutoSwitch',
|
|
($0.SetAutoSwitchRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.SetAutoSwitchReply.fromBuffer(value));
|
|
|
|
XmrConnectionsClient($grpc.ClientChannel channel,
|
|
{$grpc.CallOptions? options,
|
|
$core.Iterable<$grpc.ClientInterceptor>? interceptors})
|
|
: super(channel, options: options,
|
|
interceptors: interceptors);
|
|
|
|
$grpc.ResponseFuture<$0.AddConnectionReply> addConnection($0.AddConnectionRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$addConnection, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.RemoveConnectionReply> removeConnection($0.RemoveConnectionRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$removeConnection, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetConnectionReply> getConnection($0.GetConnectionRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getConnection, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetConnectionsReply> getConnections($0.GetConnectionsRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getConnections, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.SetConnectionReply> setConnection($0.SetConnectionRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$setConnection, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.CheckConnectionReply> checkConnection($0.CheckConnectionRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$checkConnection, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.CheckConnectionsReply> checkConnections($0.CheckConnectionsRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$checkConnections, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.StartCheckingConnectionReply> startCheckingConnection($0.StartCheckingConnectionRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$startCheckingConnection, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.StopCheckingConnectionReply> stopCheckingConnection($0.StopCheckingConnectionRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$stopCheckingConnection, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetBestAvailableConnectionReply> getBestAvailableConnection($0.GetBestAvailableConnectionRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getBestAvailableConnection, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.SetAutoSwitchReply> setAutoSwitch($0.SetAutoSwitchRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$setAutoSwitch, request, options: options);
|
|
}
|
|
}
|
|
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.XmrConnections')
|
|
abstract class XmrConnectionsServiceBase extends $grpc.Service {
|
|
$core.String get $name => 'io.haveno.protobuffer.XmrConnections';
|
|
|
|
XmrConnectionsServiceBase() {
|
|
$addMethod($grpc.ServiceMethod<$0.AddConnectionRequest, $0.AddConnectionReply>(
|
|
'AddConnection',
|
|
addConnection_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.AddConnectionRequest.fromBuffer(value),
|
|
($0.AddConnectionReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.RemoveConnectionRequest, $0.RemoveConnectionReply>(
|
|
'RemoveConnection',
|
|
removeConnection_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.RemoveConnectionRequest.fromBuffer(value),
|
|
($0.RemoveConnectionReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetConnectionRequest, $0.GetConnectionReply>(
|
|
'GetConnection',
|
|
getConnection_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetConnectionRequest.fromBuffer(value),
|
|
($0.GetConnectionReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetConnectionsRequest, $0.GetConnectionsReply>(
|
|
'GetConnections',
|
|
getConnections_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetConnectionsRequest.fromBuffer(value),
|
|
($0.GetConnectionsReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.SetConnectionRequest, $0.SetConnectionReply>(
|
|
'SetConnection',
|
|
setConnection_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.SetConnectionRequest.fromBuffer(value),
|
|
($0.SetConnectionReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.CheckConnectionRequest, $0.CheckConnectionReply>(
|
|
'CheckConnection',
|
|
checkConnection_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.CheckConnectionRequest.fromBuffer(value),
|
|
($0.CheckConnectionReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.CheckConnectionsRequest, $0.CheckConnectionsReply>(
|
|
'CheckConnections',
|
|
checkConnections_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.CheckConnectionsRequest.fromBuffer(value),
|
|
($0.CheckConnectionsReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.StartCheckingConnectionRequest, $0.StartCheckingConnectionReply>(
|
|
'StartCheckingConnection',
|
|
startCheckingConnection_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.StartCheckingConnectionRequest.fromBuffer(value),
|
|
($0.StartCheckingConnectionReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.StopCheckingConnectionRequest, $0.StopCheckingConnectionReply>(
|
|
'StopCheckingConnection',
|
|
stopCheckingConnection_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.StopCheckingConnectionRequest.fromBuffer(value),
|
|
($0.StopCheckingConnectionReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetBestAvailableConnectionRequest, $0.GetBestAvailableConnectionReply>(
|
|
'GetBestAvailableConnection',
|
|
getBestAvailableConnection_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetBestAvailableConnectionRequest.fromBuffer(value),
|
|
($0.GetBestAvailableConnectionReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.SetAutoSwitchRequest, $0.SetAutoSwitchReply>(
|
|
'SetAutoSwitch',
|
|
setAutoSwitch_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.SetAutoSwitchRequest.fromBuffer(value),
|
|
($0.SetAutoSwitchReply value) => value.writeToBuffer()));
|
|
}
|
|
|
|
$async.Future<$0.AddConnectionReply> addConnection_Pre($grpc.ServiceCall call, $async.Future<$0.AddConnectionRequest> request) async {
|
|
return addConnection(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.RemoveConnectionReply> removeConnection_Pre($grpc.ServiceCall call, $async.Future<$0.RemoveConnectionRequest> request) async {
|
|
return removeConnection(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetConnectionReply> getConnection_Pre($grpc.ServiceCall call, $async.Future<$0.GetConnectionRequest> request) async {
|
|
return getConnection(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetConnectionsReply> getConnections_Pre($grpc.ServiceCall call, $async.Future<$0.GetConnectionsRequest> request) async {
|
|
return getConnections(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.SetConnectionReply> setConnection_Pre($grpc.ServiceCall call, $async.Future<$0.SetConnectionRequest> request) async {
|
|
return setConnection(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.CheckConnectionReply> checkConnection_Pre($grpc.ServiceCall call, $async.Future<$0.CheckConnectionRequest> request) async {
|
|
return checkConnection(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.CheckConnectionsReply> checkConnections_Pre($grpc.ServiceCall call, $async.Future<$0.CheckConnectionsRequest> request) async {
|
|
return checkConnections(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.StartCheckingConnectionReply> startCheckingConnection_Pre($grpc.ServiceCall call, $async.Future<$0.StartCheckingConnectionRequest> request) async {
|
|
return startCheckingConnection(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.StopCheckingConnectionReply> stopCheckingConnection_Pre($grpc.ServiceCall call, $async.Future<$0.StopCheckingConnectionRequest> request) async {
|
|
return stopCheckingConnection(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetBestAvailableConnectionReply> getBestAvailableConnection_Pre($grpc.ServiceCall call, $async.Future<$0.GetBestAvailableConnectionRequest> request) async {
|
|
return getBestAvailableConnection(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.SetAutoSwitchReply> setAutoSwitch_Pre($grpc.ServiceCall call, $async.Future<$0.SetAutoSwitchRequest> request) async {
|
|
return setAutoSwitch(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.AddConnectionReply> addConnection($grpc.ServiceCall call, $0.AddConnectionRequest request);
|
|
$async.Future<$0.RemoveConnectionReply> removeConnection($grpc.ServiceCall call, $0.RemoveConnectionRequest request);
|
|
$async.Future<$0.GetConnectionReply> getConnection($grpc.ServiceCall call, $0.GetConnectionRequest request);
|
|
$async.Future<$0.GetConnectionsReply> getConnections($grpc.ServiceCall call, $0.GetConnectionsRequest request);
|
|
$async.Future<$0.SetConnectionReply> setConnection($grpc.ServiceCall call, $0.SetConnectionRequest request);
|
|
$async.Future<$0.CheckConnectionReply> checkConnection($grpc.ServiceCall call, $0.CheckConnectionRequest request);
|
|
$async.Future<$0.CheckConnectionsReply> checkConnections($grpc.ServiceCall call, $0.CheckConnectionsRequest request);
|
|
$async.Future<$0.StartCheckingConnectionReply> startCheckingConnection($grpc.ServiceCall call, $0.StartCheckingConnectionRequest request);
|
|
$async.Future<$0.StopCheckingConnectionReply> stopCheckingConnection($grpc.ServiceCall call, $0.StopCheckingConnectionRequest request);
|
|
$async.Future<$0.GetBestAvailableConnectionReply> getBestAvailableConnection($grpc.ServiceCall call, $0.GetBestAvailableConnectionRequest request);
|
|
$async.Future<$0.SetAutoSwitchReply> setAutoSwitch($grpc.ServiceCall call, $0.SetAutoSwitchRequest request);
|
|
}
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.XmrNode')
|
|
class XmrNodeClient extends $grpc.Client {
|
|
static final _$isXmrNodeOnline = $grpc.ClientMethod<$0.IsXmrNodeOnlineRequest, $0.IsXmrNodeOnlineReply>(
|
|
'/io.haveno.protobuffer.XmrNode/IsXmrNodeOnline',
|
|
($0.IsXmrNodeOnlineRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.IsXmrNodeOnlineReply.fromBuffer(value));
|
|
static final _$getXmrNodeSettings = $grpc.ClientMethod<$0.GetXmrNodeSettingsRequest, $0.GetXmrNodeSettingsReply>(
|
|
'/io.haveno.protobuffer.XmrNode/GetXmrNodeSettings',
|
|
($0.GetXmrNodeSettingsRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetXmrNodeSettingsReply.fromBuffer(value));
|
|
static final _$startXmrNode = $grpc.ClientMethod<$0.StartXmrNodeRequest, $0.StartXmrNodeReply>(
|
|
'/io.haveno.protobuffer.XmrNode/StartXmrNode',
|
|
($0.StartXmrNodeRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.StartXmrNodeReply.fromBuffer(value));
|
|
static final _$stopXmrNode = $grpc.ClientMethod<$0.StopXmrNodeRequest, $0.StopXmrNodeReply>(
|
|
'/io.haveno.protobuffer.XmrNode/StopXmrNode',
|
|
($0.StopXmrNodeRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.StopXmrNodeReply.fromBuffer(value));
|
|
|
|
XmrNodeClient($grpc.ClientChannel channel,
|
|
{$grpc.CallOptions? options,
|
|
$core.Iterable<$grpc.ClientInterceptor>? interceptors})
|
|
: super(channel, options: options,
|
|
interceptors: interceptors);
|
|
|
|
$grpc.ResponseFuture<$0.IsXmrNodeOnlineReply> isXmrNodeOnline($0.IsXmrNodeOnlineRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$isXmrNodeOnline, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetXmrNodeSettingsReply> getXmrNodeSettings($0.GetXmrNodeSettingsRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getXmrNodeSettings, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.StartXmrNodeReply> startXmrNode($0.StartXmrNodeRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$startXmrNode, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.StopXmrNodeReply> stopXmrNode($0.StopXmrNodeRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$stopXmrNode, request, options: options);
|
|
}
|
|
}
|
|
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.XmrNode')
|
|
abstract class XmrNodeServiceBase extends $grpc.Service {
|
|
$core.String get $name => 'io.haveno.protobuffer.XmrNode';
|
|
|
|
XmrNodeServiceBase() {
|
|
$addMethod($grpc.ServiceMethod<$0.IsXmrNodeOnlineRequest, $0.IsXmrNodeOnlineReply>(
|
|
'IsXmrNodeOnline',
|
|
isXmrNodeOnline_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.IsXmrNodeOnlineRequest.fromBuffer(value),
|
|
($0.IsXmrNodeOnlineReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetXmrNodeSettingsRequest, $0.GetXmrNodeSettingsReply>(
|
|
'GetXmrNodeSettings',
|
|
getXmrNodeSettings_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetXmrNodeSettingsRequest.fromBuffer(value),
|
|
($0.GetXmrNodeSettingsReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.StartXmrNodeRequest, $0.StartXmrNodeReply>(
|
|
'StartXmrNode',
|
|
startXmrNode_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.StartXmrNodeRequest.fromBuffer(value),
|
|
($0.StartXmrNodeReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.StopXmrNodeRequest, $0.StopXmrNodeReply>(
|
|
'StopXmrNode',
|
|
stopXmrNode_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.StopXmrNodeRequest.fromBuffer(value),
|
|
($0.StopXmrNodeReply value) => value.writeToBuffer()));
|
|
}
|
|
|
|
$async.Future<$0.IsXmrNodeOnlineReply> isXmrNodeOnline_Pre($grpc.ServiceCall call, $async.Future<$0.IsXmrNodeOnlineRequest> request) async {
|
|
return isXmrNodeOnline(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetXmrNodeSettingsReply> getXmrNodeSettings_Pre($grpc.ServiceCall call, $async.Future<$0.GetXmrNodeSettingsRequest> request) async {
|
|
return getXmrNodeSettings(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.StartXmrNodeReply> startXmrNode_Pre($grpc.ServiceCall call, $async.Future<$0.StartXmrNodeRequest> request) async {
|
|
return startXmrNode(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.StopXmrNodeReply> stopXmrNode_Pre($grpc.ServiceCall call, $async.Future<$0.StopXmrNodeRequest> request) async {
|
|
return stopXmrNode(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.IsXmrNodeOnlineReply> isXmrNodeOnline($grpc.ServiceCall call, $0.IsXmrNodeOnlineRequest request);
|
|
$async.Future<$0.GetXmrNodeSettingsReply> getXmrNodeSettings($grpc.ServiceCall call, $0.GetXmrNodeSettingsRequest request);
|
|
$async.Future<$0.StartXmrNodeReply> startXmrNode($grpc.ServiceCall call, $0.StartXmrNodeRequest request);
|
|
$async.Future<$0.StopXmrNodeReply> stopXmrNode($grpc.ServiceCall call, $0.StopXmrNodeRequest request);
|
|
}
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.Offers')
|
|
class OffersClient extends $grpc.Client {
|
|
static final _$getOffer = $grpc.ClientMethod<$0.GetOfferRequest, $0.GetOfferReply>(
|
|
'/io.haveno.protobuffer.Offers/GetOffer',
|
|
($0.GetOfferRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetOfferReply.fromBuffer(value));
|
|
static final _$getMyOffer = $grpc.ClientMethod<$0.GetMyOfferRequest, $0.GetMyOfferReply>(
|
|
'/io.haveno.protobuffer.Offers/GetMyOffer',
|
|
($0.GetMyOfferRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetMyOfferReply.fromBuffer(value));
|
|
static final _$getOffers = $grpc.ClientMethod<$0.GetOffersRequest, $0.GetOffersReply>(
|
|
'/io.haveno.protobuffer.Offers/GetOffers',
|
|
($0.GetOffersRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetOffersReply.fromBuffer(value));
|
|
static final _$getMyOffers = $grpc.ClientMethod<$0.GetMyOffersRequest, $0.GetMyOffersReply>(
|
|
'/io.haveno.protobuffer.Offers/GetMyOffers',
|
|
($0.GetMyOffersRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetMyOffersReply.fromBuffer(value));
|
|
static final _$postOffer = $grpc.ClientMethod<$0.PostOfferRequest, $0.PostOfferReply>(
|
|
'/io.haveno.protobuffer.Offers/PostOffer',
|
|
($0.PostOfferRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.PostOfferReply.fromBuffer(value));
|
|
static final _$cancelOffer = $grpc.ClientMethod<$0.CancelOfferRequest, $0.CancelOfferReply>(
|
|
'/io.haveno.protobuffer.Offers/CancelOffer',
|
|
($0.CancelOfferRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.CancelOfferReply.fromBuffer(value));
|
|
|
|
OffersClient($grpc.ClientChannel channel,
|
|
{$grpc.CallOptions? options,
|
|
$core.Iterable<$grpc.ClientInterceptor>? interceptors})
|
|
: super(channel, options: options,
|
|
interceptors: interceptors);
|
|
|
|
$grpc.ResponseFuture<$0.GetOfferReply> getOffer($0.GetOfferRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getOffer, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetMyOfferReply> getMyOffer($0.GetMyOfferRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getMyOffer, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetOffersReply> getOffers($0.GetOffersRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getOffers, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetMyOffersReply> getMyOffers($0.GetMyOffersRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getMyOffers, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.PostOfferReply> postOffer($0.PostOfferRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$postOffer, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.CancelOfferReply> cancelOffer($0.CancelOfferRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$cancelOffer, request, options: options);
|
|
}
|
|
}
|
|
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.Offers')
|
|
abstract class OffersServiceBase extends $grpc.Service {
|
|
$core.String get $name => 'io.haveno.protobuffer.Offers';
|
|
|
|
OffersServiceBase() {
|
|
$addMethod($grpc.ServiceMethod<$0.GetOfferRequest, $0.GetOfferReply>(
|
|
'GetOffer',
|
|
getOffer_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetOfferRequest.fromBuffer(value),
|
|
($0.GetOfferReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetMyOfferRequest, $0.GetMyOfferReply>(
|
|
'GetMyOffer',
|
|
getMyOffer_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetMyOfferRequest.fromBuffer(value),
|
|
($0.GetMyOfferReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetOffersRequest, $0.GetOffersReply>(
|
|
'GetOffers',
|
|
getOffers_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetOffersRequest.fromBuffer(value),
|
|
($0.GetOffersReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetMyOffersRequest, $0.GetMyOffersReply>(
|
|
'GetMyOffers',
|
|
getMyOffers_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetMyOffersRequest.fromBuffer(value),
|
|
($0.GetMyOffersReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.PostOfferRequest, $0.PostOfferReply>(
|
|
'PostOffer',
|
|
postOffer_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.PostOfferRequest.fromBuffer(value),
|
|
($0.PostOfferReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.CancelOfferRequest, $0.CancelOfferReply>(
|
|
'CancelOffer',
|
|
cancelOffer_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.CancelOfferRequest.fromBuffer(value),
|
|
($0.CancelOfferReply value) => value.writeToBuffer()));
|
|
}
|
|
|
|
$async.Future<$0.GetOfferReply> getOffer_Pre($grpc.ServiceCall call, $async.Future<$0.GetOfferRequest> request) async {
|
|
return getOffer(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetMyOfferReply> getMyOffer_Pre($grpc.ServiceCall call, $async.Future<$0.GetMyOfferRequest> request) async {
|
|
return getMyOffer(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetOffersReply> getOffers_Pre($grpc.ServiceCall call, $async.Future<$0.GetOffersRequest> request) async {
|
|
return getOffers(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetMyOffersReply> getMyOffers_Pre($grpc.ServiceCall call, $async.Future<$0.GetMyOffersRequest> request) async {
|
|
return getMyOffers(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.PostOfferReply> postOffer_Pre($grpc.ServiceCall call, $async.Future<$0.PostOfferRequest> request) async {
|
|
return postOffer(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.CancelOfferReply> cancelOffer_Pre($grpc.ServiceCall call, $async.Future<$0.CancelOfferRequest> request) async {
|
|
return cancelOffer(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetOfferReply> getOffer($grpc.ServiceCall call, $0.GetOfferRequest request);
|
|
$async.Future<$0.GetMyOfferReply> getMyOffer($grpc.ServiceCall call, $0.GetMyOfferRequest request);
|
|
$async.Future<$0.GetOffersReply> getOffers($grpc.ServiceCall call, $0.GetOffersRequest request);
|
|
$async.Future<$0.GetMyOffersReply> getMyOffers($grpc.ServiceCall call, $0.GetMyOffersRequest request);
|
|
$async.Future<$0.PostOfferReply> postOffer($grpc.ServiceCall call, $0.PostOfferRequest request);
|
|
$async.Future<$0.CancelOfferReply> cancelOffer($grpc.ServiceCall call, $0.CancelOfferRequest request);
|
|
}
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.PaymentAccounts')
|
|
class PaymentAccountsClient extends $grpc.Client {
|
|
static final _$createPaymentAccount = $grpc.ClientMethod<$0.CreatePaymentAccountRequest, $0.CreatePaymentAccountReply>(
|
|
'/io.haveno.protobuffer.PaymentAccounts/CreatePaymentAccount',
|
|
($0.CreatePaymentAccountRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.CreatePaymentAccountReply.fromBuffer(value));
|
|
static final _$getPaymentAccounts = $grpc.ClientMethod<$0.GetPaymentAccountsRequest, $0.GetPaymentAccountsReply>(
|
|
'/io.haveno.protobuffer.PaymentAccounts/GetPaymentAccounts',
|
|
($0.GetPaymentAccountsRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetPaymentAccountsReply.fromBuffer(value));
|
|
static final _$getPaymentMethods = $grpc.ClientMethod<$0.GetPaymentMethodsRequest, $0.GetPaymentMethodsReply>(
|
|
'/io.haveno.protobuffer.PaymentAccounts/GetPaymentMethods',
|
|
($0.GetPaymentMethodsRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetPaymentMethodsReply.fromBuffer(value));
|
|
static final _$getPaymentAccountForm = $grpc.ClientMethod<$0.GetPaymentAccountFormRequest, $0.GetPaymentAccountFormReply>(
|
|
'/io.haveno.protobuffer.PaymentAccounts/GetPaymentAccountForm',
|
|
($0.GetPaymentAccountFormRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetPaymentAccountFormReply.fromBuffer(value));
|
|
static final _$getPaymentAccountFormAsJson = $grpc.ClientMethod<$0.GetPaymentAccountFormAsJsonRequest, $0.GetPaymentAccountFormAsJsonReply>(
|
|
'/io.haveno.protobuffer.PaymentAccounts/GetPaymentAccountFormAsJson',
|
|
($0.GetPaymentAccountFormAsJsonRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetPaymentAccountFormAsJsonReply.fromBuffer(value));
|
|
static final _$createCryptoCurrencyPaymentAccount = $grpc.ClientMethod<$0.CreateCryptoCurrencyPaymentAccountRequest, $0.CreateCryptoCurrencyPaymentAccountReply>(
|
|
'/io.haveno.protobuffer.PaymentAccounts/CreateCryptoCurrencyPaymentAccount',
|
|
($0.CreateCryptoCurrencyPaymentAccountRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.CreateCryptoCurrencyPaymentAccountReply.fromBuffer(value));
|
|
static final _$getCryptoCurrencyPaymentMethods = $grpc.ClientMethod<$0.GetCryptoCurrencyPaymentMethodsRequest, $0.GetCryptoCurrencyPaymentMethodsReply>(
|
|
'/io.haveno.protobuffer.PaymentAccounts/GetCryptoCurrencyPaymentMethods',
|
|
($0.GetCryptoCurrencyPaymentMethodsRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetCryptoCurrencyPaymentMethodsReply.fromBuffer(value));
|
|
static final _$validateFormField = $grpc.ClientMethod<$0.ValidateFormFieldRequest, $0.ValidateFormFieldReply>(
|
|
'/io.haveno.protobuffer.PaymentAccounts/ValidateFormField',
|
|
($0.ValidateFormFieldRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.ValidateFormFieldReply.fromBuffer(value));
|
|
|
|
PaymentAccountsClient($grpc.ClientChannel channel,
|
|
{$grpc.CallOptions? options,
|
|
$core.Iterable<$grpc.ClientInterceptor>? interceptors})
|
|
: super(channel, options: options,
|
|
interceptors: interceptors);
|
|
|
|
$grpc.ResponseFuture<$0.CreatePaymentAccountReply> createPaymentAccount($0.CreatePaymentAccountRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$createPaymentAccount, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetPaymentAccountsReply> getPaymentAccounts($0.GetPaymentAccountsRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getPaymentAccounts, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetPaymentMethodsReply> getPaymentMethods($0.GetPaymentMethodsRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getPaymentMethods, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetPaymentAccountFormReply> getPaymentAccountForm($0.GetPaymentAccountFormRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getPaymentAccountForm, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetPaymentAccountFormAsJsonReply> getPaymentAccountFormAsJson($0.GetPaymentAccountFormAsJsonRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getPaymentAccountFormAsJson, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.CreateCryptoCurrencyPaymentAccountReply> createCryptoCurrencyPaymentAccount($0.CreateCryptoCurrencyPaymentAccountRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$createCryptoCurrencyPaymentAccount, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetCryptoCurrencyPaymentMethodsReply> getCryptoCurrencyPaymentMethods($0.GetCryptoCurrencyPaymentMethodsRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getCryptoCurrencyPaymentMethods, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.ValidateFormFieldReply> validateFormField($0.ValidateFormFieldRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$validateFormField, request, options: options);
|
|
}
|
|
}
|
|
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.PaymentAccounts')
|
|
abstract class PaymentAccountsServiceBase extends $grpc.Service {
|
|
$core.String get $name => 'io.haveno.protobuffer.PaymentAccounts';
|
|
|
|
PaymentAccountsServiceBase() {
|
|
$addMethod($grpc.ServiceMethod<$0.CreatePaymentAccountRequest, $0.CreatePaymentAccountReply>(
|
|
'CreatePaymentAccount',
|
|
createPaymentAccount_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.CreatePaymentAccountRequest.fromBuffer(value),
|
|
($0.CreatePaymentAccountReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetPaymentAccountsRequest, $0.GetPaymentAccountsReply>(
|
|
'GetPaymentAccounts',
|
|
getPaymentAccounts_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetPaymentAccountsRequest.fromBuffer(value),
|
|
($0.GetPaymentAccountsReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetPaymentMethodsRequest, $0.GetPaymentMethodsReply>(
|
|
'GetPaymentMethods',
|
|
getPaymentMethods_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetPaymentMethodsRequest.fromBuffer(value),
|
|
($0.GetPaymentMethodsReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetPaymentAccountFormRequest, $0.GetPaymentAccountFormReply>(
|
|
'GetPaymentAccountForm',
|
|
getPaymentAccountForm_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetPaymentAccountFormRequest.fromBuffer(value),
|
|
($0.GetPaymentAccountFormReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetPaymentAccountFormAsJsonRequest, $0.GetPaymentAccountFormAsJsonReply>(
|
|
'GetPaymentAccountFormAsJson',
|
|
getPaymentAccountFormAsJson_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetPaymentAccountFormAsJsonRequest.fromBuffer(value),
|
|
($0.GetPaymentAccountFormAsJsonReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.CreateCryptoCurrencyPaymentAccountRequest, $0.CreateCryptoCurrencyPaymentAccountReply>(
|
|
'CreateCryptoCurrencyPaymentAccount',
|
|
createCryptoCurrencyPaymentAccount_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.CreateCryptoCurrencyPaymentAccountRequest.fromBuffer(value),
|
|
($0.CreateCryptoCurrencyPaymentAccountReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetCryptoCurrencyPaymentMethodsRequest, $0.GetCryptoCurrencyPaymentMethodsReply>(
|
|
'GetCryptoCurrencyPaymentMethods',
|
|
getCryptoCurrencyPaymentMethods_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetCryptoCurrencyPaymentMethodsRequest.fromBuffer(value),
|
|
($0.GetCryptoCurrencyPaymentMethodsReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.ValidateFormFieldRequest, $0.ValidateFormFieldReply>(
|
|
'ValidateFormField',
|
|
validateFormField_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.ValidateFormFieldRequest.fromBuffer(value),
|
|
($0.ValidateFormFieldReply value) => value.writeToBuffer()));
|
|
}
|
|
|
|
$async.Future<$0.CreatePaymentAccountReply> createPaymentAccount_Pre($grpc.ServiceCall call, $async.Future<$0.CreatePaymentAccountRequest> request) async {
|
|
return createPaymentAccount(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetPaymentAccountsReply> getPaymentAccounts_Pre($grpc.ServiceCall call, $async.Future<$0.GetPaymentAccountsRequest> request) async {
|
|
return getPaymentAccounts(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetPaymentMethodsReply> getPaymentMethods_Pre($grpc.ServiceCall call, $async.Future<$0.GetPaymentMethodsRequest> request) async {
|
|
return getPaymentMethods(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetPaymentAccountFormReply> getPaymentAccountForm_Pre($grpc.ServiceCall call, $async.Future<$0.GetPaymentAccountFormRequest> request) async {
|
|
return getPaymentAccountForm(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetPaymentAccountFormAsJsonReply> getPaymentAccountFormAsJson_Pre($grpc.ServiceCall call, $async.Future<$0.GetPaymentAccountFormAsJsonRequest> request) async {
|
|
return getPaymentAccountFormAsJson(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.CreateCryptoCurrencyPaymentAccountReply> createCryptoCurrencyPaymentAccount_Pre($grpc.ServiceCall call, $async.Future<$0.CreateCryptoCurrencyPaymentAccountRequest> request) async {
|
|
return createCryptoCurrencyPaymentAccount(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetCryptoCurrencyPaymentMethodsReply> getCryptoCurrencyPaymentMethods_Pre($grpc.ServiceCall call, $async.Future<$0.GetCryptoCurrencyPaymentMethodsRequest> request) async {
|
|
return getCryptoCurrencyPaymentMethods(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.ValidateFormFieldReply> validateFormField_Pre($grpc.ServiceCall call, $async.Future<$0.ValidateFormFieldRequest> request) async {
|
|
return validateFormField(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.CreatePaymentAccountReply> createPaymentAccount($grpc.ServiceCall call, $0.CreatePaymentAccountRequest request);
|
|
$async.Future<$0.GetPaymentAccountsReply> getPaymentAccounts($grpc.ServiceCall call, $0.GetPaymentAccountsRequest request);
|
|
$async.Future<$0.GetPaymentMethodsReply> getPaymentMethods($grpc.ServiceCall call, $0.GetPaymentMethodsRequest request);
|
|
$async.Future<$0.GetPaymentAccountFormReply> getPaymentAccountForm($grpc.ServiceCall call, $0.GetPaymentAccountFormRequest request);
|
|
$async.Future<$0.GetPaymentAccountFormAsJsonReply> getPaymentAccountFormAsJson($grpc.ServiceCall call, $0.GetPaymentAccountFormAsJsonRequest request);
|
|
$async.Future<$0.CreateCryptoCurrencyPaymentAccountReply> createCryptoCurrencyPaymentAccount($grpc.ServiceCall call, $0.CreateCryptoCurrencyPaymentAccountRequest request);
|
|
$async.Future<$0.GetCryptoCurrencyPaymentMethodsReply> getCryptoCurrencyPaymentMethods($grpc.ServiceCall call, $0.GetCryptoCurrencyPaymentMethodsRequest request);
|
|
$async.Future<$0.ValidateFormFieldReply> validateFormField($grpc.ServiceCall call, $0.ValidateFormFieldRequest request);
|
|
}
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.Price')
|
|
class PriceClient extends $grpc.Client {
|
|
static final _$getMarketPrice = $grpc.ClientMethod<$0.MarketPriceRequest, $0.MarketPriceReply>(
|
|
'/io.haveno.protobuffer.Price/GetMarketPrice',
|
|
($0.MarketPriceRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.MarketPriceReply.fromBuffer(value));
|
|
static final _$getMarketPrices = $grpc.ClientMethod<$0.MarketPricesRequest, $0.MarketPricesReply>(
|
|
'/io.haveno.protobuffer.Price/GetMarketPrices',
|
|
($0.MarketPricesRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.MarketPricesReply.fromBuffer(value));
|
|
static final _$getMarketDepth = $grpc.ClientMethod<$0.MarketDepthRequest, $0.MarketDepthReply>(
|
|
'/io.haveno.protobuffer.Price/GetMarketDepth',
|
|
($0.MarketDepthRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.MarketDepthReply.fromBuffer(value));
|
|
|
|
PriceClient($grpc.ClientChannel channel,
|
|
{$grpc.CallOptions? options,
|
|
$core.Iterable<$grpc.ClientInterceptor>? interceptors})
|
|
: super(channel, options: options,
|
|
interceptors: interceptors);
|
|
|
|
$grpc.ResponseFuture<$0.MarketPriceReply> getMarketPrice($0.MarketPriceRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getMarketPrice, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.MarketPricesReply> getMarketPrices($0.MarketPricesRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getMarketPrices, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.MarketDepthReply> getMarketDepth($0.MarketDepthRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getMarketDepth, request, options: options);
|
|
}
|
|
}
|
|
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.Price')
|
|
abstract class PriceServiceBase extends $grpc.Service {
|
|
$core.String get $name => 'io.haveno.protobuffer.Price';
|
|
|
|
PriceServiceBase() {
|
|
$addMethod($grpc.ServiceMethod<$0.MarketPriceRequest, $0.MarketPriceReply>(
|
|
'GetMarketPrice',
|
|
getMarketPrice_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.MarketPriceRequest.fromBuffer(value),
|
|
($0.MarketPriceReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.MarketPricesRequest, $0.MarketPricesReply>(
|
|
'GetMarketPrices',
|
|
getMarketPrices_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.MarketPricesRequest.fromBuffer(value),
|
|
($0.MarketPricesReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.MarketDepthRequest, $0.MarketDepthReply>(
|
|
'GetMarketDepth',
|
|
getMarketDepth_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.MarketDepthRequest.fromBuffer(value),
|
|
($0.MarketDepthReply value) => value.writeToBuffer()));
|
|
}
|
|
|
|
$async.Future<$0.MarketPriceReply> getMarketPrice_Pre($grpc.ServiceCall call, $async.Future<$0.MarketPriceRequest> request) async {
|
|
return getMarketPrice(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.MarketPricesReply> getMarketPrices_Pre($grpc.ServiceCall call, $async.Future<$0.MarketPricesRequest> request) async {
|
|
return getMarketPrices(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.MarketDepthReply> getMarketDepth_Pre($grpc.ServiceCall call, $async.Future<$0.MarketDepthRequest> request) async {
|
|
return getMarketDepth(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.MarketPriceReply> getMarketPrice($grpc.ServiceCall call, $0.MarketPriceRequest request);
|
|
$async.Future<$0.MarketPricesReply> getMarketPrices($grpc.ServiceCall call, $0.MarketPricesRequest request);
|
|
$async.Future<$0.MarketDepthReply> getMarketDepth($grpc.ServiceCall call, $0.MarketDepthRequest request);
|
|
}
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.GetTradeStatistics')
|
|
class GetTradeStatisticsClient extends $grpc.Client {
|
|
static final _$getTradeStatistics = $grpc.ClientMethod<$0.GetTradeStatisticsRequest, $0.GetTradeStatisticsReply>(
|
|
'/io.haveno.protobuffer.GetTradeStatistics/GetTradeStatistics',
|
|
($0.GetTradeStatisticsRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetTradeStatisticsReply.fromBuffer(value));
|
|
|
|
GetTradeStatisticsClient($grpc.ClientChannel channel,
|
|
{$grpc.CallOptions? options,
|
|
$core.Iterable<$grpc.ClientInterceptor>? interceptors})
|
|
: super(channel, options: options,
|
|
interceptors: interceptors);
|
|
|
|
$grpc.ResponseFuture<$0.GetTradeStatisticsReply> getTradeStatistics($0.GetTradeStatisticsRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getTradeStatistics, request, options: options);
|
|
}
|
|
}
|
|
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.GetTradeStatistics')
|
|
abstract class GetTradeStatisticsServiceBase extends $grpc.Service {
|
|
$core.String get $name => 'io.haveno.protobuffer.GetTradeStatistics';
|
|
|
|
GetTradeStatisticsServiceBase() {
|
|
$addMethod($grpc.ServiceMethod<$0.GetTradeStatisticsRequest, $0.GetTradeStatisticsReply>(
|
|
'GetTradeStatistics',
|
|
getTradeStatistics_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetTradeStatisticsRequest.fromBuffer(value),
|
|
($0.GetTradeStatisticsReply value) => value.writeToBuffer()));
|
|
}
|
|
|
|
$async.Future<$0.GetTradeStatisticsReply> getTradeStatistics_Pre($grpc.ServiceCall call, $async.Future<$0.GetTradeStatisticsRequest> request) async {
|
|
return getTradeStatistics(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetTradeStatisticsReply> getTradeStatistics($grpc.ServiceCall call, $0.GetTradeStatisticsRequest request);
|
|
}
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.ShutdownServer')
|
|
class ShutdownServerClient extends $grpc.Client {
|
|
static final _$stop = $grpc.ClientMethod<$0.StopRequest, $0.StopReply>(
|
|
'/io.haveno.protobuffer.ShutdownServer/Stop',
|
|
($0.StopRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.StopReply.fromBuffer(value));
|
|
|
|
ShutdownServerClient($grpc.ClientChannel channel,
|
|
{$grpc.CallOptions? options,
|
|
$core.Iterable<$grpc.ClientInterceptor>? interceptors})
|
|
: super(channel, options: options,
|
|
interceptors: interceptors);
|
|
|
|
$grpc.ResponseFuture<$0.StopReply> stop($0.StopRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$stop, request, options: options);
|
|
}
|
|
}
|
|
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.ShutdownServer')
|
|
abstract class ShutdownServerServiceBase extends $grpc.Service {
|
|
$core.String get $name => 'io.haveno.protobuffer.ShutdownServer';
|
|
|
|
ShutdownServerServiceBase() {
|
|
$addMethod($grpc.ServiceMethod<$0.StopRequest, $0.StopReply>(
|
|
'Stop',
|
|
stop_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.StopRequest.fromBuffer(value),
|
|
($0.StopReply value) => value.writeToBuffer()));
|
|
}
|
|
|
|
$async.Future<$0.StopReply> stop_Pre($grpc.ServiceCall call, $async.Future<$0.StopRequest> request) async {
|
|
return stop(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.StopReply> stop($grpc.ServiceCall call, $0.StopRequest request);
|
|
}
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.Trades')
|
|
class TradesClient extends $grpc.Client {
|
|
static final _$getTrade = $grpc.ClientMethod<$0.GetTradeRequest, $0.GetTradeReply>(
|
|
'/io.haveno.protobuffer.Trades/GetTrade',
|
|
($0.GetTradeRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetTradeReply.fromBuffer(value));
|
|
static final _$getTrades = $grpc.ClientMethod<$0.GetTradesRequest, $0.GetTradesReply>(
|
|
'/io.haveno.protobuffer.Trades/GetTrades',
|
|
($0.GetTradesRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetTradesReply.fromBuffer(value));
|
|
static final _$takeOffer = $grpc.ClientMethod<$0.TakeOfferRequest, $0.TakeOfferReply>(
|
|
'/io.haveno.protobuffer.Trades/TakeOffer',
|
|
($0.TakeOfferRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.TakeOfferReply.fromBuffer(value));
|
|
static final _$confirmPaymentSent = $grpc.ClientMethod<$0.ConfirmPaymentSentRequest, $0.ConfirmPaymentSentReply>(
|
|
'/io.haveno.protobuffer.Trades/ConfirmPaymentSent',
|
|
($0.ConfirmPaymentSentRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.ConfirmPaymentSentReply.fromBuffer(value));
|
|
static final _$confirmPaymentReceived = $grpc.ClientMethod<$0.ConfirmPaymentReceivedRequest, $0.ConfirmPaymentReceivedReply>(
|
|
'/io.haveno.protobuffer.Trades/ConfirmPaymentReceived',
|
|
($0.ConfirmPaymentReceivedRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.ConfirmPaymentReceivedReply.fromBuffer(value));
|
|
static final _$completeTrade = $grpc.ClientMethod<$0.CompleteTradeRequest, $0.CompleteTradeReply>(
|
|
'/io.haveno.protobuffer.Trades/CompleteTrade',
|
|
($0.CompleteTradeRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.CompleteTradeReply.fromBuffer(value));
|
|
static final _$withdrawFunds = $grpc.ClientMethod<$0.WithdrawFundsRequest, $0.WithdrawFundsReply>(
|
|
'/io.haveno.protobuffer.Trades/WithdrawFunds',
|
|
($0.WithdrawFundsRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.WithdrawFundsReply.fromBuffer(value));
|
|
static final _$getChatMessages = $grpc.ClientMethod<$0.GetChatMessagesRequest, $0.GetChatMessagesReply>(
|
|
'/io.haveno.protobuffer.Trades/GetChatMessages',
|
|
($0.GetChatMessagesRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetChatMessagesReply.fromBuffer(value));
|
|
static final _$sendChatMessage = $grpc.ClientMethod<$0.SendChatMessageRequest, $0.SendChatMessageReply>(
|
|
'/io.haveno.protobuffer.Trades/SendChatMessage',
|
|
($0.SendChatMessageRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.SendChatMessageReply.fromBuffer(value));
|
|
|
|
TradesClient($grpc.ClientChannel channel,
|
|
{$grpc.CallOptions? options,
|
|
$core.Iterable<$grpc.ClientInterceptor>? interceptors})
|
|
: super(channel, options: options,
|
|
interceptors: interceptors);
|
|
|
|
$grpc.ResponseFuture<$0.GetTradeReply> getTrade($0.GetTradeRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getTrade, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetTradesReply> getTrades($0.GetTradesRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getTrades, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.TakeOfferReply> takeOffer($0.TakeOfferRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$takeOffer, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.ConfirmPaymentSentReply> confirmPaymentSent($0.ConfirmPaymentSentRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$confirmPaymentSent, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.ConfirmPaymentReceivedReply> confirmPaymentReceived($0.ConfirmPaymentReceivedRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$confirmPaymentReceived, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.CompleteTradeReply> completeTrade($0.CompleteTradeRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$completeTrade, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.WithdrawFundsReply> withdrawFunds($0.WithdrawFundsRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$withdrawFunds, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetChatMessagesReply> getChatMessages($0.GetChatMessagesRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getChatMessages, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.SendChatMessageReply> sendChatMessage($0.SendChatMessageRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$sendChatMessage, request, options: options);
|
|
}
|
|
}
|
|
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.Trades')
|
|
abstract class TradesServiceBase extends $grpc.Service {
|
|
$core.String get $name => 'io.haveno.protobuffer.Trades';
|
|
|
|
TradesServiceBase() {
|
|
$addMethod($grpc.ServiceMethod<$0.GetTradeRequest, $0.GetTradeReply>(
|
|
'GetTrade',
|
|
getTrade_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetTradeRequest.fromBuffer(value),
|
|
($0.GetTradeReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetTradesRequest, $0.GetTradesReply>(
|
|
'GetTrades',
|
|
getTrades_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetTradesRequest.fromBuffer(value),
|
|
($0.GetTradesReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.TakeOfferRequest, $0.TakeOfferReply>(
|
|
'TakeOffer',
|
|
takeOffer_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.TakeOfferRequest.fromBuffer(value),
|
|
($0.TakeOfferReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.ConfirmPaymentSentRequest, $0.ConfirmPaymentSentReply>(
|
|
'ConfirmPaymentSent',
|
|
confirmPaymentSent_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.ConfirmPaymentSentRequest.fromBuffer(value),
|
|
($0.ConfirmPaymentSentReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.ConfirmPaymentReceivedRequest, $0.ConfirmPaymentReceivedReply>(
|
|
'ConfirmPaymentReceived',
|
|
confirmPaymentReceived_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.ConfirmPaymentReceivedRequest.fromBuffer(value),
|
|
($0.ConfirmPaymentReceivedReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.CompleteTradeRequest, $0.CompleteTradeReply>(
|
|
'CompleteTrade',
|
|
completeTrade_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.CompleteTradeRequest.fromBuffer(value),
|
|
($0.CompleteTradeReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.WithdrawFundsRequest, $0.WithdrawFundsReply>(
|
|
'WithdrawFunds',
|
|
withdrawFunds_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.WithdrawFundsRequest.fromBuffer(value),
|
|
($0.WithdrawFundsReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetChatMessagesRequest, $0.GetChatMessagesReply>(
|
|
'GetChatMessages',
|
|
getChatMessages_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetChatMessagesRequest.fromBuffer(value),
|
|
($0.GetChatMessagesReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.SendChatMessageRequest, $0.SendChatMessageReply>(
|
|
'SendChatMessage',
|
|
sendChatMessage_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.SendChatMessageRequest.fromBuffer(value),
|
|
($0.SendChatMessageReply value) => value.writeToBuffer()));
|
|
}
|
|
|
|
$async.Future<$0.GetTradeReply> getTrade_Pre($grpc.ServiceCall call, $async.Future<$0.GetTradeRequest> request) async {
|
|
return getTrade(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetTradesReply> getTrades_Pre($grpc.ServiceCall call, $async.Future<$0.GetTradesRequest> request) async {
|
|
return getTrades(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.TakeOfferReply> takeOffer_Pre($grpc.ServiceCall call, $async.Future<$0.TakeOfferRequest> request) async {
|
|
return takeOffer(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.ConfirmPaymentSentReply> confirmPaymentSent_Pre($grpc.ServiceCall call, $async.Future<$0.ConfirmPaymentSentRequest> request) async {
|
|
return confirmPaymentSent(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.ConfirmPaymentReceivedReply> confirmPaymentReceived_Pre($grpc.ServiceCall call, $async.Future<$0.ConfirmPaymentReceivedRequest> request) async {
|
|
return confirmPaymentReceived(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.CompleteTradeReply> completeTrade_Pre($grpc.ServiceCall call, $async.Future<$0.CompleteTradeRequest> request) async {
|
|
return completeTrade(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.WithdrawFundsReply> withdrawFunds_Pre($grpc.ServiceCall call, $async.Future<$0.WithdrawFundsRequest> request) async {
|
|
return withdrawFunds(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetChatMessagesReply> getChatMessages_Pre($grpc.ServiceCall call, $async.Future<$0.GetChatMessagesRequest> request) async {
|
|
return getChatMessages(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.SendChatMessageReply> sendChatMessage_Pre($grpc.ServiceCall call, $async.Future<$0.SendChatMessageRequest> request) async {
|
|
return sendChatMessage(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetTradeReply> getTrade($grpc.ServiceCall call, $0.GetTradeRequest request);
|
|
$async.Future<$0.GetTradesReply> getTrades($grpc.ServiceCall call, $0.GetTradesRequest request);
|
|
$async.Future<$0.TakeOfferReply> takeOffer($grpc.ServiceCall call, $0.TakeOfferRequest request);
|
|
$async.Future<$0.ConfirmPaymentSentReply> confirmPaymentSent($grpc.ServiceCall call, $0.ConfirmPaymentSentRequest request);
|
|
$async.Future<$0.ConfirmPaymentReceivedReply> confirmPaymentReceived($grpc.ServiceCall call, $0.ConfirmPaymentReceivedRequest request);
|
|
$async.Future<$0.CompleteTradeReply> completeTrade($grpc.ServiceCall call, $0.CompleteTradeRequest request);
|
|
$async.Future<$0.WithdrawFundsReply> withdrawFunds($grpc.ServiceCall call, $0.WithdrawFundsRequest request);
|
|
$async.Future<$0.GetChatMessagesReply> getChatMessages($grpc.ServiceCall call, $0.GetChatMessagesRequest request);
|
|
$async.Future<$0.SendChatMessageReply> sendChatMessage($grpc.ServiceCall call, $0.SendChatMessageRequest request);
|
|
}
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.Wallets')
|
|
class WalletsClient extends $grpc.Client {
|
|
static final _$getBalances = $grpc.ClientMethod<$0.GetBalancesRequest, $0.GetBalancesReply>(
|
|
'/io.haveno.protobuffer.Wallets/GetBalances',
|
|
($0.GetBalancesRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetBalancesReply.fromBuffer(value));
|
|
static final _$getXmrSeed = $grpc.ClientMethod<$0.GetXmrSeedRequest, $0.GetXmrSeedReply>(
|
|
'/io.haveno.protobuffer.Wallets/GetXmrSeed',
|
|
($0.GetXmrSeedRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetXmrSeedReply.fromBuffer(value));
|
|
static final _$getXmrPrimaryAddress = $grpc.ClientMethod<$0.GetXmrPrimaryAddressRequest, $0.GetXmrPrimaryAddressReply>(
|
|
'/io.haveno.protobuffer.Wallets/GetXmrPrimaryAddress',
|
|
($0.GetXmrPrimaryAddressRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetXmrPrimaryAddressReply.fromBuffer(value));
|
|
static final _$getXmrNewSubaddress = $grpc.ClientMethod<$0.GetXmrNewSubaddressRequest, $0.GetXmrNewSubaddressReply>(
|
|
'/io.haveno.protobuffer.Wallets/GetXmrNewSubaddress',
|
|
($0.GetXmrNewSubaddressRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetXmrNewSubaddressReply.fromBuffer(value));
|
|
static final _$getXmrTxs = $grpc.ClientMethod<$0.GetXmrTxsRequest, $0.GetXmrTxsReply>(
|
|
'/io.haveno.protobuffer.Wallets/GetXmrTxs',
|
|
($0.GetXmrTxsRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetXmrTxsReply.fromBuffer(value));
|
|
static final _$createXmrTx = $grpc.ClientMethod<$0.CreateXmrTxRequest, $0.CreateXmrTxReply>(
|
|
'/io.haveno.protobuffer.Wallets/CreateXmrTx',
|
|
($0.CreateXmrTxRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.CreateXmrTxReply.fromBuffer(value));
|
|
static final _$relayXmrTx = $grpc.ClientMethod<$0.RelayXmrTxRequest, $0.RelayXmrTxReply>(
|
|
'/io.haveno.protobuffer.Wallets/relayXmrTx',
|
|
($0.RelayXmrTxRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.RelayXmrTxReply.fromBuffer(value));
|
|
static final _$getAddressBalance = $grpc.ClientMethod<$0.GetAddressBalanceRequest, $0.GetAddressBalanceReply>(
|
|
'/io.haveno.protobuffer.Wallets/GetAddressBalance',
|
|
($0.GetAddressBalanceRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetAddressBalanceReply.fromBuffer(value));
|
|
static final _$getFundingAddresses = $grpc.ClientMethod<$0.GetFundingAddressesRequest, $0.GetFundingAddressesReply>(
|
|
'/io.haveno.protobuffer.Wallets/GetFundingAddresses',
|
|
($0.GetFundingAddressesRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.GetFundingAddressesReply.fromBuffer(value));
|
|
static final _$setWalletPassword = $grpc.ClientMethod<$0.SetWalletPasswordRequest, $0.SetWalletPasswordReply>(
|
|
'/io.haveno.protobuffer.Wallets/SetWalletPassword',
|
|
($0.SetWalletPasswordRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.SetWalletPasswordReply.fromBuffer(value));
|
|
static final _$removeWalletPassword = $grpc.ClientMethod<$0.RemoveWalletPasswordRequest, $0.RemoveWalletPasswordReply>(
|
|
'/io.haveno.protobuffer.Wallets/RemoveWalletPassword',
|
|
($0.RemoveWalletPasswordRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.RemoveWalletPasswordReply.fromBuffer(value));
|
|
static final _$lockWallet = $grpc.ClientMethod<$0.LockWalletRequest, $0.LockWalletReply>(
|
|
'/io.haveno.protobuffer.Wallets/LockWallet',
|
|
($0.LockWalletRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.LockWalletReply.fromBuffer(value));
|
|
static final _$unlockWallet = $grpc.ClientMethod<$0.UnlockWalletRequest, $0.UnlockWalletReply>(
|
|
'/io.haveno.protobuffer.Wallets/UnlockWallet',
|
|
($0.UnlockWalletRequest value) => value.writeToBuffer(),
|
|
($core.List<$core.int> value) => $0.UnlockWalletReply.fromBuffer(value));
|
|
|
|
WalletsClient($grpc.ClientChannel channel,
|
|
{$grpc.CallOptions? options,
|
|
$core.Iterable<$grpc.ClientInterceptor>? interceptors})
|
|
: super(channel, options: options,
|
|
interceptors: interceptors);
|
|
|
|
$grpc.ResponseFuture<$0.GetBalancesReply> getBalances($0.GetBalancesRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getBalances, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetXmrSeedReply> getXmrSeed($0.GetXmrSeedRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getXmrSeed, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetXmrPrimaryAddressReply> getXmrPrimaryAddress($0.GetXmrPrimaryAddressRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getXmrPrimaryAddress, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetXmrNewSubaddressReply> getXmrNewSubaddress($0.GetXmrNewSubaddressRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getXmrNewSubaddress, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetXmrTxsReply> getXmrTxs($0.GetXmrTxsRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getXmrTxs, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.CreateXmrTxReply> createXmrTx($0.CreateXmrTxRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$createXmrTx, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.RelayXmrTxReply> relayXmrTx($0.RelayXmrTxRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$relayXmrTx, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetAddressBalanceReply> getAddressBalance($0.GetAddressBalanceRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getAddressBalance, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.GetFundingAddressesReply> getFundingAddresses($0.GetFundingAddressesRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$getFundingAddresses, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.SetWalletPasswordReply> setWalletPassword($0.SetWalletPasswordRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$setWalletPassword, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.RemoveWalletPasswordReply> removeWalletPassword($0.RemoveWalletPasswordRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$removeWalletPassword, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.LockWalletReply> lockWallet($0.LockWalletRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$lockWallet, request, options: options);
|
|
}
|
|
|
|
$grpc.ResponseFuture<$0.UnlockWalletReply> unlockWallet($0.UnlockWalletRequest request, {$grpc.CallOptions? options}) {
|
|
return $createUnaryCall(_$unlockWallet, request, options: options);
|
|
}
|
|
}
|
|
|
|
@$pb.GrpcServiceName('io.haveno.protobuffer.Wallets')
|
|
abstract class WalletsServiceBase extends $grpc.Service {
|
|
$core.String get $name => 'io.haveno.protobuffer.Wallets';
|
|
|
|
WalletsServiceBase() {
|
|
$addMethod($grpc.ServiceMethod<$0.GetBalancesRequest, $0.GetBalancesReply>(
|
|
'GetBalances',
|
|
getBalances_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetBalancesRequest.fromBuffer(value),
|
|
($0.GetBalancesReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetXmrSeedRequest, $0.GetXmrSeedReply>(
|
|
'GetXmrSeed',
|
|
getXmrSeed_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetXmrSeedRequest.fromBuffer(value),
|
|
($0.GetXmrSeedReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetXmrPrimaryAddressRequest, $0.GetXmrPrimaryAddressReply>(
|
|
'GetXmrPrimaryAddress',
|
|
getXmrPrimaryAddress_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetXmrPrimaryAddressRequest.fromBuffer(value),
|
|
($0.GetXmrPrimaryAddressReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetXmrNewSubaddressRequest, $0.GetXmrNewSubaddressReply>(
|
|
'GetXmrNewSubaddress',
|
|
getXmrNewSubaddress_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetXmrNewSubaddressRequest.fromBuffer(value),
|
|
($0.GetXmrNewSubaddressReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetXmrTxsRequest, $0.GetXmrTxsReply>(
|
|
'GetXmrTxs',
|
|
getXmrTxs_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetXmrTxsRequest.fromBuffer(value),
|
|
($0.GetXmrTxsReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.CreateXmrTxRequest, $0.CreateXmrTxReply>(
|
|
'CreateXmrTx',
|
|
createXmrTx_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.CreateXmrTxRequest.fromBuffer(value),
|
|
($0.CreateXmrTxReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.RelayXmrTxRequest, $0.RelayXmrTxReply>(
|
|
'relayXmrTx',
|
|
relayXmrTx_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.RelayXmrTxRequest.fromBuffer(value),
|
|
($0.RelayXmrTxReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetAddressBalanceRequest, $0.GetAddressBalanceReply>(
|
|
'GetAddressBalance',
|
|
getAddressBalance_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetAddressBalanceRequest.fromBuffer(value),
|
|
($0.GetAddressBalanceReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.GetFundingAddressesRequest, $0.GetFundingAddressesReply>(
|
|
'GetFundingAddresses',
|
|
getFundingAddresses_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.GetFundingAddressesRequest.fromBuffer(value),
|
|
($0.GetFundingAddressesReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.SetWalletPasswordRequest, $0.SetWalletPasswordReply>(
|
|
'SetWalletPassword',
|
|
setWalletPassword_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.SetWalletPasswordRequest.fromBuffer(value),
|
|
($0.SetWalletPasswordReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.RemoveWalletPasswordRequest, $0.RemoveWalletPasswordReply>(
|
|
'RemoveWalletPassword',
|
|
removeWalletPassword_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.RemoveWalletPasswordRequest.fromBuffer(value),
|
|
($0.RemoveWalletPasswordReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.LockWalletRequest, $0.LockWalletReply>(
|
|
'LockWallet',
|
|
lockWallet_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.LockWalletRequest.fromBuffer(value),
|
|
($0.LockWalletReply value) => value.writeToBuffer()));
|
|
$addMethod($grpc.ServiceMethod<$0.UnlockWalletRequest, $0.UnlockWalletReply>(
|
|
'UnlockWallet',
|
|
unlockWallet_Pre,
|
|
false,
|
|
false,
|
|
($core.List<$core.int> value) => $0.UnlockWalletRequest.fromBuffer(value),
|
|
($0.UnlockWalletReply value) => value.writeToBuffer()));
|
|
}
|
|
|
|
$async.Future<$0.GetBalancesReply> getBalances_Pre($grpc.ServiceCall call, $async.Future<$0.GetBalancesRequest> request) async {
|
|
return getBalances(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetXmrSeedReply> getXmrSeed_Pre($grpc.ServiceCall call, $async.Future<$0.GetXmrSeedRequest> request) async {
|
|
return getXmrSeed(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetXmrPrimaryAddressReply> getXmrPrimaryAddress_Pre($grpc.ServiceCall call, $async.Future<$0.GetXmrPrimaryAddressRequest> request) async {
|
|
return getXmrPrimaryAddress(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetXmrNewSubaddressReply> getXmrNewSubaddress_Pre($grpc.ServiceCall call, $async.Future<$0.GetXmrNewSubaddressRequest> request) async {
|
|
return getXmrNewSubaddress(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetXmrTxsReply> getXmrTxs_Pre($grpc.ServiceCall call, $async.Future<$0.GetXmrTxsRequest> request) async {
|
|
return getXmrTxs(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.CreateXmrTxReply> createXmrTx_Pre($grpc.ServiceCall call, $async.Future<$0.CreateXmrTxRequest> request) async {
|
|
return createXmrTx(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.RelayXmrTxReply> relayXmrTx_Pre($grpc.ServiceCall call, $async.Future<$0.RelayXmrTxRequest> request) async {
|
|
return relayXmrTx(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetAddressBalanceReply> getAddressBalance_Pre($grpc.ServiceCall call, $async.Future<$0.GetAddressBalanceRequest> request) async {
|
|
return getAddressBalance(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetFundingAddressesReply> getFundingAddresses_Pre($grpc.ServiceCall call, $async.Future<$0.GetFundingAddressesRequest> request) async {
|
|
return getFundingAddresses(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.SetWalletPasswordReply> setWalletPassword_Pre($grpc.ServiceCall call, $async.Future<$0.SetWalletPasswordRequest> request) async {
|
|
return setWalletPassword(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.RemoveWalletPasswordReply> removeWalletPassword_Pre($grpc.ServiceCall call, $async.Future<$0.RemoveWalletPasswordRequest> request) async {
|
|
return removeWalletPassword(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.LockWalletReply> lockWallet_Pre($grpc.ServiceCall call, $async.Future<$0.LockWalletRequest> request) async {
|
|
return lockWallet(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.UnlockWalletReply> unlockWallet_Pre($grpc.ServiceCall call, $async.Future<$0.UnlockWalletRequest> request) async {
|
|
return unlockWallet(call, await request);
|
|
}
|
|
|
|
$async.Future<$0.GetBalancesReply> getBalances($grpc.ServiceCall call, $0.GetBalancesRequest request);
|
|
$async.Future<$0.GetXmrSeedReply> getXmrSeed($grpc.ServiceCall call, $0.GetXmrSeedRequest request);
|
|
$async.Future<$0.GetXmrPrimaryAddressReply> getXmrPrimaryAddress($grpc.ServiceCall call, $0.GetXmrPrimaryAddressRequest request);
|
|
$async.Future<$0.GetXmrNewSubaddressReply> getXmrNewSubaddress($grpc.ServiceCall call, $0.GetXmrNewSubaddressRequest request);
|
|
$async.Future<$0.GetXmrTxsReply> getXmrTxs($grpc.ServiceCall call, $0.GetXmrTxsRequest request);
|
|
$async.Future<$0.CreateXmrTxReply> createXmrTx($grpc.ServiceCall call, $0.CreateXmrTxRequest request);
|
|
$async.Future<$0.RelayXmrTxReply> relayXmrTx($grpc.ServiceCall call, $0.RelayXmrTxRequest request);
|
|
$async.Future<$0.GetAddressBalanceReply> getAddressBalance($grpc.ServiceCall call, $0.GetAddressBalanceRequest request);
|
|
$async.Future<$0.GetFundingAddressesReply> getFundingAddresses($grpc.ServiceCall call, $0.GetFundingAddressesRequest request);
|
|
$async.Future<$0.SetWalletPasswordReply> setWalletPassword($grpc.ServiceCall call, $0.SetWalletPasswordRequest request);
|
|
$async.Future<$0.RemoveWalletPasswordReply> removeWalletPassword($grpc.ServiceCall call, $0.RemoveWalletPasswordRequest request);
|
|
$async.Future<$0.LockWalletReply> lockWallet($grpc.ServiceCall call, $0.LockWalletRequest request);
|
|
$async.Future<$0.UnlockWalletReply> unlockWallet($grpc.ServiceCall call, $0.UnlockWalletRequest request);
|
|
}
|