Git-Mirrors/haveno-ts
1
0
Fork 0
mirror of https://github.com/haveno-dex/haveno-ts.git synced 2025-03-06 21:25:58 -05:00
Code Issues Packages Projects Releases Wiki Activity

switch client to use await syntax instead of promise

Browse Source
This commit is contained in:
woodser 2023-02-20 15:01:42 -05:00
parent 3af0c7ab8f
commit 6719324d9e
1 changed files with 80 additions and 401 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

481
src/HavenoClient.ts
View File

@ -222,12 +222,7 @@ export default class HavenoClient {
*/ */
async getVersion(): Promise<string> { async getVersion(): Promise<string> {
try { try {
return await new Promise((resolve, reject) => { return (await this._getVersionClient.getVersion(new GetVersionRequest(), {password: this._password})).getVersion();
this._getVersionClient.getVersion(new GetVersionRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: GetVersionReply) {
if (err) reject(err);
else resolve(response.getVersion());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -254,12 +249,7 @@ export default class HavenoClient {
*/ */
async accountExists(): Promise<boolean> { async accountExists(): Promise<boolean> {
try { try {
return await new Promise((resolve, reject) => { return (await this._accountClient.accountExists(new AccountExistsRequest(), {password: this._password})).getAccountExists();
this._accountClient.accountExists(new AccountExistsRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: AccountExistsReply) {
if (err) reject(err);
else resolve(response.getAccountExists());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -272,12 +262,7 @@ export default class HavenoClient {
*/ */
async isAccountOpen(): Promise<boolean> { async isAccountOpen(): Promise<boolean> {
try { try {
return await new Promise((resolve, reject) => { return (await this._accountClient.isAccountOpen(new IsAccountOpenRequest(), {password: this._password})).getIsAccountOpen();
this._accountClient.isAccountOpen(new IsAccountOpenRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: IsAccountOpenReply) {
if (err) reject(err);
else resolve(response.getIsAccountOpen());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -290,12 +275,7 @@ export default class HavenoClient {
*/ */
async createAccount(password: string): Promise<void> { async createAccount(password: string): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._accountClient.createAccount(new CreateAccountRequest().setPassword(password), {password: this._password});
this._accountClient.createAccount(new CreateAccountRequest().setPassword(password), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
await this._awaitAppInitialized(); // TODO: grpc should not return before setup is complete await this._awaitAppInitialized(); // TODO: grpc should not return before setup is complete
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
@ -309,12 +289,7 @@ export default class HavenoClient {
*/ */
async openAccount(password: string): Promise<void> { async openAccount(password: string): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._accountClient.openAccount(new OpenAccountRequest().setPassword(password), {password: this._password});
this._accountClient.openAccount(new OpenAccountRequest().setPassword(password), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
return this._awaitAppInitialized(); // TODO: grpc should not return before setup is complete return this._awaitAppInitialized(); // TODO: grpc should not return before setup is complete
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
@ -328,12 +303,7 @@ export default class HavenoClient {
*/ */
async changePassword(password: string): Promise<void> { async changePassword(password: string): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._accountClient.changePassword(new ChangePasswordRequest().setPassword(password), {password: this._password});
this._accountClient.changePassword(new ChangePasswordRequest().setPassword(password), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -344,12 +314,7 @@ export default class HavenoClient {
*/ */
async closeAccount(): Promise<void> { async closeAccount(): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._accountClient.closeAccount(new CloseAccountRequest(), {password: this._password});
this._accountClient.closeAccount(new CloseAccountRequest(), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -360,12 +325,7 @@ export default class HavenoClient {
*/ */
async deleteAccount(): Promise<void> { async deleteAccount(): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._accountClient.deleteAccount(new DeleteAccountRequest(), {password: this._password});
this._accountClient.deleteAccount(new DeleteAccountRequest(), {password: this._password}, async function(err: grpcWeb.RpcError) {
if (err) reject(err);
else setTimeout(resolve, 10000); // deleteAccount() call should return after finished and without requiring shut down
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -463,12 +423,7 @@ export default class HavenoClient {
*/ */
async addMoneroConnection(connection: string | UrlConnection): Promise<void> { async addMoneroConnection(connection: string | UrlConnection): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._moneroConnectionsClient.addConnection(new AddConnectionRequest().setConnection(typeof connection === "string" ? new UrlConnection().setUrl(connection) : connection), {password: this._password});
this._moneroConnectionsClient.addConnection(new AddConnectionRequest().setConnection(typeof connection === "string" ? new UrlConnection().setUrl(connection) : connection), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -481,12 +436,7 @@ export default class HavenoClient {
*/ */
async removeMoneroConnection(url: string): Promise<void> { async removeMoneroConnection(url: string): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._moneroConnectionsClient.removeConnection(new RemoveConnectionRequest().setUrl(url), {password: this._password});
this._moneroConnectionsClient.removeConnection(new RemoveConnectionRequest().setUrl(url), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -499,12 +449,7 @@ export default class HavenoClient {
*/ */
async getMoneroConnection(): Promise<UrlConnection | undefined> { async getMoneroConnection(): Promise<UrlConnection | undefined> {
try { try {
return await new Promise((resolve, reject) => { return await (await this._moneroConnectionsClient.getConnection(new GetConnectionRequest(), {password: this._password})).getConnection();
this._moneroConnectionsClient.getConnection(new GetConnectionRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: GetConnectionReply) {
if (err) reject(err);
else resolve(response.getConnection());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -517,12 +462,7 @@ export default class HavenoClient {
*/ */
async getMoneroConnections(): Promise<UrlConnection[]> { async getMoneroConnections(): Promise<UrlConnection[]> {
try { try {
return await new Promise((resolve, reject) => { return (await this._moneroConnectionsClient.getConnections(new GetConnectionsRequest(), {password: this._password})).getConnectionsList();
this._moneroConnectionsClient.getConnections(new GetConnectionsRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: GetConnectionsReply) {
if (err) reject(err);
else resolve(response.getConnectionsList());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -543,12 +483,7 @@ export default class HavenoClient {
if (typeof connection === "string") request.setUrl(connection); if (typeof connection === "string") request.setUrl(connection);
else request.setConnection(connection); else request.setConnection(connection);
try { try {
await new Promise<void>((resolve, reject) => { await this._moneroConnectionsClient.setConnection(request, {password: this._password});
this._moneroConnectionsClient.setConnection(request, {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -563,12 +498,7 @@ export default class HavenoClient {
*/ */
async checkMoneroConnection(): Promise<UrlConnection | undefined> { async checkMoneroConnection(): Promise<UrlConnection | undefined> {
try { try {
return await new Promise((resolve, reject) => { return (await this._moneroConnectionsClient.checkConnection(new CheckConnectionRequest(), {password: this._password})).getConnection();
this._moneroConnectionsClient.checkConnection(new CheckConnectionRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: CheckConnectionReply) {
if (err) reject(err);
else resolve(response.getConnection());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -581,12 +511,7 @@ export default class HavenoClient {
*/ */
async checkMoneroConnections(): Promise<UrlConnection[]> { async checkMoneroConnections(): Promise<UrlConnection[]> {
try { try {
return await new Promise((resolve, reject) => { return (await this._moneroConnectionsClient.checkConnections(new CheckConnectionsRequest(), {password: this._password})).getConnectionsList();
this._moneroConnectionsClient.checkConnections(new CheckConnectionsRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: CheckConnectionsReply) {
if (err) reject(err);
else resolve(response.getConnectionsList());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -599,12 +524,7 @@ export default class HavenoClient {
*/ */
async startCheckingConnection(refreshPeriod: number): Promise<void> { async startCheckingConnection(refreshPeriod: number): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._moneroConnectionsClient.startCheckingConnections(new StartCheckingConnectionsRequest().setRefreshPeriod(refreshPeriod), {password: this._password});
this._moneroConnectionsClient.startCheckingConnections(new StartCheckingConnectionsRequest().setRefreshPeriod(refreshPeriod), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -615,12 +535,7 @@ export default class HavenoClient {
*/ */
async stopCheckingConnection(): Promise<void> { async stopCheckingConnection(): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._moneroConnectionsClient.stopCheckingConnections(new StopCheckingConnectionsRequest(), {password: this._password});
this._moneroConnectionsClient.stopCheckingConnections(new StopCheckingConnectionsRequest(), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -633,12 +548,7 @@ export default class HavenoClient {
*/ */
async getBestAvailableConnection(): Promise<UrlConnection | undefined> { async getBestAvailableConnection(): Promise<UrlConnection | undefined> {
try { try {
return await new Promise((resolve, reject) => { return (await this._moneroConnectionsClient.getBestAvailableConnection(new GetBestAvailableConnectionRequest(), {password: this._password})).getConnection();
this._moneroConnectionsClient.getBestAvailableConnection(new GetBestAvailableConnectionRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: GetBestAvailableConnectionReply) {
if (err) reject(err);
else resolve(response.getConnection());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -651,12 +561,7 @@ export default class HavenoClient {
*/ */
async setAutoSwitch(autoSwitch: boolean): Promise<void> { async setAutoSwitch(autoSwitch: boolean): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._moneroConnectionsClient.setAutoSwitch(new SetAutoSwitchRequest().setAutoSwitch(autoSwitch), {password: this._password});
this._moneroConnectionsClient.setAutoSwitch(new SetAutoSwitchRequest().setAutoSwitch(autoSwitch), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -667,12 +572,7 @@ export default class HavenoClient {
*/ */
async isMoneroNodeOnline(): Promise<boolean> { async isMoneroNodeOnline(): Promise<boolean> {
try { try {
return await new Promise((resolve, reject) => { return (await this._moneroNodeClient.isMoneroNodeOnline(new IsMoneroNodeOnlineRequest(), {password: this._password})).getIsRunning();
this._moneroNodeClient.isMoneroNodeOnline(new IsMoneroNodeOnlineRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: IsMoneroNodeOnlineReply) {
if (err) reject(err);
else resolve(response.getIsRunning());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -683,13 +583,8 @@ export default class HavenoClient {
*/ */
async getMoneroNodeSettings(): Promise<MoneroNodeSettings | undefined> { async getMoneroNodeSettings(): Promise<MoneroNodeSettings | undefined> {
try { try {
return await new Promise((resolve, reject) => { const request = new GetMoneroNodeSettingsRequest();
const request = new GetMoneroNodeSettingsRequest(); return (await this._moneroNodeClient.getMoneroNodeSettings(request, {password: this._password})).getSettings();
this._moneroNodeClient.getMoneroNodeSettings(request, {password: this._password}, function(err: grpcWeb.RpcError, response: GetMoneroNodeSettingsReply) {
if (err) reject(err);
else resolve(response.getSettings());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -702,13 +597,8 @@ export default class HavenoClient {
*/ */
async startMoneroNode(settings: MoneroNodeSettings): Promise<void> { async startMoneroNode(settings: MoneroNodeSettings): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { const request = new StartMoneroNodeRequest().setSettings(settings);
const request = new StartMoneroNodeRequest().setSettings(settings); await this._moneroNodeClient.startMoneroNode(request, {password: this._password});
this._moneroNodeClient.startMoneroNode(request, {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -719,12 +609,7 @@ export default class HavenoClient {
*/ */
async stopMoneroNode(): Promise<void> { async stopMoneroNode(): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._moneroNodeClient.stopMoneroNode(new StopMoneroNodeRequest(), {password: this._password});
this._moneroNodeClient.stopMoneroNode(new StopMoneroNodeRequest(), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -741,12 +626,7 @@ export default class HavenoClient {
const request = new RegisterDisputeAgentRequest() const request = new RegisterDisputeAgentRequest()
.setDisputeAgentType(disputeAgentType) .setDisputeAgentType(disputeAgentType)
.setRegistrationKey(registrationKey); .setRegistrationKey(registrationKey);
return await new Promise((resolve, reject) => { await this._disputeAgentsClient.registerDisputeAgent(request, {password: this._password});
this._disputeAgentsClient.registerDisputeAgent(request, {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -759,12 +639,7 @@ export default class HavenoClient {
*/ */
async unregisterDisputeAgent(disputeAgentType: string): Promise<void> { async unregisterDisputeAgent(disputeAgentType: string): Promise<void> {
try { try {
return await new Promise((resolve, reject) => { await this._disputeAgentsClient.unregisterDisputeAgent(new UnregisterDisputeAgentRequest().setDisputeAgentType(disputeAgentType), {password: this._password});
this._disputeAgentsClient.unregisterDisputeAgent(new UnregisterDisputeAgentRequest().setDisputeAgentType(disputeAgentType), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -777,12 +652,7 @@ export default class HavenoClient {
*/ */
async getBalances(): Promise<XmrBalanceInfo> { async getBalances(): Promise<XmrBalanceInfo> {
try { try {
return await new Promise((resolve, reject) => { return (await this._walletsClient.getBalances(new GetBalancesRequest().setCurrencyCode("XMR"), {password: this._password})).getBalances()!.getXmr()!;
this._walletsClient.getBalances(new GetBalancesRequest().setCurrencyCode("XMR"), {password: this._password}, function(err: grpcWeb.RpcError, response: GetBalancesReply) {
if (err) reject(err);
else resolve(response.getBalances()!.getXmr()!);
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -795,12 +665,7 @@ export default class HavenoClient {
*/ */
async getXmrSeed(): Promise<string> { async getXmrSeed(): Promise<string> {
try { try {
return await new Promise((resolve, reject) => { return (await this._walletsClient.getXmrSeed(new GetXmrSeedRequest(), {password: this._password})).getSeed();
this._walletsClient.getXmrSeed(new GetXmrSeedRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: GetXmrSeedReply) {
if (err) reject(err);
else resolve(response.getSeed());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -813,12 +678,7 @@ export default class HavenoClient {
*/ */
async getXmrPrimaryAddress(): Promise<string> { async getXmrPrimaryAddress(): Promise<string> {
try { try {
return await new Promise((resolve, reject) => { return (await this._walletsClient.getXmrPrimaryAddress(new GetXmrPrimaryAddressRequest(), {password: this._password})).getPrimaryAddress();
this._walletsClient.getXmrPrimaryAddress(new GetXmrPrimaryAddressRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: GetXmrPrimaryAddressReply) {
if (err) reject(err);
else resolve(response.getPrimaryAddress());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -831,12 +691,7 @@ export default class HavenoClient {
*/ */
async getXmrNewSubaddress(): Promise<string> { async getXmrNewSubaddress(): Promise<string> {
try { try {
return await new Promise((resolve, reject) => { return (await this._walletsClient.getXmrNewSubaddress(new GetXmrNewSubaddressRequest(), {password: this._password})).getSubaddress();
this._walletsClient.getXmrNewSubaddress(new GetXmrNewSubaddressRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: GetXmrNewSubaddressReply) {
if (err) reject(err);
else resolve(response.getSubaddress());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -849,12 +704,7 @@ export default class HavenoClient {
*/ */
async getXmrTxs(): Promise<XmrTx[]> { async getXmrTxs(): Promise<XmrTx[]> {
try { try {
return await new Promise((resolve, reject) => { return (await this._walletsClient.getXmrTxs(new GetXmrTxsRequest(), {password: this._password})).getTxsList();
this._walletsClient.getXmrTxs(new GetXmrTxsRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: GetXmrTxsReply) {
if (err) reject(err);
else resolve(response.getTxsList());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -881,12 +731,7 @@ export default class HavenoClient {
*/ */
async createXmrTx(destinations: XmrDestination[]): Promise<XmrTx> { async createXmrTx(destinations: XmrDestination[]): Promise<XmrTx> {
try { try {
return await new Promise((resolve, reject) => { return (await this._walletsClient.createXmrTx(new CreateXmrTxRequest().setDestinationsList(destinations), {password: this._password})).getTx()!;
this._walletsClient.createXmrTx(new CreateXmrTxRequest().setDestinationsList(destinations), {password: this._password}, function(err: grpcWeb.RpcError, response: CreateXmrTxReply) {
if (err) reject(err);
else resolve(response.getTx()!);
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -899,12 +744,7 @@ export default class HavenoClient {
*/ */
async relayXmrTx(metadata: string): Promise<string> { async relayXmrTx(metadata: string): Promise<string> {
try { try {
return await new Promise((resolve, reject) => { return (await this._walletsClient.relayXmrTx(new RelayXmrTxRequest().setMetadata(metadata), {password: this._password})).getHash();
this._walletsClient.relayXmrTx(new RelayXmrTxRequest().setMetadata(metadata), {password: this._password}, function(err: grpcWeb.RpcError, response: RelayXmrTxReply) {
if (err) reject(err);
else resolve(response.getHash());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -931,12 +771,7 @@ export default class HavenoClient {
*/ */
async getPrice(assetCode: string): Promise<number> { async getPrice(assetCode: string): Promise<number> {
try { try {
return await new Promise((resolve, reject) => { return (await this._priceClient.getMarketPrice(new MarketPriceRequest().setCurrencyCode(assetCode), {password: this._password})).getPrice();
this._priceClient.getMarketPrice(new MarketPriceRequest().setCurrencyCode(assetCode), {password: this._password}, function(err: grpcWeb.RpcError, response: MarketPriceReply) {
if (err) reject(err);
else resolve(response.getPrice());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -949,12 +784,7 @@ export default class HavenoClient {
*/ */
async getPrices(): Promise<MarketPriceInfo[]> { async getPrices(): Promise<MarketPriceInfo[]> {
try { try {
return await new Promise((resolve, reject) => { return (await this._priceClient.getMarketPrices(new MarketPricesRequest(), {password: this._password})).getMarketPriceList();
this._priceClient.getMarketPrices(new MarketPricesRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: MarketPricesReply) {
if (err) reject(err);
else resolve(response.getMarketPriceList());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -968,12 +798,7 @@ export default class HavenoClient {
*/ */
async getMarketDepth(assetCode: string): Promise<MarketDepthInfo> { async getMarketDepth(assetCode: string): Promise<MarketDepthInfo> {
try { try {
return await new Promise((resolve, reject) => { return (await this._priceClient.getMarketDepth(new MarketDepthRequest().setCurrencyCode(assetCode), {password: this._password})).getMarketDepth()!;
this._priceClient.getMarketDepth(new MarketDepthRequest().setCurrencyCode(assetCode), {password: this._password}, function(err: grpcWeb.RpcError, response: MarketDepthReply) {
if (err) reject(err);
else resolve(response.getMarketDepth()!);
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -988,12 +813,7 @@ export default class HavenoClient {
async getPaymentMethods(assetCode?: string): Promise<PaymentMethod[]> { async getPaymentMethods(assetCode?: string): Promise<PaymentMethod[]> {
try { try {
if (!this._paymentMethods) { if (!this._paymentMethods) {
this._paymentMethods = await new Promise((resolve, reject) => { this._paymentMethods = (await this._paymentAccountsClient.getPaymentMethods(new GetPaymentMethodsRequest(), {password: this._password})).getPaymentMethodsList();
this._paymentAccountsClient.getPaymentMethods(new GetPaymentMethodsRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: GetPaymentMethodsReply) {
if (err) reject(err);
else resolve(response.getPaymentMethodsList());
});
});
} }
if (!assetCode) return this._paymentMethods!; if (!assetCode) return this._paymentMethods!;
const assetPaymentMethods: PaymentMethod[] = []; const assetPaymentMethods: PaymentMethod[] = [];
@ -1013,12 +833,7 @@ export default class HavenoClient {
*/ */
async getPaymentAccounts(): Promise<PaymentAccount[]> { async getPaymentAccounts(): Promise<PaymentAccount[]> {
try { try {
return await new Promise((resolve, reject) => { return (await this._paymentAccountsClient.getPaymentAccounts(new GetPaymentAccountsRequest(), {password: this._password})).getPaymentAccountsList();
this._paymentAccountsClient.getPaymentAccounts(new GetPaymentAccountsRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: GetPaymentAccountsReply) {
if (err) reject(err);
else resolve(response.getPaymentAccountsList());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1047,12 +862,7 @@ export default class HavenoClient {
*/ */
async getPaymentAccountForm(paymentMethodId: string): Promise<PaymentAccountForm> { async getPaymentAccountForm(paymentMethodId: string): Promise<PaymentAccountForm> {
try { try {
return await new Promise((resolve, reject) => { return (await this._paymentAccountsClient.getPaymentAccountForm(new GetPaymentAccountFormRequest().setPaymentMethodId(paymentMethodId), {password: this._password})).getPaymentAccountForm()!;
this._paymentAccountsClient.getPaymentAccountForm(new GetPaymentAccountFormRequest().setPaymentMethodId(paymentMethodId), {password: this._password}, function(err: grpcWeb.RpcError, response: GetPaymentAccountFormReply) {
if (err) reject(err);
else resolve(response.getPaymentAccountForm()!);
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1066,12 +876,7 @@ export default class HavenoClient {
*/ */
async getPaymentAccountPayloadForm(paymentAccountPayload: PaymentAccountPayload): Promise<PaymentAccountForm> { async getPaymentAccountPayloadForm(paymentAccountPayload: PaymentAccountPayload): Promise<PaymentAccountForm> {
try { try {
return await new Promise((resolve, reject) => { return (await this._paymentAccountsClient.getPaymentAccountForm(new GetPaymentAccountFormRequest().setPaymentAccountPayload(paymentAccountPayload), {password: this._password})).getPaymentAccountForm()!;
this._paymentAccountsClient.getPaymentAccountForm(new GetPaymentAccountFormRequest().setPaymentAccountPayload(paymentAccountPayload), {password: this._password}, function(err: grpcWeb.RpcError, response: GetPaymentAccountFormReply) {
if (err) reject(err);
else resolve(response.getPaymentAccountForm()!);
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1090,12 +895,7 @@ export default class HavenoClient {
.setFieldId(fieldId) .setFieldId(fieldId)
.setValue(value); .setValue(value);
try { try {
await new Promise<void>((resolve, reject) => { await this._paymentAccountsClient.validateFormField(request, {password: this._password});
this._paymentAccountsClient.validateFormField(request, {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1109,12 +909,7 @@ export default class HavenoClient {
*/ */
async createPaymentAccount(paymentAccountForm: PaymentAccountForm): Promise<PaymentAccount> { async createPaymentAccount(paymentAccountForm: PaymentAccountForm): Promise<PaymentAccount> {
try { try {
return await new Promise((resolve, reject) => { return (await this._paymentAccountsClient.createPaymentAccount(new CreatePaymentAccountRequest().setPaymentAccountForm(paymentAccountForm), {password: this._password})).getPaymentAccount()!;
this._paymentAccountsClient.createPaymentAccount(new CreatePaymentAccountRequest().setPaymentAccountForm(paymentAccountForm), {password: this._password}, function(err: grpcWeb.RpcError, response: CreatePaymentAccountReply) {
if (err) reject(err);
else resolve(response.getPaymentAccount()!);
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1135,12 +930,7 @@ export default class HavenoClient {
.setCurrencyCode(assetCode) .setCurrencyCode(assetCode)
.setAddress(address) .setAddress(address)
.setTradeInstant(false); // not using instant trades .setTradeInstant(false); // not using instant trades
return await new Promise((resolve, reject) => { return (await this._paymentAccountsClient.createCryptoCurrencyPaymentAccount(request, {password: this._password})).getPaymentAccount()!;
this._paymentAccountsClient.createCryptoCurrencyPaymentAccount(request, {password: this._password}, function(err: grpcWeb.RpcError, response: CreateCryptoCurrencyPaymentAccountReply) {
if (err) reject(err);
else resolve(response.getPaymentAccount()!);
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1156,12 +946,7 @@ export default class HavenoClient {
async getOffers(assetCode: string, direction?: string): Promise<OfferInfo[]> { async getOffers(assetCode: string, direction?: string): Promise<OfferInfo[]> {
try { try {
if (!direction) return (await this.getOffers(assetCode, "buy")).concat(await this.getOffers(assetCode, "sell")); // TODO: implement in backend if (!direction) return (await this.getOffers(assetCode, "buy")).concat(await this.getOffers(assetCode, "sell")); // TODO: implement in backend
return await new Promise((resolve, reject) => { return (await this._offersClient.getOffers(new GetOffersRequest().setDirection(direction).setCurrencyCode(assetCode), {password: this._password})).getOffersList();
this._offersClient.getOffers(new GetOffersRequest().setDirection(direction).setCurrencyCode(assetCode), {password: this._password}, function(err: grpcWeb.RpcError, response: GetOffersReply) {
if (err) reject(err);
else resolve(response.getOffersList());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1177,12 +962,7 @@ export default class HavenoClient {
async getMyOffers(assetCode: string, direction?: string): Promise<OfferInfo[]> { async getMyOffers(assetCode: string, direction?: string): Promise<OfferInfo[]> {
try { try {
if (!direction) return (await this.getMyOffers(assetCode, "buy")).concat(await this.getMyOffers(assetCode, "sell")); // TODO: implement in backend if (!direction) return (await this.getMyOffers(assetCode, "buy")).concat(await this.getMyOffers(assetCode, "sell")); // TODO: implement in backend
return await new Promise((resolve, reject) => { return (await this._offersClient.getMyOffers(new GetOffersRequest().setDirection(direction).setCurrencyCode(assetCode), {password: this._password})).getOffersList();
this._offersClient.getMyOffers(new GetOffersRequest().setDirection(direction).setCurrencyCode(assetCode), {password: this._password}, function(err: grpcWeb.RpcError, response: GetOffersReply) {
if (err) reject(err);
else resolve(response.getOffersList());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1196,12 +976,7 @@ export default class HavenoClient {
*/ */
async getMyOffer(offerId: string): Promise<OfferInfo> { async getMyOffer(offerId: string): Promise<OfferInfo> {
try { try {
return await new Promise((resolve, reject) => { return (await this._offersClient.getMyOffer(new GetMyOfferRequest().setId(offerId), {password: this._password})).getOffer()!;
this._offersClient.getMyOffer(new GetMyOfferRequest().setId(offerId), {password: this._password}, function(err: grpcWeb.RpcError, response: GetMyOfferReply) {
if (err) reject(err);
else resolve(response.getOffer()!);
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1242,12 +1017,7 @@ export default class HavenoClient {
if (price) request.setPrice(price.toString()); if (price) request.setPrice(price.toString());
if (marketPriceMarginPct) request.setMarketPriceMarginPct(marketPriceMarginPct); if (marketPriceMarginPct) request.setMarketPriceMarginPct(marketPriceMarginPct);
if (triggerPrice) request.setTriggerPrice(triggerPrice.toString()); if (triggerPrice) request.setTriggerPrice(triggerPrice.toString());
return await new Promise((resolve, reject) => { return (await this._offersClient.postOffer(request, {password: this._password})).getOffer()!;
this._offersClient.postOffer(request, {password: this._password}, function(err: grpcWeb.RpcError, response: PostOfferReply) {
if (err) reject(err);
else resolve(response.getOffer()!);
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1260,12 +1030,7 @@ export default class HavenoClient {
*/ */
async removeOffer(offerId: string): Promise<void> { async removeOffer(offerId: string): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._offersClient.cancelOffer(new CancelOfferRequest().setId(offerId), {password: this._password});
this._offersClient.cancelOffer(new CancelOfferRequest().setId(offerId), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1283,13 +1048,7 @@ export default class HavenoClient {
const request = new TakeOfferRequest() const request = new TakeOfferRequest()
.setOfferId(offerId) .setOfferId(offerId)
.setPaymentAccountId(paymentAccountId); .setPaymentAccountId(paymentAccountId);
return await new Promise((resolve, reject) => { return (await this._tradesClient.takeOffer(request, {password: this._password})).getTrade()!;
this._tradesClient.takeOffer(request, {password: this._password}, function(err: grpcWeb.RpcError, response: TakeOfferReply) {
if (err) reject(err);
else if (response.getFailureReason() && response.getFailureReason()!.getAvailabilityResult() !== AvailabilityResult.AVAILABLE) reject(new Error(response.getFailureReason()!.getDescription())); // TODO: api should throw grpcWeb.RpcError
else resolve(response.getTrade()!);
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1303,12 +1062,7 @@ export default class HavenoClient {
*/ */
async getTrade(tradeId: string): Promise<TradeInfo> { async getTrade(tradeId: string): Promise<TradeInfo> {
try { try {
return await new Promise((resolve, reject) => { return (await this._tradesClient.getTrade(new GetTradeRequest().setTradeId(tradeId), {password: this._password})).getTrade()!;
this._tradesClient.getTrade(new GetTradeRequest().setTradeId(tradeId), {password: this._password}, function(err: grpcWeb.RpcError, response: GetTradeReply) {
if (err) reject(err);
else resolve(response.getTrade()!);
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1321,12 +1075,7 @@ export default class HavenoClient {
*/ */
async getTrades(): Promise<TradeInfo[]> { async getTrades(): Promise<TradeInfo[]> {
try { try {
return await new Promise((resolve, reject) => { return (await this._tradesClient.getTrades(new GetTradesRequest(), {password: this._password})).getTradesList();
this._tradesClient.getTrades(new GetTradesRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: GetTradesReply) {
if (err) reject(err);
else resolve(response.getTradesList());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1339,12 +1088,7 @@ export default class HavenoClient {
*/ */
async confirmPaymentSent(tradeId: string): Promise<void> { async confirmPaymentSent(tradeId: string): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._tradesClient.confirmPaymentSent(new ConfirmPaymentSentRequest().setTradeId(tradeId), {password: this._password});
this._tradesClient.confirmPaymentSent(new ConfirmPaymentSentRequest().setTradeId(tradeId), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1357,12 +1101,7 @@ export default class HavenoClient {
*/ */
async confirmPaymentReceived(tradeId: string): Promise<void> { async confirmPaymentReceived(tradeId: string): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._tradesClient.confirmPaymentReceived(new ConfirmPaymentReceivedRequest().setTradeId(tradeId), {password: this._password});
this._tradesClient.confirmPaymentReceived(new ConfirmPaymentReceivedRequest().setTradeId(tradeId), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1375,12 +1114,7 @@ export default class HavenoClient {
*/ */
async completeTrade(tradeId: string): Promise<void> { async completeTrade(tradeId: string): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._tradesClient.completeTrade(new CompleteTradeRequest().setTradeId(tradeId), {password: this._password});
this._tradesClient.completeTrade(new CompleteTradeRequest().setTradeId(tradeId), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1393,13 +1127,8 @@ export default class HavenoClient {
*/ */
async getChatMessages(tradeId: string): Promise<ChatMessage[]> { async getChatMessages(tradeId: string): Promise<ChatMessage[]> {
try { try {
return await new Promise((resolve, reject) => { const request = new GetChatMessagesRequest().setTradeId(tradeId);
const request = new GetChatMessagesRequest().setTradeId(tradeId); return (await this._tradesClient.getChatMessages(request, {password: this._password})).getMessageList();
this._tradesClient.getChatMessages(request, {password: this._password}, function(err: grpcWeb.RpcError, response: GetChatMessagesReply) {
if (err) reject(err);
else resolve(response.getMessageList());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1413,15 +1142,10 @@ export default class HavenoClient {
*/ */
async sendChatMessage(tradeId: string, message: string): Promise<void> { async sendChatMessage(tradeId: string, message: string): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { const request = new SendChatMessageRequest()
const request = new SendChatMessageRequest() .setTradeId(tradeId)
.setTradeId(tradeId) .setMessage(message);
.setMessage(message); await this._tradesClient.sendChatMessage(request, {password: this._password});
this._tradesClient.sendChatMessage(request, {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1434,12 +1158,7 @@ export default class HavenoClient {
*/ */
async getDispute(tradeId: string): Promise<Dispute> { async getDispute(tradeId: string): Promise<Dispute> {
try { try {
return await new Promise((resolve, reject) => { return (await this._disputesClient.getDispute(new GetDisputeRequest().setTradeId(tradeId), {password: this._password})).getDispute()!;
this._disputesClient.getDispute(new GetDisputeRequest().setTradeId(tradeId), {password: this._password}, function(err: grpcWeb.RpcError, response: GetDisputeReply) {
if (err) reject(err);
else resolve(response.getDispute()!);
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1450,12 +1169,7 @@ export default class HavenoClient {
*/ */
async getDisputes(): Promise<Dispute[]> { async getDisputes(): Promise<Dispute[]> {
try { try {
return await new Promise((resolve, reject) => { return (await this._disputesClient.getDisputes(new GetDisputesRequest(), {password: this._password})).getDisputesList();
this._disputesClient.getDisputes(new GetDisputesRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: GetDisputesReply) {
if (err) reject(err);
else resolve(response.getDisputesList());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1468,12 +1182,7 @@ export default class HavenoClient {
*/ */
async openDispute(tradeId: string): Promise<void> { async openDispute(tradeId: string): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._disputesClient.openDispute(new OpenDisputeRequest().setTradeId(tradeId), {password: this._password});
this._disputesClient.openDispute(new OpenDisputeRequest().setTradeId(tradeId), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1491,18 +1200,13 @@ export default class HavenoClient {
*/ */
async resolveDispute(tradeId: string, winner: DisputeResult.Winner, reason: DisputeResult.Reason, summaryNotes: string, customWinnerAmount?: bigint): Promise<void> { async resolveDispute(tradeId: string, winner: DisputeResult.Winner, reason: DisputeResult.Reason, summaryNotes: string, customWinnerAmount?: bigint): Promise<void> {
try { try {
return await new Promise((resolve, reject) => { const request = new ResolveDisputeRequest()
const request = new ResolveDisputeRequest() .setTradeId(tradeId)
.setTradeId(tradeId) .setWinner(winner)
.setWinner(winner) .setReason(reason)
.setReason(reason) .setSummaryNotes(summaryNotes)
.setSummaryNotes(summaryNotes) .setCustomPayoutAmount(customWinnerAmount ? customWinnerAmount.toString() : "0");
.setCustomPayoutAmount(customWinnerAmount ? customWinnerAmount.toString() : "0"); await this._disputesClient.resolveDispute(request, {password: this._password});
this._disputesClient.resolveDispute(request, {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1517,16 +1221,11 @@ export default class HavenoClient {
*/ */
async sendDisputeChatMessage(disputeId: string, message: string, attachments: Attachment[]): Promise<void> { async sendDisputeChatMessage(disputeId: string, message: string, attachments: Attachment[]): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { const request = new SendDisputeChatMessageRequest()
const request = new SendDisputeChatMessageRequest() .setDisputeId(disputeId)
.setDisputeId(disputeId) .setMessage(message)
.setMessage(message) .setAttachmentsList(attachments);
.setAttachmentsList(attachments); await this._disputesClient.sendDisputeChatMessage(request, {password: this._password});
this._disputesClient.sendDisputeChatMessage(request, {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1545,12 +1244,7 @@ export default class HavenoClient {
async shutdownServer() { async shutdownServer() {
try { try {
await this.disconnect(); await this.disconnect();
await new Promise<void>((resolve, reject) => { await this._shutdownServerClient.stop(new StopRequest(), {password: this._password}); // process receives 'exit' event
this._shutdownServerClient.stop(new StopRequest(), {password: this._password}, function(err: grpcWeb.RpcError) { // process receives 'exit' event
if (err) reject(err);
else resolve();
});
});
if (this._process) return HavenoUtils.kill(this._process); if (this._process) return HavenoUtils.kill(this._process);
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
@ -1600,12 +1294,7 @@ export default class HavenoClient {
/** @private */ /** @private */
async _isAppInitialized(): Promise<boolean> { async _isAppInitialized(): Promise<boolean> {
try { try {
return await new Promise((resolve, reject) => { return (await this._accountClient.isAppInitialized(new IsAppInitializedRequest(), {password: this._password})).getIsAppInitialized();
this._accountClient.isAppInitialized(new IsAppInitializedRequest(), {password: this._password}, function(err: grpcWeb.RpcError, response: IsAppInitializedReply) {
if (err) reject(err);
else resolve(response.getIsAppInitialized());
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1678,12 +1367,7 @@ export default class HavenoClient {
*/ */
async _sendNotification(notification: NotificationMessage): Promise<void> { async _sendNotification(notification: NotificationMessage): Promise<void> {
try { try {
await new Promise<void>((resolve, reject) => { await this._notificationsClient.sendNotification(new SendNotificationRequest().setNotification(notification), {password: this._password});
this._notificationsClient.sendNotification(new SendNotificationRequest().setNotification(notification), {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }
@ -1701,12 +1385,7 @@ export default class HavenoClient {
.setOffset(offset) .setOffset(offset)
.setTotalLength(totalLength) .setTotalLength(totalLength)
.setHasMore(hasMore); .setHasMore(hasMore);
await new Promise<void>((resolve, reject) => { await this._accountClient.restoreAccount(request, {password: this._password});
this._accountClient.restoreAccount(request, {password: this._password}, function(err: grpcWeb.RpcError) {
if (err) reject(err);
else resolve();
});
});
} catch (e: any) { } catch (e: any) {
throw new HavenoError(e.message, e.code); throw new HavenoError(e.message, e.code);
} }