loopout: add asset id and edge node

Author: sputn1ck

client.go

@@ -506,6 +506,40 @@ func (s *Client) resumeSwaps(ctx context.Context,
 func (s *Client) LoopOut(globalCtx context.Context,
 	request *OutRequest) (*LoopOutSwapInfo, error) {
 
+	if request.AssetId != nil {
+		if request.AssetEdgeNode == nil {
+			return nil, errors.New("asset edge node 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")
+		}
+
+		rfq, err := s.assetClient.GetRfqForAsset(
+			globalCtx, request.AssetAmount, request.AssetId,
+			request.AssetEdgeNode,
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		satAmt, err := assets.GetSatAmtFromRfq(
+			request.AssetAmount, rfq.BidAssetRate,
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		log.Infof("LoopOut %v sats to %v (channels: %v) with asset %x",
+			satAmt, request.DestAddr, request.OutgoingChanSet,
+			request.AssetId,
+		)
+		request.Amount = satAmt
+	}
+
 	log.Infof("LoopOut %v to %v (channels: %v)",
 		request.Amount, request.DestAddr, request.OutgoingChanSet,
 	)
@@ -530,6 +564,7 @@ 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)
+
 	initResult, err := newLoopOutSwap(
 		globalCtx, swapCfg, initiationHeight, request,
 	)
@@ -579,11 +614,31 @@ func (s *Client) LoopOutQuote(ctx context.Context,
 		return nil, err
 	}
 
-	if request.Amount < terms.MinSwapAmount {
+	invoiceAmountSat := request.Amount
+	// If we use an Asset we'll rfq to check if the sat amount meets the
+	// min swap amount criteria.
+	if request.AssetId != nil {
+		rfq, err := s.assetClient.GetRfqForAsset(
+			ctx, request.Amount, request.AssetId,
+			request.AssetEdgeNode,
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		invoiceAmountSat, err = assets.GetSatAmtFromRfq(
+			request.Amount, rfq.BidAssetRate,
+		)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if invoiceAmountSat < terms.MinSwapAmount {
 		return nil, ErrSwapAmountTooLow
 	}
 
-	if request.Amount > terms.MaxSwapAmount {
+	if invoiceAmountSat > terms.MaxSwapAmount {
 		return nil, ErrSwapAmountTooHigh
 	}
 
@@ -594,7 +649,7 @@ func (s *Client) LoopOutQuote(ctx context.Context,
 	}
 
 	quote, err := s.Server.GetLoopOutQuote(
-		ctx, request.Amount, expiry, request.SwapPublicationDeadline,
+		ctx, invoiceAmountSat, expiry, request.SwapPublicationDeadline,
 		request.Initiator,
 	)
 	if err != nil {
@@ -613,6 +668,7 @@ func (s *Client) LoopOutQuote(ctx context.Context,
 		MinerFee:        minerFee,
 		PrepayAmount:    quote.PrepayAmount,
 		SwapPaymentDest: quote.SwapPaymentDest,
+		InvoiceAmtSat:   invoiceAmountSat,
 	}, nil
 }
 

interface.go

@@ -98,6 +98,20 @@ 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
+
+	// AssetEdgeNode is an optional Parameter that is required should the
+	// tapd server have multiple channels with different peers for the given
+	// asset id.
+	AssetEdgeNode []byte
+
+	// AssetAmount is the amount of the asset that will be used to pay for
+	// the swap. This is only set if the asset id is set.
+	AssetAmount btcutil.Amount
 }
 
 // Out contains the full details of a loop out request. This includes things
@@ -145,6 +159,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 +201,9 @@ type LoopOutQuote struct {
 	// SwapPaymentDest is the node pubkey where to swap payment needs to be
 	// sent to.
 	SwapPaymentDest [33]byte
+
+	// InvoiceAmtSat is the amount of the invoice in satoshis.
+	InvoiceAmtSat btcutil.Amount
 }
 
 // LoopInRequest contains the required parameters for the swap.

loopd/swapclient_server.go

@@ -208,6 +208,25 @@ 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 ||
+			in.AssetInfo.AssetEdgeNode == nil {
+			return nil, fmt.Errorf(
+				"asset id and edge node must both be set",
+			)
+		}
+
+		req.AssetAmount = btcutil.Amount(in.Amt)
+		req.AssetId = in.AssetInfo.AssetId
+		req.AssetEdgeNode = in.AssetInfo.AssetEdgeNode
+
+		// We'll set the sat amount to zero, as this gets set later
+		// when we calculate the total amount to send.
+		req.Amount = 0
+	}
+
 	switch {
 	case in.LoopOutChannel != 0 && len(in.OutgoingChanSet) > 0: // nolint:staticcheck
 		return nil, errors.New("loop_out_channel and outgoing_" +
@@ -707,12 +726,25 @@ 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 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
 	}
@@ -723,6 +755,7 @@ func (s *swapClientServer) LoopOutQuote(ctx context.Context,
 		SwapFeeSat:      int64(quote.SwapFee),
 		SwapPaymentDest: quote.SwapPaymentDest[:],
 		ConfTarget:      confTarget,
+		InvoiceAmtSat:   int64(quote.InvoiceAmtSat),
 	}, nil
 }
 

loopdb/loopout.go

@@ -65,6 +65,13 @@ type LoopOutContract struct {
 	// PaymentTimeout is the timeout for any individual off-chain payment
 	// attempt.
 	PaymentTimeout time.Duration
+
+	// AssetId is the optional asset id that is used to pay the swap invoice.
+	AssetId []byte
+
+	// AssetEdgeNode is the asset edge node that is used to pay the
+	// swap invoice.
+	AssetEdgeNode []byte
 }
 
 // ChannelSet stores a set of channels.

loopout.go

@@ -206,6 +206,8 @@ func newLoopOutSwap(globalCtx context.Context, cfg *swapConfig,
 		},
 		OutgoingChanSet: chanSet,
 		PaymentTimeout:  request.PaymentTimeout,
+		AssetId:         request.AssetId,
+		AssetEdgeNode:   request.AssetEdgeNode,
 	}
 
 	swapKit := newSwapKit(