feat(raiden): channel balance by currency

This modifies the logic around querying raiden for channel balances.
Rather than summing up all balances across all tokens, it allows for
specifying a currency and retrieving only the balance for that
currency. Calling `ChannelBalance` without specifying a currency will
return each currency separately.

It also scales the balance returned by raiden to satoshis (10^-8). This
is because the default units of 10^-18 for currencies such as WETH can
exceed the maximum value of a `uint64` used by the gRPC layer.

Closes #1051.

lib/raidenclient/RaidenClient.ts

@@ -41,6 +41,12 @@ class RaidenClient extends SwapClient {
   private host: string;
   private disable: boolean;
 
+  // TODO: Populate the mapping from the database (Currency.decimalPlaces).
+  private static readonly UNITS_PER_CURRENCY: { [key: string]: number } = {
+    WETH: 10 ** 10,
+    DAI: 10 ** 10,
+  };
+
   /**
    * Creates a raiden client.
    */
@@ -272,14 +278,17 @@ class RaidenClient extends SwapClient {
   }
 
   /**
-   * Returns the total balance available across all channels.
+   * Returns the total balance available across all channels for a specified currency.
    */
-  public channelBalance = async (): Promise<ChannelBalance> => {
-    // TODO: refine logic to determine balance per token rather than all combined
-    const channels = await this.getChannels();
+  public channelBalance = async (currency?: string): Promise<ChannelBalance> => {
+    if (!currency) {
+      return { balance: 0, pendingOpenBalance: 0 };
+    }
+
+    const channels = await this.getChannels(this.tokenAddresses.get(currency));
     const balance = channels.filter(channel => channel.state === 'opened')
       .map(channel => channel.balance)
-      .reduce((acc, sum) => sum + acc, 0);
+      .reduce((acc, sum) => sum + (acc / RaidenClient.UNITS_PER_CURRENCY[currency]), 0);
     return { balance, pendingOpenBalance: 0 };
   }
 

lib/service/Service.ts

@@ -119,23 +119,27 @@ class Service {
   public channelBalance = async (args: { currency: string }) => {
     const { currency } = args;
     const balances = new Map<string, { balance: number, pendingOpenBalance: number }>();
-    const getBalance = async (currency: string) => {
+
+    if (currency) {
+      argChecks.VALID_CURRENCY(args);
+
       const swapClient = this.swapClientManager.get(currency.toUpperCase());
       if (swapClient) {
-        const channelBalance = await swapClient.channelBalance();
-        return channelBalance;
+        const channelBalance = await swapClient.channelBalance(currency);
+        balances.set(currency, channelBalance);
       } else {
         throw swapsErrors.SWAP_CLIENT_NOT_FOUND(currency);
       }
-    };
-
-    if (currency) {
-      argChecks.VALID_CURRENCY(args);
-      balances.set(currency, await getBalance(currency));
     } else {
-      for (const currency of this.orderBook.currencies) {
-        balances.set(currency, await getBalance(currency));
-      }
+      const balancePromises: Promise<any>[] = [];
+      this.swapClientManager.swapClients.forEach((swapClient, currency) => {
+        if (swapClient.isConnected()) {
+          balancePromises.push(swapClient.channelBalance(currency).then((channelBalance) => {
+            balances.set(currency, channelBalance);
+          }));
+        }
+      });
+      await Promise.all(balancePromises);
     }
 
     return balances;

lib/swaps/SwapClient.ts

@@ -44,8 +44,10 @@ abstract class SwapClient extends EventEmitter {
 
   /**
    * Returns the total balance available across all channels.
+   * @param currency the currency whose balance to query for, otherwise all/any
+   * currencies supported by this client are included in the balance.
    */
-  public abstract channelBalance(): Promise<ChannelBalance>;
+  public abstract channelBalance(currency?: string): Promise<ChannelBalance>;
 
   protected setStatus = async (status: ClientStatus): Promise<void> => {
     this.logger.info(`${this.constructor.name} status: ${ClientStatus[status]}`);