fix(swaps): don't retry verified currency sanity

This modifies the logic for determining which currencies to perform
sanity swaps for. Previously, if a sanity swap failed for either
currency in a trading pair, when that trading pair was retried we would
retry sanity swaps for both currencies in the pair including the one
that worked previously. This change tracks currencies for which we
have had a successful sanity swap for and prevents retrying sanity
swaps for that currency - until we encounter an error that deactivates
a trading pair that includes that currency.

Fixes #946.

lib/orderbook/OrderBook.ts

@@ -702,41 +702,42 @@ class OrderBook extends EventEmitter {
     const currenciesToVerify = new Set<string>();
     pairIds.forEach((pairId) => {
       const [baseCurrency, quoteCurrency] = pairId.split('/');
-      currenciesToVerify.add(baseCurrency);
-      currenciesToVerify.add(quoteCurrency);
+      if (!peer.verifiedCurrencies.has(baseCurrency)) {
+        currenciesToVerify.add(baseCurrency);
+      }
+      if (!peer.verifiedCurrencies.has(quoteCurrency)) {
+        currenciesToVerify.add(quoteCurrency);
+      }
     });
 
-    const verifiedCurrencies = new Set<string>();
     const verifiedPairs: string[] = [];
     const sanitySwapPromises: Promise<void>[] = [];
 
-    if (this.swaps) {
-      // Set a time limit for all sanity swaps to complete.
-      const sanitySwapTimeout = setTimeoutPromise(OrderBook.MAX_SANITY_SWAP_TIME, false);
-
-      currenciesToVerify.forEach((currency) => {
-        if (this.currencyInstances.has(currency)) {
-          // perform sanity swaps for each of the currencies that we support
-          const sanitySwapPromise = new Promise<void>(async (resolve) => {
-            // success resolves to true if the sanity swap succeeds before the timeout
-            const success = await Promise.race([this.swaps!.executeSanitySwap(currency, peer), sanitySwapTimeout]);
-            if (success) {
-              verifiedCurrencies.add(currency);
-            }
-            resolve();
-          });
-          sanitySwapPromises.push(sanitySwapPromise);
-        }
-      });
-    }
+    // Set a time limit for all sanity swaps to complete.
+    const sanitySwapTimeout = setTimeoutPromise(OrderBook.MAX_SANITY_SWAP_TIME, false);
+
+    currenciesToVerify.forEach((currency) => {
+      if (this.currencyInstances.has(currency)) {
+        // perform sanity swaps for each of the currencies that we support
+        const sanitySwapPromise = new Promise<void>(async (resolve) => {
+          // success resolves to true if the sanity swap succeeds before the timeout
+          const success = await Promise.race([this.swaps!.executeSanitySwap(currency, peer), sanitySwapTimeout]);
+          if (success) {
+            peer.verifiedCurrencies.add(currency);
+          }
+          resolve();
+        });
+        sanitySwapPromises.push(sanitySwapPromise);
+      }
+    });
 
     // wait for all sanity swaps to finish or timeout
     await Promise.all(sanitySwapPromises);
 
     // activate pairs that have had both currencies verified
     pairIds.forEach(async (pairId) => {
       const [baseCurrency, quoteCurrency] = pairId.split('/');
-      if (verifiedCurrencies.has(baseCurrency) && verifiedCurrencies.has(quoteCurrency)) {
+      if (peer.verifiedCurrencies.has(baseCurrency) && peer.verifiedCurrencies.has(quoteCurrency)) {
         peer.activePairs.add(pairId);
         verifiedPairs.push(pairId);
       }

lib/p2p/Peer.ts

@@ -66,6 +66,8 @@ class Peer extends EventEmitter {
   public discoverTimer?: NodeJS.Timer;
   /** Trading pairs advertised by this peer which we have verified that we can swap. */
   public activePairs = new Set<string>();
+  /** Currencies that we have verified that we can swap with for this peer. */
+  public verifiedCurrencies = new Set<string>();
   /** Whether we have received and authenticated a [[SessionInitPacket]] from the peer. */
   private opened = false;
   private opening = false;
@@ -341,6 +343,9 @@ class Peer extends EventEmitter {
       throw new Error('cannot deactivate a trading pair before handshake is complete');
     }
     if (this.activePairs.delete(pairId)) {
+      const [baseCurrency, quoteCurrency] = pairId.split('/');
+      this.verifiedCurrencies.delete(baseCurrency);
+      this.verifiedCurrencies.delete(quoteCurrency);
       this.emit('pairDropped', pairId);
     }
     // TODO: notify peer that we have deactivated this pair?