perf(swaps/orderbook): placeOrder parallel swaps

This commit begins all swaps in parallel when placing/matching an order
and retries failed swaps immediately. Any unmatched quantity is tracked
and added to the orderbook (for limit orders) after matching and swaps
are complete. Previously, swaps would execute one at a time and any
failed quantity would wait to be retried until all first-attempt swaps
completed. This should result in significantly faster order execution
for orders that match with multiple peer orders and therefore require
multiple swaps.

Closes #654.

Author: sangaman

lib/orderbook/OrderBook.ts

@@ -288,25 +288,37 @@ class OrderBook extends EventEmitter {
     // perform match. maker orders will be removed from the repository
     const tp = this.getTradingPair(order.pairId);
     const matchingResult = tp.match(order);
-
-    // instantiate the final response object
-    const result: PlaceOrderResult = {
-      internalMatches: [],
-      swapResults: [],
-      remainingOrder: matchingResult.remainingOrder,
+    /** Any portion of the placed order that could not be swapped or matched internally. */
+    let { remainingOrder } = matchingResult;
+    /** Local orders that matched with the placed order. */
+    const internalMatches: OwnOrder[] = [];
+    /** Successful swaps performed for the placed order. */
+    const swapResults: SwapResult[] = [];
+
+    const retryFailedSwap = async (failedSwapQuantity: number) => {
+      this.logger.debug(`repeating matching routine for ${order.id} for failed quantity of ${failedSwapQuantity}`);
+      const orderToRetry: OwnOrder = { ...order, quantity: failedSwapQuantity };
+
+      // invoke placeOrder recursively, append matches/swaps and any remaining order
+      const retryResult = await this.placeOrder(orderToRetry, true, onUpdate, maxTime);
+      internalMatches.push(...retryResult.internalMatches);
+      swapResults.push(...retryResult.swapResults);
+      if (retryResult.remainingOrder) {
+        if (remainingOrder) {
+          remainingOrder.quantity += retryResult.remainingOrder.quantity;
+        } else {
+          remainingOrder = retryResult.remainingOrder;
+        }
+      }
     };
 
-    /** The quantity that was attempted to be swapped but failed. */
-    let failedSwapQuantity = 0;
-
-    // iterate over the matches
-    for (const { maker, taker } of matchingResult.matches) {
+    const handleMatch = async (maker: Order, taker: OwnOrder) => {
       const portion: OrderPortion = { id: maker.id, pairId: maker.pairId, quantity: maker.quantity };
       if (isOwnOrder(maker)) {
         // internal match
         this.logger.info(`internal match executed on taker ${taker.id} and maker ${maker.id} for ${maker.quantity}`);
         portion.localId = maker.localId;
-        result.internalMatches.push(maker);
+        internalMatches.push(maker);
         this.emit('ownOrder.filled', portion);
         await this.persistTrade(portion.quantity, maker, taker);
         onUpdate && onUpdate({ type: PlaceOrderEventType.InternalMatch, payload: maker });
@@ -315,8 +327,7 @@ class OrderBook extends EventEmitter {
           // swaps should only be undefined during integration testing of the order book
           // for now we treat this case like a swap failure
           this.emit('peerOrder.invalidation', portion);
-          failedSwapQuantity += portion.quantity;
-          continue;
+          return;
         }
 
         try {
@@ -327,43 +338,39 @@ class OrderBook extends EventEmitter {
             // swap was only partially completed
             portion.quantity = swapResult.quantity;
             const rejectedQuantity = maker.quantity - swapResult.quantity;
-            failedSwapQuantity += rejectedQuantity; // add unswapped quantity to failed quantity
             this.logger.info(`match partially executed on taker ${taker.id} and maker ${maker.id} for ${swapResult.quantity} ` +
               `with peer ${maker.peerPubKey}, ${rejectedQuantity} quantity not accepted and will repeat matching routine`);
+            await retryFailedSwap(rejectedQuantity);
           } else {
             this.logger.info(`match executed on taker ${taker.id} and maker ${maker.id} for ${maker.quantity} with peer ${maker.peerPubKey}`);
           }
-          result.swapResults.push(swapResult);
+          swapResults.push(swapResult);
           onUpdate && onUpdate({ type: PlaceOrderEventType.SwapSuccess, payload: swapResult });
         } catch (err) {
-          failedSwapQuantity += portion.quantity;
-          onUpdate && onUpdate({ type: PlaceOrderEventType.SwapFailure, payload: maker });
           this.logger.warn(`swap for ${portion.quantity} failed during order matching, will repeat matching routine for failed swap quantity`);
+          onUpdate && onUpdate({ type: PlaceOrderEventType.SwapFailure, payload: maker });
+          await retryFailedSwap(portion.quantity);
         }
       }
-    }
-
-    // if we have swap failures, attempt one retry for all available quantity. don't re-add the maker orders
-    if (failedSwapQuantity > 0) {
-      this.logger.debug(`${failedSwapQuantity} quantity of swaps failed for order ${order.id}, repeating matching routine for failed quantity`);
-      // aggregate failures quantities with the remaining order
-      const remainingOrder: OwnOrder = result.remainingOrder || { ...order, quantity: 0 };
-      remainingOrder.quantity += failedSwapQuantity;
+    };
 
-      // invoke placeOrder recursively, append matches/swaps and set the consecutive remaining order
-      const remainingOrderResult = await this.placeOrder(remainingOrder, true, onUpdate, maxTime);
-      result.internalMatches.push(...remainingOrderResult.internalMatches);
-      result.swapResults.push(...remainingOrderResult.swapResults);
-      result.remainingOrder = remainingOrderResult.remainingOrder;
+    // iterate over the matches
+    const matchPromises: Promise<void>[] = [];
+    for (const { maker, taker } of matchingResult.matches) {
+      matchPromises.push(handleMatch(maker, taker));
     }
+    await Promise.all(matchPromises);
 
-    const { remainingOrder } = result;
     if (remainingOrder && !discardRemaining) {
       this.addOwnOrder(remainingOrder);
       onUpdate && onUpdate({ type: PlaceOrderEventType.RemainingOrder, payload: remainingOrder });
     }
 
-    return result;
+    return {
+      internalMatches,
+      swapResults,
+      remainingOrder,
+    };
   }
 
   /**