loopout: add asset loop out payment flow

Author: sputn1ck

client.go

@@ -506,9 +506,31 @@ func (s *Client) resumeSwaps(ctx context.Context,
 func (s *Client) LoopOut(globalCtx context.Context,
 	request *OutRequest) (*LoopOutSwapInfo, error) {
 
-	log.Infof("LoopOut %v to %v (channels: %v)",
-		request.Amount, request.DestAddr, request.OutgoingChanSet,
-	)
+	if request.AssetId != nil {
+		if request.AssetPrepayRfqId == nil ||
+			request.AssetSwapRfqId == nil {
+
+			return nil, errors.New("asset prepay and swap rfq ids " +
+				"must be set when using an asset id")
+		}
+
+		// Verify that if we have an asset id set, we have a valid asset
+		// client to use.
+		if s.assetClient == nil {
+			return nil, errors.New("asset client must be set " +
+				"when using an asset id")
+		}
+
+		log.Infof("LoopOut %v sats to %v (channels: %v) with asset %x",
+			request.Amount, request.DestAddr,
+			request.OutgoingChanSet, request.AssetId,
+		)
+	} else {
+		log.Infof("LoopOut %v to %v (channels: %v)",
+			request.Amount, request.DestAddr,
+			request.OutgoingChanSet,
+		)
+	}
 
 	if err := s.waitForInitialized(globalCtx); err != nil {
 		return nil, err
@@ -529,7 +551,10 @@ func (s *Client) LoopOut(globalCtx context.Context,
 	}
 
 	// Create a new swap object for this swap.
-	swapCfg := newSwapConfig(s.lndServices, s.Store, s.Server, s.assetClient)
+	swapCfg := newSwapConfig(
+		s.lndServices, s.Store, s.Server, s.assetClient,
+	)
+
 	initResult, err := newLoopOutSwap(
 		globalCtx, swapCfg, initiationHeight, request,
 	)
@@ -574,6 +599,16 @@ func (s *Client) getExpiry(height int32, terms *LoopOutTerms,
 func (s *Client) LoopOutQuote(ctx context.Context,
 	request *LoopOutQuoteRequest) (*LoopOutQuote, error) {
 
+	if request.AssetId != nil && request.AssetEdgeNode == nil {
+		return nil, errors.New("asset edge node must be set " +
+			"when using an asset id")
+	}
+
+	if request.AssetEdgeNode != nil && request.AssetId == nil {
+		return nil, errors.New("asset id must be set " +
+			"when using an asset edge node")
+	}
+
 	terms, err := s.Server.GetLoopOutTerms(ctx, request.Initiator)
 	if err != nil {
 		return nil, err
@@ -608,12 +643,55 @@ func (s *Client) LoopOutQuote(ctx context.Context,
 		return nil, err
 	}
 
-	return &LoopOutQuote{
+	loopOutQuote := &LoopOutQuote{
 		SwapFee:         quote.SwapFee,
 		MinerFee:        minerFee,
 		PrepayAmount:    quote.PrepayAmount,
 		SwapPaymentDest: quote.SwapPaymentDest,
-	}, nil
+	}
+
+	// If we use an Asset we'll rfq to get the asset amounts to use for
+	// the swap.
+	if request.AssetId != nil {
+		// First we'll get the prepay prepayRfq.
+		prepayRfq, err := s.assetClient.GetRfqForAsset(
+			ctx, quote.PrepayAmount, request.AssetId,
+			request.AssetEdgeNode,
+		)
+		if err != nil {
+			return nil, err
+		}
+		log.Infof("Prepay RFQ: %v", prepayRfq)
+
+		invoiceAmt := request.Amount + quote.SwapFee -
+			quote.PrepayAmount
+
+		swapRfq, err := s.assetClient.GetRfqForAsset(
+			ctx, invoiceAmt, request.AssetId, request.AssetEdgeNode,
+		)
+		if err != nil {
+			return nil, err
+		}
+		log.Infof("Swap RFQ: %v", swapRfq)
+
+		// We'll also want the asset name to verify for the client.
+		assetName, err := s.assetClient.GetAssetName(
+			ctx, request.AssetId,
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		loopOutQuote.LoopOutRfq = &LoopOutRfq{
+			PrepayRfqId:    prepayRfq.Id,
+			PrepayAssetAmt: btcutil.Amount(prepayRfq.AssetAmount),
+			SwapRfqId:      swapRfq.Id,
+			SwapAssetAmt:   btcutil.Amount(swapRfq.AssetAmount),
+			AssetName:      assetName,
+		}
+	}
+
+	return loopOutQuote, nil
 }
 
 // getLoopOutSweepFee is a helper method to estimate the loop out htlc sweep

interface.go

@@ -98,6 +98,18 @@ type OutRequest struct {
 	// the configured maximum payment timeout) the total time spent may be
 	// a multiple of this value.
 	PaymentTimeout time.Duration
+
+	// AssetId is an optional asset id that can be used to specify the asset
+	// that will be used to pay for the swap. If this is set, a connection
+	// to a tapd server is required to pay for the asset.
+	AssetId []byte
+
+	// AssetPrepayRfqId is the rfq id that is used to pay the prepay
+	// invoice.
+	AssetPrepayRfqId []byte
+
+	// AssetSwapRfqId is the rfq id that is used to pay the swap invoice.
+	AssetSwapRfqId []byte
 }
 
 // Out contains the full details of a loop out request. This includes things
@@ -145,6 +157,12 @@ type LoopOutQuoteRequest struct {
 	// initiated the swap (loop CLI, autolooper, LiT UI and so on) and is
 	// appended to the user agent string.
 	Initiator string
+
+	// AssetId is the asset that we'll quote for.
+	AssetId []byte
+
+	// AssetEdgeNode is the pubkey of the peer that we'll quote for.
+	AssetEdgeNode []byte
 }
 
 // LoopOutTerms are the server terms on which it executes swaps.
@@ -181,6 +199,31 @@ type LoopOutQuote struct {
 	// SwapPaymentDest is the node pubkey where to swap payment needs to be
 	// sent to.
 	SwapPaymentDest [33]byte
+
+	// LoopOutRfq is the RFQ that can be used in the actual loop out to
+	// commit to an asset exchange rate.
+	LoopOutRfq *LoopOutRfq
+}
+
+// LoopOutRfq contains the details of an asset request for quote for a loop out
+// swap.
+type LoopOutRfq struct {
+	// PrepayRfqId is the ID of the prepay RFQ.
+	PrepayRfqId []byte
+
+	// PrepayAssetAmt is the amount of the asset that will be used to pay
+	// for the prepay invoice.
+	PrepayAssetAmt btcutil.Amount
+
+	// SwapRfqId is the ID of the swap RFQ.
+	SwapRfqId []byte
+
+	// SwapAssetAmt is the amount of the asset that will be used to pay for
+	// the swap invoice.
+	SwapAssetAmt btcutil.Amount
+
+	// AssetName is the human readable name of the asset.
+	AssetName string
 }
 
 // LoopInRequest contains the required parameters for the swap.
@@ -430,6 +473,9 @@ type SwapInfo struct {
 	// channels that may be used to loop out. On a loop in this field
 	// is nil.
 	OutgoingChanSet loopdb.ChannelSet
+
+	// AssetSwapInfo contains the asset information for the swap.
+	AssetSwapInfo *loopdb.LoopOutAssetSwap
 }
 
 // LastUpdate returns the last update time of the swap.

loopd/swapclient_server.go

@@ -210,6 +210,38 @@ func (s *swapClientServer) LoopOut(ctx context.Context,
 		PaymentTimeout:          paymentTimeout,
 	}
 
+	// If the asset id is set, we need to set the asset amount and asset id
+	// in the request.
+	if in.AssetInfo != nil {
+		if in.AssetInfo.AssetId == nil &&
+			len(in.AssetInfo.AssetId) != 32 {
+
+			return nil, fmt.Errorf(
+				"asset id must be set to a 32 byte value",
+			)
+		}
+
+		if in.AssetRfqInfo.PrepayRfqId == nil &&
+			len(in.AssetRfqInfo.PrepayRfqId) != 32 {
+
+			return nil, fmt.Errorf(
+				"prepay rfq id must be set to a 32 byte value",
+			)
+		}
+
+		if in.AssetRfqInfo.SwapRfqId == nil &&
+			len(in.AssetRfqInfo.SwapRfqId) != 32 {
+
+			return nil, fmt.Errorf(
+				"swap rfq id must be set to a 32 byte value",
+			)
+		}
+
+		req.AssetId = in.AssetInfo.AssetId
+		req.AssetPrepayRfqId = in.AssetRfqInfo.PrepayRfqId
+		req.AssetSwapRfqId = in.AssetRfqInfo.SwapRfqId
+	}
+
 	switch {
 	case in.LoopOutChannel != 0 && len(in.OutgoingChanSet) > 0: // nolint:staticcheck
 		return nil, errors.New("loop_out_channel and outgoing_" +
@@ -709,23 +741,49 @@ func (s *swapClientServer) LoopOutQuote(ctx context.Context,
 		req.SwapPublicationDeadline,
 	)
 
-	quote, err := s.impl.LoopOutQuote(ctx, &loop.LoopOutQuoteRequest{
+	loopOutQuoteReq := &loop.LoopOutQuoteRequest{
 		Amount:                  btcutil.Amount(req.Amt),
 		SweepConfTarget:         confTarget,
 		SwapPublicationDeadline: publicactionDeadline,
 		Initiator:               defaultLoopdInitiator,
-	})
+	}
+
+	if req.AssetInfo != nil {
+		if req.AssetInfo.AssetId == nil ||
+			req.AssetInfo.AssetEdgeNode == nil {
+
+			return nil, fmt.Errorf(
+				"asset id and edge node must both be set")
+		}
+
+		loopOutQuoteReq.AssetId = req.AssetInfo.AssetId
+		loopOutQuoteReq.AssetEdgeNode = req.AssetInfo.AssetEdgeNode
+	}
+
+	quote, err := s.impl.LoopOutQuote(ctx, loopOutQuoteReq)
 	if err != nil {
 		return nil, err
 	}
 
-	return &looprpc.OutQuoteResponse{
+	response := &looprpc.OutQuoteResponse{
 		HtlcSweepFeeSat: int64(quote.MinerFee),
 		PrepayAmtSat:    int64(quote.PrepayAmount),
 		SwapFeeSat:      int64(quote.SwapFee),
 		SwapPaymentDest: quote.SwapPaymentDest[:],
 		ConfTarget:      confTarget,
-	}, nil
+	}
+
+	if quote.LoopOutRfq != nil {
+		response.AssetRfqInfo = &looprpc.AssetRfqInfo{
+			PrepayRfqId:    quote.LoopOutRfq.PrepayRfqId,
+			PrepayAssetAmt: uint64(quote.LoopOutRfq.PrepayAssetAmt),
+			SwapRfqId:      quote.LoopOutRfq.SwapRfqId,
+			SwapAssetAmt:   uint64(quote.LoopOutRfq.SwapAssetAmt),
+			AssetName:      quote.LoopOutRfq.AssetName,
+		}
+	}
+
+	return response, nil
 }
 
 // GetLoopInTerms returns the terms that the server enforces for swaps.
@@ -2025,6 +2083,15 @@ func validateLoopOutRequest(ctx context.Context, lnd lndclient.LightningClient,
 		return 0, errInvalidAddress
 	}
 
+	// If this is an asset payment, we'll check that we have the necessary
+	// outbound asset capacaity to fulfill the request.
+	if req.AssetInfo != nil {
+		// Todo(sputn1ck) actually check outbound capacity.
+		return validateConfTarget(
+			req.SweepConfTarget, loop.DefaultSweepConfTarget,
+		)
+	}
+
 	// Check that the label is valid.
 	if err := labels.Validate(req.Label); err != nil {
 		return 0, err

loopdb/loopout.go

@@ -65,6 +65,28 @@ type LoopOutContract struct {
 	// PaymentTimeout is the timeout for any individual off-chain payment
 	// attempt.
 	PaymentTimeout time.Duration
+
+	// AssetSwapInfo contains information, should the loop out swpa be
+	// paid via an asset channel.
+	AssetSwapInfo *LoopOutAssetSwap
+}
+
+type LoopOutAssetSwap struct {
+	// AssetId is the optional asset id that is used to pay the swap invoice.
+	AssetId []byte
+
+	// PrepayRfqId is the rfq id that is used to pay the prepay invoice.
+	PrepayRfqId []byte
+
+	// SwapRfqId is the rfq id that is used to pay the swap invoice.
+	SwapRfqId []byte
+
+	// PrepayPaidAmt is the asset amount that was paid for the prepay
+	// invoice.
+	PrepayPaidAmt btcutil.Amount
+
+	// SwapPaidAmt is the asset amount that was paid for the swap invoice.
+	SwapPaidAmt btcutil.Amount
 }
 
 // ChannelSet stores a set of channels.