test scheduling offer with exact reserve amount

dist/protobuf/GrpcServiceClientPb.d.ts

@@ -20,7 +20,7 @@ export declare class HelpClient {
         [index: string]: any;
     });
     methodDescriptorGetMethodHelp: grpcWeb.MethodDescriptor<grpc_pb.GetMethodHelpRequest, grpc_pb.GetMethodHelpReply>;
-    getMethodHelp(request: grpc_pb.GetMethodHelpRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetMethodHelpReply>;
+    getMethodHelp(request: grpc_pb.GetMethodHelpRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetMethodHelpReply>;
     getMethodHelp(request: grpc_pb.GetMethodHelpRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetMethodHelpReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetMethodHelpReply>;
 }
 export declare class GetVersionClient {
@@ -38,7 +38,7 @@ export declare class GetVersionClient {
         [index: string]: any;
     });
     methodDescriptorGetVersion: grpcWeb.MethodDescriptor<grpc_pb.GetVersionRequest, grpc_pb.GetVersionReply>;
-    getVersion(request: grpc_pb.GetVersionRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetVersionReply>;
+    getVersion(request: grpc_pb.GetVersionRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetVersionReply>;
     getVersion(request: grpc_pb.GetVersionRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetVersionReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetVersionReply>;
 }
 export declare class AccountClient {
@@ -56,33 +56,33 @@ export declare class AccountClient {
         [index: string]: any;
     });
     methodDescriptorAccountExists: grpcWeb.MethodDescriptor<grpc_pb.AccountExistsRequest, grpc_pb.AccountExistsReply>;
-    accountExists(request: grpc_pb.AccountExistsRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.AccountExistsReply>;
+    accountExists(request: grpc_pb.AccountExistsRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.AccountExistsReply>;
     accountExists(request: grpc_pb.AccountExistsRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.AccountExistsReply) => void): grpcWeb.ClientReadableStream<grpc_pb.AccountExistsReply>;
     methodDescriptorIsAccountOpen: grpcWeb.MethodDescriptor<grpc_pb.IsAccountOpenRequest, grpc_pb.IsAccountOpenReply>;
-    isAccountOpen(request: grpc_pb.IsAccountOpenRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.IsAccountOpenReply>;
+    isAccountOpen(request: grpc_pb.IsAccountOpenRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.IsAccountOpenReply>;
     isAccountOpen(request: grpc_pb.IsAccountOpenRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.IsAccountOpenReply) => void): grpcWeb.ClientReadableStream<grpc_pb.IsAccountOpenReply>;
     methodDescriptorCreateAccount: grpcWeb.MethodDescriptor<grpc_pb.CreateAccountRequest, grpc_pb.CreateAccountReply>;
-    createAccount(request: grpc_pb.CreateAccountRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.CreateAccountReply>;
+    createAccount(request: grpc_pb.CreateAccountRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.CreateAccountReply>;
     createAccount(request: grpc_pb.CreateAccountRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.CreateAccountReply) => void): grpcWeb.ClientReadableStream<grpc_pb.CreateAccountReply>;
     methodDescriptorOpenAccount: grpcWeb.MethodDescriptor<grpc_pb.OpenAccountRequest, grpc_pb.OpenAccountReply>;
-    openAccount(request: grpc_pb.OpenAccountRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.OpenAccountReply>;
+    openAccount(request: grpc_pb.OpenAccountRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.OpenAccountReply>;
     openAccount(request: grpc_pb.OpenAccountRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.OpenAccountReply) => void): grpcWeb.ClientReadableStream<grpc_pb.OpenAccountReply>;
     methodDescriptorIsAppInitialized: grpcWeb.MethodDescriptor<grpc_pb.IsAppInitializedRequest, grpc_pb.IsAppInitializedReply>;
-    isAppInitialized(request: grpc_pb.IsAppInitializedRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.IsAppInitializedReply>;
+    isAppInitialized(request: grpc_pb.IsAppInitializedRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.IsAppInitializedReply>;
     isAppInitialized(request: grpc_pb.IsAppInitializedRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.IsAppInitializedReply) => void): grpcWeb.ClientReadableStream<grpc_pb.IsAppInitializedReply>;
     methodDescriptorChangePassword: grpcWeb.MethodDescriptor<grpc_pb.ChangePasswordRequest, grpc_pb.ChangePasswordReply>;
-    changePassword(request: grpc_pb.ChangePasswordRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.ChangePasswordReply>;
+    changePassword(request: grpc_pb.ChangePasswordRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.ChangePasswordReply>;
     changePassword(request: grpc_pb.ChangePasswordRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.ChangePasswordReply) => void): grpcWeb.ClientReadableStream<grpc_pb.ChangePasswordReply>;
     methodDescriptorCloseAccount: grpcWeb.MethodDescriptor<grpc_pb.CloseAccountRequest, grpc_pb.CloseAccountReply>;
-    closeAccount(request: grpc_pb.CloseAccountRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.CloseAccountReply>;
+    closeAccount(request: grpc_pb.CloseAccountRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.CloseAccountReply>;
     closeAccount(request: grpc_pb.CloseAccountRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.CloseAccountReply) => void): grpcWeb.ClientReadableStream<grpc_pb.CloseAccountReply>;
     methodDescriptorDeleteAccount: grpcWeb.MethodDescriptor<grpc_pb.DeleteAccountRequest, grpc_pb.DeleteAccountReply>;
-    deleteAccount(request: grpc_pb.DeleteAccountRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.DeleteAccountReply>;
+    deleteAccount(request: grpc_pb.DeleteAccountRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.DeleteAccountReply>;
     deleteAccount(request: grpc_pb.DeleteAccountRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.DeleteAccountReply) => void): grpcWeb.ClientReadableStream<grpc_pb.DeleteAccountReply>;
     methodDescriptorBackupAccount: grpcWeb.MethodDescriptor<grpc_pb.BackupAccountRequest, grpc_pb.BackupAccountReply>;
     backupAccount(request: grpc_pb.BackupAccountRequest, metadata?: grpcWeb.Metadata): grpcWeb.ClientReadableStream<grpc_pb.BackupAccountReply>;
     methodDescriptorRestoreAccount: grpcWeb.MethodDescriptor<grpc_pb.RestoreAccountRequest, grpc_pb.RestoreAccountReply>;
-    restoreAccount(request: grpc_pb.RestoreAccountRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.RestoreAccountReply>;
+    restoreAccount(request: grpc_pb.RestoreAccountRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.RestoreAccountReply>;
     restoreAccount(request: grpc_pb.RestoreAccountRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.RestoreAccountReply) => void): grpcWeb.ClientReadableStream<grpc_pb.RestoreAccountReply>;
 }
 export declare class DisputesClient {
@@ -100,19 +100,19 @@ export declare class DisputesClient {
         [index: string]: any;
     });
     methodDescriptorGetDispute: grpcWeb.MethodDescriptor<grpc_pb.GetDisputeRequest, grpc_pb.GetDisputeReply>;
-    getDispute(request: grpc_pb.GetDisputeRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetDisputeReply>;
+    getDispute(request: grpc_pb.GetDisputeRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetDisputeReply>;
     getDispute(request: grpc_pb.GetDisputeRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetDisputeReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetDisputeReply>;
     methodDescriptorGetDisputes: grpcWeb.MethodDescriptor<grpc_pb.GetDisputesRequest, grpc_pb.GetDisputesReply>;
-    getDisputes(request: grpc_pb.GetDisputesRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetDisputesReply>;
+    getDisputes(request: grpc_pb.GetDisputesRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetDisputesReply>;
     getDisputes(request: grpc_pb.GetDisputesRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetDisputesReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetDisputesReply>;
     methodDescriptorOpenDispute: grpcWeb.MethodDescriptor<grpc_pb.OpenDisputeRequest, grpc_pb.OpenDisputeReply>;
-    openDispute(request: grpc_pb.OpenDisputeRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.OpenDisputeReply>;
+    openDispute(request: grpc_pb.OpenDisputeRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.OpenDisputeReply>;
     openDispute(request: grpc_pb.OpenDisputeRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.OpenDisputeReply) => void): grpcWeb.ClientReadableStream<grpc_pb.OpenDisputeReply>;
     methodDescriptorResolveDispute: grpcWeb.MethodDescriptor<grpc_pb.ResolveDisputeRequest, grpc_pb.ResolveDisputeReply>;
-    resolveDispute(request: grpc_pb.ResolveDisputeRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.ResolveDisputeReply>;
+    resolveDispute(request: grpc_pb.ResolveDisputeRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.ResolveDisputeReply>;
     resolveDispute(request: grpc_pb.ResolveDisputeRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.ResolveDisputeReply) => void): grpcWeb.ClientReadableStream<grpc_pb.ResolveDisputeReply>;
     methodDescriptorSendDisputeChatMessage: grpcWeb.MethodDescriptor<grpc_pb.SendDisputeChatMessageRequest, grpc_pb.SendDisputeChatMessageReply>;
-    sendDisputeChatMessage(request: grpc_pb.SendDisputeChatMessageRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.SendDisputeChatMessageReply>;
+    sendDisputeChatMessage(request: grpc_pb.SendDisputeChatMessageRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.SendDisputeChatMessageReply>;
     sendDisputeChatMessage(request: grpc_pb.SendDisputeChatMessageRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.SendDisputeChatMessageReply) => void): grpcWeb.ClientReadableStream<grpc_pb.SendDisputeChatMessageReply>;
 }
 export declare class DisputeAgentsClient {
@@ -130,10 +130,10 @@ export declare class DisputeAgentsClient {
         [index: string]: any;
     });
     methodDescriptorRegisterDisputeAgent: grpcWeb.MethodDescriptor<grpc_pb.RegisterDisputeAgentRequest, grpc_pb.RegisterDisputeAgentReply>;
-    registerDisputeAgent(request: grpc_pb.RegisterDisputeAgentRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.RegisterDisputeAgentReply>;
+    registerDisputeAgent(request: grpc_pb.RegisterDisputeAgentRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.RegisterDisputeAgentReply>;
     registerDisputeAgent(request: grpc_pb.RegisterDisputeAgentRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.RegisterDisputeAgentReply) => void): grpcWeb.ClientReadableStream<grpc_pb.RegisterDisputeAgentReply>;
     methodDescriptorUnregisterDisputeAgent: grpcWeb.MethodDescriptor<grpc_pb.UnregisterDisputeAgentRequest, grpc_pb.UnregisterDisputeAgentReply>;
-    unregisterDisputeAgent(request: grpc_pb.UnregisterDisputeAgentRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.UnregisterDisputeAgentReply>;
+    unregisterDisputeAgent(request: grpc_pb.UnregisterDisputeAgentRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.UnregisterDisputeAgentReply>;
     unregisterDisputeAgent(request: grpc_pb.UnregisterDisputeAgentRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.UnregisterDisputeAgentReply) => void): grpcWeb.ClientReadableStream<grpc_pb.UnregisterDisputeAgentReply>;
 }
 export declare class NotificationsClient {
@@ -153,7 +153,7 @@ export declare class NotificationsClient {
     methodDescriptorRegisterNotificationListener: grpcWeb.MethodDescriptor<grpc_pb.RegisterNotificationListenerRequest, grpc_pb.NotificationMessage>;
     registerNotificationListener(request: grpc_pb.RegisterNotificationListenerRequest, metadata?: grpcWeb.Metadata): grpcWeb.ClientReadableStream<grpc_pb.NotificationMessage>;
     methodDescriptorSendNotification: grpcWeb.MethodDescriptor<grpc_pb.SendNotificationRequest, grpc_pb.SendNotificationReply>;
-    sendNotification(request: grpc_pb.SendNotificationRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.SendNotificationReply>;
+    sendNotification(request: grpc_pb.SendNotificationRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.SendNotificationReply>;
     sendNotification(request: grpc_pb.SendNotificationRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.SendNotificationReply) => void): grpcWeb.ClientReadableStream<grpc_pb.SendNotificationReply>;
 }
 export declare class XmrConnectionsClient {
@@ -171,37 +171,37 @@ export declare class XmrConnectionsClient {
         [index: string]: any;
     });
     methodDescriptorAddConnection: grpcWeb.MethodDescriptor<grpc_pb.AddConnectionRequest, grpc_pb.AddConnectionReply>;
-    addConnection(request: grpc_pb.AddConnectionRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.AddConnectionReply>;
+    addConnection(request: grpc_pb.AddConnectionRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.AddConnectionReply>;
     addConnection(request: grpc_pb.AddConnectionRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.AddConnectionReply) => void): grpcWeb.ClientReadableStream<grpc_pb.AddConnectionReply>;
     methodDescriptorRemoveConnection: grpcWeb.MethodDescriptor<grpc_pb.RemoveConnectionRequest, grpc_pb.RemoveConnectionReply>;
-    removeConnection(request: grpc_pb.RemoveConnectionRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.RemoveConnectionReply>;
+    removeConnection(request: grpc_pb.RemoveConnectionRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.RemoveConnectionReply>;
     removeConnection(request: grpc_pb.RemoveConnectionRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.RemoveConnectionReply) => void): grpcWeb.ClientReadableStream<grpc_pb.RemoveConnectionReply>;
     methodDescriptorGetConnection: grpcWeb.MethodDescriptor<grpc_pb.GetConnectionRequest, grpc_pb.GetConnectionReply>;
-    getConnection(request: grpc_pb.GetConnectionRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetConnectionReply>;
+    getConnection(request: grpc_pb.GetConnectionRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetConnectionReply>;
     getConnection(request: grpc_pb.GetConnectionRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetConnectionReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetConnectionReply>;
     methodDescriptorGetConnections: grpcWeb.MethodDescriptor<grpc_pb.GetConnectionsRequest, grpc_pb.GetConnectionsReply>;
-    getConnections(request: grpc_pb.GetConnectionsRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetConnectionsReply>;
+    getConnections(request: grpc_pb.GetConnectionsRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetConnectionsReply>;
     getConnections(request: grpc_pb.GetConnectionsRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetConnectionsReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetConnectionsReply>;
     methodDescriptorSetConnection: grpcWeb.MethodDescriptor<grpc_pb.SetConnectionRequest, grpc_pb.SetConnectionReply>;
-    setConnection(request: grpc_pb.SetConnectionRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.SetConnectionReply>;
+    setConnection(request: grpc_pb.SetConnectionRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.SetConnectionReply>;
     setConnection(request: grpc_pb.SetConnectionRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.SetConnectionReply) => void): grpcWeb.ClientReadableStream<grpc_pb.SetConnectionReply>;
     methodDescriptorCheckConnection: grpcWeb.MethodDescriptor<grpc_pb.CheckConnectionRequest, grpc_pb.CheckConnectionReply>;
-    checkConnection(request: grpc_pb.CheckConnectionRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.CheckConnectionReply>;
+    checkConnection(request: grpc_pb.CheckConnectionRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.CheckConnectionReply>;
     checkConnection(request: grpc_pb.CheckConnectionRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.CheckConnectionReply) => void): grpcWeb.ClientReadableStream<grpc_pb.CheckConnectionReply>;
     methodDescriptorCheckConnections: grpcWeb.MethodDescriptor<grpc_pb.CheckConnectionsRequest, grpc_pb.CheckConnectionsReply>;
-    checkConnections(request: grpc_pb.CheckConnectionsRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.CheckConnectionsReply>;
+    checkConnections(request: grpc_pb.CheckConnectionsRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.CheckConnectionsReply>;
     checkConnections(request: grpc_pb.CheckConnectionsRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.CheckConnectionsReply) => void): grpcWeb.ClientReadableStream<grpc_pb.CheckConnectionsReply>;
     methodDescriptorStartCheckingConnections: grpcWeb.MethodDescriptor<grpc_pb.StartCheckingConnectionsRequest, grpc_pb.StartCheckingConnectionsReply>;
-    startCheckingConnections(request: grpc_pb.StartCheckingConnectionsRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.StartCheckingConnectionsReply>;
+    startCheckingConnections(request: grpc_pb.StartCheckingConnectionsRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.StartCheckingConnectionsReply>;
     startCheckingConnections(request: grpc_pb.StartCheckingConnectionsRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.StartCheckingConnectionsReply) => void): grpcWeb.ClientReadableStream<grpc_pb.StartCheckingConnectionsReply>;
     methodDescriptorStopCheckingConnections: grpcWeb.MethodDescriptor<grpc_pb.StopCheckingConnectionsRequest, grpc_pb.StopCheckingConnectionsReply>;
-    stopCheckingConnections(request: grpc_pb.StopCheckingConnectionsRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.StopCheckingConnectionsReply>;
+    stopCheckingConnections(request: grpc_pb.StopCheckingConnectionsRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.StopCheckingConnectionsReply>;
     stopCheckingConnections(request: grpc_pb.StopCheckingConnectionsRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.StopCheckingConnectionsReply) => void): grpcWeb.ClientReadableStream<grpc_pb.StopCheckingConnectionsReply>;
     methodDescriptorGetBestAvailableConnection: grpcWeb.MethodDescriptor<grpc_pb.GetBestAvailableConnectionRequest, grpc_pb.GetBestAvailableConnectionReply>;
-    getBestAvailableConnection(request: grpc_pb.GetBestAvailableConnectionRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetBestAvailableConnectionReply>;
+    getBestAvailableConnection(request: grpc_pb.GetBestAvailableConnectionRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetBestAvailableConnectionReply>;
     getBestAvailableConnection(request: grpc_pb.GetBestAvailableConnectionRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetBestAvailableConnectionReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetBestAvailableConnectionReply>;
     methodDescriptorSetAutoSwitch: grpcWeb.MethodDescriptor<grpc_pb.SetAutoSwitchRequest, grpc_pb.SetAutoSwitchReply>;
-    setAutoSwitch(request: grpc_pb.SetAutoSwitchRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.SetAutoSwitchReply>;
+    setAutoSwitch(request: grpc_pb.SetAutoSwitchRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.SetAutoSwitchReply>;
     setAutoSwitch(request: grpc_pb.SetAutoSwitchRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.SetAutoSwitchReply) => void): grpcWeb.ClientReadableStream<grpc_pb.SetAutoSwitchReply>;
 }
 export declare class XmrNodeClient {
@@ -219,16 +219,16 @@ export declare class XmrNodeClient {
         [index: string]: any;
     });
     methodDescriptorIsXmrNodeOnline: grpcWeb.MethodDescriptor<grpc_pb.IsXmrNodeOnlineRequest, grpc_pb.IsXmrNodeOnlineReply>;
-    isXmrNodeOnline(request: grpc_pb.IsXmrNodeOnlineRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.IsXmrNodeOnlineReply>;
+    isXmrNodeOnline(request: grpc_pb.IsXmrNodeOnlineRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.IsXmrNodeOnlineReply>;
     isXmrNodeOnline(request: grpc_pb.IsXmrNodeOnlineRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.IsXmrNodeOnlineReply) => void): grpcWeb.ClientReadableStream<grpc_pb.IsXmrNodeOnlineReply>;
     methodDescriptorGetXmrNodeSettings: grpcWeb.MethodDescriptor<grpc_pb.GetXmrNodeSettingsRequest, grpc_pb.GetXmrNodeSettingsReply>;
-    getXmrNodeSettings(request: grpc_pb.GetXmrNodeSettingsRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetXmrNodeSettingsReply>;
+    getXmrNodeSettings(request: grpc_pb.GetXmrNodeSettingsRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetXmrNodeSettingsReply>;
     getXmrNodeSettings(request: grpc_pb.GetXmrNodeSettingsRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetXmrNodeSettingsReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetXmrNodeSettingsReply>;
     methodDescriptorStartXmrNode: grpcWeb.MethodDescriptor<grpc_pb.StartXmrNodeRequest, grpc_pb.StartXmrNodeReply>;
-    startXmrNode(request: grpc_pb.StartXmrNodeRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.StartXmrNodeReply>;
+    startXmrNode(request: grpc_pb.StartXmrNodeRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.StartXmrNodeReply>;
     startXmrNode(request: grpc_pb.StartXmrNodeRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.StartXmrNodeReply) => void): grpcWeb.ClientReadableStream<grpc_pb.StartXmrNodeReply>;
     methodDescriptorStopXmrNode: grpcWeb.MethodDescriptor<grpc_pb.StopXmrNodeRequest, grpc_pb.StopXmrNodeReply>;
-    stopXmrNode(request: grpc_pb.StopXmrNodeRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.StopXmrNodeReply>;
+    stopXmrNode(request: grpc_pb.StopXmrNodeRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.StopXmrNodeReply>;
     stopXmrNode(request: grpc_pb.StopXmrNodeRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.StopXmrNodeReply) => void): grpcWeb.ClientReadableStream<grpc_pb.StopXmrNodeReply>;
 }
 export declare class OffersClient {
@@ -246,22 +246,22 @@ export declare class OffersClient {
         [index: string]: any;
     });
     methodDescriptorGetOffer: grpcWeb.MethodDescriptor<grpc_pb.GetOfferRequest, grpc_pb.GetOfferReply>;
-    getOffer(request: grpc_pb.GetOfferRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetOfferReply>;
+    getOffer(request: grpc_pb.GetOfferRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetOfferReply>;
     getOffer(request: grpc_pb.GetOfferRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetOfferReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetOfferReply>;
     methodDescriptorGetMyOffer: grpcWeb.MethodDescriptor<grpc_pb.GetMyOfferRequest, grpc_pb.GetMyOfferReply>;
-    getMyOffer(request: grpc_pb.GetMyOfferRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetMyOfferReply>;
+    getMyOffer(request: grpc_pb.GetMyOfferRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetMyOfferReply>;
     getMyOffer(request: grpc_pb.GetMyOfferRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetMyOfferReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetMyOfferReply>;
     methodDescriptorGetOffers: grpcWeb.MethodDescriptor<grpc_pb.GetOffersRequest, grpc_pb.GetOffersReply>;
-    getOffers(request: grpc_pb.GetOffersRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetOffersReply>;
+    getOffers(request: grpc_pb.GetOffersRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetOffersReply>;
     getOffers(request: grpc_pb.GetOffersRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetOffersReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetOffersReply>;
     methodDescriptorGetMyOffers: grpcWeb.MethodDescriptor<grpc_pb.GetMyOffersRequest, grpc_pb.GetMyOffersReply>;
-    getMyOffers(request: grpc_pb.GetMyOffersRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetMyOffersReply>;
+    getMyOffers(request: grpc_pb.GetMyOffersRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetMyOffersReply>;
     getMyOffers(request: grpc_pb.GetMyOffersRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetMyOffersReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetMyOffersReply>;
     methodDescriptorPostOffer: grpcWeb.MethodDescriptor<grpc_pb.PostOfferRequest, grpc_pb.PostOfferReply>;
-    postOffer(request: grpc_pb.PostOfferRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.PostOfferReply>;
+    postOffer(request: grpc_pb.PostOfferRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.PostOfferReply>;
     postOffer(request: grpc_pb.PostOfferRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.PostOfferReply) => void): grpcWeb.ClientReadableStream<grpc_pb.PostOfferReply>;
     methodDescriptorCancelOffer: grpcWeb.MethodDescriptor<grpc_pb.CancelOfferRequest, grpc_pb.CancelOfferReply>;
-    cancelOffer(request: grpc_pb.CancelOfferRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.CancelOfferReply>;
+    cancelOffer(request: grpc_pb.CancelOfferRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.CancelOfferReply>;
     cancelOffer(request: grpc_pb.CancelOfferRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.CancelOfferReply) => void): grpcWeb.ClientReadableStream<grpc_pb.CancelOfferReply>;
 }
 export declare class PaymentAccountsClient {
@@ -279,28 +279,28 @@ export declare class PaymentAccountsClient {
         [index: string]: any;
     });
     methodDescriptorCreatePaymentAccount: grpcWeb.MethodDescriptor<grpc_pb.CreatePaymentAccountRequest, grpc_pb.CreatePaymentAccountReply>;
-    createPaymentAccount(request: grpc_pb.CreatePaymentAccountRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.CreatePaymentAccountReply>;
+    createPaymentAccount(request: grpc_pb.CreatePaymentAccountRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.CreatePaymentAccountReply>;
     createPaymentAccount(request: grpc_pb.CreatePaymentAccountRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.CreatePaymentAccountReply) => void): grpcWeb.ClientReadableStream<grpc_pb.CreatePaymentAccountReply>;
     methodDescriptorGetPaymentAccounts: grpcWeb.MethodDescriptor<grpc_pb.GetPaymentAccountsRequest, grpc_pb.GetPaymentAccountsReply>;
-    getPaymentAccounts(request: grpc_pb.GetPaymentAccountsRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetPaymentAccountsReply>;
+    getPaymentAccounts(request: grpc_pb.GetPaymentAccountsRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetPaymentAccountsReply>;
     getPaymentAccounts(request: grpc_pb.GetPaymentAccountsRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetPaymentAccountsReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetPaymentAccountsReply>;
     methodDescriptorGetPaymentMethods: grpcWeb.MethodDescriptor<grpc_pb.GetPaymentMethodsRequest, grpc_pb.GetPaymentMethodsReply>;
-    getPaymentMethods(request: grpc_pb.GetPaymentMethodsRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetPaymentMethodsReply>;
+    getPaymentMethods(request: grpc_pb.GetPaymentMethodsRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetPaymentMethodsReply>;
     getPaymentMethods(request: grpc_pb.GetPaymentMethodsRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetPaymentMethodsReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetPaymentMethodsReply>;
     methodDescriptorGetPaymentAccountForm: grpcWeb.MethodDescriptor<grpc_pb.GetPaymentAccountFormRequest, grpc_pb.GetPaymentAccountFormReply>;
-    getPaymentAccountForm(request: grpc_pb.GetPaymentAccountFormRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetPaymentAccountFormReply>;
+    getPaymentAccountForm(request: grpc_pb.GetPaymentAccountFormRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetPaymentAccountFormReply>;
     getPaymentAccountForm(request: grpc_pb.GetPaymentAccountFormRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetPaymentAccountFormReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetPaymentAccountFormReply>;
     methodDescriptorGetPaymentAccountFormAsJson: grpcWeb.MethodDescriptor<grpc_pb.GetPaymentAccountFormAsJsonRequest, grpc_pb.GetPaymentAccountFormAsJsonReply>;
-    getPaymentAccountFormAsJson(request: grpc_pb.GetPaymentAccountFormAsJsonRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetPaymentAccountFormAsJsonReply>;
+    getPaymentAccountFormAsJson(request: grpc_pb.GetPaymentAccountFormAsJsonRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetPaymentAccountFormAsJsonReply>;
     getPaymentAccountFormAsJson(request: grpc_pb.GetPaymentAccountFormAsJsonRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetPaymentAccountFormAsJsonReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetPaymentAccountFormAsJsonReply>;
     methodDescriptorCreateCryptoCurrencyPaymentAccount: grpcWeb.MethodDescriptor<grpc_pb.CreateCryptoCurrencyPaymentAccountRequest, grpc_pb.CreateCryptoCurrencyPaymentAccountReply>;
-    createCryptoCurrencyPaymentAccount(request: grpc_pb.CreateCryptoCurrencyPaymentAccountRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.CreateCryptoCurrencyPaymentAccountReply>;
+    createCryptoCurrencyPaymentAccount(request: grpc_pb.CreateCryptoCurrencyPaymentAccountRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.CreateCryptoCurrencyPaymentAccountReply>;
     createCryptoCurrencyPaymentAccount(request: grpc_pb.CreateCryptoCurrencyPaymentAccountRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.CreateCryptoCurrencyPaymentAccountReply) => void): grpcWeb.ClientReadableStream<grpc_pb.CreateCryptoCurrencyPaymentAccountReply>;
     methodDescriptorGetCryptoCurrencyPaymentMethods: grpcWeb.MethodDescriptor<grpc_pb.GetCryptoCurrencyPaymentMethodsRequest, grpc_pb.GetCryptoCurrencyPaymentMethodsReply>;
-    getCryptoCurrencyPaymentMethods(request: grpc_pb.GetCryptoCurrencyPaymentMethodsRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetCryptoCurrencyPaymentMethodsReply>;
+    getCryptoCurrencyPaymentMethods(request: grpc_pb.GetCryptoCurrencyPaymentMethodsRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetCryptoCurrencyPaymentMethodsReply>;
     getCryptoCurrencyPaymentMethods(request: grpc_pb.GetCryptoCurrencyPaymentMethodsRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetCryptoCurrencyPaymentMethodsReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetCryptoCurrencyPaymentMethodsReply>;
     methodDescriptorValidateFormField: grpcWeb.MethodDescriptor<grpc_pb.ValidateFormFieldRequest, grpc_pb.ValidateFormFieldReply>;
-    validateFormField(request: grpc_pb.ValidateFormFieldRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.ValidateFormFieldReply>;
+    validateFormField(request: grpc_pb.ValidateFormFieldRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.ValidateFormFieldReply>;
     validateFormField(request: grpc_pb.ValidateFormFieldRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.ValidateFormFieldReply) => void): grpcWeb.ClientReadableStream<grpc_pb.ValidateFormFieldReply>;
 }
 export declare class PriceClient {
@@ -318,13 +318,13 @@ export declare class PriceClient {
         [index: string]: any;
     });
     methodDescriptorGetMarketPrice: grpcWeb.MethodDescriptor<grpc_pb.MarketPriceRequest, grpc_pb.MarketPriceReply>;
-    getMarketPrice(request: grpc_pb.MarketPriceRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.MarketPriceReply>;
+    getMarketPrice(request: grpc_pb.MarketPriceRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.MarketPriceReply>;
     getMarketPrice(request: grpc_pb.MarketPriceRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.MarketPriceReply) => void): grpcWeb.ClientReadableStream<grpc_pb.MarketPriceReply>;
     methodDescriptorGetMarketPrices: grpcWeb.MethodDescriptor<grpc_pb.MarketPricesRequest, grpc_pb.MarketPricesReply>;
-    getMarketPrices(request: grpc_pb.MarketPricesRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.MarketPricesReply>;
+    getMarketPrices(request: grpc_pb.MarketPricesRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.MarketPricesReply>;
     getMarketPrices(request: grpc_pb.MarketPricesRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.MarketPricesReply) => void): grpcWeb.ClientReadableStream<grpc_pb.MarketPricesReply>;
     methodDescriptorGetMarketDepth: grpcWeb.MethodDescriptor<grpc_pb.MarketDepthRequest, grpc_pb.MarketDepthReply>;
-    getMarketDepth(request: grpc_pb.MarketDepthRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.MarketDepthReply>;
+    getMarketDepth(request: grpc_pb.MarketDepthRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.MarketDepthReply>;
     getMarketDepth(request: grpc_pb.MarketDepthRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.MarketDepthReply) => void): grpcWeb.ClientReadableStream<grpc_pb.MarketDepthReply>;
 }
 export declare class GetTradeStatisticsClient {
@@ -342,7 +342,7 @@ export declare class GetTradeStatisticsClient {
         [index: string]: any;
     });
     methodDescriptorGetTradeStatistics: grpcWeb.MethodDescriptor<grpc_pb.GetTradeStatisticsRequest, grpc_pb.GetTradeStatisticsReply>;
-    getTradeStatistics(request: grpc_pb.GetTradeStatisticsRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetTradeStatisticsReply>;
+    getTradeStatistics(request: grpc_pb.GetTradeStatisticsRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetTradeStatisticsReply>;
     getTradeStatistics(request: grpc_pb.GetTradeStatisticsRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetTradeStatisticsReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetTradeStatisticsReply>;
 }
 export declare class ShutdownServerClient {
@@ -360,7 +360,7 @@ export declare class ShutdownServerClient {
         [index: string]: any;
     });
     methodDescriptorStop: grpcWeb.MethodDescriptor<grpc_pb.StopRequest, grpc_pb.StopReply>;
-    stop(request: grpc_pb.StopRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.StopReply>;
+    stop(request: grpc_pb.StopRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.StopReply>;
     stop(request: grpc_pb.StopRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.StopReply) => void): grpcWeb.ClientReadableStream<grpc_pb.StopReply>;
 }
 export declare class TradesClient {
@@ -378,31 +378,31 @@ export declare class TradesClient {
         [index: string]: any;
     });
     methodDescriptorGetTrade: grpcWeb.MethodDescriptor<grpc_pb.GetTradeRequest, grpc_pb.GetTradeReply>;
-    getTrade(request: grpc_pb.GetTradeRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetTradeReply>;
+    getTrade(request: grpc_pb.GetTradeRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetTradeReply>;
     getTrade(request: grpc_pb.GetTradeRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetTradeReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetTradeReply>;
     methodDescriptorGetTrades: grpcWeb.MethodDescriptor<grpc_pb.GetTradesRequest, grpc_pb.GetTradesReply>;
-    getTrades(request: grpc_pb.GetTradesRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetTradesReply>;
+    getTrades(request: grpc_pb.GetTradesRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetTradesReply>;
     getTrades(request: grpc_pb.GetTradesRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetTradesReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetTradesReply>;
     methodDescriptorTakeOffer: grpcWeb.MethodDescriptor<grpc_pb.TakeOfferRequest, grpc_pb.TakeOfferReply>;
-    takeOffer(request: grpc_pb.TakeOfferRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.TakeOfferReply>;
+    takeOffer(request: grpc_pb.TakeOfferRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.TakeOfferReply>;
     takeOffer(request: grpc_pb.TakeOfferRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.TakeOfferReply) => void): grpcWeb.ClientReadableStream<grpc_pb.TakeOfferReply>;
     methodDescriptorConfirmPaymentSent: grpcWeb.MethodDescriptor<grpc_pb.ConfirmPaymentSentRequest, grpc_pb.ConfirmPaymentSentReply>;
-    confirmPaymentSent(request: grpc_pb.ConfirmPaymentSentRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.ConfirmPaymentSentReply>;
+    confirmPaymentSent(request: grpc_pb.ConfirmPaymentSentRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.ConfirmPaymentSentReply>;
     confirmPaymentSent(request: grpc_pb.ConfirmPaymentSentRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.ConfirmPaymentSentReply) => void): grpcWeb.ClientReadableStream<grpc_pb.ConfirmPaymentSentReply>;
     methodDescriptorConfirmPaymentReceived: grpcWeb.MethodDescriptor<grpc_pb.ConfirmPaymentReceivedRequest, grpc_pb.ConfirmPaymentReceivedReply>;
-    confirmPaymentReceived(request: grpc_pb.ConfirmPaymentReceivedRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.ConfirmPaymentReceivedReply>;
+    confirmPaymentReceived(request: grpc_pb.ConfirmPaymentReceivedRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.ConfirmPaymentReceivedReply>;
     confirmPaymentReceived(request: grpc_pb.ConfirmPaymentReceivedRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.ConfirmPaymentReceivedReply) => void): grpcWeb.ClientReadableStream<grpc_pb.ConfirmPaymentReceivedReply>;
     methodDescriptorCompleteTrade: grpcWeb.MethodDescriptor<grpc_pb.CompleteTradeRequest, grpc_pb.CompleteTradeReply>;
-    completeTrade(request: grpc_pb.CompleteTradeRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.CompleteTradeReply>;
+    completeTrade(request: grpc_pb.CompleteTradeRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.CompleteTradeReply>;
     completeTrade(request: grpc_pb.CompleteTradeRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.CompleteTradeReply) => void): grpcWeb.ClientReadableStream<grpc_pb.CompleteTradeReply>;
     methodDescriptorWithdrawFunds: grpcWeb.MethodDescriptor<grpc_pb.WithdrawFundsRequest, grpc_pb.WithdrawFundsReply>;
-    withdrawFunds(request: grpc_pb.WithdrawFundsRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.WithdrawFundsReply>;
+    withdrawFunds(request: grpc_pb.WithdrawFundsRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.WithdrawFundsReply>;
     withdrawFunds(request: grpc_pb.WithdrawFundsRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.WithdrawFundsReply) => void): grpcWeb.ClientReadableStream<grpc_pb.WithdrawFundsReply>;
     methodDescriptorGetChatMessages: grpcWeb.MethodDescriptor<grpc_pb.GetChatMessagesRequest, grpc_pb.GetChatMessagesReply>;
-    getChatMessages(request: grpc_pb.GetChatMessagesRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetChatMessagesReply>;
+    getChatMessages(request: grpc_pb.GetChatMessagesRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetChatMessagesReply>;
     getChatMessages(request: grpc_pb.GetChatMessagesRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetChatMessagesReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetChatMessagesReply>;
     methodDescriptorSendChatMessage: grpcWeb.MethodDescriptor<grpc_pb.SendChatMessageRequest, grpc_pb.SendChatMessageReply>;
-    sendChatMessage(request: grpc_pb.SendChatMessageRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.SendChatMessageReply>;
+    sendChatMessage(request: grpc_pb.SendChatMessageRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.SendChatMessageReply>;
     sendChatMessage(request: grpc_pb.SendChatMessageRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.SendChatMessageReply) => void): grpcWeb.ClientReadableStream<grpc_pb.SendChatMessageReply>;
 }
 export declare class WalletsClient {
@@ -420,42 +420,42 @@ export declare class WalletsClient {
         [index: string]: any;
     });
     methodDescriptorGetBalances: grpcWeb.MethodDescriptor<grpc_pb.GetBalancesRequest, grpc_pb.GetBalancesReply>;
-    getBalances(request: grpc_pb.GetBalancesRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetBalancesReply>;
+    getBalances(request: grpc_pb.GetBalancesRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetBalancesReply>;
     getBalances(request: grpc_pb.GetBalancesRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetBalancesReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetBalancesReply>;
     methodDescriptorGetXmrSeed: grpcWeb.MethodDescriptor<grpc_pb.GetXmrSeedRequest, grpc_pb.GetXmrSeedReply>;
-    getXmrSeed(request: grpc_pb.GetXmrSeedRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetXmrSeedReply>;
+    getXmrSeed(request: grpc_pb.GetXmrSeedRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetXmrSeedReply>;
     getXmrSeed(request: grpc_pb.GetXmrSeedRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetXmrSeedReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetXmrSeedReply>;
     methodDescriptorGetXmrPrimaryAddress: grpcWeb.MethodDescriptor<grpc_pb.GetXmrPrimaryAddressRequest, grpc_pb.GetXmrPrimaryAddressReply>;
-    getXmrPrimaryAddress(request: grpc_pb.GetXmrPrimaryAddressRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetXmrPrimaryAddressReply>;
+    getXmrPrimaryAddress(request: grpc_pb.GetXmrPrimaryAddressRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetXmrPrimaryAddressReply>;
     getXmrPrimaryAddress(request: grpc_pb.GetXmrPrimaryAddressRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetXmrPrimaryAddressReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetXmrPrimaryAddressReply>;
     methodDescriptorGetXmrNewSubaddress: grpcWeb.MethodDescriptor<grpc_pb.GetXmrNewSubaddressRequest, grpc_pb.GetXmrNewSubaddressReply>;
-    getXmrNewSubaddress(request: grpc_pb.GetXmrNewSubaddressRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetXmrNewSubaddressReply>;
+    getXmrNewSubaddress(request: grpc_pb.GetXmrNewSubaddressRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetXmrNewSubaddressReply>;
     getXmrNewSubaddress(request: grpc_pb.GetXmrNewSubaddressRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetXmrNewSubaddressReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetXmrNewSubaddressReply>;
     methodDescriptorGetXmrTxs: grpcWeb.MethodDescriptor<grpc_pb.GetXmrTxsRequest, grpc_pb.GetXmrTxsReply>;
-    getXmrTxs(request: grpc_pb.GetXmrTxsRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetXmrTxsReply>;
+    getXmrTxs(request: grpc_pb.GetXmrTxsRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetXmrTxsReply>;
     getXmrTxs(request: grpc_pb.GetXmrTxsRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetXmrTxsReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetXmrTxsReply>;
     methodDescriptorCreateXmrTx: grpcWeb.MethodDescriptor<grpc_pb.CreateXmrTxRequest, grpc_pb.CreateXmrTxReply>;
-    createXmrTx(request: grpc_pb.CreateXmrTxRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.CreateXmrTxReply>;
+    createXmrTx(request: grpc_pb.CreateXmrTxRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.CreateXmrTxReply>;
     createXmrTx(request: grpc_pb.CreateXmrTxRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.CreateXmrTxReply) => void): grpcWeb.ClientReadableStream<grpc_pb.CreateXmrTxReply>;
     methodDescriptorrelayXmrTx: grpcWeb.MethodDescriptor<grpc_pb.RelayXmrTxRequest, grpc_pb.RelayXmrTxReply>;
-    relayXmrTx(request: grpc_pb.RelayXmrTxRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.RelayXmrTxReply>;
+    relayXmrTx(request: grpc_pb.RelayXmrTxRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.RelayXmrTxReply>;
     relayXmrTx(request: grpc_pb.RelayXmrTxRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.RelayXmrTxReply) => void): grpcWeb.ClientReadableStream<grpc_pb.RelayXmrTxReply>;
     methodDescriptorGetAddressBalance: grpcWeb.MethodDescriptor<grpc_pb.GetAddressBalanceRequest, grpc_pb.GetAddressBalanceReply>;
-    getAddressBalance(request: grpc_pb.GetAddressBalanceRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetAddressBalanceReply>;
+    getAddressBalance(request: grpc_pb.GetAddressBalanceRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetAddressBalanceReply>;
     getAddressBalance(request: grpc_pb.GetAddressBalanceRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetAddressBalanceReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetAddressBalanceReply>;
     methodDescriptorGetFundingAddresses: grpcWeb.MethodDescriptor<grpc_pb.GetFundingAddressesRequest, grpc_pb.GetFundingAddressesReply>;
-    getFundingAddresses(request: grpc_pb.GetFundingAddressesRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.GetFundingAddressesReply>;
+    getFundingAddresses(request: grpc_pb.GetFundingAddressesRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.GetFundingAddressesReply>;
     getFundingAddresses(request: grpc_pb.GetFundingAddressesRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.GetFundingAddressesReply) => void): grpcWeb.ClientReadableStream<grpc_pb.GetFundingAddressesReply>;
     methodDescriptorSetWalletPassword: grpcWeb.MethodDescriptor<grpc_pb.SetWalletPasswordRequest, grpc_pb.SetWalletPasswordReply>;
-    setWalletPassword(request: grpc_pb.SetWalletPasswordRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.SetWalletPasswordReply>;
+    setWalletPassword(request: grpc_pb.SetWalletPasswordRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.SetWalletPasswordReply>;
     setWalletPassword(request: grpc_pb.SetWalletPasswordRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.SetWalletPasswordReply) => void): grpcWeb.ClientReadableStream<grpc_pb.SetWalletPasswordReply>;
     methodDescriptorRemoveWalletPassword: grpcWeb.MethodDescriptor<grpc_pb.RemoveWalletPasswordRequest, grpc_pb.RemoveWalletPasswordReply>;
-    removeWalletPassword(request: grpc_pb.RemoveWalletPasswordRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.RemoveWalletPasswordReply>;
+    removeWalletPassword(request: grpc_pb.RemoveWalletPasswordRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.RemoveWalletPasswordReply>;
     removeWalletPassword(request: grpc_pb.RemoveWalletPasswordRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.RemoveWalletPasswordReply) => void): grpcWeb.ClientReadableStream<grpc_pb.RemoveWalletPasswordReply>;
     methodDescriptorLockWallet: grpcWeb.MethodDescriptor<grpc_pb.LockWalletRequest, grpc_pb.LockWalletReply>;
-    lockWallet(request: grpc_pb.LockWalletRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.LockWalletReply>;
+    lockWallet(request: grpc_pb.LockWalletRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.LockWalletReply>;
     lockWallet(request: grpc_pb.LockWalletRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.LockWalletReply) => void): grpcWeb.ClientReadableStream<grpc_pb.LockWalletReply>;
     methodDescriptorUnlockWallet: grpcWeb.MethodDescriptor<grpc_pb.UnlockWalletRequest, grpc_pb.UnlockWalletReply>;
-    unlockWallet(request: grpc_pb.UnlockWalletRequest, metadata: grpcWeb.Metadata | null): Promise<grpc_pb.UnlockWalletReply>;
+    unlockWallet(request: grpc_pb.UnlockWalletRequest, metadata?: grpcWeb.Metadata | null): Promise<grpc_pb.UnlockWalletReply>;
     unlockWallet(request: grpc_pb.UnlockWalletRequest, metadata: grpcWeb.Metadata | null, callback: (err: grpcWeb.RpcError, response: grpc_pb.UnlockWalletReply) => void): grpcWeb.ClientReadableStream<grpc_pb.UnlockWalletReply>;
 }

dist/protobuf/GrpcServiceClientPb.js

@@ -29,11 +29,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WalletsClient = exports.TradesClient = exports.ShutdownServerClient = exports.GetTradeStatisticsClient = exports.PriceClient = exports.PaymentAccountsClient = exports.OffersClient = exports.XmrNodeClient = exports.XmrConnectionsClient = exports.NotificationsClient = exports.DisputeAgentsClient = exports.DisputesClient = exports.AccountClient = exports.GetVersionClient = exports.HelpClient = void 0;
-// GENERATED CODE -- DO NOT EDIT!
+// Code generated by protoc-gen-grpc-web. DO NOT EDIT.
+// versions:
+// 	protoc-gen-grpc-web v1.5.0
+// 	protoc              v3.20.3
+// source: grpc.proto
 /* eslint-disable */
 // @ts-nocheck
 const grpcWeb = __importStar(require("grpc-web"));
-const grpc_pb = __importStar(require("./grpc_pb"));
+const grpc_pb = __importStar(require("./grpc_pb")); // proto import: "grpc.proto"
 class HelpClient {
     constructor(hostname, credentials, options) {
         this.methodDescriptorGetMethodHelp = new grpcWeb.MethodDescriptor('/io.haveno.protobuffer.Help/GetMethodHelp', grpcWeb.MethodType.UNARY, grpc_pb.GetMethodHelpRequest, grpc_pb.GetMethodHelpReply, (request) => {
@@ -45,7 +49,7 @@ class HelpClient {
             credentials = {};
         options['format'] = 'text';
         this.client_ = new grpcWeb.GrpcWebClientBase(options);
-        this.hostname_ = hostname;
+        this.hostname_ = hostname.replace(/\/+$/, '');
         this.credentials_ = credentials;
         this.options_ = options;
     }
@@ -70,7 +74,7 @@ class GetVersionClient {
             credentials = {};
         options['format'] = 'text';
         this.client_ = new grpcWeb.GrpcWebClientBase(options);
-        this.hostname_ = hostname;
+        this.hostname_ = hostname.replace(/\/+$/, '');
         this.credentials_ = credentials;
         this.options_ = options;
     }
@@ -122,7 +126,7 @@ class AccountClient {
             credentials = {};
         options['format'] = 'text';
         this.client_ = new grpcWeb.GrpcWebClientBase(options);
-        this.hostname_ = hostname;
+        this.hostname_ = hostname.replace(/\/+$/, '');
         this.credentials_ = credentials;
         this.options_ = options;
     }
@@ -227,7 +231,7 @@ class DisputesClient {
             credentials = {};
         options['format'] = 'text';
         this.client_ = new grpcWeb.GrpcWebClientBase(options);
-        this.hostname_ = hostname;
+        this.hostname_ = hostname.replace(/\/+$/, '');
         this.credentials_ = credentials;
         this.options_ = options;
     }
@@ -287,7 +291,7 @@ class DisputeAgentsClient {
             credentials = {};
         options['format'] = 'text';
         this.client_ = new grpcWeb.GrpcWebClientBase(options);
-        this.hostname_ = hostname;
+        this.hostname_ = hostname.replace(/\/+$/, '');
         this.credentials_ = credentials;
         this.options_ = options;
     }
@@ -323,7 +327,7 @@ class NotificationsClient {
             credentials = {};
         options['format'] = 'text';
         this.client_ = new grpcWeb.GrpcWebClientBase(options);
-        this.hostname_ = hostname;
+        this.hostname_ = hostname.replace(/\/+$/, '');
         this.credentials_ = credentials;
         this.options_ = options;
     }
@@ -382,7 +386,7 @@ class XmrConnectionsClient {
             credentials = {};
         options['format'] = 'text';
         this.client_ = new grpcWeb.GrpcWebClientBase(options);
-        this.hostname_ = hostname;
+        this.hostname_ = hostname.replace(/\/+$/, '');
         this.credentials_ = credentials;
         this.options_ = options;
     }
@@ -496,7 +500,7 @@ class XmrNodeClient {
             credentials = {};
         options['format'] = 'text';
         this.client_ = new grpcWeb.GrpcWebClientBase(options);
-        this.hostname_ = hostname;
+        this.hostname_ = hostname.replace(/\/+$/, '');
         this.credentials_ = credentials;
         this.options_ = options;
     }
@@ -560,7 +564,7 @@ class OffersClient {
             credentials = {};
         options['format'] = 'text';
         this.client_ = new grpcWeb.GrpcWebClientBase(options);
-        this.hostname_ = hostname;
+        this.hostname_ = hostname.replace(/\/+$/, '');
         this.credentials_ = credentials;
         this.options_ = options;
     }
@@ -646,7 +650,7 @@ class PaymentAccountsClient {
             credentials = {};
         options['format'] = 'text';
         this.client_ = new grpcWeb.GrpcWebClientBase(options);
-        this.hostname_ = hostname;
+        this.hostname_ = hostname.replace(/\/+$/, '');
         this.credentials_ = credentials;
         this.options_ = options;
     }
@@ -733,7 +737,7 @@ class PriceClient {
             credentials = {};
         options['format'] = 'text';
         this.client_ = new grpcWeb.GrpcWebClientBase(options);
-        this.hostname_ = hostname;
+        this.hostname_ = hostname.replace(/\/+$/, '');
         this.credentials_ = credentials;
         this.options_ = options;
     }
@@ -774,7 +778,7 @@ class GetTradeStatisticsClient {
             credentials = {};
         options['format'] = 'text';
         this.client_ = new grpcWeb.GrpcWebClientBase(options);
-        this.hostname_ = hostname;
+        this.hostname_ = hostname.replace(/\/+$/, '');
         this.credentials_ = credentials;
         this.options_ = options;
     }
@@ -799,7 +803,7 @@ class ShutdownServerClient {
             credentials = {};
         options['format'] = 'text';
         this.client_ = new grpcWeb.GrpcWebClientBase(options);
-        this.hostname_ = hostname;
+        this.hostname_ = hostname.replace(/\/+$/, '');
         this.credentials_ = credentials;
         this.options_ = options;
     }
@@ -848,7 +852,7 @@ class TradesClient {
             credentials = {};
         options['format'] = 'text';
         this.client_ = new grpcWeb.GrpcWebClientBase(options);
-        this.hostname_ = hostname;
+        this.hostname_ = hostname.replace(/\/+$/, '');
         this.credentials_ = credentials;
         this.options_ = options;
     }
@@ -973,7 +977,7 @@ class WalletsClient {
             credentials = {};
         options['format'] = 'text';
         this.client_ = new grpcWeb.GrpcWebClientBase(options);
-        this.hostname_ = hostname;
+        this.hostname_ = hostname.replace(/\/+$/, '');
         this.credentials_ = credentials;
         this.options_ = options;
     }

dist/protobuf/grpc_pb.d.ts

@@ -1,6 +1,6 @@
 import * as jspb from 'google-protobuf'
 
-import * as pb_pb from './pb_pb';
+import * as pb_pb from './pb_pb'; // proto import: "pb.proto"
 
 
 export class GetMethodHelpRequest extends jspb.Message {

src/HavenoClient.test.ts

@@ -355,7 +355,7 @@ const TestConfig = {
         password: "abc123",
         walletPassword: "abc123",
         defaultPath: "funding_wallet-" + getBaseCurrencyNetwork(),
-        minimumFunding: BigInt("5000000000000"),
+        minimumFunding: 5000000000000n,
         seed: "origin hickory pavements tudor sizes hornet tether segments sack technical elbow unsafe legion nitrogen adapt yearbook idols fuzzy pitched goes tusks elbow erase fossil erase",
         primaryAddress: "9xSyMy1r9h3BVjMrF3CTqQCQy36yCfkpn7uVfMyTUbez3hhumqBUqGUNNALjcd7f1HJBRdeH82bCC3veFHW7z3xm28gug4d",
         restoreHeight: 150
@@ -554,7 +554,7 @@ test("Can get the version (CI)", async () => {
 test("Can convert between XMR and atomic units (CI)", async () => {
   expect(BigInt(250000000000)).toEqual(HavenoUtils.xmrToAtomicUnits(0.25));
   expect(HavenoUtils.atomicUnitsToXmr("250000000000")).toEqual(.25);
-  expect(HavenoUtils.atomicUnitsToXmr(BigInt("250000000000"))).toEqual(.25);
+  expect(HavenoUtils.atomicUnitsToXmr(250000000000n)).toEqual(.25);
 });
 
 test("Can manage an account (CI)", async () => {
@@ -945,12 +945,12 @@ test("Has a Monero wallet (CI)", async () => {
   await moneroTs.MoneroUtils.validateAddress(primaryAddress, TestConfig.networkType);
 
   // wait for user1 to have unlocked balance
-  const tradeAmount = BigInt("250000000000");
+  const tradeAmount = 250000000000n;
-  await waitForAvailableBalance(tradeAmount * BigInt("2"), user1);
+  await waitForAvailableBalance(tradeAmount * 2n, user1);
 
   // test balances
   const balancesBefore: XmrBalanceInfo = await user1.getBalances(); // TODO: rename to getXmrBalances() for consistency?
-  expect(BigInt(balancesBefore.getAvailableBalance())).toBeGreaterThan(BigInt("0"));
+  expect(BigInt(balancesBefore.getAvailableBalance())).toBeGreaterThan(0n);
   expect(BigInt(balancesBefore.getBalance())).toBeGreaterThanOrEqual(BigInt(balancesBefore.getAvailableBalance()));
 
   // get transactions
@@ -1092,13 +1092,13 @@ test("Can get market depth (CI, sanity check)", async () => {
     expect(marketDepth.getSellDepthList().length).toEqual(0);
 
     // post offers to buy and sell
-    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.BUY, offerAmount: BigInt("150000000000"), assetCode: assetCode, price: 17.0});
+    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.BUY, offerAmount: 150000000000n, assetCode: assetCode, price: 17.0});
-    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.BUY, offerAmount: BigInt("150000000000"), assetCode: assetCode, price: 17.2});
+    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.BUY, offerAmount: 150000000000n, assetCode: assetCode, price: 17.2});
-    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.BUY, offerAmount: BigInt("200000000000"), assetCode: assetCode, price: 17.3});
+    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.BUY, offerAmount: 200000000000n, assetCode: assetCode, price: 17.3});
-    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.BUY, offerAmount: BigInt("150000000000"), assetCode: assetCode, price: 17.3});
+    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.BUY, offerAmount: 150000000000n, assetCode: assetCode, price: 17.3});
-    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.SELL, offerAmount: BigInt("300000000000"), assetCode: assetCode, priceMargin: 0.00});
+    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.SELL, offerAmount: 300000000000n, assetCode: assetCode, priceMargin: 0.00});
-    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.SELL, offerAmount: BigInt("300000000000"), assetCode: assetCode, priceMargin: 0.02});
+    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.SELL, offerAmount: 300000000000n, assetCode: assetCode, priceMargin: 0.02});
-    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.SELL, offerAmount: BigInt("400000000000"), assetCode: assetCode, priceMargin: 0.05});
+    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.SELL, offerAmount: 400000000000n, assetCode: assetCode, priceMargin: 0.05});
 
     // get user2's market depth
     await wait(TestConfig.trade.maxTimePeerNoticeMs);
@@ -1188,8 +1188,8 @@ test("Can get payment methods (CI)", async () => {
   expect(paymentMethods.length).toBeGreaterThan(0);
   for (const paymentMethod of paymentMethods) {
     expect(paymentMethod.getId().length).toBeGreaterThan(0);
-    expect(BigInt(paymentMethod.getMaxTradeLimit())).toBeGreaterThan(BigInt(0));
+    expect(BigInt(paymentMethod.getMaxTradeLimit())).toBeGreaterThan(0n);
-    expect(BigInt(paymentMethod.getMaxTradePeriod())).toBeGreaterThan(BigInt(0));
+    expect(BigInt(paymentMethod.getMaxTradePeriod())).toBeGreaterThan(0n);
     expect(paymentMethod.getSupportedAssetCodesList().length).toBeGreaterThanOrEqual(0);
   }
 });
@@ -1345,7 +1345,7 @@ test("Can prepare for trading (CI)", async () => {
 test("Can post and remove an offer (CI, sanity check)", async () => {
 
   // wait for user1 to have unlocked balance to post offer
-  await waitForAvailableBalance(BigInt("250000000000") * BigInt("2"), user1);
+  await waitForAvailableBalance(250000000000n * 2n, user1);
 
   // get unlocked balance before reserving funds for offer
   const availableBalanceBefore = BigInt((await user1.getBalances()).getAvailableBalance());
@@ -1415,13 +1415,13 @@ test("Can schedule offers with locked funds (CI)", async () => {
     const user3Wallet = await moneroTs.connectToWalletRpc("http://127.0.0.1:" + user3.getWalletRpcPort(), TestConfig.defaultHavenod.walletUsername, TestConfig.defaultHavenod.accountPassword);
 
     // fund user3 with 2 outputs of 0.5 XMR
-    const outputAmt = BigInt("500000000000");
+    const outputAmt = 500000000000n;
     await fundOutputs([user3Wallet], outputAmt, 2, false);
 
     // schedule offer
     const assetCode = "BCH";
     const direction = OfferDirection.BUY;
-    const ctx = new TradeContext({maker: {havenod: user3}, assetCode: assetCode, direction: direction, awaitFundsToMakeOffer: false});
+    const ctx = new TradeContext({maker: {havenod: user3}, assetCode: assetCode, direction: direction, awaitFundsToMakeOffer: false, reserveExactAmount: true});
     let offer: OfferInfo = await makeOffer(ctx);
     assert.equal(offer.getState(), "SCHEDULED");
 
@@ -1430,8 +1430,8 @@ test("Can schedule offers with locked funds (CI)", async () => {
     assert.equal(offer.getState(), "SCHEDULED");
 
     // balances unchanged
-    expect(BigInt((await user3.getBalances()).getPendingBalance())).toEqual(outputAmt * BigInt(2));
+    expect(BigInt((await user3.getBalances()).getPendingBalance())).toEqual(outputAmt * 2n);
-    expect(BigInt((await user3.getBalances()).getReservedOfferBalance())).toEqual(BigInt(0));
+    expect(BigInt((await user3.getBalances()).getReservedOfferBalance())).toEqual(0n);
 
     // peer does not see offer because it's scheduled
     await wait(TestConfig.trade.maxTimePeerNoticeMs);
@@ -1442,11 +1442,11 @@ test("Can schedule offers with locked funds (CI)", async () => {
     if (getOffer(await user3.getOffers(assetCode, direction), offer.getId())) throw new Error("Offer " + offer.getId() + " was found after canceling offer");
 
     // balances unchanged
-    expect(BigInt((await user3.getBalances()).getPendingBalance())).toEqual(outputAmt * BigInt(2));
+    expect(BigInt((await user3.getBalances()).getPendingBalance())).toEqual(outputAmt * 2n);
-    expect(BigInt((await user3.getBalances()).getReservedOfferBalance())).toEqual(BigInt(0));
+    expect(BigInt((await user3.getBalances()).getReservedOfferBalance())).toEqual(0n);
 
     // schedule offer
-    offer = await makeOffer({maker: {havenod: user3}, assetCode: assetCode, direction: direction, awaitFundsToMakeOffer: false});
+    offer = await makeOffer({maker: {havenod: user3}, assetCode: assetCode, direction: direction, awaitFundsToMakeOffer: false, reserveExactAmount: true});
     assert.equal(offer.getState(), "SCHEDULED");
 
     // peer does not see offer because it's scheduled
@@ -1454,7 +1454,7 @@ test("Can schedule offers with locked funds (CI)", async () => {
     if (getOffer(await user1.getOffers(assetCode, direction), offer.getId())) throw new Error("Offer " + offer.getId() + " was found in peer's offers before posted");
 
     // stop user3
-    const user3Config = {appName: user3.getAppName()};
+    let user3Config = {appName: user3.getAppName()};
     await releaseHavenoProcess(user3);
 
     // mine 10 blocks
@@ -1464,16 +1464,34 @@ test("Can schedule offers with locked funds (CI)", async () => {
     user3 = await initHaveno(user3Config);
     ctx.maker.havenod = user3;
 
-    // has offer
+    // awaiting split output
     await waitForAvailableBalance(outputAmt, user3);
     offer = await user3.getMyOffer(offer.getId());
     assert.equal(offer.getState(), "SCHEDULED");
 
-    // one output is reserved, one is unlocked
+    // stop user3
-    await wait(TestConfig.trade.maxTimePeerNoticeMs + TestConfig.trade.walletSyncPeriodMs);
+    user3Config = {appName: user3.getAppName()};
-    expect(BigInt((await user3.getBalances()).getAvailableBalance())).toEqual(outputAmt);
+    await releaseHavenoProcess(user3);
-    expect(BigInt((await user3.getBalances()).getPendingBalance())).toEqual(BigInt(0));
+
-    expect(BigInt((await user3.getBalances()).getReservedOfferBalance())).toEqual(outputAmt);
+    // mine 10 blocks
+    await mineBlocks(10);
+
+    // restart user3
+    user3 = await initHaveno(user3Config);
+    ctx.maker.havenod = user3;
+
+    // offer is available
+    await waitForAvailableBalance(outputAmt + outputAmt / 2n, user3);
+    await wait(TestConfig.trade.walletSyncPeriodMs);
+    offer = await user3.getMyOffer(offer.getId());
+    assert.equal(offer.getState(), "AVAILABLE");
+    ctx.maker.splitOutputTxFee = BigInt(offer.getSplitOutputTxFee());
+
+    // one output is reserved, remaining is unlocked
+    const balances = await user3.getBalances();
+    expect(BigInt((balances.getPendingBalance()))).toEqual(0n);
+    expect(BigInt((balances.getAvailableBalance()))).toBeGreaterThan(outputAmt); // TODO: testScheduleOffer(reserveExactAmount) to test these
+    expect(BigInt((balances.getReservedOfferBalance()))).toEqual(outputAmt * 2n - ctx.maker.splitOutputTxFee! - BigInt(balances.getAvailableBalance()));
 
     // peer sees offer
     await wait(TestConfig.trade.maxTimePeerNoticeMs);
@@ -1492,9 +1510,9 @@ test("Can schedule offers with locked funds (CI)", async () => {
       if (getOffer(await user3.getMyOffers(assetCode), offer.getId())) throw new Error("Offer " + offer.getId() + " was found in my offers after removal");
 
       // reserved balance becomes unlocked
-      expect(BigInt((await user3.getBalances()).getAvailableBalance())).toEqual(outputAmt * BigInt(2));
+      expect(BigInt((await user3.getBalances()).getAvailableBalance())).toEqual(outputAmt * 2n);
-      expect(BigInt((await user3.getBalances()).getPendingBalance())).toEqual(BigInt(0));
+      expect(BigInt((await user3.getBalances()).getPendingBalance())).toEqual(0n);
-      expect(BigInt((await user3.getBalances()).getReservedOfferBalance())).toEqual(BigInt(0));
+      expect(BigInt((await user3.getBalances()).getReservedOfferBalance())).toEqual(0n);
     }
   } catch (err2) {
     err = err2;
@@ -1551,7 +1569,7 @@ test("Cannot post offer exceeding trade limit (CI, sanity check)", async () => {
 
   // test that sell limit is higher than buy limit
   let offerId = await executeTrade({
-    offerAmount: BigInt("2100000000000"),
+    offerAmount: 2100000000000n,
     direction: OfferDirection.SELL,
     assetCode: assetCode,
     makerPaymentAccountId: account.getId(),
@@ -1656,8 +1674,8 @@ test("Can go offline while completing a trade (CI, sanity check)", async () => {
 
     // fund traders
     HavenoUtils.log(1, "Funding traders");
-    const tradeAmount = BigInt("250000000000");
+    const tradeAmount = 250000000000n;
-    await waitForAvailableBalance(tradeAmount * BigInt("2"), ...traders);
+    await waitForAvailableBalance(tradeAmount * 2n, ...traders);
 
     // execute trade
     await executeTrade(ctx);
@@ -1734,7 +1752,7 @@ test("Can resolve disputes (CI)", async () => {
     disputeWinner: DisputeResult.Winner.BUYER,
     disputeReason: DisputeResult.Reason.SELLER_NOT_RESPONDING,
     disputeSummary: "Split trade amount",
-    disputeWinnerAmount: BigInt(trade1.getAmount()) / BigInt(2) + BigInt(trade1.getBuyerSecurityDeposit())
+    disputeWinnerAmount: BigInt(trade1.getAmount()) / 2n + BigInt(trade1.getBuyerSecurityDeposit())
   });
   Object.assign(ctxs[2], {
     resolveDispute: false,
@@ -1790,8 +1808,8 @@ test("Can go offline while resolving a dispute (CI)", async () => {
     });
 
     // fund traders
-    const tradeAmount = BigInt("250000000000");
+    const tradeAmount = 250000000000n;
-    await waitForAvailableBalance(tradeAmount * BigInt("2"), ...traders);
+    await waitForAvailableBalance(tradeAmount * 2n, ...traders);
 
     // execute trade
     await executeTrade(ctx);
@@ -1831,8 +1849,8 @@ test("Cannot make or take offer with insufficient unlocked funds (CI, sanity che
     let offer: OfferInfo;
     if (offers.length) offer = offers[0];
     else {
-      const tradeAmount = BigInt("250000000000");
+      const tradeAmount = 250000000000n;
-      await waitForAvailableBalance(tradeAmount * BigInt("2"), user1);
+      await waitForAvailableBalance(tradeAmount * 2n, user1);
       offer = await makeOffer({maker: {havenod: user1}, offerAmount: tradeAmount, awaitFundsToMakeOffer: false});
       assert.equal(offer.getState(), "AVAILABLE");
       await wait(TestConfig.trade.walletSyncPeriodMs * 2);
@@ -1874,8 +1892,8 @@ test("Invalidates offers when reserved funds are spent (CI)", async () => {
   try {
     
     // wait for user1 to have unlocked balance for trade
-    const tradeAmount = BigInt("250000000000");
+    const tradeAmount = 250000000000n;
-    await waitForAvailableBalance(tradeAmount * BigInt("2"), user1);
+    await waitForAvailableBalance(tradeAmount * 2n, user1);
 
     // get frozen key images before posting offer
     const frozenKeyImagesBefore: any[] = [];
@@ -1941,8 +1959,8 @@ test("Can handle unexpected errors during trade initialization", async () => {
     HavenoUtils.log(1, "Starting trader processes");
     traders = await initHavenos(3);
     HavenoUtils.log(1, "Funding traders");
-    const tradeAmount = BigInt("250000000000");
+    const tradeAmount = 250000000000n;
-    await waitForAvailableBalance(tradeAmount * BigInt("2"), traders[0], traders[1], traders[2]);
+    await waitForAvailableBalance(tradeAmount * 2n, traders[0], traders[1], traders[2]);
 
     // trader 0 posts offer
     HavenoUtils.log(1, "Posting offer");
@@ -2013,8 +2031,8 @@ test("Can handle unexpected errors during trade initialization", async () => {
 
     // trader 2's balance is unreserved
     const trader2Balances = await traders[2].getBalances();
-    expect(BigInt(trader2Balances.getReservedTradeBalance())).toEqual(BigInt("0"));
+    expect(BigInt(trader2Balances.getReservedTradeBalance())).toEqual(0n);
-    expect(BigInt(trader2Balances.getAvailableBalance())).toBeGreaterThan(BigInt("0"));
+    expect(BigInt(trader2Balances.getAvailableBalance())).toBeGreaterThan(0n);
   } catch (err2) {
     err = err2;
   }
@@ -2174,7 +2192,7 @@ async function executeTrades(ctxs: Partial<TradeContext>[], executionCtx?: Parti
     const fundWalletPromises: Promise<void>[] = [];
     for (const wallet of outputCounts.keys()) {
       if (outputCounts.get(wallet)! > 0) {
-        fundWalletPromises.push(fundOutputs([wallet], tradeAmount! * BigInt("2"), outputCounts.get(wallet)));
+        fundWalletPromises.push(fundOutputs([wallet], tradeAmount! * 2n, outputCounts.get(wallet)));
       }
     }
     await Promise.all(fundWalletPromises);
@@ -2223,7 +2241,7 @@ async function executeTrade(ctxP: Partial<TradeContext>): Promise<string> {
     if (!ctx.concurrentTrades) { // already funded
       if (ctx.awaitFundsToMakeOffer && makingOffer && !ctx.offerId) clientsToFund.push(ctx.maker.havenod!);
       if (ctx.awaitFundsToTakeOffer && ctx.takeOffer && !ctx.isOfferTaken) clientsToFund.push(ctx.taker.havenod!);
-      await waitForAvailableBalance(ctx.offerAmount! * BigInt("2"), ...clientsToFund);
+      await waitForAvailableBalance(ctx.offerAmount! * 2n, ...clientsToFund);
     }
 
     // make offer if configured
@@ -2565,18 +2583,18 @@ async function makeOffer(ctxP?: Partial<TradeContext>): Promise<OfferInfo> {
   let ctx = TradeContext.init(ctxP);
 
   // wait for unlocked balance
-  if (!ctx.concurrentTrades && ctx.awaitFundsToMakeOffer) await waitForAvailableBalance(ctx.offerAmount! * BigInt("2"), ctx.maker.havenod);
+  if (!ctx.concurrentTrades && ctx.awaitFundsToMakeOffer) await waitForAvailableBalance(ctx.offerAmount! * 2n, ctx.maker.havenod);
 
   // create payment account if not given // TODO: re-use existing payment account
   if (!ctx.makerPaymentAccountId) ctx.makerPaymentAccountId = (await createPaymentAccount(ctx.maker.havenod!, ctx.assetCode!)).getId();
 
   // get unlocked balance before reserving offer
   let unlockedBalanceBefore = BigInt((await ctx.maker.havenod!.getBalances()).getAvailableBalance());
-  if (ctx.awaitFundsToMakeOffer && unlockedBalanceBefore === BigInt(0)) {
+  if (ctx.awaitFundsToMakeOffer && unlockedBalanceBefore === 0n) {
     HavenoUtils.log(0, "WARNING: unlocked balance before posting offer is 0, waiting...");
     await wait(5000);
     unlockedBalanceBefore = BigInt((await ctx.maker.havenod!.getBalances()).getAvailableBalance());
-    if (unlockedBalanceBefore === BigInt(0)) throw new Error("Unlocked balance before posting offer was 0, even after waiting");
+    if (unlockedBalanceBefore === 0n) throw new Error("Unlocked balance before posting offer was 0, even after waiting");
   }
 
   // initialize balances before offer, once
@@ -2653,7 +2671,7 @@ async function takeOffer(ctxP: Partial<TradeContext>): Promise<TradeInfo> {
   expect(takerOffer.getState()).toEqual("UNKNOWN"); // TODO: offer state should be known
 
   // wait for unlocked balance
-  if (ctx.awaitFundsToTakeOffer) await waitForAvailableBalance(ctx.offerAmount! * BigInt("2"), ctx.taker.havenod);
+  if (ctx.awaitFundsToTakeOffer) await waitForAvailableBalance(ctx.offerAmount! * 2n, ctx.taker.havenod);
 
   // create payment account if not given // TODO: re-use existing payment account
   if (!ctx.takerPaymentAccountId) ctx.takerPaymentAccountId = (await createPaymentAccount(ctx.taker.havenod!, ctx.assetCode!)).getId();
@@ -2941,7 +2959,7 @@ async function resolveDispute(ctxP: Partial<TradeContext>) {
   // award too little to loser (minority receiver)
   let makerDepositTx = await monerod.getTx(trade.getMakerDepositTxId());
   let takerDepositTx = await monerod.getTx(trade.getTakerDepositTxId());
-  customWinnerAmount = tradeAmount + BigInt(trade.getBuyerSecurityDeposit()) + BigInt(trade.getSellerSecurityDeposit()) - BigInt("10000");
+  customWinnerAmount = tradeAmount + BigInt(trade.getBuyerSecurityDeposit()) + BigInt(trade.getSellerSecurityDeposit()) - 10000n;
   try {
     await arbitrator.resolveDispute(ctx.offerId!, ctx.disputeWinner!, ctx.disputeReason!, "Loser gets too little", customWinnerAmount);
     throw new Error("Should have failed resolving dispute with insufficient loser payout");
@@ -3376,10 +3394,10 @@ async function prepareForTrading(numTrades: number, ...havenods: HavenoClient[])
   }
 
   // fund wallets
-  const tradeAmount = BigInt("500000000000");
+  const tradeAmount = 500000000000n;
   const wallets: moneroTs.MoneroWallet[] = [];
   for (const havenod of havenods) wallets.push(await getWallet(havenod));
-  await fundOutputs(wallets, tradeAmount * BigInt("2"), numTrades);
+  await fundOutputs(wallets, tradeAmount * 2n, numTrades);
 }
 
 async function getWallet(havenod: HavenoClient) {
@@ -3464,9 +3482,9 @@ async function waitForAvailableBalance(amount: bigint, ...wallets: any[]) {
     const availableBalance = await wallet.getAvailableBalance();
     if (availableBalance < amount) miningNeeded = true;
     const depositNeeded: bigint = amount - availableBalance - await wallet.getPendingBalance();
-    if (depositNeeded > BigInt("0") && wallet._wallet !== fundingWallet) {
+    if (depositNeeded > 0n && wallet._wallet !== fundingWallet) {
       for (let i = 0; i < 5; i++) {
-        fundConfig.addDestination(await wallet.getDepositAddress(), depositNeeded * BigInt("2")); // make several deposits
+        fundConfig.addDestination(await wallet.getDepositAddress(), depositNeeded * 2n); // make several deposits
       }
     }
   }
@@ -3668,7 +3686,7 @@ function testCreatedTx(tx: XmrTx) {
 }
 
 function testTransfer(transfer: XmrIncomingTransfer | XmrOutgoingTransfer, ctx: TxContext) {
-  expect(BigInt(transfer.getAmount())).toBeGreaterThanOrEqual(BigInt("0"));
+  expect(BigInt(transfer.getAmount())).toBeGreaterThanOrEqual(0n);
   assert(transfer.getAccountIndex() >= 0);
   if (transfer instanceof XmrIncomingTransfer) testIncomingTransfer(transfer);
   else testOutgoingTransfer(transfer, ctx);
@@ -3686,10 +3704,10 @@ function testOutgoingTransfer(transfer: XmrOutgoingTransfer, ctx: TxContext) {
 
   // test destinations sum to outgoing amount
   if (transfer.getDestinationsList().length > 0) {
-    let sum = BigInt(0);
+    let sum = 0n;
     for (const destination of transfer.getDestinationsList()) {
       testDestination(destination);
-      expect(BigInt(destination.getAmount())).toBeGreaterThan(BigInt("0"));
+      expect(BigInt(destination.getAmount())).toBeGreaterThan(0n);
       sum += BigInt(destination.getAmount());
     }
     assert.equal(sum, BigInt(transfer.getAmount()));
@@ -3698,7 +3716,7 @@ function testOutgoingTransfer(transfer: XmrOutgoingTransfer, ctx: TxContext) {
 
 function testDestination(destination: XmrDestination) {
   assert(destination.getAddress());
-  expect(BigInt(destination.getAmount())).toBeGreaterThan(BigInt("0"));
+  expect(BigInt(destination.getAmount())).toBeGreaterThan(0n);
 }
 
 function getRandomAssetCode() {