feat(rpc): include aliases in ListOrders

This adds an optional alias field on the orders returned by `ListOrders`
and enables and displays aliases automatically on `xucli listorders`.

Closes #643.

Author: sangaman

Diff for: docs/api.md

@@ -11,7 +11,7 @@ type FormattedTradingPairOrders = {
   orders: string[][],
 };
 
-const COLUMNS = [19, 19, 12, 19, 19, 12];
+const COLUMNS = [15, 13, 18, 15, 13, 18];
 const COLUMNS_IN_ORDER_SIDE = COLUMNS.length / 2;
 const HEADER = [
   { content: colors.green('Buy'), colSpan: 3 },
@@ -26,14 +26,13 @@ const SECONDARY_HEADER = [
   colors.red('Alias'),
 ];
 
-const addSide = (orderSide: Order.AsObject[]): string[] => {
+const addOrderToSide = (orderSide: Order.AsObject[]): string[] => {
   const order = orderSide.pop();
   if (order) {
-    const isOwn = order.isOwnOrder ? 'X' : '';
     return [
       satsToCoinsStr(order.quantity),
       order.price.toString(),
-      isOwn,
+      order.nodeIdentifier!.alias,
     ].map(i => order.isOwnOrder ? colors.cyan(i) : i);
   } else {
     return Array.from(Array(COLUMNS_IN_ORDER_SIDE)).map(() => '');
@@ -42,17 +41,17 @@ const addSide = (orderSide: Order.AsObject[]): string[] => {
 
 export const formatOrders = (orders: ListOrdersResponse.AsObject) => {
   const formattedOrders: FormattedTradingPairOrders[] = [];
-  orders.ordersMap.map(orderMapping => orderMapping[1]).forEach((tradingPair) => {
+  orders.ordersMap.forEach(([pairId, tradingPair]) => {
     const buy = tradingPair.buyOrdersList;
     const sell = tradingPair.sellOrdersList;
     const totalRows = buy.length < sell.length
       ? sell.length : buy.length;
     const tradingPairOrders = Array.from(Array(totalRows))
       .map(() => {
-        return addSide(buy).concat(addSide(sell));
+        return addOrderToSide(buy).concat(addOrderToSide(sell));
       });
     formattedOrders.push({
-      pairId: tradingPair[0],
+      pairId,
       orders: tradingPairOrders,
     });
   });
@@ -107,5 +106,6 @@ export const handler = async (argv: Arguments<any>) => {
   request.setPairId(pairId);
   request.setOwner(Number(Owner[argv.owner]));
   request.setLimit(argv.limit);
+  request.setIncludeAliases(true);
   (await loadXudClient(argv)).listOrders(request, callback(argv, displayTables));
 };

Diff for: lib/cli/commands/listorders.ts

@@ -5,13 +5,37 @@ import { CurrencyInstance, OrderInstance, TradeInstance } from '../db/types';
 import { LndInfo } from '../lndclient/types';
 import { isOwnOrder, Order, OrderPortion, PlaceOrderEvent, PlaceOrderEventType, PlaceOrderResult } from '../orderbook/types';
 import * as xudrpc from '../proto/xudrpc_pb';
-import Service from '../service/Service';
+import Service, { ServiceOrder } from '../service/Service';
 import { SwapFailure, SwapSuccess } from '../swaps/types';
 import getGrpcError from './getGrpcError';
 
 /**
  * Creates an xudrpc Order message from an [[Order]].
  */
+const createServiceOrder = (order: ServiceOrder) => {
+  const grpcOrder = new xudrpc.Order();
+  grpcOrder.setCreatedAt(order.createdAt);
+  grpcOrder.setId(order.id);
+  if (order.hold) {
+    grpcOrder.setHold(order.hold);
+  }
+  if (order.localId) {
+    grpcOrder.setLocalId(order.localId);
+  }
+  grpcOrder.setIsOwnOrder(order.isOwnOrder);
+  const nodeIdentifier = new xudrpc.NodeIdentifier();
+  nodeIdentifier.setNodePubKey(order.nodeIdentifier.nodePubKey);
+  if (order.nodeIdentifier.alias) {
+    nodeIdentifier.setAlias(order.nodeIdentifier.alias);
+  }
+  grpcOrder.setNodeIdentifier(nodeIdentifier);
+  grpcOrder.setPairId(order.pairId);
+  grpcOrder.setPrice(order.price);
+  grpcOrder.setQuantity(order.quantity);
+  grpcOrder.setSide(order.side as number);
+  return grpcOrder;
+};
+
 const createOrder = (order: Order) => {
   const grpcOrder = new xudrpc.Order();
   grpcOrder.setCreatedAt(order.createdAt);
@@ -21,7 +45,9 @@ const createOrder = (order: Order) => {
     grpcOrder.setLocalId((order).localId);
     grpcOrder.setIsOwnOrder(true);
   } else {
-    grpcOrder.setPeerPubKey((order).peerPubKey);
+    const nodeIdentifier = new xudrpc.NodeIdentifier();
+    nodeIdentifier.setNodePubKey(order.peerPubKey);
+    grpcOrder.setNodeIdentifier(nodeIdentifier);
     grpcOrder.setIsOwnOrder(false);
   }
   grpcOrder.setPairId(order.pairId);
@@ -566,9 +592,9 @@ class GrpcService {
       const listOrdersResponse = this.service.listOrders(call.request.toObject());
       const response = new xudrpc.ListOrdersResponse();
 
-      const listOrdersList = <T extends Order>(orders: T[]) => {
+      const listOrdersList = <T extends ServiceOrder>(orders: T[]) => {
         const ordersList: xudrpc.Order[] = [];
-        orders.forEach(order => ordersList.push(createOrder(<Order>order)));
+        orders.forEach(order => ordersList.push(createServiceOrder(order)));
         return ordersList;
       };
 

Diff for: lib/grpc/GrpcService.ts

@@ -76,6 +76,11 @@ type Stamp = OrderIdentifier & {
   initialQuantity: number;
 };
 
+export type SortableOrder = {
+  price: number;
+  createdAt: number;
+};
+
 export type OwnMarketOrder = MarketOrder & Local;
 
 export type OwnLimitOrder = LimitOrder & Local;

Diff for: lib/orderbook/types.ts

@@ -148,7 +148,7 @@ class Pool extends EventEmitter {
     return this.nodeState.addresses;
   }
 
-  public getTokenIdentifier(currency: string) {
+  public getTokenIdentifier = (currency: string) => {
     return this.nodeState.tokenIdentifiers[currency];
   }