Merge pull request #791 from ExchangeUnion/listTrades-grpc

feat: listtrades grpc command #667

lib/cli/commands/listtrades.ts

@@ -0,0 +1,53 @@
+import { Arguments } from 'yargs';
+import { callback, loadXudClient } from '../command';
+import { ListTradesRequest, ListTradesResponse, Trade } from '../../proto/xudrpc_pb';
+import Table, { HorizontalTable } from 'cli-table3';
+import colors from 'colors/safe';
+import { satsToCoinsStr } from '../utils';
+
+const HEADERS = [
+  colors.blue('Trading Pair'),
+  colors.blue('Trade Quantity'),
+  colors.blue('Price'),
+  colors.blue('Order Type'),
+];
+
+const displayTrades = (trades: ListTradesResponse.AsObject) => {
+  const table = new Table({ head: HEADERS }) as HorizontalTable;
+  trades.tradesList.forEach((trade: Trade.AsObject) => {
+    const type = trade.makerOrder ? 'maker' : 'taker';
+    let price = 0;
+    if (trade.makerOrder) {
+      price = trade.makerOrder.price;
+    } else if (trade.takerOrder) {
+      price = trade.takerOrder.price;
+    }
+
+    table.push([
+      trade.pairId,
+      satsToCoinsStr(trade.quantity),
+      parseFloat(price.toFixed(5)),
+      type,
+    ]);
+  });
+  console.log(colors.underline(colors.bold('\Trades:')));
+  console.log(table.toString());
+};
+
+export const command = 'listtrades [limit]';
+
+export const describe = 'list completed trades';
+
+export const builder = {
+  limit: {
+    description: 'the maximum number of trades to display',
+    type: 'number',
+    default: 15,
+  },
+};
+
+export const handler = (argv: Arguments) => {
+  const request = new ListTradesRequest();
+  request.setLimit(argv.limit);
+  loadXudClient(argv).listTrades(request, callback(argv, displayTrades));
+};

lib/grpc/GrpcService.ts

@@ -12,6 +12,7 @@ import { errorCodes as lndErrorCodes } from '../lndclient/errors';
 import { LndInfo } from '../lndclient/types';
 import { SwapSuccess, SwapFailure } from '../swaps/types';
 import { SwapFailureReason } from '../constants/enums';
+import { TradeInstance, OrderInstance } from '../db/types';
 
 /**
  * Creates an xudrpc Order message from an [[Order]].
@@ -69,6 +70,26 @@ const createSwapFailure = (swapFailure: SwapFailure) => {
   return grpcSwapFailure;
 };
 
+/**
+ * Creates an xudrpc Order from OrderInstance.
+ */
+const getGrpcOrderFromOrderInstance = (order: OrderInstance) => {
+  const grpcOrder = new xudrpc.Order();
+  grpcOrder.setCreatedAt(order.createdAt);
+  grpcOrder.setId(order.id);
+  grpcOrder.setIsOwnOrder(order.nodeId === undefined);
+  if (order.localId) {
+    grpcOrder.setLocalId(order.localId);
+  }
+  grpcOrder.setPairId(order.pairId);
+  // TODO: set peer pub key if order.nodeId has a value
+  if (order.price) {
+    grpcOrder.setPrice(order.price);
+  }
+  grpcOrder.setSide(order.isBuy ? xudrpc.OrderSide.BUY : xudrpc.OrderSide.SELL);
+  return grpcOrder;
+};
+
 /**
  * Creates an xudrpc PlaceOrderResponse message from a [[PlaceOrderResult]].
  */
@@ -503,6 +524,33 @@ class GrpcService {
     }
   }
 
+  /**
+   * See [[Service.listTrades]]
+   */
+  public listTrades: grpc.handleUnaryCall<xudrpc.ListTradesRequest, xudrpc.ListTradesResponse> = async (call, callback) => {
+    try {
+      const trades = await this.service.listTrades(call.request.toObject());
+      const response = new xudrpc.ListTradesResponse();
+      const tradesList: xudrpc.Trade[] = [];
+      await Promise.all(trades.map(async (trade: TradeInstance) => {
+        const grpcTrade = new xudrpc.Trade();
+        const makerOrder = await trade.getMakerOrder();
+        const takerOrder = await trade.getTakerOrder();
+        grpcTrade.setQuantity(trade.quantity);
+        grpcTrade.setRHash(trade.rHash ? trade.rHash : '');
+        grpcTrade.setMakerOrder(getGrpcOrderFromOrderInstance(makerOrder!));
+        grpcTrade.setTakerOrder(takerOrder ? getGrpcOrderFromOrderInstance(takerOrder) : undefined);
+        grpcTrade.setPairId(makerOrder!.pairId);
+        tradesList.push(grpcTrade);
+      }));
+
+      response.setTradesList(tradesList);
+      callback(null, response);
+    } catch (err) {
+      callback(this.getGrpcError(err), null);
+    }
+  }
+
   /**
    * See [[Service.listPeers]]
    */

lib/orderbook/OrderBook.ts

@@ -200,6 +200,14 @@ class OrderBook extends EventEmitter {
     return currencyInstance ? currencyInstance.toJSON() : undefined;
   }
 
+  /**
+   * Gets all trades or a limited number of trades from the database.
+   */
+  public getTrades = async (limit?: number) => {
+    const response = await this.repository.getTrades(limit);
+    return response;
+  }
+
   /**
    * Get lists of buy and sell orders of peers.
    */

lib/orderbook/OrderBookRepository.ts

@@ -49,6 +49,14 @@ class OrderbookRepository {
   public addTrade = (trade: db.TradeFactory) => {
     return this.models.Trade.create(trade);
   }
+
+  public getTrades = (limit?: number): Bluebird<db.TradeInstance[]> => {
+    if (limit) {
+      return this.models.Trade.findAll({ limit, order: [['createdAt', 'DESC']] });
+    } else {
+      return this.models.Trade.findAll({ order: [['createdAt', 'DESC']] });
+    }
+  }
 }
 
 export default OrderbookRepository;