swap: infer swap direction based on balance mode

Author: jamaljsr

app/src/__tests__/store/buildSwapStore.spec.ts

@@ -3,6 +3,7 @@ import { BuildSwapSteps, SwapDirection } from 'types/state';
 import { grpc } from '@improbable-eng/grpc-web';
 import { waitFor } from '@testing-library/react';
 import Big from 'big.js';
+import { BalanceMode } from 'util/constants';
 import { injectIntoGrpcUnary } from 'util/tests';
 import { lndChannel, loopTerms } from 'util/tests/sampleData';
 import { BuildSwapStore, createStore, Store } from 'store';
@@ -38,12 +39,43 @@ describe('BuildSwapStore', () => {
     expect(store.selectedChanIds).toHaveLength(0);
   });
 
-  it('should infer the swap direction based on the selected channels', () => {
+  it('should infer the swap direction based on the selected channels (receiving mode)', () => {
+    rootStore.settingsStore.setBalanceMode(BalanceMode.receive);
     const channels = rootStore.channelStore.sortedChannels;
     store.toggleSelectedChannel(channels[0].chanId);
     expect(store.inferredDirection).toEqual(SwapDirection.OUT);
     store.toggleSelectedChannel(channels[channels.length - 1].chanId);
+    expect(store.inferredDirection).toEqual(SwapDirection.OUT);
+  });
+
+  it('should infer the swap direction based on the selected channels (sending mode)', () => {
+    rootStore.settingsStore.setBalanceMode(BalanceMode.send);
+    const channels = rootStore.channelStore.sortedChannels;
+    store.toggleSelectedChannel(channels[0].chanId);
+    expect(store.inferredDirection).toEqual(SwapDirection.IN);
+    store.toggleSelectedChannel(channels[channels.length - 1].chanId);
+    expect(store.inferredDirection).toEqual(SwapDirection.IN);
+  });
+
+  it('should infer the swap direction based on the selected channels (routing mode)', () => {
+    rootStore.settingsStore.setBalanceMode(BalanceMode.routing);
+    const channels = rootStore.channelStore.sortedChannels;
+    let c = channels[0];
+    c.localBalance = c.capacity.mul(0.2);
+    c.remoteBalance = c.capacity.sub(c.localBalance);
+    store.toggleSelectedChannel(c.chanId);
     expect(store.inferredDirection).toEqual(SwapDirection.IN);
+
+    c = channels[channels.length - 1];
+    c.localBalance = c.capacity.mul(0.85);
+    c.remoteBalance = c.capacity.sub(c.localBalance);
+    store.toggleSelectedChannel(channels[channels.length - 1].chanId);
+    expect(store.inferredDirection).toEqual(SwapDirection.OUT);
+  });
+
+  it('should not infer the swap direction with no selected channels (routing mode)', () => {
+    rootStore.settingsStore.setBalanceMode(BalanceMode.routing);
+    expect(store.inferredDirection).toBeUndefined();
   });
 
   it('should fetch loop terms', async () => {

app/src/store/stores/buildSwapStore.ts

@@ -3,6 +3,7 @@ import { SwapResponse } from 'types/generated/loop_pb';
 import { BuildSwapSteps, Quote, SwapDirection, SwapTerms } from 'types/state';
 import Big from 'big.js';
 import { percentage } from 'util/bigmath';
+import { BalanceMode } from 'util/constants';
 import { formatSats } from 'util/formatters';
 import { prefixTranslation } from 'util/translate';
 import { Store } from 'store';
@@ -134,17 +135,29 @@ class BuildSwapStore {
   /** infer a swap direction based on the selected channels */
   @computed
   get inferredDirection(): SwapDirection | undefined {
-    if (this.selectedChanIds.length === 0) return undefined;
-
-    // calculate the average local balance percent
-    const percents = values(this._store.channelStore.channels)
-      .filter(c => this.selectedChanIds.includes(c.chanId))
-      .map(c => c.localPercent);
-    const sum = percents.reduce((s, p) => s + p, 0);
-    const avgPct = sum / percents.length;
-
-    // if the average is low, suggest Loop In. Otherwise, suggest Loop Out
-    return avgPct < 50 ? SwapDirection.IN : SwapDirection.OUT;
+    const mode = this._store.settingsStore.balanceMode;
+    switch (mode) {
+      case BalanceMode.routing:
+        // unable to infer a direction with no selection
+        if (this.selectedChanIds.length === 0) return undefined;
+
+        // calculate the average local balance percent
+        const percents = values(this._store.channelStore.channels)
+          .filter(c => this.selectedChanIds.includes(c.chanId))
+          .map(c => c.localPercent);
+        const sum = percents.reduce((s, p) => s + p, 0);
+        const avgPct = sum / percents.length;
+
+        // if the average is low, suggest Loop In. Otherwise, suggest Loop Out
+        return avgPct < 50 ? SwapDirection.IN : SwapDirection.OUT;
+      case BalanceMode.send:
+        // always infer Loop In when using Sending mode
+        return SwapDirection.IN;
+      case BalanceMode.receive:
+      default:
+        // always suggest Loop Out when using Receiving mode
+        return SwapDirection.OUT;
+    }
   }
 
   /**