multi: pass private, routehints from loopcli - loopd - loop server

This commit passes routehints all the way from when/if the user passes
them from the cli all the way to the backend loop server. If private is
used, this commit passes that boolean down to different stages, where it
is then converted into routehints.

main: add --private and --route_hints to quote

Adds --private and --route_hints flags to quote cli

Author: arshbot

client.go

@@ -15,6 +15,7 @@ import (
 	"github.com/lightninglabs/loop/loopdb"
 	"github.com/lightninglabs/loop/swap"
 	"github.com/lightninglabs/loop/sweep"
+	"github.com/lightningnetwork/lnd/routing/route"
 	"google.golang.org/grpc/status"
 )
 
@@ -563,6 +564,30 @@ func (s *Client) LoopInQuote(ctx context.Context,
 		return nil, ErrSwapAmountTooHigh
 	}
 
+	// Private and routehints are mutually exclusive as setting private
+	// means we retrieve our own routehints from the connected node.
+	if len(request.RouteHints) != 0 && request.Private {
+		return nil, fmt.Errorf("private and route_hints both set")
+	}
+
+	if request.Private {
+		// If last_hop is set, we'll only add channels with peers
+		// set to the last_hop parameter
+		includeNodes := make(map[route.Vertex]struct{})
+		if request.LastHop != nil {
+			includeNodes[*request.LastHop] = struct{}{}
+		}
+
+		// Because the Private flag is set, we'll generate our own
+		// set of hop hints and use that
+		request.RouteHints, err = SelectHopHints(
+			ctx, s.lndServices, request.Amount, DefaultMaxHopHints, includeNodes,
+		)
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	quote, err := s.Server.GetLoopInQuote(
 		ctx, request.Amount, s.lndServices.NodePubkey, request.LastHop,
 		request.RouteHints,

cmd/loop/loopin.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 
 	"github.com/lightninglabs/loop"
@@ -134,12 +133,12 @@ func loopIn(ctx *cli.Context) error {
 
 		lastHop = lastHopVertex[:]
 	}
-	var hints []*looprpc.RouteHint
-	if ctx.IsSet(routeHints.Name) {
-		err = json.Unmarshal([]byte(ctx.String(routeHints.Name)), &hints)
-		if err != nil {
-			return fmt.Errorf("unable to parse json: %v", err)
-		}
+
+	// Private and routehints are mutually exclusive as setting private
+	// means we retrieve our own routehints from the connected node.
+	hints, err := validateRouteHints(ctx)
+	if err != nil {
+		return err
 	}
 
 	quoteReq := &looprpc.QuoteRequest{
@@ -148,6 +147,7 @@ func loopIn(ctx *cli.Context) error {
 		ExternalHtlc:     external,
 		LoopInLastHop:    lastHop,
 		LoopInRouteHints: hints,
+		Private:          ctx.Bool(privateFlag.Name),
 	}
 
 	quote, err := client.GetLoopInQuote(context.Background(), quoteReq)
@@ -184,6 +184,8 @@ func loopIn(ctx *cli.Context) error {
 		Label:          label,
 		Initiator:      defaultInitiator,
 		LastHop:        lastHop,
+		RouteHints:     hints,
+		Private:        ctx.Bool(privateFlag.Name),
 	}
 
 	resp, err := client.LoopIn(context.Background(), req)

cmd/loop/quote.go

@@ -31,6 +31,8 @@ var quoteInCommand = cli.Command{
 		},
 		confTargetFlag,
 		verboseFlag,
+		privateFlag,
+		routeHintsFlag,
 	},
 	Action: quoteIn,
 }
@@ -53,9 +55,18 @@ func quoteIn(ctx *cli.Context) error {
 	}
 	defer cleanup()
 
+	// Private and routehints are mutually exclusive as setting private
+	// means we retrieve our own routehints from the connected node.
+	hints, err := validateRouteHints(ctx)
+	if err != nil {
+		return err
+	}
+
 	quoteReq := &looprpc.QuoteRequest{
-		Amt:        int64(amt),
-		ConfTarget: int32(ctx.Uint64("conf_target")),
+		Amt:              int64(amt),
+		ConfTarget:       int32(ctx.Uint64("conf_target")),
+		LoopInRouteHints: hints,
+		Private:          ctx.Bool(privateFlag.Name),
 	}
 
 	if ctx.IsSet(lastHopFlag.Name) {

cmd/loop/utils.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/lightninglabs/loop/looprpc"
+	"github.com/urfave/cli"
+)
+
+// validateRouteHints ensures that the Private flag isn't set along with
+// the RouteHints flag. We don't allow both options to be set as these options
+// are alternatives to each other. Private autogenerates hopHints while
+// RouteHints are manually passed.
+func validateRouteHints(ctx *cli.Context) ([]*looprpc.RouteHint, error) {
+	var hints []*looprpc.RouteHint
+
+	if ctx.IsSet(routeHintsFlag.Name) {
+		if ctx.IsSet(privateFlag.Name) {
+			return nil, fmt.Errorf(
+				"private and route_hints both set",
+			)
+		}
+
+		stringHints := []byte(ctx.String(routeHintsFlag.Name))
+		err := json.Unmarshal(stringHints, &hints)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse json: %v", err)
+		}
+	}
+
+	return hints, nil
+}

interface.go

@@ -207,6 +207,15 @@ type LoopInRequest struct {
 	// initiated the swap (loop CLI, autolooper, LiT UI and so on) and is
 	// appended to the user agent string.
 	Initiator string
+
+	// Private indicates whether the destination node should be considered
+	// private. In which case, loop will generate hophints to assist with
+	// probing and payment.
+	Private bool
+
+	// RouteHints are optional route hints to reach the destination through
+	// private channels.
+	RouteHints [][]zpay32.HopHint
 }
 
 // LoopInTerms are the server terms on which it executes loop in swaps.
@@ -253,6 +262,11 @@ type LoopInQuoteRequest struct {
 	// RouteHints are optional route hints to reach the destination through
 	// private channels.
 	RouteHints [][]zpay32.HopHint
+
+	// Private indicates whether the destination node should be considered
+	// private. In which case, loop will generate hophints to assist with
+	// probing and payment.
+	Private bool
 }
 
 // LoopInQuote contains estimates for the fees making up the total swap cost

loopd/swapclient_server.go

@@ -483,21 +483,26 @@ func (s *swapClientServer) GetLoopInQuote(ctx context.Context,
 		return nil, err
 	}
 
-	var lastHop *route.Vertex
+	var (
+		routeHints [][]zpay32.HopHint
+		lastHop    *route.Vertex
+	)
+
 	if req.LoopInLastHop != nil {
 		lastHopVertex, err := route.NewVertexFromBytes(
 			req.LoopInLastHop,
 		)
 		if err != nil {
 			return nil, err
 		}
-
 		lastHop = &lastHopVertex
 	}
 
-	routeHints, err := unmarshallRouteHints(req.LoopInRouteHints)
-	if err != nil {
-		return nil, err
+	if len(req.LoopInRouteHints) != 0 {
+		routeHints, err = unmarshallRouteHints(req.LoopInRouteHints)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	quote, err := s.impl.LoopInQuote(ctx, &loop.LoopInQuoteRequest{
@@ -506,10 +511,12 @@ func (s *swapClientServer) GetLoopInQuote(ctx context.Context,
 		ExternalHtlc:   req.ExternalHtlc,
 		LastHop:        lastHop,
 		RouteHints:     routeHints,
+		Private:        req.Private,
 	})
 	if err != nil {
 		return nil, err
 	}
+
 	return &looprpc.InQuoteResponse{
 		HtlcPublishFeeSat: int64(quote.MinerFee),
 		SwapFeeSat:        int64(quote.SwapFee),
@@ -613,6 +620,11 @@ func (s *swapClientServer) LoopIn(ctx context.Context,
 		return nil, err
 	}
 
+	routeHints, err := unmarshallRouteHints(in.RouteHints)
+	if err != nil {
+		return nil, err
+	}
+
 	req := &loop.LoopInRequest{
 		Amount:         btcutil.Amount(in.Amt),
 		MaxMinerFee:    btcutil.Amount(in.MaxMinerFee),
@@ -621,6 +633,8 @@ func (s *swapClientServer) LoopIn(ctx context.Context,
 		ExternalHtlc:   in.ExternalHtlc,
 		Label:          in.Label,
 		Initiator:      in.Initiator,
+		Private:        in.Private,
+		RouteHints:     routeHints,
 	}
 	if in.LastHop != nil {
 		lastHop, err := route.NewVertexFromBytes(in.LastHop)

loopin.go

@@ -23,6 +23,7 @@ import (
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
 	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/lightningnetwork/lnd/routing/route"
 )
 
 var (
@@ -80,6 +81,33 @@ func newLoopInSwap(globalCtx context.Context, cfg *swapConfig,
 	currentHeight int32, request *LoopInRequest) (*loopInInitResult,
 	error) {
 
+	var err error
+
+	// Private and routehints are mutually exclusive as setting private
+	// means we retrieve our own routehints from the connected node.
+	if len(request.RouteHints) != 0 && request.Private {
+		return nil, fmt.Errorf("private and route_hints both set")
+	}
+
+	// If Private is set, we generate route hints
+	if request.Private {
+		// If last_hop is set, we'll only add channels with peers
+		// set to the last_hop parameter
+		includeNodes := make(map[route.Vertex]struct{})
+		if request.LastHop != nil {
+			includeNodes[*request.LastHop] = struct{}{}
+		}
+
+		// Because the Private flag is set, we'll generate our own
+		// set of hop hints
+		request.RouteHints, err = SelectHopHints(
+			globalCtx, cfg.lnd, request.Amount, DefaultMaxHopHints, includeNodes,
+		)
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	// Request current server loop in terms and use these to calculate the
 	// swap fee that we should subtract from the swap amount in the payment
 	// request that we send to the server. We pass nil as optional route
@@ -89,7 +117,7 @@ func newLoopInSwap(globalCtx context.Context, cfg *swapConfig,
 	// route hints.
 	quote, err := cfg.server.GetLoopInQuote(
 		globalCtx, request.Amount, cfg.lnd.NodePubkey, request.LastHop,
-		nil,
+		request.RouteHints,
 	)
 	if err != nil {
 		return nil, wrapGrpcError("loop in terms", err)
@@ -129,10 +157,11 @@ func newLoopInSwap(globalCtx context.Context, cfg *swapConfig,
 	// Create the swap invoice in lnd.
 	_, swapInvoice, err := cfg.lnd.Client.AddInvoice(
 		globalCtx, &invoicesrpc.AddInvoiceData{
-			Preimage: &swapPreimage,
-			Value:    lnwire.NewMSatFromSatoshis(swapInvoiceAmt),
-			Memo:     "swap",
-			Expiry:   3600 * 24 * 365,
+			Preimage:   &swapPreimage,
+			Value:      lnwire.NewMSatFromSatoshis(swapInvoiceAmt),
+			Memo:       "swap",
+			Expiry:     3600 * 24 * 365,
+			RouteHints: request.RouteHints,
 		},
 	)
 	if err != nil {
@@ -148,10 +177,11 @@ func newLoopInSwap(globalCtx context.Context, cfg *swapConfig,
 	log.Infof("Creating probe invoice %v", probeHash)
 	probeInvoice, err := cfg.lnd.Invoices.AddHoldInvoice(
 		globalCtx, &invoicesrpc.AddInvoiceData{
-			Hash:   &probeHash,
-			Value:  lnwire.NewMSatFromSatoshis(swapInvoiceAmt),
-			Memo:   "loop in probe",
-			Expiry: 3600,
+			Hash:       &probeHash,
+			Value:      lnwire.NewMSatFromSatoshis(swapInvoiceAmt),
+			Memo:       "loop in probe",
+			Expiry:     3600,
+			RouteHints: request.RouteHints,
 		},
 	)
 	if err != nil {