loop: add swap params for conf target and dest addr

Author: jamaljsr

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

@@ -5,7 +5,7 @@ import { waitFor } from '@testing-library/react';
 import Big from 'big.js';
 import { BalanceMode } from 'util/constants';
 import { injectIntoGrpcUnary } from 'util/tests';
-import { lndChannel, loopInTerms } from 'util/tests/sampleData';
+import { lndChannel, loopInTerms, loopOutTerms } from 'util/tests/sampleData';
 import { BuildSwapStore, createStore, Store } from 'store';
 import { Channel } from 'store/models';
 import { SWAP_ABORT_DELAY } from 'store/stores/buildSwapStore';
@@ -83,7 +83,12 @@ describe('BuildSwapStore', () => {
     expect(store.terms.out).toEqual({ min: Big(0), max: Big(0) });
     await store.getTerms();
     expect(store.terms.in).toEqual({ min: Big(250000), max: Big(1000000) });
-    expect(store.terms.out).toEqual({ min: Big(250000), max: Big(1000000) });
+    expect(store.terms.out).toEqual({
+      min: Big(250000),
+      max: Big(1000000),
+      minCltv: 20,
+      maxCltv: 60,
+    });
   });
 
   it('should handle errors fetching loop terms', async () => {
@@ -116,6 +121,68 @@ describe('BuildSwapStore', () => {
     expect(+store.amountForSelected).toBe(loopInTerms.maxSwapAmount);
   });
 
+  it('should validate the conf target', async () => {
+    const { minCltvDelta, maxCltvDelta } = loopOutTerms;
+    expect(store.confTarget).toBeUndefined();
+
+    let target = maxCltvDelta - 10;
+    store.setConfTarget(target);
+    expect(store.confTarget).toBe(target);
+
+    store.setDirection(SwapDirection.OUT);
+    await store.getTerms();
+
+    store.setConfTarget(target);
+    expect(store.confTarget).toBe(target);
+
+    target = minCltvDelta - 10;
+    expect(() => store.setConfTarget(target)).toThrow();
+
+    target = maxCltvDelta + 10;
+    expect(() => store.setConfTarget(target)).toThrow();
+  });
+
+  it('should submit the Loop Out conf target', async () => {
+    const target = 23;
+    store.setDirection(SwapDirection.OUT);
+    store.setAmount(Big(500000));
+
+    expect(store.confTarget).toBeUndefined();
+    store.setConfTarget(target);
+    expect(store.confTarget).toBe(target);
+
+    let reqTarget = '';
+    // mock the grpc unary function in order to capture the supplied dest
+    // passed in with the API request
+    injectIntoGrpcUnary((desc, props) => {
+      reqTarget = (props.request.toObject() as any).sweepConfTarget;
+    });
+
+    store.requestSwap();
+    await waitFor(() => expect(reqTarget).toBe(target));
+  });
+
+  it('should submit the Loop Out address', async () => {
+    const addr = 'xyzabc';
+    store.setDirection(SwapDirection.OUT);
+    store.setAmount(Big(500000));
+
+    expect(store.loopOutAddress).toBeUndefined();
+    store.setLoopOutAddress(addr);
+    expect(store.loopOutAddress).toBe(addr);
+    // store.goToNextStep();
+
+    let reqAddr = '';
+    // mock the grpc unary function in order to capture the supplied dest
+    // passed in with the API request
+    injectIntoGrpcUnary((desc, props) => {
+      reqAddr = (props.request.toObject() as any).dest;
+    });
+
+    store.requestSwap();
+    await waitFor(() => expect(reqAddr).toBe(addr));
+  });
+
   it('should select all channels with the same peer for loop in', () => {
     const channels = rootStore.channelStore.sortedChannels;
     channels[1].remotePubkey = channels[0].remotePubkey;

app/src/api/loop.ts

@@ -51,19 +51,27 @@ class LoopApi extends BaseApi<LoopEvents> {
   /**
    * call the Loop `GetLoopInQuote` RPC and return the response
    */
-  async getLoopInQuote(amount: Big): Promise<LOOP.InQuoteResponse.AsObject> {
+  async getLoopInQuote(
+    amount: Big,
+    confTarget?: number,
+  ): Promise<LOOP.InQuoteResponse.AsObject> {
     const req = new LOOP.QuoteRequest();
     req.setAmt(+amount);
+    if (confTarget) req.setConfTarget(confTarget);
     const res = await this._grpc.request(SwapClient.GetLoopInQuote, req, this._meta);
     return res.toObject();
   }
 
   /**
    * call the Loop `LoopOutQuote` RPC and return the response
    */
-  async getLoopOutQuote(amount: Big): Promise<LOOP.OutQuoteResponse.AsObject> {
+  async getLoopOutQuote(
+    amount: Big,
+    confTarget?: number,
+  ): Promise<LOOP.OutQuoteResponse.AsObject> {
     const req = new LOOP.QuoteRequest();
     req.setAmt(+amount);
+    if (confTarget) req.setConfTarget(confTarget);
     const res = await this._grpc.request(SwapClient.LoopOutQuote, req, this._meta);
     return res.toObject();
   }
@@ -75,12 +83,14 @@ class LoopApi extends BaseApi<LoopEvents> {
     amount: Big,
     quote: Quote,
     lastHop?: string,
+    confTarget?: number,
   ): Promise<LOOP.SwapResponse.AsObject> {
     const req = new LOOP.LoopInRequest();
     req.setAmt(+amount);
     req.setMaxSwapFee(+quote.swapFee);
     req.setMaxMinerFee(+quote.minerFee);
     if (lastHop) req.setLastHop(Buffer.from(lastHop, 'hex').toString('base64'));
+    if (confTarget) req.setHtlcConfTarget(confTarget);
     const res = await this._grpc.request(SwapClient.LoopIn, req, this._meta);
     return res.toObject();
   }
@@ -93,6 +103,8 @@ class LoopApi extends BaseApi<LoopEvents> {
     quote: Quote,
     chanIds: number[],
     deadline: number,
+    confTarget?: number,
+    destAddress?: string,
   ): Promise<LOOP.SwapResponse.AsObject> {
     const req = new LOOP.LoopOutRequest();
     req.setAmt(+amount);
@@ -103,6 +115,8 @@ class LoopApi extends BaseApi<LoopEvents> {
     req.setMaxPrepayRoutingFee(this._calcRoutingFee(+quote.prepayAmount));
     req.setOutgoingChanSetList(chanIds);
     req.setSwapPublicationDeadline(deadline);
+    if (confTarget) req.setSweepConfTarget(confTarget);
+    if (destAddress) req.setDest(destAddress);
 
     const res = await this._grpc.request(SwapClient.LoopOut, req, this._meta);
     return res.toObject();

app/src/store/stores/buildSwapStore.ts

@@ -35,6 +35,12 @@ class BuildSwapStore {
   /** the amount to swap */
   @observable amount: Big = Big(0);
 
+  /** the confirmation target of the on-chain txn used in the swap */
+  @observable confTarget?: number;
+
+  /** the on-chain address to send funds to during a loop out swap */
+  @observable loopOutAddress?: string;
+
   /** the min/max amount this node is allowed to swap */
   @observable terms: SwapTerms = {
     in: { min: Big(0), max: Big(0) },
@@ -302,6 +308,38 @@ class BuildSwapStore {
     this.amount = amount;
   }
 
+  /**
+   * Set the confirmation target for the swap
+   */
+  @action.bound
+  setConfTarget(target?: number) {
+    // ensure the Loop Out target is between the CLTV min & max
+    if (
+      this.direction === SwapDirection.OUT &&
+      this.terms.out.minCltv &&
+      this.terms.out.maxCltv &&
+      target !== undefined &&
+      (isNaN(target) ||
+        this.terms.out.minCltv > target ||
+        this.terms.out.maxCltv < target)
+    ) {
+      throw new Error(
+        `Confirmation target must be between ${this.terms.out.minCltv} and ${this.terms.out.maxCltv}.`,
+      );
+    }
+    this.confTarget = target;
+    this._store.log.info(`updated buildSwapStore.confTarget`, this.confTarget);
+  }
+
+  /**
+   * Set the on-chain destination address for the loop out swap
+   */
+  @action.bound
+  setLoopOutAddress(address: string) {
+    this.loopOutAddress = address;
+    this._store.log.info(`updated buildSwapStore.loopOutAddress`, this.loopOutAddress);
+  }
+
   /**
    * Navigate to the next step in the wizard
    */
@@ -340,6 +378,8 @@ class BuildSwapStore {
     this.currentStep = BuildSwapSteps.Closed;
     this.selectedChanIds = [];
     this.amount = Big(0);
+    this.confTarget = undefined;
+    this.loopOutAddress = undefined;
     this.quote.swapFee = Big(0);
     this.quote.minerFee = Big(0);
     this.quote.prepayAmount = Big(0);
@@ -364,6 +404,8 @@ class BuildSwapStore {
           out: {
             min: Big(outTerms.minSwapAmount),
             max: Big(outTerms.maxSwapAmount),
+            minCltv: outTerms.minCltvDelta,
+            maxCltv: outTerms.maxCltvDelta,
           },
         };
         this._store.log.info('updated store.terms', toJS(this.terms));
@@ -385,14 +427,20 @@ class BuildSwapStore {
     try {
       let quote: Quote;
       if (direction === SwapDirection.IN) {
-        const inQuote = await this._store.api.loop.getLoopInQuote(amount);
+        const inQuote = await this._store.api.loop.getLoopInQuote(
+          amount,
+          this.confTarget,
+        );
         quote = {
           swapFee: Big(inQuote.swapFeeSat),
           minerFee: Big(inQuote.htlcPublishFeeSat),
           prepayAmount: Big(0),
         };
       } else {
-        const outQuote = await this._store.api.loop.getLoopOutQuote(amount);
+        const outQuote = await this._store.api.loop.getLoopOutQuote(
+          amount,
+          this.confTarget,
+        );
         quote = {
           swapFee: Big(outQuote.swapFeeSat),
           minerFee: Big(outQuote.htlcSweepFeeSat),
@@ -430,7 +478,12 @@ class BuildSwapStore {
       try {
         let res: SwapResponse.AsObject;
         if (direction === SwapDirection.IN) {
-          res = await this._store.api.loop.loopIn(amount, quote, this.loopInLastHop);
+          res = await this._store.api.loop.loopIn(
+            amount,
+            quote,
+            this.loopInLastHop,
+            this.confTarget,
+          );
           // save the channels that were used in the swap. for Loop In all channels
           // with the same peer will be used
           this._store.swapStore.addSwappedChannels(res.id, this.selectedChanIds);
@@ -442,7 +495,14 @@ class BuildSwapStore {
             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);
+          res = await this._store.api.loop.loopOut(
+            amount,
+            quote,
+            chanIds,
+            deadline,
+            this.confTarget,
+            this.loopOutAddress,
+          );
           // save the channels that were used in the swap
           this._store.swapStore.addSwappedChannels(res.id, this.selectedChanIds);
         }

app/src/types/state.ts

@@ -19,6 +19,8 @@ export interface SwapTerms {
   out: {
     min: Big;
     max: Big;
+    minCltv?: number;
+    maxCltv?: number;
   };
 }