rpcserver: further break apart AddInvoice into helpers

We extract some more of the AddInvoice logic into individual helper
functions. We use one to calculate the max units to use in the rfq quote
and another helper to validate and derive the final value to encode in
the invoice itself.

Co-authored-by: Oliver Gugger <[email protected]>

Author: GeorgeTsagk

rpcserver.go

@@ -7621,6 +7621,147 @@ func checkOverpayment(quote *rfqrpc.PeerAcceptedSellQuote,
 	return nil
 }
 
+// calculateAssetMaxAmount calculates the max units to be placed in the invoice
+// RFQ quote order. When adding invoices based on asset units, that value is
+// directly returned. If using the value/value_msat fields of the invoice then
+// a price oracle query will take place to calculate the max units of the quote.
+func calculateAssetMaxAmount(ctx context.Context, priceOracle rfq.PriceOracle,
+	specifier asset.Specifier, requestAssetAmount uint64,
+	inv *lnrpc.Invoice, deviationPPM uint64) (uint64, error) {
+
+	// Let's unmarshall the satoshi related fields to see if an amount was
+	// set based on those.
+	amtMsat, err := lnrpc.UnmarshallAmt(inv.Value, inv.ValueMsat)
+	if err != nil {
+		return 0, err
+	}
+
+	// Let's make sure that only one type of amount is set, in order to
+	// avoid ambiguous behavior. This field dictates the actual value of the
+	// invoice so let's be strict and only allow one possible value to be
+	// set.
+	if requestAssetAmount > 0 && amtMsat != 0 {
+		return 0, fmt.Errorf("cannot set both asset amount and sats" +
+			"amount")
+	}
+
+	// If the invoice is being added based on asset units, there's nothing
+	// to do so return the amount directly.
+	if amtMsat == 0 {
+		return requestAssetAmount, nil
+	}
+
+	// If the invoice defines the desired amount in satoshis, we need to
+	// query our oracle first to get an estimation on the asset rate. This
+	// will help us establish a quote with the correct amount of asset
+	// units.
+	maxUnits, err := rfq.EstimateAssetUnits(
+		ctx, priceOracle, specifier, amtMsat,
+	)
+	if err != nil {
+		return 0, err
+	}
+
+	maxMathUnits := rfqmath.NewBigIntFromUint64(maxUnits)
+	tolerance := rfqmath.NewBigIntFromUint64(deviationPPM)
+
+	// Since we used a different oracle price query above to
+	// calculate the max amount of units, we want to add some
+	// breathing room to account for price fluctuations caused by
+	// the small time delay, plus the fact that the agreed upon
+	// quote may be different. If we don't add this safety window
+	// the peer may allow a routable amount that evaluates to less
+	// than what we ask for. This is also checked below, after
+	// acquiring the quote.
+
+	// Apply the tolerance margin twice. Once due to the ask/bid
+	// price deviation that may occur during rfq negotiation, and
+	// once for the price movement that may occur between querying
+	// the oracle and acquiring the quote. We don't really care
+	// about this margin being too big, this only affects the max
+	// units our peer agrees to route.
+	maxMathUnits = rfqmath.AddTolerance(maxMathUnits, tolerance)
+	maxMathUnits = rfqmath.AddTolerance(maxMathUnits, tolerance)
+
+	return maxMathUnits.ToUint64(), nil
+}
+
+// validateInvoiceAmount validates the quote against the invoice we're trying to
+// add. It returns the value in msat that should be included in the invoice.
+func validateInvoiceAmount(acceptedQuote *rfqrpc.PeerAcceptedBuyQuote,
+	requestAssetAmount uint64, inv *lnrpc.Invoice) (int64, error) {
+
+	amtMsat, err := lnrpc.UnmarshallAmt(inv.Value, inv.ValueMsat)
+	if err != nil {
+		return 0, err
+	}
+
+	invUnits := requestAssetAmount
+
+	// Now that we have the accepted quote, we know the amount in Satoshi
+	// that we need to pay. We can now update the invoice with this amount.
+	//
+	// First, un-marshall the ask asset rate from the accepted quote.
+	askAssetRate, err := rfqrpc.UnmarshalFixedPoint(
+		acceptedQuote.AskAssetRate,
+	)
+	if err != nil {
+		return 0, fmt.Errorf("error unmarshalling ask asset rate: %w",
+			err)
+	}
+
+	var invoiceValueMsat int64
+	switch {
+	case amtMsat != 0:
+		// If the invoice was created over a satoshi amount, we need to
+		// calculate the units.
+		invUnits = rfqmath.MilliSatoshiToUnits(
+			amtMsat, *askAssetRate,
+		).ScaleTo(0).ToUint64()
+
+		// Now let's see if the negotiated quote can actually route the
+		// amount we need in msat.
+		maxFixedUnits := rfqmath.NewBigIntFixedPoint(
+			acceptedQuote.AssetMaxAmount, 0,
+		)
+		maxRoutableMsat := rfqmath.UnitsToMilliSatoshi(
+			maxFixedUnits, *askAssetRate,
+		)
+
+		if maxRoutableMsat <= amtMsat {
+			return 0, fmt.Errorf("cannot create invoice for %v "+
+				"msat, max routable amount is %v msat", amtMsat,
+				maxRoutableMsat)
+		}
+
+		invoiceValueMsat = int64(amtMsat)
+	default:
+		// Convert the asset amount into a fixed-point.
+		assetAmount := rfqmath.NewBigIntFixedPoint(
+			requestAssetAmount, 0,
+		)
+
+		// Calculate the invoice amount in msat.
+		valMsat := rfqmath.UnitsToMilliSatoshi(
+			assetAmount, *askAssetRate,
+		)
+		invoiceValueMsat = int64(valMsat)
+	}
+
+	// If the invoice is for an asset unit amount smaller than the minimal
+	// transportable amount, we'll return an error, as it wouldn't be
+	// payable by the network.
+	if acceptedQuote.MinTransportableUnits > invUnits {
+		return 0, fmt.Errorf("cannot create invoice over %d asset "+
+			"units, as the minimal transportable amount is %d "+
+			"units with the current rate of %v units/BTC",
+			invUnits, acceptedQuote.MinTransportableUnits,
+			acceptedQuote.AskAssetRate)
+	}
+
+	return invoiceValueMsat, nil
+}
+
 // AddInvoice is a wrapper around lnd's lnrpc.AddInvoice method with asset
 // specific parameters. It allows RPC users to create invoices that correspond
 // to the specified asset amount.
@@ -7638,29 +7779,6 @@ func (r *rpcServer) AddInvoice(ctx context.Context,
 		return nil, fmt.Errorf("asset ID must be 32 bytes")
 	}
 
-	amtMsat, err := lnrpc.UnmarshallAmt(
-		req.InvoiceRequest.Value, req.InvoiceRequest.ValueMsat,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	// Let's make sure that only one type of amount is set, in order to
-	// avoid ambiguous behavior. This field dictates the actual value of the
-	// invoice so let's be strict and only allow one possible value to be
-	// set.
-	if req.AssetAmount > 0 && amtMsat != 0 {
-		return nil, fmt.Errorf("cannot set both asset amount and sats" +
-			"amount")
-	}
-
-	// In order to avoid repeating the following check let's assign it to a
-	// boolean for easier access.
-	var satsMode bool
-	if amtMsat != 0 {
-		satsMode = true
-	}
-
 	var assetID asset.ID
 	copy(assetID[:], req.AssetId)
 
@@ -7700,45 +7818,13 @@ func (r *rpcServer) AddInvoice(ctx context.Context,
 		time.Duration(expirySeconds) * time.Second,
 	)
 
-	maxUnits := req.AssetAmount
-
-	// If the invoice defines the desired amount in satoshis, we need to
-	// query our oracle first to get an estimation on the asset rate. This
-	// will help us establish a quote with the correct amount of asset
-	// units.
-	if satsMode {
-		maxUnits, err = rfq.EstimateAssetUnits(
-			ctx, r.cfg.PriceOracle, specifier, amtMsat,
-		)
-		if err != nil {
-			return nil, err
-		}
-
-		maxMathUnits := rfqmath.NewBigIntFromUint64(maxUnits)
-
-		tolerance := rfqmath.NewBigIntFromUint64(
-			r.cfg.RfqManager.GetPriceDeviationPpm(),
-		)
-
-		// Since we used a different oracle price query above to
-		// calculate the max amount of units, we want to add some
-		// breathing room to account for price fluctuations caused by
-		// the small time delay, plus the fact that the agreed upon
-		// quote may be different. If we don't add this safety window
-		// the peer may allow a routable amount that evaluates to less
-		// than what we ask for. This is also checked below, after
-		// acquiring the quote.
-
-		// Apply the tolerance margin twice. Once due to the ask/bid
-		// price deviation that may occur during rfq negotiation, and
-		// once for the price movement that may occur between querying
-		// the oracle and acquiring the quote. We don't really care
-		// about this margin being too big, this only affects the max
-		// units our peer agrees to route.
-		maxMathUnits = rfqmath.AddTolerance(maxMathUnits, tolerance)
-		maxMathUnits = rfqmath.AddTolerance(maxMathUnits, tolerance)
-
-		maxUnits = maxMathUnits.ToUint64()
+	maxUnits, err := calculateAssetMaxAmount(
+		ctx, r.cfg.PriceOracle, specifier, req.AssetAmount, iReq,
+		r.cfg.RfqManager.GetPriceDeviationPpm(),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("error calculating asset max "+
+			"amount: %w", err)
 	}
 
 	resp, err := r.AddAssetBuyOrder(ctx, &rfqrpc.AddAssetBuyOrderRequest{
@@ -7777,68 +7863,14 @@ func (r *rpcServer) AddInvoice(ctx context.Context,
 		return nil, fmt.Errorf("unexpected response type: %T", r)
 	}
 
-	// Now that we have the accepted quote, we know the amount in Satoshi
-	// that we need to pay. We can now update the invoice with this amount.
-	//
-	// First, un-marshall the ask asset rate from the accepted quote.
-	askAssetRate, err := rfqrpc.UnmarshalFixedPoint(
-		acceptedQuote.AskAssetRate,
+	invoiceAmtMsat, err := validateInvoiceAmount(
+		acceptedQuote, req.AssetAmount, iReq,
 	)
 	if err != nil {
-		return nil, fmt.Errorf("error unmarshalling ask asset rate: %w",
-			err)
-	}
-
-	invUnits := req.AssetAmount
-
-	if satsMode {
-		// If the invoice was created over a satoshi amount, we need to
-		// calculate the units.
-		invUnits = rfqmath.MilliSatoshiToUnits(
-			amtMsat, *askAssetRate,
-		).ScaleTo(0).ToUint64()
-
-		// Now let's see if the negotiated quote can actually route the
-		// amount we need in msat.
-		maxFixedUnits := rfqmath.NewBigIntFixedPoint(
-			acceptedQuote.AssetMaxAmount, 0,
-		)
-		maxRoutableMsat := rfqmath.UnitsToMilliSatoshi(
-			maxFixedUnits, *askAssetRate,
-		)
-
-		if maxRoutableMsat <= amtMsat {
-			return nil, fmt.Errorf("cannot create invoice for %v "+
-				"msat, max routable amount is %v msat", amtMsat,
-				maxRoutableMsat)
-		}
-	}
-
-	// If the invoice is for an asset unit amount smaller than the minimal
-	// transportable amount, we'll return an error, as it wouldn't be
-	// payable by the network.
-	if acceptedQuote.MinTransportableUnits > invUnits {
-		return nil, fmt.Errorf("cannot create invoice over %d asset "+
-			"units, as the minimal transportable amount is %d "+
-			"units with the current rate of %v units/BTC",
-			invUnits, acceptedQuote.MinTransportableUnits,
-			acceptedQuote.AskAssetRate)
-	}
-
-	switch {
-	case satsMode:
-		iReq.ValueMsat = int64(amtMsat)
-
-	default:
-		// Convert the asset amount into a fixed-point.
-		assetAmount := rfqmath.NewBigIntFixedPoint(req.AssetAmount, 0)
-
-		// Calculate the invoice amount in msat.
-		valMsat := rfqmath.UnitsToMilliSatoshi(
-			assetAmount, *askAssetRate,
-		)
-		iReq.ValueMsat = int64(valMsat)
+		return nil, fmt.Errorf("error validating invoice "+
+			"amount: %w", err)
 	}
+	iReq.ValueMsat = invoiceAmtMsat
 
 	// The last step is to create a hop hint that includes the fake SCID of
 	// the quote, alongside the channel's routing policy. We need to choose