feat(rpc): add failureReason to SwapFailure msg

This specifies the `SwapFailureReason` for each `SwapFailure` message
sent in gRPC responses.

Closes #807.

lib/cli/utils.ts

@@ -80,12 +80,13 @@ export const orderHandler = (argv: Arguments, isSell = false) => {
 };
 
 const formatPlaceOrderOutput = (response: PlaceOrderResponse.AsObject) => {
-  const { internalMatchesList, swapSuccessesList, remainingOrder } = response;
-  if (internalMatchesList.length === 0 && swapSuccessesList.length === 0) {
+  const { internalMatchesList, swapSuccessesList, swapFailuresList, remainingOrder } = response;
+  if (internalMatchesList.length === 0 && swapSuccessesList.length === 0 && swapFailuresList.length === 0) {
     console.log('no matches found');
   } else {
     internalMatchesList.forEach(formatInternalMatch);
     swapSuccessesList.forEach(formatSwapSuccess);
+    swapFailuresList.forEach(formatSwapFailure);
   }
   if (remainingOrder) {
     formatRemainingOrder(remainingOrder);

lib/constants/enums.ts

@@ -101,6 +101,8 @@ export enum SwapFailureReason {
   SwapTimedOut = 10,
   /** The deal timed out while we were waiting for the peer to respond to our swap request. */
   DealTimedOut = 11,
+  /** The swap failed due to an unrecognized error. */
+  UnknownError = 12,
 }
 
 export enum DisconnectionReason {

lib/grpc/GrpcService.ts

@@ -10,7 +10,7 @@ import { errorCodes as serviceErrorCodes } from '../service/errors';
 import { errorCodes as p2pErrorCodes } from '../p2p/errors';
 import { errorCodes as lndErrorCodes } from '../lndclient/errors';
 import { LndInfo } from '../lndclient/LndClient';
-import { SwapSuccess } from '../swaps/types';
+import { SwapSuccess, SwapFailure } from '../swaps/types';
 import { SwapFailureReason } from '../constants/enums';
 
 /**
@@ -57,15 +57,16 @@ const createSwapSuccess = (result: SwapSuccess) => {
 };
 
 /**
- * Creates an xudrpc SwapFailure message from a [[PeerOrder]] that could not be swapped.
+ * Creates an xudrpc SwapFailure message from a [[SwapFailure]].
  */
-const createSwapFailure = (order: PeerOrder) => {
-  const swapFailure = new xudrpc.SwapFailure();
-  swapFailure.setOrderId(order.id);
-  swapFailure.setPairId(order.pairId);
-  swapFailure.setPeerPubKey(order.peerPubKey);
-  swapFailure.setQuantity(order.quantity);
-  return swapFailure;
+const createSwapFailure = (swapFailure: SwapFailure) => {
+  const grpcSwapFailure = new xudrpc.SwapFailure();
+  grpcSwapFailure.setOrderId(swapFailure.orderId);
+  grpcSwapFailure.setPairId(swapFailure.pairId);
+  grpcSwapFailure.setPeerPubKey(swapFailure.peerPubKey);
+  grpcSwapFailure.setQuantity(swapFailure.quantity);
+  grpcSwapFailure.setFailureReason(SwapFailureReason[swapFailure.failureReason]);
+  return grpcSwapFailure;
 };
 
 /**
@@ -106,7 +107,7 @@ const createPlaceOrderEvent = (e: PlaceOrderEvent) => {
       placeOrderEvent.setRemainingOrder(createOrder(e.payload as Order));
       break;
     case PlaceOrderEventType.SwapFailure:
-      placeOrderEvent.setSwapFailure(createSwapFailure(e.payload as PeerOrder));
+      placeOrderEvent.setSwapFailure(createSwapFailure(e.payload as SwapFailure));
       break;
   }
   return placeOrderEvent;
@@ -323,6 +324,7 @@ class GrpcService {
             code = status.FAILED_PRECONDITION;
             break;
           case SwapFailureReason.UnexpectedLndError:
+          case SwapFailureReason.UnknownError:
           default:
             code = status.UNKNOWN;
             break;

lib/orderbook/OrderBook.ts

@@ -15,7 +15,7 @@ import { CurrencyInstance, PairInstance, CurrencyFactory } from '../db/types';
 import { Pair, OrderIdentifier, OwnOrder, OrderPortion, OwnLimitOrder, PeerOrder, Order, PlaceOrderEvent,
   PlaceOrderEventType, PlaceOrderResult, OutgoingOrder, OwnMarketOrder, isOwnOrder, IncomingOrder } from './types';
 import { SwapRequestPacket, SwapFailedPacket } from '../p2p/packets';
-import { SwapSuccess, SwapDeal } from '../swaps/types';
+import { SwapSuccess, SwapDeal, SwapFailure } from '../swaps/types';
 import Bluebird from 'bluebird';
 
 interface OrderBook {
@@ -309,7 +309,7 @@ class OrderBook extends EventEmitter {
     /** Successful swaps performed for the placed order. */
     const swapSuccesses: SwapSuccess[] = [];
     /** Failed swaps attempted for the placed order. */
-    const swapFailures: PeerOrder[] = [];
+    const swapFailures: SwapFailure[] = [];
 
     /**
      * The routine for retrying a portion of the order that failed a swap attempt.
@@ -374,14 +374,26 @@ class OrderBook extends EventEmitter {
           onUpdate && onUpdate({ type: PlaceOrderEventType.SwapSuccess, payload: swapResult });
         } catch (err) {
           const failMsg = `swap for ${portion.quantity} failed during order matching`;
+          let failureReason: SwapFailureReason;
           if (typeof err === 'number') {
             // treat the error as a SwapFailureReason
             this.logger.warn(`${failMsg} due to ${SwapFailureReason[err]}, will repeat matching routine for failed quantity`);
+            failureReason = err;
           } else {
-            this.logger.error(`${failMsg}, will repeat matching routine for failed quantity`, err);
+            this.logger.error(`${failMsg} due to unexpected error, will repeat matching routine for failed quantity`, err);
+            failureReason = SwapFailureReason.UnknownError;
+            throw err;
           }
-          swapFailures.push(maker);
-          onUpdate && onUpdate({ type: PlaceOrderEventType.SwapFailure, payload: maker });
+
+          const swapFailure: SwapFailure = {
+            failureReason,
+            orderId: maker.id,
+            pairId: maker.pairId,
+            quantity: portion.quantity,
+            peerPubKey: maker.peerPubKey,
+          };
+          swapFailures.push(swapFailure);
+          onUpdate && onUpdate({ type: PlaceOrderEventType.SwapFailure, payload: swapFailure });
           await retryFailedSwap(portion.quantity);
         }
       }

lib/orderbook/types.ts

@@ -1,5 +1,5 @@
 import { SwapClients } from '../constants/enums';
-import { SwapSuccess } from 'lib/swaps/types';
+import { SwapSuccess, SwapFailure } from 'lib/swaps/types';
 
 export type OrderMatch = {
   maker: Order;
@@ -14,13 +14,13 @@ export type MatchingResult = {
 export type PlaceOrderResult = {
   internalMatches: OwnOrder[];
   swapSuccesses: SwapSuccess[];
-  swapFailures: PeerOrder[];
+  swapFailures: SwapFailure[];
   remainingOrder?: OwnOrder;
 };
 
 export type PlaceOrderEvent = {
   type: PlaceOrderEventType;
-  payload: OwnOrder | SwapSuccess | PeerOrder;
+  payload: OwnOrder | SwapSuccess | SwapFailure;
 };
 
 export enum PlaceOrderEventType {

lib/swaps/types.ts

@@ -68,3 +68,9 @@ export type SwapSuccess = Pick<SwapDeal, 'orderId' | 'localId' | 'pairId' | 'rHa
   /** The quantity that was swapped. */
   quantity: number;
 };
+
+export type SwapFailure = Pick<SwapDeal, 'orderId' | 'pairId' | 'quantity' | 'peerPubKey' > & {
+  /** The quantity that was attempted and failed for the swap. */
+  quantity: number;
+  failureReason: SwapFailureReason;
+};

proto/xudrpc.proto

@@ -304,6 +304,8 @@ message SwapFailure {
   double quantity = 3 [json_name = "quantity"];
   // The node pub key of the peer that we attempted to swap with.
   string peer_pub_key = 4 [json_name = "peer_pub_key"];
+  // The reason why the swap failed.
+  string failure_reason = 5 [json_name = "failure_reason"];
 }
 
 message GetInfoRequest {}