refactoring / refresh WIP

lib/wallet/cryptoApi.ts

@@ -21,12 +21,12 @@
  */
 
 
-import {PreCoin} from "./types";
+import {PreCoin, Coin, ReserveRecord, AmountJson} from "./types";
-import {Reserve} from "./types";
 import {Denomination} from "./types";
 import {Offer} from "./wallet";
 import {CoinWithDenom} from "./wallet";
 import {PayCoinInfo} from "./types";
+import {RefreshSession} from "./types";
 
 interface RegistryEntry {
   resolve: any;
@@ -228,7 +228,7 @@ export class CryptoApi {
   }
 
 
-  createPreCoin(denom: Denomination, reserve: Reserve): Promise<PreCoin> {
+  createPreCoin(denom: Denomination, reserve: ReserveRecord): Promise<PreCoin> {
     return this.doRpc("createPreCoin", 1, denom, reserve);
   }
 
@@ -257,4 +257,17 @@ export class CryptoApi {
   rsaUnblind(sig: string, bk: string, pk: string): Promise<string> {
     return this.doRpc("rsaUnblind", 4, sig, bk, pk);
   }
+
+  createWithdrawSession(kappa: number, meltCoin: Coin,
+                        newCoinDenoms: Denomination[],
+                        meltAmount: AmountJson,
+                        meltFee: AmountJson): Promise<RefreshSession> {
+    return this.doRpc("createWithdrawSession",
+                      4,
+                      kappa,
+                      meltCoin,
+                      newCoinDenoms,
+                      meltAmount,
+                      meltFee);
+  }
 }

lib/wallet/cryptoLib.ts

@@ -22,13 +22,21 @@
 "use strict";
 
 import * as native from "./emscriptif";
-import {PreCoin, Reserve, PayCoinInfo} from "./types";
+import {
+  PreCoin, PayCoinInfo, AmountJson,
+  RefreshSession, RefreshPreCoin, ReserveRecord
+} from "./types";
 import create = chrome.alarms.create;
 import {Offer} from "./wallet";
 import {CoinWithDenom} from "./wallet";
 import {CoinPaySig} from "./types";
 import {Denomination} from "./types";
 import {Amount} from "./emscriptif";
+import {Coin} from "../../background/lib/wallet/types";
+import {HashContext} from "./emscriptif";
+import {RefreshMeltCoinAffirmationPS} from "./emscriptif";
+import {EddsaPublicKey} from "./emscriptif";
+import {HashCode} from "./emscriptif";
 
 
 export function main(worker: Worker) {
@@ -61,7 +69,7 @@ namespace RpcFunctions {
    * reserve.
    */
   export function createPreCoin(denom: Denomination,
-                                reserve: Reserve): PreCoin {
+                                reserve: ReserveRecord): PreCoin {
     let reservePriv = new native.EddsaPrivateKey();
     reservePriv.loadCrock(reserve.reserve_priv);
     let reservePub = new native.EddsaPublicKey();
@@ -224,4 +232,82 @@ namespace RpcFunctions {
     }
     return ret;
   }
+
+
+  function createWithdrawSession(kappa: number, meltCoin: Coin,
+                                 newCoinDenoms: Denomination[],
+                                 meltAmount: AmountJson,
+                                 meltFee: AmountJson): RefreshSession {
+
+    let sessionHc = new HashContext();
+
+    let transferPubs: string[] = [];
+
+    let preCoinsForGammas: RefreshPreCoin[][] = [];
+
+    for (let i = 0; i < newCoinDenoms.length; i++) {
+      let t = native.EcdsaPrivateKey.create();
+      sessionHc.read(t);
+      transferPubs.push(t.toCrock());
+    }
+
+    for (let i = 0; i < newCoinDenoms.length; i++) {
+      let r = native.RsaPublicKey.fromCrock(newCoinDenoms[i].denom_pub);
+      sessionHc.read(r.encode());
+    }
+
+    sessionHc.read(native.RsaPublicKey.fromCrock(meltCoin.coinPub).encode());
+    sessionHc.read((new native.Amount(meltAmount)).toNbo());
+
+    for (let j = 0; j < kappa; j++) {
+      let preCoins: RefreshPreCoin[] = [];
+      for (let i = 0; i < newCoinDenoms.length; i++) {
+
+        let coinPriv = native.EddsaPrivateKey.create();
+        let coinPub = coinPriv.getPublicKey();
+        let blindingFactor = native.RsaBlindingKeySecret.create();
+        let pubHash: native.HashCode = coinPub.hash();
+        let denomPub = native.RsaPublicKey.fromCrock(newCoinDenoms[i].denom_pub);
+        let ev: native.ByteArray = native.rsaBlind(pubHash,
+                                                   blindingFactor,
+                                                   denomPub);
+        let preCoin: RefreshPreCoin = {
+          blindingKey: blindingFactor.toCrock(),
+          coinEv: ev.toCrock(),
+          publicKey: coinPub.toCrock(),
+          privateKey: coinPriv.toCrock(),
+        };
+        preCoins.push(preCoin);
+        sessionHc.read(ev);
+      }
+      preCoinsForGammas.push(preCoins);
+    }
+
+    let sessionHash = new HashCode();
+    sessionHash.alloc();
+    sessionHc.finish(sessionHash);
+
+    let confirmData = new RefreshMeltCoinAffirmationPS({
+      coin_pub: EddsaPublicKey.fromCrock(meltCoin.coinPub),
+      amount_with_fee: (new Amount(meltAmount)).toNbo(),
+      session_hash: sessionHash,
+      melt_fee: (new Amount(meltFee)).toNbo()
+    });
+
+    let confirmSig: string = native.eddsaSign(confirmData.toPurpose(),
+                                              native.EddsaPrivateKey.fromCrock(
+                                                meltCoin.coinPriv)).toCrock();
+
+    let refreshSession: RefreshSession = {
+      meltCoinPub: meltCoin.coinPub,
+      newDenoms: newCoinDenoms.map((d) => d.denom_pub),
+      confirmSig,
+      valueWithFee: meltAmount,
+      transferPubs,
+      preCoinsForGammas,
+    };
+
+    return refreshSession;
+  }
+
 }

lib/wallet/db.ts

@@ -25,7 +25,7 @@
  */
 
 const DB_NAME = "taler";
-const DB_VERSION = 7;
+const DB_VERSION = 8;
 
 /**
  * Return a promise that resolves
@@ -72,7 +72,7 @@ export function openTalerDb(): Promise<IDBDatabase> {
           if (e.oldVersion != DB_VERSION) {
             window.alert("Incompatible wallet dababase version, please reset" +
                          " db.");
-            chrome.browserAction.setBadgeText({text: "R!"});
+            chrome.browserAction.setBadgeText({text: "err"});
             chrome.browserAction.setBadgeBackgroundColor({color: "#F00"});
             throw Error("incompatible DB");
           }

lib/wallet/emscriptif.ts

@@ -119,10 +119,16 @@ var emscAlloc = {
     ['number', 'number', 'number', 'string']),
   eddsa_key_create: getEmsc('GNUNET_CRYPTO_eddsa_key_create',
     'number', []),
+  ecdsa_key_create: getEmsc('GNUNET_CRYPTO_ecdsa_key_create',
+                            'number', []),
   eddsa_public_key_from_private: getEmsc(
     'TALER_WRALL_eddsa_public_key_from_private',
     'number',
     ['number']),
+  ecdsa_public_key_from_private: getEmsc(
+    'TALER_WRALL_ecdsa_public_key_from_private',
+    'number',
+    ['number']),
   data_to_string_alloc: getEmsc('GNUNET_STRINGS_data_to_string_alloc',
     'number',
     ['number', 'number']),
@@ -181,7 +187,7 @@ interface ArenaObject {
 }
 
 
-class HashContext implements ArenaObject {
+export class HashContext implements ArenaObject {
   private hashContextPtr: number | undefined;
 
   constructor() {
@@ -590,6 +596,29 @@ export class EddsaPrivateKey extends PackedArenaObject {
 mixinStatic(EddsaPrivateKey, fromCrock);
 
 
+export class EcdsaPrivateKey extends PackedArenaObject {
+  static create(a?: Arena): EcdsaPrivateKey {
+    let obj = new EcdsaPrivateKey(a);
+    obj.nativePtr = emscAlloc.ecdsa_key_create();
+    return obj;
+  }
+
+  size() {
+    return 32;
+  }
+
+  getPublicKey(a?: Arena): EcdsaPublicKey {
+    let obj = new EcdsaPublicKey(a);
+    obj.nativePtr = emscAlloc.ecdsa_public_key_from_private(this.nativePtr);
+    return obj;
+  }
+
+  static fromCrock: (s: string) => EcdsaPrivateKey;
+}
+mixinStatic(EcdsaPrivateKey, fromCrock);
+
+
+
 function fromCrock(s: string) {
   let x = new this();
   x.alloc();
@@ -629,6 +658,16 @@ export class EddsaPublicKey extends PackedArenaObject {
 }
 mixinStatic(EddsaPublicKey, fromCrock);
 
+export class EcdsaPublicKey extends PackedArenaObject {
+  size() {
+    return 32;
+  }
+
+  static fromCrock: (s: string) => EcdsaPublicKey;
+}
+mixinStatic(EddsaPublicKey, fromCrock);
+
+
 function makeFromCrock(decodeFn: (p: number, s: number) => number) {
   function fromCrock(s: string, a?: Arena) {
     let obj = new this(a);

lib/wallet/query.ts

@@ -24,10 +24,6 @@
 "use strict";
 
 
-export function Query(db: IDBDatabase) {
-  return new QueryRoot(db);
-}
-
 /**
  * Stream that can be filtered, reduced or joined
  * with indices.
@@ -265,7 +261,7 @@ class IterQueryStream<T> extends QueryStreamBase<T> {
 }
 
 
-class QueryRoot {
+export class QueryRoot {
   private work: ((t: IDBTransaction) => void)[] = [];
   private db: IDBDatabase;
   private stores = new Set();
@@ -332,7 +328,7 @@ class QueryRoot {
   /**
    * Get one object from a store by its key.
    */
-  get(storeName: any, key: any): Promise<any> {
+  get<T>(storeName: any, key: any): Promise<T|undefined> {
     if (key === void 0) {
       throw Error("key must not be undefined");
     }

lib/wallet/types.ts

@@ -42,6 +42,30 @@ export class AmountJson {
 }
 
 
+export interface ReserveRecord {
+  reserve_pub: string;
+  reserve_priv: string,
+  exchange_base_url: string,
+  created: number,
+  last_query: number | null,
+  /**
+   * Current amount left in the reserve
+   */
+  current_amount: AmountJson | null,
+  /**
+   * Amount requested when the reserve was created.
+   * When a reserve is re-used (rare!)  the current_amount can
+   * be higher than the requested_amount
+   */
+  requested_amount: AmountJson,
+  /**
+   * Amount we've already withdrawn from the reserve.
+   */
+  withdrawn_amount: AmountJson;
+  confirmed: boolean,
+}
+
+
 @Checkable.Class
 export class CreateReserveResponse {
   /**
@@ -147,6 +171,13 @@ export interface PreCoin {
   coinValue: AmountJson;
 }
 
+export interface RefreshPreCoin {
+  publicKey: string;
+  privateKey: string;
+  coinEv: string;
+  blindingKey: string
+}
+
 
 /**
  * Ongoing refresh
@@ -173,20 +204,9 @@ export interface RefreshSession {
    */
   newDenoms: string[];
 
-  /**
-   * Blinded public keys for the requested coins.
-   */
-  newCoinBlanks: string[][];
 
-  /**
+  preCoinsForGammas: RefreshPreCoin[][];
-   * Blinding factors for the new coins.
-   */
-  newCoinBlindingFactors: string[][];
 
-  /**
-   * Private keys for the requested coins.
-   */
-  newCoinPrivs: string[][];
 
   /**
    * The transfer keys, kappa of them.
@@ -195,15 +215,6 @@ export interface RefreshSession {
 }
 
 
-export interface Reserve {
-  exchange_base_url: string
-  reserve_priv: string;
-  reserve_pub: string;
-  created: number;
-  current_amount: AmountJson;
-}
-
-
 export interface CoinPaySig {
   coin_sig: string;
   coin_pub: string;

lib/wallet/wallet.ts

@@ -27,21 +27,20 @@ import {
   IExchangeInfo,
   Denomination,
   Notifier,
-  WireInfo
+  WireInfo, RefreshSession, ReserveRecord
 } from "./types";
-import { HttpResponse, RequestException } from "./http";
+import {HttpResponse, RequestException} from "./http";
-import { Query } from "./query";
+import {QueryRoot} from "./query";
-import { Checkable } from "./checkable";
+import {Checkable} from "./checkable";
-import { canonicalizeBaseUrl } from "./helpers";
+import {canonicalizeBaseUrl} from "./helpers";
-import { ReserveCreationInfo, Amounts } from "./types";
+import {ReserveCreationInfo, Amounts} from "./types";
-import { PreCoin } from "./types";
+import {PreCoin} from "./types";
-import { Reserve } from "./types";
+import {CryptoApi} from "./cryptoApi";
-import { CryptoApi } from "./cryptoApi";
+import {Coin} from "./types";
-import { Coin } from "./types";
+import {PayCoinInfo} from "./types";
-import { PayCoinInfo } from "./types";
+import {CheckRepurchaseResult} from "./types";
-import { CheckRepurchaseResult } from "./types";
+import {Contract} from "./types";
-import { Contract } from "./types";
+import {ExchangeHandle} from "./types";
-import { ExchangeHandle } from "./types";
 
 "use strict";
 
@@ -50,29 +49,6 @@ export interface CoinWithDenom {
   denom: Denomination;
 }
 
-interface ReserveRecord {
-  reserve_pub: string;
-  reserve_priv: string,
-  exchange_base_url: string,
-  created: number,
-  last_query: number | null,
-  /**
-   * Current amount left in the reserve
-   */
-  current_amount: AmountJson | null,
-  /**
-   * Amount requested when the reserve was created.
-   * When a reserve is re-used (rare!)  the current_amount can
-   * be higher than the requested_amount
-   */
-  requested_amount: AmountJson,
-  /**
-   * Amount we've already withdrawn from the reserve.
-   */
-  withdrawn_amount: AmountJson;
-  confirmed: boolean,
-}
-
 
 @Checkable.Class
 export class KeysJson {
@@ -330,6 +306,10 @@ export class Wallet {
    */
   private runningOperations: Set<string> = new Set();
 
+  q(): QueryRoot {
+    return new QueryRoot(this.db);
+  }
+
   constructor(db: IDBDatabase,
               http: HttpRequestLibrary,
               badge: Badge,
@@ -359,7 +339,7 @@ export class Wallet {
   updateExchanges(): void {
     console.log("updating exchanges");
 
-    Query(this.db)
+    this.q()
         .iter("exchanges")
         .reduce((exchange: IExchangeInfo) => {
           this.updateExchangeFromUrl(exchange.baseUrl)
@@ -376,14 +356,14 @@ export class Wallet {
   private resumePendingFromDb(): void {
     console.log("resuming pending operations from db");
 
-    Query(this.db)
+    this.q()
         .iter("reserves")
         .reduce((reserve: any) => {
           console.log("resuming reserve", reserve.reserve_pub);
           this.processReserve(reserve);
         });
 
-    Query(this.db)
+    this.q()
         .iter("precoins")
         .reduce((preCoin: any) => {
           console.log("resuming precoin");
@@ -425,7 +405,7 @@ export class Wallet {
         console.warn("same pubkey for different currencies");
         return;
       }
-      let cd = { coin, denom };
+      let cd = {coin, denom};
       let x = m[url];
       if (!x) {
         m[url] = [cd];
@@ -445,9 +425,11 @@ export class Wallet {
       handledExchanges.add(info.url);
       console.log("Checking for merchant's exchange", JSON.stringify(info));
       return [
-        Query(this.db)
+        this.q()
-          .iter("exchanges", { indexName: "pubKey", only: info.master_pub })
+            .iter("exchanges", {indexName: "pubKey", only: info.master_pub})
-          .indexJoin("coins", "exchangeBaseUrl", (exchange) => exchange.baseUrl)
+            .indexJoin("coins",
+                       "exchangeBaseUrl",
+                       (exchange) => exchange.baseUrl)
             .reduce((x) => storeExchangeCoin(x, info.url))
       ];
     });
@@ -539,7 +521,7 @@ export class Wallet {
       }
     };
 
-    await Query(this.db)
+    await this.q()
               .put("transactions", t)
               .put("history", historyEntry)
               .putAll("coins", payCoinInfo.map((pci) => pci.updatedCoin))
@@ -550,7 +532,7 @@ export class Wallet {
 
 
   async putHistory(historyEntry: HistoryRecord): Promise<void> {
-    await Query(this.db).put("history", historyEntry).finish();
+    await this.q().put("history", historyEntry).finish();
     this.notifier.notify();
   }
 
@@ -562,8 +544,7 @@ export class Wallet {
   async confirmPay(offer: Offer): Promise<any> {
     console.log("executing confirmPay");
 
-    let transaction = await Query(this.db)
+    let transaction = await this.q().get("transactions", offer.H_contract);
-      .get("transactions", offer.H_contract);
 
     if (transaction) {
       // Already payed ...
@@ -596,11 +577,9 @@ export class Wallet {
    */
   async checkPay(offer: Offer): Promise<any> {
     // First check if we already payed for it.
-    let transaction = await
+    let transaction = await this.q().get("transactions", offer.H_contract);
-      Query(this.db)
-        .get("transactions", offer.H_contract);
     if (transaction) {
-      return { isPayed: true };
+      return {isPayed: true};
     }
 
     // If not already payed, check if we could pay for it.
@@ -614,7 +593,7 @@ export class Wallet {
         error: "coins-insufficient",
       };
     }
-    return { isPayed: false };
+    return {isPayed: false};
   }
 
 
@@ -623,8 +602,7 @@ export class Wallet {
    * with the given hash.
    */
   async executePayment(H_contract: string): Promise<any> {
-    let t = await Query(this.db)
+    let t = await this.q().get<Transaction>("transactions", H_contract);
-      .get("transactions", H_contract);
     if (!t) {
       return {
         success: false,
@@ -667,7 +645,7 @@ export class Wallet {
             currentAmount: reserveRecord.current_amount,
           }
         };
-        await Query(this.db).put("history", depleted).finish();
+        await this.q().put("history", depleted).finish();
       }
     } catch (e) {
       // random, exponential backoff truncated at 3 minutes
@@ -730,7 +708,7 @@ export class Wallet {
       }
     };
 
-    await Query(this.db)
+    await this.q()
               .put("reserves", reserveRecord)
               .put("history", historyEntry)
               .finish();
@@ -754,8 +732,13 @@ export class Wallet {
    */
   async confirmReserve(req: ConfirmReserveRequest): Promise<void> {
     const now = (new Date).getTime();
-    let reserve: ReserveRecord = await Query(this.db)
+    let reserve: ReserveRecord|undefined = await (
-      .get("reserves", req.reservePub);
+      this.q().get<ReserveRecord>("reserves",
+                                  req.reservePub));
+    if (!reserve) {
+      console.error("Unable to confirm reserve, not found in DB");
+      return;
+    }
     const historyEntry = {
       type: "confirm-reserve",
       timestamp: now,
@@ -766,12 +749,8 @@ export class Wallet {
         requestedAmount: reserve.requested_amount,
       }
     };
-    if (!reserve) {
-      console.error("Unable to confirm reserve, not found in DB");
-      return;
-    }
     reserve.confirmed = true;
-    await Query(this.db)
+    await this.q()
               .put("reserves", reserve)
               .put("history", historyEntry)
               .finish();
@@ -781,8 +760,11 @@ export class Wallet {
 
 
   private async withdrawExecute(pc: PreCoin): Promise<Coin> {
-    let reserve = await Query(this.db)
+    let reserve = await this.q().get<ReserveRecord>("reserves", pc.reservePub);
-      .get("reserves", pc.reservePub);
+
+    if (!reserve) {
+      throw Error("db inconsistent");
+    }
 
     let wd: any = {};
     wd.denom_pub = pc.denomPub;
@@ -825,7 +807,7 @@ export class Wallet {
         coinPub: coin.coinPub,
       }
     };
-    await Query(this.db)
+    await this.q()
               .delete("precoins", coin.coinPub)
               .add("coins", coin)
               .add("history", historyEntry)
@@ -837,11 +819,12 @@ export class Wallet {
   /**
    * Withdraw one coin of the given denomination from the given reserve.
    */
-  private async withdraw(denom: Denomination, reserve: Reserve): Promise<void> {
+  private async withdraw(denom: Denomination,
+                         reserve: ReserveRecord): Promise<void> {
     console.log("creating pre coin at", new Date());
     let preCoin = await this.cryptoApi
                             .createPreCoin(denom, reserve);
-    await Query(this.db)
+    await this.q()
               .put("precoins", preCoin)
               .finish();
     await this.processPreCoin(preCoin);
@@ -868,11 +851,14 @@ export class Wallet {
    * by quering the reserve's exchange.
    */
   private async updateReserve(reservePub: string,
-    exchange: IExchangeInfo): Promise<Reserve> {
+                              exchange: IExchangeInfo): Promise<ReserveRecord> {
-    let reserve = await Query(this.db)
+    let reserve = await this.q()
-      .get("reserves", reservePub);
+                            .get<ReserveRecord>("reserves", reservePub);
+    if (!reserve) {
+      throw Error("reserve not in db");
+    }
     let reqUrl = URI("reserve/status").absoluteTo(exchange.baseUrl);
-    reqUrl.query({ 'reserve_pub': reservePub });
+    reqUrl.query({'reserve_pub': reservePub});
     let resp = await this.http.get(reqUrl);
     if (resp.status != 200) {
       throw Error();
@@ -895,7 +881,7 @@ export class Wallet {
         newAmount
       }
     };
-    await Query(this.db)
+    await this.q()
               .put("reserves", reserve)
               .finish();
     return reserve;
@@ -966,17 +952,18 @@ export class Wallet {
   }
 
   private async suspendCoins(exchangeInfo: IExchangeInfo): Promise<void> {
-    let suspendedCoins = await Query(this.db)
+    let suspendedCoins = await (
+      this.q()
           .iter("coins",
-      { indexName: "exchangeBaseUrl", only: exchangeInfo.baseUrl })
+                {indexName: "exchangeBaseUrl", only: exchangeInfo.baseUrl})
           .reduce((coin: Coin, suspendedCoins: Coin[]) => {
             if (!exchangeInfo.active_denoms.find((c) => c.denom_pub == coin.denomPub)) {
               return Array.prototype.concat(suspendedCoins, [coin]);
             }
             return Array.prototype.concat(suspendedCoins);
-      }, []);
+          }, []));
 
-    let q = Query(this.db);
+    let q = this.q();
     suspendedCoins.map((c) => {
       console.log("suspending coin", c);
       c.suspended = true;
@@ -993,7 +980,7 @@ export class Wallet {
       throw Error("invalid update time");
     }
 
-    let r = await Query(this.db).get("exchanges", baseUrl);
+    let r = await this.q().get<IExchangeInfo>("exchanges", baseUrl);
 
     let exchangeInfo: IExchangeInfo;
 
@@ -1019,7 +1006,7 @@ export class Wallet {
                                                             exchangeKeysJson);
     await this.suspendCoins(updatedExchangeInfo);
 
-    await Query(this.db)
+    await this.q()
               .put("exchanges", updatedExchangeInfo)
               .finish();
 
@@ -1064,7 +1051,7 @@ export class Wallet {
       return true;
     });
 
-    let ps = denomsToCheck.map(async (denom) => {
+    let ps = denomsToCheck.map(async(denom) => {
       let valid = await this.cryptoApi
                             .isValidDenom(denom,
                                           exchangeInfo.masterPublicKey);
@@ -1103,11 +1090,54 @@ export class Wallet {
       return byCurrency;
     }
 
-    let byCurrency = await Query(this.db)
+    let byCurrency = await (
+      this.q()
           .iter("coins")
-      .reduce(collectBalances, {});
+          .reduce(collectBalances, {}));
+
+    return {balances: byCurrency};
+  }
+
+
+  async refresh(oldCoinPub: string): Promise<void> {
+    // FIXME: this is not running in a transaction.
+
+    let coin = await this.q().get<Coin>("coins", oldCoinPub);
+
+    if (!coin) {
+      console.error("coin not found");
+      return;
+    }
+
+    let exchange = await this.q().get<IExchangeInfo>("exchanges",
+                                                     coin.exchangeBaseUrl);
+    if (!exchange) {
+      throw Error("db inconsistent");
+    }
+
+    let oldDenom = exchange.all_denoms.find((d) => d.denom_pub == coin!.denomPub);
+
+    if (!oldDenom) {
+      throw Error("db inconsistent");
+    }
+
+    let availableDenoms: Denomination[] = exchange.active_denoms;
+
+    let newCoinDenoms = getWithdrawDenomList(coin.currentAmount,
+                                             availableDenoms);
+
+    console.log("refreshing into", newCoinDenoms);
+
+
+    let refreshSession: RefreshSession = await (
+      this.cryptoApi.createWithdrawSession(3,
+                                           coin,
+                                           newCoinDenoms,
+                                           coin.currentAmount,
+                                           oldDenom.fee_refresh));
+
+    // FIXME: implement rest
 
-    return { balances: byCurrency };
   }
 
 
@@ -1120,37 +1150,37 @@ export class Wallet {
       return acc;
     }
 
-    let history = await
+    let history = await (
-      Query(this.db)
+      this.q()
-        .iter("history", { indexName: "timestamp" })
+          .iter("history", {indexName: "timestamp"})
-        .reduce(collect, []);
+          .reduce(collect, []));
 
-    return { history };
+    return {history};
   }
 
   async getExchanges(): Promise<IExchangeInfo[]> {
-    return Query(this.db)
+    return this.q()
                .iter<IExchangeInfo>("exchanges")
                .flatMap((e) => [e])
                .toArray();
   }
 
-  async getReserves(exchangeBaseUrl: string): Promise<Reserve[]> {
+  async getReserves(exchangeBaseUrl: string): Promise<ReserveRecord[]> {
-    return Query(this.db)
+    return this.q()
-      .iter<Reserve>("reserves")
+               .iter<ReserveRecord>("reserves")
-      .filter((r: Reserve) => r.exchange_base_url === exchangeBaseUrl)
+               .filter((r: ReserveRecord) => r.exchange_base_url === exchangeBaseUrl)
                .toArray();
   }
 
   async getCoins(exchangeBaseUrl: string): Promise<Coin[]> {
-    return Query(this.db)
+    return this.q()
                .iter<Coin>("coins")
                .filter((c: Coin) => c.exchangeBaseUrl === exchangeBaseUrl)
                .toArray();
   }
 
   async getPreCoins(exchangeBaseUrl: string): Promise<PreCoin[]> {
-    return Query(this.db)
+    return this.q()
                .iter<PreCoin>("precoins")
                .filter((c: PreCoin) => c.exchangeBaseUrl === exchangeBaseUrl)
                .toArray();
@@ -1167,12 +1197,16 @@ export class Wallet {
   async checkRepurchase(contract: Contract): Promise<CheckRepurchaseResult> {
     if (!contract.repurchase_correlation_id) {
       console.log("no repurchase: no correlation id");
-      return { isRepurchase: false };
+      return {isRepurchase: false};
     }
-    let result: Transaction = await Query(this.db)
+    let result: Transaction = await (
+      this.q()
           .getIndexed("transactions",
                       "repurchase",
-      [contract.merchant_pub, contract.repurchase_correlation_id]);
+                      [
+                        contract.merchant_pub,
+                        contract.repurchase_correlation_id
+                      ]));
 
     if (result) {
       console.assert(result.contract.repurchase_correlation_id == contract.repurchase_correlation_id);
@@ -1182,7 +1216,7 @@ export class Wallet {
         existingFulfillmentUrl: result.contract.fulfillment_url,
       };
     } else {
-      return { isRepurchase: false };
+      return {isRepurchase: false};
     }
   }
 }

lib/wallet/wxApi.ts

@@ -20,7 +20,7 @@ import {
   PreCoin,
   ReserveCreationInfo,
   IExchangeInfo,
-  Reserve
+  ReserveRecord
 } from "./types";
 
 /**
@@ -58,7 +58,7 @@ export async function getExchanges(): Promise<IExchangeInfo[]> {
   return await callBackend("get-exchanges");
 }
 
-export async function getReserves(exchangeBaseUrl: string): Promise<Reserve[]> {
+export async function getReserves(exchangeBaseUrl: string): Promise<ReserveRecord[]> {
   return await callBackend("get-reserves", { exchangeBaseUrl });
 }
 

pages/tree.tsx

@@ -23,18 +23,18 @@
 /// <reference path="../lib/decl/preact.d.ts" />
 
 import { IExchangeInfo } from "../lib/wallet/types";
-import { Reserve, Coin, PreCoin, Denomination } from "../lib/wallet/types";
+import { ReserveRecord, Coin, PreCoin, Denomination } from "../lib/wallet/types";
 import { ImplicitStateComponent, StateHolder } from "../lib/components";
 import { getReserves, getExchanges, getCoins, getPreCoins } from "../lib/wallet/wxApi";
 import { prettyAmount, abbrev } from "../lib/wallet/renderHtml";
 
 interface ReserveViewProps {
-  reserve: Reserve;
+  reserve: ReserveRecord;
 }
 
 class ReserveView extends preact.Component<ReserveViewProps, void> {
   render(): JSX.Element {
-    let r: Reserve = this.props.reserve;
+    let r: ReserveRecord = this.props.reserve;
     return (
       <div className="tree-item">
         <ul>
@@ -248,7 +248,7 @@ class DenominationList extends ImplicitStateComponent<DenominationListProps> {
 }
 
 class ReserveList extends ImplicitStateComponent<ReserveListProps> {
-  reserves = this.makeState<Reserve[] | null>(null);
+  reserves = this.makeState<ReserveRecord[] | null>(null);
   expanded = this.makeState<boolean>(false);
 
   constructor(props: ReserveListProps) {