Merge pull request #415 from lightninglabs/routehints

loopin: Add --private parameter

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

@@ -31,6 +31,17 @@ var (
 			"with our reserved prefix: %v.",
 			labels.MaxLength, labels.Reserved),
 	}
+	routeHintsFlag = cli.StringSliceFlag{
+		Name: "route_hints",
+		Usage: "Route hints that can each be individually used " +
+			"to assist in reaching the invoice's destination.",
+	}
+	privateFlag = cli.BoolFlag{
+		Name: "private",
+		Usage: "Generates and passes routehints. Should be used " +
+			"if the connected node is only reachable via private " +
+			"channels",
+	}
 
 	forceFlag = cli.BoolFlag{
 		Name:  "force, f",
@@ -67,6 +78,8 @@ var (
 			labelFlag,
 			forceFlag,
 			verboseFlag,
+			routeHintsFlag,
+			privateFlag,
 		},
 		Action: loopIn,
 	}
@@ -127,11 +140,20 @@ func loopIn(ctx *cli.Context) error {
 		lastHop = lastHopVertex[:]
 	}
 
+	// 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:    htlcConfTarget,
-		ExternalHtlc:  external,
-		LoopInLastHop: lastHop,
+		Amt:              int64(amt),
+		ConfTarget:       htlcConfTarget,
+		ExternalHtlc:     external,
+		LoopInLastHop:    lastHop,
+		LoopInRouteHints: hints,
+		Private:          ctx.Bool(privateFlag.Name),
 	}
 
 	quote, err := client.GetLoopInQuote(context.Background(), quoteReq)
@@ -172,6 +194,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 {