Merge pull request #86 from guggero/external-loop-in-fee-est

loopd: don't fail external loop in on fee estimation failure

Author: alexbosworth

client.go

@@ -470,6 +470,15 @@ func (s *Client) LoopInQuote(ctx context.Context,
 		request.Amount*btcutil.Amount(terms.SwapFeeRate)/
 			btcutil.Amount(swap.FeeRateTotalParts)
 
+	// We don't calculate the on-chain fee if the HTLC is going to be
+	// published externally.
+	if request.ExternalHtlc {
+		return &LoopInQuote{
+			SwapFee:  swapFee,
+			MinerFee: 0,
+		}, nil
+	}
+	
 	// Get estimate for miner fee.
 	minerFee, err := s.lndServices.Client.EstimateFeeToP2WSH(
 		ctx, request.Amount, request.HtlcConfTarget,

cmd/loop/loopin.go

@@ -56,27 +56,29 @@ func loopIn(ctx *cli.Context) error {
 	}
 	defer cleanup()
 
+	external := ctx.Bool("external")
 	quote, err := client.GetLoopInQuote(
 		context.Background(),
 		&looprpc.QuoteRequest{
-			Amt: int64(amt),
+			Amt:          int64(amt),
+			ExternalHtlc: external,
 		},
 	)
 	if err != nil {
 		return err
 	}
 
 	limits := getInLimits(amt, quote)
-
-	if err := displayLimits(loop.TypeIn, amt, limits); err != nil {
+	err = displayLimits(loop.TypeIn, amt, limits, external)
+	if err != nil {
 		return err
 	}
 
 	resp, err := client.LoopIn(context.Background(), &looprpc.LoopInRequest{
 		Amt:          int64(amt),
 		MaxMinerFee:  int64(limits.maxMinerFee),
 		MaxSwapFee:   int64(limits.maxSwapFee),
-		ExternalHtlc: ctx.Bool("external"),
+		ExternalHtlc: external,
 	})
 	if err != nil {
 		return err

cmd/loop/loopout.go

@@ -94,7 +94,7 @@ func loopOut(ctx *cli.Context) error {
 
 	limits := getLimits(amt, quote)
 
-	if err := displayLimits(loop.TypeOut, amt, limits); err != nil {
+	if err := displayLimits(loop.TypeOut, amt, limits, false); err != nil {
 		return err
 	}
 

cmd/loop/main.go

@@ -116,14 +116,23 @@ func getLimits(amt btcutil.Amount, quote *looprpc.QuoteResponse) *limits {
 	}
 }
 
-func displayLimits(swapType loop.Type, amt btcutil.Amount, l *limits) error {
+func displayLimits(swapType loop.Type, amt btcutil.Amount, l *limits,
+	externalHtlc bool) error {
+
 	totalSuccessMax := l.maxMinerFee + l.maxSwapFee
 	if l.maxSwapRoutingFee != nil {
 		totalSuccessMax += *l.maxSwapRoutingFee
 	}
 	if l.maxPrepayRoutingFee != nil {
 		totalSuccessMax += *l.maxPrepayRoutingFee
 	}
+	
+	if swapType == loop.TypeIn && externalHtlc {
+		fmt.Printf("On-chain fee for external loop in is not " +
+			"included.\nSufficient fees will need to be paid " +
+			"when constructing the transaction in the external " +
+			"wallet.\n\n")
+	}
 
 	fmt.Printf("Max swap fees for %d Loop %v: %d\n",
 		btcutil.Amount(amt), swapType, totalSuccessMax,
@@ -139,7 +148,10 @@ func displayLimits(swapType loop.Type, amt btcutil.Amount, l *limits) error {
 		return nil
 	case "x":
 		fmt.Println()
-		fmt.Printf("Max on-chain fee:                 %d\n", l.maxMinerFee)
+		if swapType != loop.TypeIn || !externalHtlc {
+			fmt.Printf("Max on-chain fee:                 %d\n",
+				l.maxMinerFee)
+		}
 
 		if l.maxSwapRoutingFee != nil {
 			fmt.Printf("Max off-chain swap routing fee:   %d\n",

cmd/loopd/swapclient_server.go

@@ -306,6 +306,7 @@ func (s *swapClientServer) GetLoopInQuote(ctx context.Context,
 	quote, err := s.impl.LoopInQuote(ctx, &loop.LoopInQuoteRequest{
 		Amount:         btcutil.Amount(req.Amt),
 		HtlcConfTarget: defaultConfTarget,
+		ExternalHtlc:   req.ExternalHtlc,
 	})
 	if err != nil {
 		return nil, err

interface.go

@@ -224,6 +224,10 @@ type LoopInQuoteRequest struct {
 	// HtlcConfTarget specifies the targeted confirmation target for the
 	// client sweep tx.
 	HtlcConfTarget int32
+
+	// ExternalHtlc specifies whether the htlc is published by an external
+	// source.
+	ExternalHtlc bool
 }
 
 // LoopInQuote contains estimates for the fees making up the total swap cost