loop: set swap deadline based on the network (regtest is immediate)

Author: jamaljsr

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

@@ -2,7 +2,6 @@ import { values } from 'mobx';
 import { SwapDirection } from 'types/state';
 import { grpc } from '@improbable-eng/grpc-web';
 import { waitFor } from '@testing-library/react';
-import * as config from 'config';
 import { injectIntoGrpcUnary } from 'util/tests';
 import { BuildSwapStore, createStore, Store } from 'store';
 import { SWAP_ABORT_DELAY } from 'store/stores/buildSwapStore';
@@ -149,8 +148,8 @@ describe('BuildSwapStore', () => {
       deadline = (props.request.toObject() as any).swapPublicationDeadline;
     });
 
-    // run a loop in production and verify the deadline
-    Object.defineProperty(config, 'IS_PROD', { get: () => true });
+    // run a loop on mainnet and verify the deadline
+    rootStore.nodeStore.network = 'mainnet';
     store.requestSwap();
     await waitFor(() => expect(deadline).toBeGreaterThan(0));
 
@@ -159,8 +158,8 @@ describe('BuildSwapStore', () => {
       deadline = (props.request.toObject() as any).swapPublicationDeadline;
     });
 
-    // run a loop NOT in production and verify the deadline
-    Object.defineProperty(config, 'IS_PROD', { get: () => false });
+    // run a loop on regtest and verify the deadline
+    rootStore.nodeStore.network = 'regtest';
     store.requestSwap();
     await waitFor(() => expect(deadline).toEqual(0));
   });

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

@@ -1,7 +1,7 @@
 import { values } from 'mobx';
 import { grpc } from '@improbable-eng/grpc-web';
 import { waitFor } from '@testing-library/react';
-import { lndChannelBalance, lndWalletBalance } from 'util/tests/sampleData';
+import { lndChannelBalance, lndGetInfo, lndWalletBalance } from 'util/tests/sampleData';
 import { createStore, NodeStore, Store } from 'store';
 
 const grpcMock = grpc as jest.Mocked<typeof grpc>;
@@ -15,6 +15,31 @@ describe('NodeStore', () => {
     store = rootStore.nodeStore;
   });
 
+  it('should fetch node info', async () => {
+    expect(store.pubkey).toBe('');
+    expect(store.alias).toBe('');
+    expect(store.chain).toBe('bitcoin');
+    expect(store.network).toBe('mainnet');
+    await store.fetchInfo();
+    expect(store.pubkey).toEqual(lndGetInfo.identityPubkey);
+    expect(store.alias).toEqual(lndGetInfo.alias);
+    expect(store.chain).toEqual(lndGetInfo.chainsList[0].chain);
+    expect(store.network).toEqual(lndGetInfo.chainsList[0].network);
+  });
+
+  it('should handle errors fetching balances', async () => {
+    grpcMock.unary.mockImplementationOnce(desc => {
+      if (desc.methodName === 'GetInfo') throw new Error('test-err');
+      return undefined as any;
+    });
+    expect(rootStore.uiStore.alerts.size).toBe(0);
+    await store.fetchInfo();
+    await waitFor(() => {
+      expect(rootStore.uiStore.alerts.size).toBe(1);
+      expect(values(rootStore.uiStore.alerts)[0].message).toBe('test-err');
+    });
+  });
+
   it('should fetch node balances', async () => {
     expect(store.wallet.channelBalance).toBe(0);
     expect(store.wallet.walletBalance).toBe(0);
@@ -23,7 +48,7 @@ describe('NodeStore', () => {
     expect(store.wallet.walletBalance).toEqual(lndWalletBalance.totalBalance);
   });
 
-  it('should handle errors fetching channels', async () => {
+  it('should handle errors fetching balances', async () => {
     grpcMock.unary.mockImplementationOnce(desc => {
       if (desc.methodName === 'ChannelBalance') throw new Error('test-err');
       return undefined as any;

app/src/api/lnd.ts

@@ -18,6 +18,15 @@ class LndApi {
     this._grpc = grpc;
   }
 
+  /**
+   * call the LND `GetInfo` RPC and return the response
+   */
+  async getInfo(): Promise<LND.GetInfoResponse.AsObject> {
+    const req = new LND.GetInfoRequest();
+    const res = await this._grpc.request(Lightning.GetInfo, req, this._meta);
+    return res.toObject();
+  }
+
   /**
    * call the LND `ChannelBalance` RPC and return the response
    */

app/src/api/loop.ts

@@ -1,7 +1,7 @@
 import * as LOOP from 'types/generated/loop_pb';
 import { SwapClient } from 'types/generated/loop_pb_service';
 import { Quote } from 'types/state';
-import { IS_PROD } from 'config';
+
 import GrpcClient from './grpc';
 
 /**
@@ -89,6 +89,7 @@ class LoopApi {
     amount: number,
     quote: Quote,
     chanIds: number[],
+    deadline: number,
   ): Promise<LOOP.SwapResponse.AsObject> {
     const req = new LOOP.LoopOutRequest();
     req.setAmt(amount);
@@ -98,15 +99,7 @@ class LoopApi {
     req.setMaxSwapRoutingFee(this._calcRoutingFee(quote.swapFee));
     req.setMaxPrepayRoutingFee(this._calcRoutingFee(quote.prepayAmount));
     req.setOutgoingChanSetList(chanIds);
-
-    if (IS_PROD) {
-      // in prod env, push the deadline out for 30 mins for lower fees
-      const thirtyMins = 30 * 60 * 1000;
-      req.setSwapPublicationDeadline(Date.now() + thirtyMins);
-    } else {
-      // use the --fast option in dev env
-      req.setSwapPublicationDeadline(0);
-    }
+    req.setSwapPublicationDeadline(deadline);
 
     const res = await this._grpc.request(SwapClient.LoopOut, req, this._meta);
     return res.toObject();

app/src/store/store.ts

@@ -65,6 +65,7 @@ export class Store {
    */
   async init() {
     this.settingsStore.init();
+    await this.nodeStore.fetchInfo();
     await this.channelStore.fetchChannels();
     await this.swapStore.fetchSwaps();
     await this.nodeStore.fetchBalances();

app/src/store/stores/buildSwapStore.ts

@@ -1,4 +1,5 @@
 import { action, computed, observable, runInAction, toJS, values } from 'mobx';
+import { SwapResponse } from 'types/generated/loop_pb';
 import { BuildSwapSteps, Quote, SwapDirection, SwapTerms } from 'types/state';
 import { formatSats } from 'util/formatters';
 import { Store } from 'store';
@@ -326,11 +327,19 @@ class BuildSwapStore {
     );
     this.processingTimeout = setTimeout(async () => {
       try {
-        const chanIds = this.selectedChanIds.map(v => parseInt(v));
-        const res =
-          direction === SwapDirection.IN
-            ? await this._store.api.loop.loopIn(amount, quote, this.loopInLastHop)
-            : await this._store.api.loop.loopOut(amount, quote, chanIds);
+        let res: SwapResponse.AsObject;
+        if (direction === SwapDirection.IN) {
+          res = await this._store.api.loop.loopIn(amount, quote, this.loopInLastHop);
+        } else {
+          // on regtest, set the publication deadline to 0 for faster swaps, otherwise
+          // set it to 30 minutes in the future to reduce swap fees
+          const thirtyMins = 30 * 60 * 1000;
+          const deadline =
+            this._store.nodeStore.network === 'regtest' ? 0 : Date.now() + thirtyMins;
+          // convert the selected channel ids to numbers
+          const chanIds = this.selectedChanIds.map(v => parseInt(v));
+          res = await this._store.api.loop.loopOut(amount, quote, chanIds, deadline);
+        }
         this._store.log.info('completed loop', toJS(res));
         runInAction('requestSwapContinuation', () => {
           // hide the swap UI after it is complete

app/src/store/stores/nodeStore.ts

@@ -2,16 +2,51 @@ import { action, observable, runInAction, toJS } from 'mobx';
 import { Store } from 'store';
 import { Wallet } from '../models';
 
+type NodeChain = 'bitcoin' | 'litecoin';
+type NodeNetwork = 'mainnet' | 'testnet' | 'regtest';
+
 export default class NodeStore {
   private _store: Store;
 
+  /** the pubkey of the LND node */
+  @observable pubkey = '';
+  /** the alias of the LND node */
+  @observable alias = '';
+  /** the chain that the LND node is connected to */
+  @observable chain: NodeChain = 'bitcoin';
+  /** the network that the LND node is connected to */
+  @observable network: NodeNetwork = 'mainnet';
   /** the channel and wallet balances */
   @observable wallet: Wallet = new Wallet();
 
   constructor(store: Store) {
     this._store = store;
   }
 
+  /**
+   * fetch wallet balances from the LND RPC
+   */
+  @action.bound
+  async fetchInfo() {
+    this._store.log.info('fetching node info');
+    try {
+      const info = await this._store.api.lnd.getInfo();
+      runInAction('getInfoContinuation', () => {
+        this.pubkey = info.identityPubkey;
+        this.alias = info.alias;
+        if (info.chainsList && info.chainsList[0]) {
+          this.chain = info.chainsList[0].chain as NodeChain;
+          this.network = info.chainsList[0].network as NodeNetwork;
+        }
+        this._store.log.info('updated nodeStore info', toJS(this));
+      });
+    } catch (error) {
+      runInAction('getInfoError', () => {
+        this._store.uiStore.notify(error.message, 'Unable to fetch node info');
+      });
+    }
+  }
+
   /**
    * fetch wallet balances from the LND RPC
    */

app/src/util/tests/sampleData.ts

@@ -7,7 +7,7 @@ import * as LOOP from 'types/generated/loop_pb';
 //
 
 export const lndGetInfo: LND.GetInfoResponse.AsObject = {
-  version: '0.9.0-beta commit=v0.9.0-beta',
+  version: '0.10.0-beta commit=v0.10.0-beta',
   identityPubkey: '038b3fc29cfc195c9b190d86ad2d40ce7550a5c6f13941f53c7d7ac5b25c912a6c',
   alias: 'alice',
   color: '#cccccc',