more async

lib/wallet/wallet.ts

@@ -125,24 +125,11 @@ export class Offer {
 }
 
 
-interface ConfirmPayRequest {
-  offer: Offer;
-}
-
 interface ExchangeCoins {
   [exchangeUrl: string]: CoinWithDenom[];
 }
 
 
-interface CoinPaySig {
-  coin_sig: string;
-  coin_pub: string;
-  ub_sig: string;
-  denom_pub: string;
-  f: AmountJson;
-}
-
-
 interface Transaction {
   contractHash: string;
   contract: Contract;
@@ -505,21 +492,21 @@ export class Wallet {
    * Add a contract to the wallet and sign coins,
    * but do not send them yet.
    */
-  confirmPay(offer: Offer): Promise<any> {
+  async confirmPay(offer: Offer): Promise<any> {
     console.log("executing confirmPay");
 
-    return Query(this.db)
+    let transaction = await Query(this.db)
-      .get("transactions", offer.H_contract)
+      .get("transactions", offer.H_contract);
-      .then((transaction) => {
+
     if (transaction) {
       // Already payed ...
       return {};
     }
-        return Promise.resolve().then(() => {
+
-          return this.getPossibleExchangeCoins(offer.contract.amount,
+    let mcs = await this.getPossibleExchangeCoins(offer.contract.amount,
                                                   offer.contract.max_fee,
-                                               offer.contract.exchanges)
+                                                  offer.contract.exchanges);
-        }).then((mcs) => {
+
     if (Object.keys(mcs).length == 0) {
       console.log("not confirming payment, insufficient coins");
       return {
@@ -528,13 +515,11 @@ export class Wallet {
     }
     let exchangeUrl = Object.keys(mcs)[0];
 
-          return this.cryptoApi.signDeposit(offer, mcs[exchangeUrl])
+    let ds = await this.cryptoApi.signDeposit(offer, mcs[exchangeUrl]);
-                     .then((ds) => this.recordConfirmPay(offer,
+    await this.recordConfirmPay(offer,
                                 ds,
-                                                         exchangeUrl))
+                                exchangeUrl);
-                     .then(() => ({}));
+    return {};
-        });
-      });
   }
 
 
@@ -542,23 +527,20 @@ export class Wallet {
    * Add a contract to the wallet and sign coins,
    * but do not send them yet.
    */
-  checkPay(offer: Offer): Promise<any> {
+  async checkPay(offer: Offer): Promise<any> {
-    console.log("executing checkPay");
-
     // First check if we already payed for it.
-    return Query(this.db)
+    let transaction = await
-      .get("transactions", offer.H_contract)
+      Query(this.db)
-      .then((transaction) => {
+        .get("transactions", offer.H_contract);
     if (transaction) {
       return {isPayed: true};
     }
 
     // If not already payed, check if we could pay for it.
-        return Promise.resolve().then(() => {
+    let mcs = await this.getPossibleExchangeCoins(offer.contract.amount,
-          return this.getPossibleExchangeCoins(offer.contract.amount,
                                                   offer.contract.max_fee,
-                                               offer.contract.exchanges)
+                                                  offer.contract.exchanges);
-        }).then((mcs) => {
+
     if (Object.keys(mcs).length == 0) {
       console.log("not confirming payment, insufficient coins");
       return {
@@ -566,9 +548,6 @@ export class Wallet {
       };
     }
     return {isPayed: false};
-        });
-
-      });
   }
 
 
@@ -576,11 +555,9 @@ export class Wallet {
    * Retrieve all necessary information for looking up the contract
    * with the given hash.
    */
-  executePayment(H_contract: string): Promise<any> {
+  async executePayment(H_contract: string): Promise<any> {
-    return Promise.resolve().then(() => {
+    let t = await Query(this.db)
-      return Query(this.db)
+      .get("transactions", H_contract);
-        .get("transactions", H_contract)
-        .then((t) => {
     if (!t) {
       return {
         success: false,
@@ -593,8 +570,6 @@ export class Wallet {
       contract: t.contract,
     };
     return resp;
-        });
-    });
   }
 
 
@@ -602,16 +577,16 @@ export class Wallet {
    * First fetch information requred to withdraw from the reserve,
    * then deplete the reserve, withdrawing coins until it is empty.
    */
-  private processReserve(reserveRecord: any, retryDelayMs: number = 250): void {
+  private async processReserve(reserveRecord: any,
+                               retryDelayMs: number = 250): Promise<void> {
     const opId = "reserve-" + reserveRecord.reserve_pub;
     this.startOperation(opId);
-    this.updateExchangeFromUrl(reserveRecord.exchange_base_url)
+
-        .then((exchange) =>
+    try {
-                this.updateReserve(reserveRecord.reserve_pub, exchange)
+      let exchange = await this.updateExchangeFromUrl(reserveRecord.exchange_base_url);
-                    .then((reserve) => this.depleteReserve(reserve,
+      let reserve = await this.updateReserve(reserveRecord.reserve_pub,
-                                                           exchange)))
+                                             exchange);
-        .then(() => {
+      await this.depleteReserve(reserve, exchange);
-          this.stopOperation(opId);
       let depleted = {
         type: "depleted-reserve",
         timestamp: (new Date).getTime(),
@@ -619,42 +594,42 @@ export class Wallet {
           reservePub: reserveRecord.reserve_pub,
         }
       };
-          return Query(this.db).put("history", depleted).finish();
+      await Query(this.db).put("history", depleted).finish();
-        })
+    } catch (e) {
-        .catch((e) => {
-          // Don't show progress while we're sleeping
-          this.stopOperation(opId);
       // random, exponential backoff truncated at 3 minutes
       let nextDelay = Math.min(2 * retryDelayMs + retryDelayMs * Math.random(),
                                3000 * 60);
       console.warn(`Failed to deplete reserve, trying again in ${retryDelayMs} ms`);
       setTimeout(() => this.processReserve(reserveRecord, nextDelay),
                  retryDelayMs);
-        });
+    } finally {
+      this.stopOperation(opId);
+    }
   }
 
 
-  private processPreCoin(preCoin: any, retryDelayMs = 100): void {
+  private async processPreCoin(preCoin: any,
-    this.withdrawExecute(preCoin)
+                               retryDelayMs = 100): Promise<void> {
-        .then((c) => this.storeCoin(c))
+    try {
-        .catch((e) => {
+      const coin = await this.withdrawExecute(preCoin);
+      this.storeCoin(coin);
+    } catch (e) {
       console.error("Failed to withdraw coin from precoin, retrying in",
                     retryDelayMs,
-                        "ms");
+                    "ms", e);
-          console.error(e);
       // exponential backoff truncated at one minute
       let nextRetryDelayMs = Math.min(retryDelayMs * 2, 1000 * 60);
       setTimeout(() => this.processPreCoin(preCoin, nextRetryDelayMs),
                  retryDelayMs);
-        });
+    }
   }
 
 
   /**
    * Create a reserve, but do not flag it as confirmed yet.
    */
-  createReserve(req: CreateReserveRequest): Promise<CreateReserveResponse> {
+  async createReserve(req: CreateReserveRequest): Promise<CreateReserveResponse> {
-    return this.cryptoApi.createEddsaKeypair().then((keypair) => {
+    let keypair = await this.cryptoApi.createEddsaKeypair();
     const now = (new Date).getTime();
     const canonExchange = canonicalizeBaseUrl(req.exchange);
 
@@ -669,7 +644,6 @@ export class Wallet {
       confirmed: false,
     };
 
-
     const historyEntry = {
       type: "create-reserve",
       timestamp: now,
@@ -679,18 +653,16 @@ export class Wallet {
       }
     };
 
-      return Query(this.db)
+    await Query(this.db)
       .put("reserves", reserveRecord)
       .put("history", historyEntry)
-        .finish()
+      .finish();
-        .then(() => {
+
     let r: CreateReserveResponse = {
       exchange: canonExchange,
       reservePub: keypair.pub,
     };
     return r;
-        });
-    });
   }
 
 
@@ -703,7 +675,7 @@ export class Wallet {
    * A confirmed reserve should be shown to the user in the UI, while
    * an unconfirmed reserve should be hidden.
    */
-  confirmReserve(req: ConfirmReserveRequest): Promise<void> {
+  async confirmReserve(req: ConfirmReserveRequest): Promise<void> {
     const now = (new Date).getTime();
     const historyEntry = {
       type: "confirm-reserve",
@@ -712,9 +684,8 @@ export class Wallet {
         reservePub: req.reservePub,
       }
     };
-    return Query(this.db)
+    let r = await Query(this.db)
-      .get("reserves", req.reservePub)
+      .get("reserves", req.reservePub);
-      .then((r) => {
     if (!r) {
       console.error("Unable to confirm reserve, not found in DB");
       return;
@@ -728,23 +699,22 @@ export class Wallet {
         // Do this in the background
         this.processReserve(r);
       });
-      });
   }
 
 
-  private withdrawExecute(pc: PreCoin): Promise<Coin> {
+  private async withdrawExecute(pc: PreCoin): Promise<Coin> {
-    return Query(this.db)
+    let reserve = await Query(this.db)
-      .get("reserves", pc.reservePub)
+      .get("reserves", pc.reservePub);
-      .then((r) => {
+
     let wd: any = {};
     wd.denom_pub = pc.denomPub;
     wd.reserve_pub = pc.reservePub;
     wd.reserve_sig = pc.withdrawSig;
     wd.coin_ev = pc.coinEv;
-        let reqUrl = URI("reserve/withdraw").absoluteTo(r.exchange_base_url);
+    let reqUrl = URI("reserve/withdraw").absoluteTo(reserve.exchange_base_url);
-        return this.http.postJson(reqUrl, wd);
+    let resp = await this.http.postJson(reqUrl, wd);
-      })
+
-      .then(resp => {
+
     if (resp.status != 200) {
       throw new RequestException({
         hint: "Withdrawal failed",
@@ -752,8 +722,9 @@ export class Wallet {
       });
     }
     let r = JSON.parse(resp.responseText);
-        return this.cryptoApi.rsaUnblind(r.ev_sig, pc.blindingKey, pc.denomPub)
+    let denomSig = await this.cryptoApi.rsaUnblind(r.ev_sig,
-                   .then((denomSig) => {
+                                                   pc.blindingKey,
+                                                   pc.denomPub);
     let coin: Coin = {
       coinPub: pc.coinPub,
       coinPriv: pc.coinPriv,
@@ -763,12 +734,9 @@ export class Wallet {
       exchangeBaseUrl: pc.exchangeBaseUrl,
     };
     return coin;
-
-                   });
-      });
   }
 
-  storeCoin(coin: Coin): Promise<void> {
+  async storeCoin(coin: Coin): Promise<void> {
     console.log("storing coin", new Date());
     let historyEntry = {
       type: "withdraw",
@@ -777,14 +745,12 @@ export class Wallet {
         coinPub: coin.coinPub,
       }
     };
-    return Query(this.db)
+    await Query(this.db)
       .delete("precoins", coin.coinPub)
       .add("coins", coin)
       .add("history", historyEntry)
-      .finish()
+      .finish();
-      .then(() => {
     this.notifier.notify();
-      });
   }
 
 
@@ -823,7 +789,7 @@ export class Wallet {
    * Update the information about a reserve that is stored in the wallet
    * by quering the reserve's exchange.
    */
-  private updateReserve(reservePub: string,
+  private async updateReserve(reservePub: string,
                               exchange: IExchangeInfo): Promise<Reserve> {
     return Query(this.db)
       .get("reserves", reservePub)
@@ -862,10 +828,11 @@ export class Wallet {
   /**
    * Get the wire information for the exchange with the given base URL.
    */
-  getWireInfo(exchangeBaseUrl: string): Promise<WireInfo> {
+  async getWireInfo(exchangeBaseUrl: string): Promise<WireInfo> {
     exchangeBaseUrl = canonicalizeBaseUrl(exchangeBaseUrl);
     let reqUrl = URI("wire").absoluteTo(exchangeBaseUrl);
-    return this.http.get(reqUrl).then((resp: HttpResponse) => {
+    let resp = await this.http.get(reqUrl);
+
     if (resp.status != 200) {
       throw Error("/wire request failed");
     }
@@ -875,13 +842,12 @@ export class Wallet {
       throw Error("/wire response malformed")
     }
     return wiJson;
-    });
   }
 
-  getReserveCreationInfo(baseUrl: string,
+  async getReserveCreationInfo(baseUrl: string,
                                amount: AmountJson): Promise<ReserveCreationInfo> {
-    let p = this.updateExchangeFromUrl(baseUrl);
+    let exchangeInfo = await this.updateExchangeFromUrl(baseUrl);
-    return p.then((exchangeInfo: IExchangeInfo) => {
+
     let selectedDenoms = getWithdrawDenomList(amount,
                                               exchangeInfo.active_denoms);
     let acc = Amounts.getZero(amount.currency);
@@ -892,7 +858,9 @@ export class Wallet {
       .map((d: Denomination) => Amounts.add(d.value,
                                             d.fee_withdraw).amount)
       .reduce((a, b) => Amounts.add(a, b).amount);
-      return this.getWireInfo(baseUrl).then((wireInfo) => {
+
+    let wireInfo = await this.getWireInfo(baseUrl);
+
     let ret: ReserveCreationInfo = {
       exchangeInfo,
       selectedDenoms,
@@ -901,9 +869,6 @@ export class Wallet {
       overhead: Amounts.sub(amount, actualCoinCost).amount,
     };
     return ret;
-      });
-
-    });
   }
 
 
@@ -912,16 +877,15 @@ export class Wallet {
    * Optionally link the reserve entry to the new or existing
    * exchange entry in then DB.
    */
-  updateExchangeFromUrl(baseUrl: string): Promise<IExchangeInfo> {
+  async updateExchangeFromUrl(baseUrl: string): Promise<IExchangeInfo> {
     baseUrl = canonicalizeBaseUrl(baseUrl);
     let reqUrl = URI("keys").absoluteTo(baseUrl);
-    return this.http.get(reqUrl).then((resp) => {
+    let resp = await this.http.get(reqUrl);
     if (resp.status != 200) {
       throw Error("/keys request failed");
     }
     let exchangeKeysJson = KeysJson.checked(JSON.parse(resp.responseText));
     return this.updateExchangeFromJson(baseUrl, exchangeKeysJson);
-    });
   }
 
   private async suspendCoins(exchangeInfo: IExchangeInfo): Promise<void> {