Merge pull request #387 from bhandras/loop_in_probe

loop-in:  allow clients to request server probes and extend loop-in quote with additional parameters for more accurate swap fees

Author: bhandras

client.go

@@ -48,6 +48,9 @@ var (
 	// and pay for an LSAT token.
 	globalCallTimeout = serverRPCTimeout + lsat.PaymentTimeout
 
+	// probeTimeout is the maximum time until a probe is allowed to take.
+	probeTimeout = 3 * time.Minute
+
 	republishDelay = 10 * time.Second
 
 	// MinerFeeEstimationFailed is a magic number that is returned in a
@@ -560,7 +563,10 @@ func (s *Client) LoopInQuote(ctx context.Context,
 		return nil, ErrSwapAmountTooHigh
 	}
 
-	quote, err := s.Server.GetLoopInQuote(ctx, request.Amount)
+	quote, err := s.Server.GetLoopInQuote(
+		ctx, request.Amount, s.lndServices.NodePubkey, request.LastHop,
+		request.RouteHints,
+	)
 	if err != nil {
 		return nil, err
 	}
@@ -625,3 +631,13 @@ func wrapGrpcError(message string, err error) error {
 			grpcStatus.Message()),
 	)
 }
+
+// Probe asks the server to probe a route to us given a requested amount and
+// last hop. The server is free to discard frequent request to avoid abuse or if
+// there's been a recent probe to us for the same amount.
+func (s *Client) Probe(ctx context.Context, req *ProbeRequest) error {
+	return s.Server.Probe(
+		ctx, req.Amount, s.lndServices.NodePubkey, req.LastHop,
+		req.RouteHints,
+	)
+}

cmd/loop/loopin.go

@@ -109,11 +109,25 @@ func loopIn(ctx *cli.Context) error {
 		return err
 	}
 
+	var lastHop []byte
+	if ctx.IsSet(lastHopFlag.Name) {
+		lastHopVertex, err := route.NewVertexFromStr(
+			ctx.String(lastHopFlag.Name),
+		)
+		if err != nil {
+			return err
+		}
+
+		lastHop = lastHopVertex[:]
+	}
+
 	quoteReq := &looprpc.QuoteRequest{
-		Amt:          int64(amt),
-		ConfTarget:   htlcConfTarget,
-		ExternalHtlc: external,
+		Amt:           int64(amt),
+		ConfTarget:    htlcConfTarget,
+		ExternalHtlc:  external,
+		LoopInLastHop: lastHop,
 	}
+
 	quote, err := client.GetLoopInQuote(context.Background(), quoteReq)
 	if err != nil {
 		return err
@@ -147,17 +161,7 @@ func loopIn(ctx *cli.Context) error {
 		HtlcConfTarget: htlcConfTarget,
 		Label:          label,
 		Initiator:      defaultInitiator,
-	}
-
-	if ctx.IsSet(lastHopFlag.Name) {
-		lastHop, err := route.NewVertexFromStr(
-			ctx.String(lastHopFlag.Name),
-		)
-		if err != nil {
-			return err
-		}
-
-		req.LastHop = lastHop[:]
+		LastHop:        lastHop,
 	}
 
 	resp, err := client.LoopIn(context.Background(), req)

cmd/loop/quote.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/lightninglabs/loop"
 	"github.com/lightninglabs/loop/looprpc"
+	"github.com/lightningnetwork/lnd/routing/route"
 	"github.com/urfave/cli"
 )
 
@@ -22,8 +23,16 @@ var quoteInCommand = cli.Command{
 	Usage:       "get a quote for the cost of a loop in swap",
 	ArgsUsage:   "amt",
 	Description: "Allows to determine the cost of a swap up front",
-	Flags:       []cli.Flag{confTargetFlag, verboseFlag},
-	Action:      quoteIn,
+	Flags: []cli.Flag{
+		cli.StringFlag{
+			Name: lastHopFlag.Name,
+			Usage: "the pubkey of the last hop to use for the " +
+				"quote",
+		},
+		confTargetFlag,
+		verboseFlag,
+	},
+	Action: quoteIn,
 }
 
 func quoteIn(ctx *cli.Context) error {
@@ -44,11 +53,23 @@ func quoteIn(ctx *cli.Context) error {
 	}
 	defer cleanup()
 
-	ctxb := context.Background()
 	quoteReq := &looprpc.QuoteRequest{
 		Amt:        int64(amt),
 		ConfTarget: int32(ctx.Uint64("conf_target")),
 	}
+
+	if ctx.IsSet(lastHopFlag.Name) {
+		lastHopVertex, err := route.NewVertexFromStr(
+			ctx.String(lastHopFlag.Name),
+		)
+		if err != nil {
+			return err
+		}
+
+		quoteReq.LoopInLastHop = lastHopVertex[:]
+	}
+
+	ctxb := context.Background()
 	quoteResp, err := client.GetLoopInQuote(ctxb, quoteReq)
 	if err != nil {
 		return err

interface.go

@@ -8,6 +8,7 @@ import (
 	"github.com/lightninglabs/loop/swap"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/routing/route"
+	"github.com/lightningnetwork/lnd/zpay32"
 )
 
 // OutRequest contains the required parameters for a loop out swap.
@@ -243,6 +244,15 @@ type LoopInQuoteRequest struct {
 	// ExternalHtlc specifies whether the htlc is published by an external
 	// source.
 	ExternalHtlc bool
+
+	// LastHop is an optional last hop to use. This last hop is used when
+	// the client has already requested a server probe for more accurate
+	// routing fee estimation.
+	LastHop *route.Vertex
+
+	// RouteHints are optional route hints to reach the destination through
+	// private channels.
+	RouteHints [][]zpay32.HopHint
 }
 
 // LoopInQuote contains estimates for the fees making up the total swap cost
@@ -340,3 +350,15 @@ func (s *In) LastUpdate() time.Time {
 func (s *In) SwapHash() lntypes.Hash {
 	return s.Hash
 }
+
+// ProbeRequest specifies probe parameters for the server probe.
+type ProbeRequest struct {
+	// Amount is the amount that will be probed.
+	Amount btcutil.Amount
+
+	// LastHop is the last hop along the route.
+	LastHop *route.Vertex
+
+	// Optional hop hints.
+	RouteHints [][]zpay32.HopHint
+}

loopd/macaroons.go

@@ -95,6 +95,13 @@ var (
 			Entity: "suggestions",
 			Action: "write",
 		}},
+		"/looprpc.SwapClient/Probe": {{
+			Entity: "swap",
+			Action: "execute",
+		}, {
+			Entity: "loop",
+			Action: "in",
+		}},
 	}
 
 	// allPermissions is the list of all existing permissions that exist

loopd/swapclient_server.go

@@ -2,12 +2,14 @@ package loopd
 
 import (
 	"context"
+	"encoding/hex"
 	"errors"
 	"fmt"
 	"sort"
 	"sync"
 	"time"
 
+	"github.com/btcsuite/btcd/btcec"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcutil"
 	"github.com/lightninglabs/lndclient"
@@ -22,6 +24,7 @@ import (
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/queue"
 	"github.com/lightningnetwork/lnd/routing/route"
+	"github.com/lightningnetwork/lnd/zpay32"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
@@ -480,10 +483,29 @@ func (s *swapClientServer) GetLoopInQuote(ctx context.Context,
 		return nil, err
 	}
 
+	var 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
+	}
+
 	quote, err := s.impl.LoopInQuote(ctx, &loop.LoopInQuoteRequest{
 		Amount:         btcutil.Amount(req.Amt),
 		HtlcConfTarget: htlcConfTarget,
 		ExternalHtlc:   req.ExternalHtlc,
+		LastHop:        lastHop,
+		RouteHints:     routeHints,
 	})
 	if err != nil {
 		return nil, err
@@ -495,6 +517,84 @@ func (s *swapClientServer) GetLoopInQuote(ctx context.Context,
 	}, nil
 }
 
+// unmarshallRouteHints unmarshalls a list of route hints.
+func unmarshallRouteHints(rpcRouteHints []*looprpc.RouteHint) (
+	[][]zpay32.HopHint, error) {
+
+	routeHints := make([][]zpay32.HopHint, 0, len(rpcRouteHints))
+	for _, rpcRouteHint := range rpcRouteHints {
+		routeHint := make(
+			[]zpay32.HopHint, 0, len(rpcRouteHint.HopHints),
+		)
+		for _, rpcHint := range rpcRouteHint.HopHints {
+			hint, err := unmarshallHopHint(rpcHint)
+			if err != nil {
+				return nil, err
+			}
+
+			routeHint = append(routeHint, hint)
+		}
+		routeHints = append(routeHints, routeHint)
+	}
+
+	return routeHints, nil
+}
+
+// unmarshallHopHint unmarshalls a single hop hint.
+func unmarshallHopHint(rpcHint *looprpc.HopHint) (zpay32.HopHint, error) {
+	pubBytes, err := hex.DecodeString(rpcHint.NodeId)
+	if err != nil {
+		return zpay32.HopHint{}, err
+	}
+
+	pubkey, err := btcec.ParsePubKey(pubBytes, btcec.S256())
+	if err != nil {
+		return zpay32.HopHint{}, err
+	}
+
+	return zpay32.HopHint{
+		NodeID:                    pubkey,
+		ChannelID:                 rpcHint.ChanId,
+		FeeBaseMSat:               rpcHint.FeeBaseMsat,
+		FeeProportionalMillionths: rpcHint.FeeProportionalMillionths,
+		CLTVExpiryDelta:           uint16(rpcHint.CltvExpiryDelta),
+	}, nil
+}
+
+// Probe requests the server to probe the client's node to test inbound
+// liquidity.
+func (s *swapClientServer) Probe(ctx context.Context,
+	req *looprpc.ProbeRequest) (*looprpc.ProbeResponse, error) {
+
+	log.Infof("Probe request received")
+
+	var lastHop *route.Vertex
+	if req.LastHop != nil {
+		lastHopVertex, err := route.NewVertexFromBytes(req.LastHop)
+		if err != nil {
+			return nil, err
+		}
+
+		lastHop = &lastHopVertex
+	}
+
+	routeHints, err := unmarshallRouteHints(req.RouteHints)
+	if err != nil {
+		return nil, err
+	}
+
+	err = s.impl.Probe(ctx, &loop.ProbeRequest{
+		Amount:     btcutil.Amount(req.Amt),
+		LastHop:    lastHop,
+		RouteHints: routeHints,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &looprpc.ProbeResponse{}, nil
+}
+
 func (s *swapClientServer) LoopIn(ctx context.Context,
 	in *looprpc.LoopInRequest) (
 	*looprpc.SwapResponse, error) {

loopdb/protocol_version.go

@@ -43,13 +43,17 @@ const (
 	// canceling loop out swaps.
 	ProtocolVersionLoopOutCancel = 7
 
+	// ProtocolVerionProbe indicates that the client is able to request
+	// the server to perform a probe to test inbound liquidty.
+	ProtocolVersionProbe ProtocolVersion = 8
+
 	// ProtocolVersionUnrecorded is set for swaps were created before we
 	// started saving protocol version with swaps.
 	ProtocolVersionUnrecorded ProtocolVersion = math.MaxUint32
 
 	// CurrentRPCProtocolVersion defines the version of the RPC protocol
 	// that is currently supported by the loop client.
-	CurrentRPCProtocolVersion = looprpc.ProtocolVersion_LOOP_OUT_CANCEL
+	CurrentRPCProtocolVersion = looprpc.ProtocolVersion_PROBE
 
 	// CurrentInternalProtocolVersion defines the RPC current protocol in
 	// the internal representation.
@@ -88,6 +92,9 @@ func (p ProtocolVersion) String() string {
 	case ProtocolVersionLoopOutCancel:
 		return "Loop Out Cancel"
 
+	case ProtocolVersionProbe:
+		return "Probe"
+
 	default:
 		return "Unknown"
 	}

loopdb/protocol_version_test.go

@@ -22,6 +22,7 @@ func TestProtocolVersionSanity(t *testing.T) {
 		ProtocolVersionHtlcV2,
 		ProtocolVersionMultiLoopIn,
 		ProtocolVersionLoopOutCancel,
+		ProtocolVersionProbe,
 	}
 
 	rpcVersions := [...]looprpc.ProtocolVersion{
@@ -33,6 +34,7 @@ func TestProtocolVersionSanity(t *testing.T) {
 		looprpc.ProtocolVersion_HTLC_V2,
 		looprpc.ProtocolVersion_MULTI_LOOP_IN,
 		looprpc.ProtocolVersion_LOOP_OUT_CANCEL,
+		looprpc.ProtocolVersion_PROBE,
 	}
 
 	require.Equal(t, len(versions), len(rpcVersions))

loopin.go

@@ -82,8 +82,15 @@ func newLoopInSwap(globalCtx context.Context, cfg *swapConfig,
 
 	// 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.
-	quote, err := cfg.server.GetLoopInQuote(globalCtx, request.Amount)
+	// request that we send to the server. We pass nil as optional route
+	// hints as hop hint selection when generating invoices with private
+	// channels is an LND side black box feaure. Advanced users will quote
+	// directly anyway and there they have the option to add specific
+	// route hints.
+	quote, err := cfg.server.GetLoopInQuote(
+		globalCtx, request.Amount, cfg.lnd.NodePubkey, request.LastHop,
+		nil,
+	)
 	if err != nil {
 		return nil, wrapGrpcError("loop in terms", err)
 	}