loop: add support for the probe API

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,9 @@ 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,
+	)
 	if err != nil {
 		return nil, err
 	}
@@ -625,3 +630,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,
+	)
+}

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,11 @@ 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
 }
 
 // LoopInQuote contains estimates for the fees making up the total swap cost
@@ -340,3 +346,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"
 )
@@ -495,6 +498,85 @@ 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

@@ -83,7 +83,9 @@ 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)
+	quote, err := cfg.server.GetLoopInQuote(
+		globalCtx, request.Amount, cfg.lnd.NodePubkey, request.LastHop,
+	)
 	if err != nil {
 		return nil, wrapGrpcError("loop in terms", err)
 	}