Merge pull request #249 from joostjager/split-client-messages

looprpc: split client messages

Author: joostjager

cmd/loop/loopin.go

@@ -7,7 +7,6 @@ import (
 	"github.com/btcsuite/btcutil"
 	"github.com/lightninglabs/loop"
 	"github.com/lightninglabs/loop/looprpc"
-	"github.com/lightninglabs/loop/swap"
 	"github.com/lightningnetwork/lnd/routing/route"
 	"github.com/urfave/cli"
 )
@@ -111,17 +110,18 @@ func loopIn(ctx *cli.Context) error {
 	// HTLC. If the wallet doesn't have enough funds to create this TX, we
 	// know it won't have enough to pay the real transaction either. It
 	// makes sense to abort the loop in this case.
-	if !external && quote.MinerFee == int64(loop.MinerFeeEstimationFailed) {
+	if !external && quote.HtlcPublishFeeSat ==
+		int64(loop.MinerFeeEstimationFailed) {
+
 		return fmt.Errorf("miner fee estimation not " +
 			"possible, lnd has insufficient funds to " +
 			"create a sample transaction for selected " +
 			"amount")
 	}
 
-	limits := getInLimits(amt, quote)
-	err = displayLimits(
-		swap.TypeIn, amt, btcutil.Amount(quote.MinerFee), limits,
-		external, "",
+	limits := getInLimits(quote)
+	err = displayInLimits(
+		amt, btcutil.Amount(quote.HtlcPublishFeeSat), limits, external,
 	)
 	if err != nil {
 		return err
@@ -165,12 +165,3 @@ func loopIn(ctx *cli.Context) error {
 
 	return nil
 }
-
-func getInLimits(amt btcutil.Amount, quote *looprpc.QuoteResponse) *limits {
-	return &limits{
-		// Apply a multiplier to the estimated miner fee, to not get
-		// the swap canceled because fees increased in the mean time.
-		maxMinerFee: btcutil.Amount(quote.MinerFee) * 3,
-		maxSwapFee:  btcutil.Amount(quote.SwapFee),
-	}
-}

cmd/loop/loopout.go

@@ -10,7 +10,6 @@ import (
 	"github.com/btcsuite/btcutil"
 	"github.com/lightninglabs/loop"
 	"github.com/lightninglabs/loop/looprpc"
-	"github.com/lightninglabs/loop/swap"
 	"github.com/urfave/cli"
 )
 
@@ -148,16 +147,15 @@ func loopOut(ctx *cli.Context) error {
 			defaultSwapWaitTime)
 	}
 
-	limits := getLimits(amt, quote)
+	limits := getOutLimits(amt, quote)
 	// If configured, use the specified maximum swap routing fee.
 	if ctx.IsSet("max_swap_routing_fee") {
-		*limits.maxSwapRoutingFee = btcutil.Amount(
+		limits.maxSwapRoutingFee = btcutil.Amount(
 			ctx.Int64("max_swap_routing_fee"),
 		)
 	}
-	err = displayLimits(
-		swap.TypeOut, amt, btcutil.Amount(quote.MinerFee), limits,
-		false, warning,
+	err = displayOutLimits(
+		amt, btcutil.Amount(quote.HtlcSweepFeeSat), limits, warning,
 	)
 	if err != nil {
 		return err
@@ -167,10 +165,10 @@ func loopOut(ctx *cli.Context) error {
 		Amt:                     int64(amt),
 		Dest:                    destAddr,
 		MaxMinerFee:             int64(limits.maxMinerFee),
-		MaxPrepayAmt:            int64(*limits.maxPrepayAmt),
+		MaxPrepayAmt:            int64(limits.maxPrepayAmt),
 		MaxSwapFee:              int64(limits.maxSwapFee),
-		MaxPrepayRoutingFee:     int64(*limits.maxPrepayRoutingFee),
-		MaxSwapRoutingFee:       int64(*limits.maxSwapRoutingFee),
+		MaxPrepayRoutingFee:     int64(limits.maxPrepayRoutingFee),
+		MaxSwapRoutingFee:       int64(limits.maxSwapRoutingFee),
 		OutgoingChanSet:         outgoingChanSet,
 		SweepConfTarget:         sweepConfTarget,
 		SwapPublicationDeadline: uint64(swapDeadline.Unix()),

cmd/loop/main.go

@@ -136,59 +136,65 @@ func getMaxRoutingFee(amt btcutil.Amount) btcutil.Amount {
 	return swap.CalcFee(amt, maxRoutingFeeBase, maxRoutingFeeRate)
 }
 
-type limits struct {
-	maxSwapRoutingFee   *btcutil.Amount
-	maxPrepayRoutingFee *btcutil.Amount
+type inLimits struct {
+	maxMinerFee btcutil.Amount
+	maxSwapFee  btcutil.Amount
+}
+
+func getInLimits(quote *looprpc.InQuoteResponse) *inLimits {
+	return &inLimits{
+		// Apply a multiplier to the estimated miner fee, to not get
+		// the swap canceled because fees increased in the mean time.
+		maxMinerFee: btcutil.Amount(quote.HtlcPublishFeeSat) * 3,
+		maxSwapFee:  btcutil.Amount(quote.SwapFeeSat),
+	}
+}
+
+type outLimits struct {
+	maxSwapRoutingFee   btcutil.Amount
+	maxPrepayRoutingFee btcutil.Amount
 	maxMinerFee         btcutil.Amount
 	maxSwapFee          btcutil.Amount
-	maxPrepayAmt        *btcutil.Amount
+	maxPrepayAmt        btcutil.Amount
 }
 
-func getLimits(amt btcutil.Amount, quote *looprpc.QuoteResponse) *limits {
+func getOutLimits(amt btcutil.Amount,
+	quote *looprpc.OutQuoteResponse) *outLimits {
+
 	maxSwapRoutingFee := getMaxRoutingFee(amt)
 	maxPrepayRoutingFee := getMaxRoutingFee(btcutil.Amount(
-		quote.PrepayAmt,
+		quote.PrepayAmtSat,
 	))
-	maxPrepayAmt := btcutil.Amount(quote.PrepayAmt)
+	maxPrepayAmt := btcutil.Amount(quote.PrepayAmtSat)
 
-	return &limits{
-		maxSwapRoutingFee:   &maxSwapRoutingFee,
-		maxPrepayRoutingFee: &maxPrepayRoutingFee,
+	return &outLimits{
+		maxSwapRoutingFee:   maxSwapRoutingFee,
+		maxPrepayRoutingFee: maxPrepayRoutingFee,
 
 		// Apply a multiplier to the estimated miner fee, to not get
 		// the swap canceled because fees increased in the mean time.
-		maxMinerFee: btcutil.Amount(quote.MinerFee) * 100,
+		maxMinerFee: btcutil.Amount(quote.HtlcSweepFeeSat) * 100,
 
-		maxSwapFee:   btcutil.Amount(quote.SwapFee),
-		maxPrepayAmt: &maxPrepayAmt,
+		maxSwapFee:   btcutil.Amount(quote.SwapFeeSat),
+		maxPrepayAmt: maxPrepayAmt,
 	}
 }
 
-func displayLimits(swapType swap.Type, amt, minerFees btcutil.Amount, l *limits,
-	externalHtlc bool, warning string) error {
+func displayInLimits(amt, minerFees btcutil.Amount, l *inLimits,
+	externalHtlc bool) error {
 
 	totalSuccessMax := l.maxMinerFee + l.maxSwapFee
-	if l.maxSwapRoutingFee != nil {
-		totalSuccessMax += *l.maxSwapRoutingFee
-	}
-	if l.maxPrepayRoutingFee != nil {
-		totalSuccessMax += *l.maxPrepayRoutingFee
-	}
 
-	if swapType == swap.TypeIn && externalHtlc {
+	if 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 sat Loop %v: %d sat\n", amt, swapType,
+	fmt.Printf("Max swap fees for %d sat Loop %v: %d sat\n", amt, swap.TypeIn,
 		totalSuccessMax)
 
-	if warning != "" {
-		fmt.Println(warning)
-	}
-
 	fmt.Printf("CONTINUE SWAP? (y/n), expand fee detail (x): ")
 
 	var answer string
@@ -201,32 +207,55 @@ func displayLimits(swapType swap.Type, amt, minerFees btcutil.Amount, l *limits,
 		fmt.Println()
 		f := "%-36s %d sat\n"
 
-		switch swapType {
-		case swap.TypeOut:
-			fmt.Printf(f, "Estimated on-chain sweep fee:",
+		if !externalHtlc {
+			fmt.Printf(f, "Estimated on-chain HTLC fee:",
 				minerFees)
-			fmt.Printf(f, "Max on-chain sweep fee:", l.maxMinerFee)
-
-		case swap.TypeIn:
-			if !externalHtlc {
-				fmt.Printf(f, "Estimated on-chain HTLC fee:",
-					minerFees)
-			}
 		}
 
-		if l.maxSwapRoutingFee != nil {
-			fmt.Printf(f, "Max off-chain swap routing fee:",
-				*l.maxSwapRoutingFee)
-		}
+		fmt.Printf(f, "Max swap fee:", l.maxSwapFee)
 
-		if l.maxPrepayAmt != nil {
-			fmt.Printf(f, "Max no show penalty (prepay):",
-				*l.maxPrepayAmt)
-		}
-		if l.maxPrepayRoutingFee != nil {
-			fmt.Printf(f, "Max off-chain prepay routing fee:",
-				*l.maxPrepayRoutingFee)
+		fmt.Printf("CONTINUE SWAP? (y/n): ")
+		fmt.Scanln(&answer)
+		if answer == "y" {
+			return nil
 		}
+	}
+
+	return errors.New("swap canceled")
+}
+
+func displayOutLimits(amt, minerFees btcutil.Amount, l *outLimits,
+	warning string) error {
+
+	totalSuccessMax := l.maxMinerFee + l.maxSwapFee + l.maxSwapRoutingFee +
+		l.maxPrepayRoutingFee
+
+	fmt.Printf("Max swap fees for %d sat Loop %v: %d sat\n", amt, swap.TypeOut,
+		totalSuccessMax)
+
+	if warning != "" {
+		fmt.Println(warning)
+	}
+
+	fmt.Printf("CONTINUE SWAP? (y/n), expand fee detail (x): ")
+
+	var answer string
+	fmt.Scanln(&answer)
+
+	switch answer {
+	case "y":
+		return nil
+	case "x":
+		fmt.Println()
+		f := "%-36s %d sat\n"
+
+		fmt.Printf(f, "Estimated on-chain sweep fee:", minerFees)
+		fmt.Printf(f, "Max on-chain sweep fee:", l.maxMinerFee)
+		fmt.Printf(f, "Max off-chain swap routing fee:",
+			l.maxSwapRoutingFee)
+		fmt.Printf(f, "Max no show penalty (prepay):", l.maxPrepayAmt)
+		fmt.Printf(f, "Max off-chain prepay routing fee:",
+			l.maxPrepayRoutingFee)
 		fmt.Printf(f, "Max swap fee:", l.maxSwapFee)
 
 		fmt.Printf("CONTINUE SWAP? (y/n): ")

cmd/loop/quote.go

@@ -59,7 +59,7 @@ func quoteIn(ctx *cli.Context) error {
 	// HTLC. If the wallet doesn't have enough funds to create this TX, we
 	// don't want to fail the quote. But the user should still be informed
 	// why the fee shows as -1.
-	if quoteResp.MinerFee == int64(loop.MinerFeeEstimationFailed) {
+	if quoteResp.HtlcPublishFeeSat == int64(loop.MinerFeeEstimationFailed) {
 		_, _ = fmt.Fprintf(os.Stderr, "Warning: Miner fee estimation "+
 			"not possible, lnd has insufficient funds to "+
 			"create a sample transaction for selected "+

cmd/loop/terms.go

@@ -4,10 +4,9 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/urfave/cli"
-
 	"github.com/btcsuite/btcutil"
 	"github.com/lightninglabs/loop/looprpc"
+	"github.com/urfave/cli"
 )
 
 var termsCommand = cli.Command{
@@ -23,10 +22,9 @@ func terms(ctx *cli.Context) error {
 	}
 	defer cleanup()
 
-	printTerms := func(terms *looprpc.TermsResponse) {
+	printAmountRange := func(min, max int64) {
 		fmt.Printf("Amount: %d - %d\n",
-			btcutil.Amount(terms.MinSwapAmount),
-			btcutil.Amount(terms.MaxSwapAmount),
+			btcutil.Amount(min), btcutil.Amount(max),
 		)
 	}
 
@@ -37,7 +35,10 @@ func terms(ctx *cli.Context) error {
 	if err != nil {
 		fmt.Println(err)
 	} else {
-		printTerms(loopOutTerms)
+		printAmountRange(
+			loopOutTerms.MinSwapAmount,
+			loopOutTerms.MaxSwapAmount,
+		)
 	}
 
 	fmt.Println()
@@ -50,7 +51,10 @@ func terms(ctx *cli.Context) error {
 	if err != nil {
 		fmt.Println(err)
 	} else {
-		printTerms(loopInTerms)
+		printAmountRange(
+			loopInTerms.MinSwapAmount,
+			loopInTerms.MaxSwapAmount,
+		)
 	}
 
 	return nil

loopd/swapclient_server.go

@@ -328,7 +328,7 @@ func (s *swapClientServer) SwapInfo(_ context.Context,
 
 // LoopOutTerms returns the terms that the server enforces for loop out swaps.
 func (s *swapClientServer) LoopOutTerms(ctx context.Context,
-	req *looprpc.TermsRequest) (*looprpc.TermsResponse, error) {
+	req *looprpc.TermsRequest) (*looprpc.OutTermsResponse, error) {
 
 	log.Infof("Loop out terms request received")
 
@@ -338,7 +338,7 @@ func (s *swapClientServer) LoopOutTerms(ctx context.Context,
 		return nil, err
 	}
 
-	return &looprpc.TermsResponse{
+	return &looprpc.OutTermsResponse{
 		MinSwapAmount: int64(terms.MinSwapAmount),
 		MaxSwapAmount: int64(terms.MaxSwapAmount),
 	}, nil
@@ -347,7 +347,7 @@ func (s *swapClientServer) LoopOutTerms(ctx context.Context,
 // LoopOutQuote returns a quote for a loop out swap with the provided
 // parameters.
 func (s *swapClientServer) LoopOutQuote(ctx context.Context,
-	req *looprpc.QuoteRequest) (*looprpc.QuoteResponse, error) {
+	req *looprpc.QuoteRequest) (*looprpc.OutQuoteResponse, error) {
 
 	confTarget, err := validateConfTarget(
 		req.ConfTarget, loop.DefaultSweepConfTarget,
@@ -366,18 +366,18 @@ func (s *swapClientServer) LoopOutQuote(ctx context.Context,
 		return nil, err
 	}
 
-	return &looprpc.QuoteResponse{
-		MinerFee:        int64(quote.MinerFee),
-		PrepayAmt:       int64(quote.PrepayAmount),
-		SwapFee:         int64(quote.SwapFee),
+	return &looprpc.OutQuoteResponse{
+		HtlcSweepFeeSat: int64(quote.MinerFee),
+		PrepayAmtSat:    int64(quote.PrepayAmount),
+		SwapFeeSat:      int64(quote.SwapFee),
 		SwapPaymentDest: quote.SwapPaymentDest[:],
 		CltvDelta:       quote.CltvDelta,
 	}, nil
 }
 
 // GetTerms returns the terms that the server enforces for swaps.
-func (s *swapClientServer) GetLoopInTerms(ctx context.Context, req *looprpc.TermsRequest) (
-	*looprpc.TermsResponse, error) {
+func (s *swapClientServer) GetLoopInTerms(ctx context.Context,
+	req *looprpc.TermsRequest) (*looprpc.InTermsResponse, error) {
 
 	log.Infof("Loop in terms request received")
 
@@ -387,15 +387,15 @@ func (s *swapClientServer) GetLoopInTerms(ctx context.Context, req *looprpc.Term
 		return nil, err
 	}
 
-	return &looprpc.TermsResponse{
+	return &looprpc.InTermsResponse{
 		MinSwapAmount: int64(terms.MinSwapAmount),
 		MaxSwapAmount: int64(terms.MaxSwapAmount),
 	}, nil
 }
 
 // GetQuote returns a quote for a swap with the provided parameters.
 func (s *swapClientServer) GetLoopInQuote(ctx context.Context,
-	req *looprpc.QuoteRequest) (*looprpc.QuoteResponse, error) {
+	req *looprpc.QuoteRequest) (*looprpc.InQuoteResponse, error) {
 
 	log.Infof("Loop in quote request received")
 
@@ -414,9 +414,9 @@ func (s *swapClientServer) GetLoopInQuote(ctx context.Context,
 	if err != nil {
 		return nil, err
 	}
-	return &looprpc.QuoteResponse{
-		MinerFee: int64(quote.MinerFee),
-		SwapFee:  int64(quote.SwapFee),
+	return &looprpc.InQuoteResponse{
+		HtlcPublishFeeSat: int64(quote.MinerFee),
+		SwapFeeSat:        int64(quote.SwapFee),
 	}, nil
 }