rfq+rfqmsg: use new AssetRate type in BuyRequest.AssetRateHint

This commit includes the following changes:
* Rename the `BuyRequest.SuggestedAssetRate` field to `AssetRateHint`
  with the new `AssetRate` type.
* Update the `queryAskFromPriceOracle` function to accept the
  `AssetRate` type as an argument.
* Update the `PriceOracle.QueryAskPrice` function to accept the
  `AssetRate` type as an argument.

This change provides the price oracle with the asset rate hint's expiry
timestamp from the BuyRequest, instead of relying on the default expiry
lifetime.

Author: ffranr

rfq/negotiator.go

@@ -215,15 +215,15 @@ func (n *Negotiator) HandleOutgoingBuyOrder(buyOrder BuyOrder) error {
 // peer.
 func (n *Negotiator) queryAskFromPriceOracle(peer *route.Vertex,
 	assetId *asset.ID, assetGroupKey *btcec.PublicKey, assetAmount uint64,
-	suggestedAssetRate fn.Option[rfqmath.BigIntFixedPoint]) (
+	assetRateHint fn.Option[rfqmsg.AssetRate]) (
 	*rfqmath.BigIntFixedPoint, uint64, error) {
 
 	// Query the price oracle for an asking price.
 	ctx, cancel := n.WithCtxQuitNoTimeout()
 	defer cancel()
 
 	oracleResponse, err := n.cfg.PriceOracle.QueryAskPrice(
-		ctx, assetId, assetGroupKey, assetAmount, suggestedAssetRate,
+		ctx, assetId, assetGroupKey, assetAmount, assetRateHint,
 	)
 	if err != nil {
 		return nil, 0, fmt.Errorf("failed to query price oracle for "+
@@ -312,7 +312,7 @@ func (n *Negotiator) HandleIncomingBuyRequest(
 		// Query the price oracle for an asking price.
 		assetRate, rateExpiry, err := n.queryAskFromPriceOracle(
 			nil, request.AssetID, request.AssetGroupKey,
-			request.AssetAmount, request.SuggestedAssetRate,
+			request.AssetAmount, request.AssetRateHint,
 		)
 		if err != nil {
 			// Send a reject message to the peer.
@@ -455,7 +455,7 @@ func (n *Negotiator) HandleOutgoingSellOrder(order SellOrder) {
 			rate, _, err := n.queryAskFromPriceOracle(
 				order.Peer, order.AssetID, order.AssetGroupKey,
 				order.MaxAssetAmount,
-				fn.None[rfqmath.BigIntFixedPoint](),
+				fn.None[rfqmsg.AssetRate](),
 			)
 			if err != nil {
 				err := fmt.Errorf("negotiator failed to "+
@@ -568,8 +568,7 @@ func (n *Negotiator) HandleIncomingBuyAccept(msg rfqmsg.BuyAccept,
 		// by the price oracle with the ask price provided by the peer.
 		assetRate, _, err := n.queryAskFromPriceOracle(
 			&msg.Peer, msg.Request.AssetID, nil,
-			msg.Request.AssetAmount,
-			fn.None[rfqmath.BigIntFixedPoint](),
+			msg.Request.AssetAmount, fn.None[rfqmsg.AssetRate](),
 		)
 		if err != nil {
 			// The price oracle returned an error. We will return

rfq/oracle.go

@@ -18,18 +18,6 @@ import (
 	"google.golang.org/grpc/credentials/insecure"
 )
 
-const (
-	// defaultAssetRateExpirySeconds is the default asset units to BTC rate
-	// expiry lifetime in seconds. 600s = 10 minutes.
-	//
-	// TODO(ffranr): This const is currently used in conjunction with the
-	//  AcceptSuggestedPrices flag. It is used to set the expiry time of the
-	//  asset units to BTC rate in the accept message. This is a temporary
-	//  solution and should be replaced with an expiry time provided by the
-	//  peer in the quote request message.
-	defaultAssetRateExpirySeconds = 600
-)
-
 // OracleError is a struct that holds an error returned by the price oracle
 // service.
 type OracleError struct {
@@ -111,7 +99,7 @@ type PriceOracle interface {
 	// from another peer to provide the specified asset amount.
 	QueryAskPrice(ctx context.Context, assetId *asset.ID,
 		assetGroupKey *btcec.PublicKey, assetAmount uint64,
-		assetRateHint fn.Option[rfqmath.BigIntFixedPoint]) (
+		assetRateHint fn.Option[rfqmsg.AssetRate]) (
 		*OracleResponse, error)
 
 	// QueryBidPrice returns the bid price for a given asset amount.
@@ -204,7 +192,7 @@ func NewRpcPriceOracle(addrStr string, dialInsecure bool) (*RpcPriceOracle,
 // QueryAskPrice returns the ask price for the given asset amount.
 func (r *RpcPriceOracle) QueryAskPrice(ctx context.Context,
 	assetId *asset.ID, assetGroupKey *btcec.PublicKey, assetAmount uint64,
-	assetRateHint fn.Option[rfqmath.BigIntFixedPoint]) (*OracleResponse,
+	assetRateHint fn.Option[rfqmsg.AssetRate]) (*OracleResponse,
 	error) {
 
 	// For now, we only support querying the ask price with an asset ID.
@@ -222,38 +210,9 @@ func (r *RpcPriceOracle) QueryAskPrice(ctx context.Context,
 	copy(subjectAssetId, assetId[:])
 
 	// Construct the RPC asset rates hint.
-	var (
-		rpcAssetRatesHint *oraclerpc.AssetRates
-		err               error
-	)
-	assetRateHint.WhenSome(func(rate rfqmath.BigIntFixedPoint) {
-		// Compute an expiry time using the default expiry delay.
-		expiryTimestamp := uint64(time.Now().Unix()) +
-			defaultAssetRateExpirySeconds
-
-		// Marshal the subject asset rate.
-		subjectAssetRate, err := oraclerpc.MarshalBigIntFixedPoint(
-			rate,
-		)
-		if err != nil {
-			return
-		}
-
-		// Marshal the payment asset rate. For now, we only support BTC
-		// as the payment asset.
-		paymentAssetRate, err := oraclerpc.MarshalBigIntFixedPoint(
-			rfqmsg.MilliSatPerBtc,
-		)
-		if err != nil {
-			return
-		}
-
-		rpcAssetRatesHint = &oraclerpc.AssetRates{
-			SubjectAssetRate: subjectAssetRate,
-			PaymentAssetRate: paymentAssetRate,
-			ExpiryTimestamp:  expiryTimestamp,
-		}
-	})
+	rpcAssetRatesHint, err := fn.MapOptionZ(
+		assetRateHint, oraclerpc.MarshalAssetRates,
+	).Unpack()
 	if err != nil {
 		return nil, err
 	}
@@ -437,7 +396,7 @@ func NewMockPriceOracleSatPerAsset(expiryDelay uint64,
 // QueryAskPrice returns the ask price for the given asset amount.
 func (m *MockPriceOracle) QueryAskPrice(_ context.Context,
 	_ *asset.ID, _ *btcec.PublicKey, _ uint64,
-	_ fn.Option[rfqmath.BigIntFixedPoint]) (*OracleResponse, error) {
+	_ fn.Option[rfqmsg.AssetRate]) (*OracleResponse, error) {
 
 	// Calculate the rate expiryDelay lifetime.
 	expiry := uint64(time.Now().Unix()) + m.expiryDelay

rfq/oracle_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/internal/test"
 	"github.com/lightninglabs/taproot-assets/rfqmath"
+	"github.com/lightninglabs/taproot-assets/rfqmsg"
 	"github.com/lightninglabs/taproot-assets/taprpc/priceoraclerpc"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/stretchr/testify/require"
@@ -158,10 +159,12 @@ func runQueryAskPriceTest(t *testing.T, tc *testCaseQueryAskPrice) {
 	inAssetRate := rfqmath.NewBigIntFixedPoint(
 		tc.suggestedAssetRate, 3,
 	)
+	expiry := time.Now().Add(rfqmsg.DefaultQuoteLifetime).UTC()
+	assetRateHint := rfqmsg.NewAssetRate(inAssetRate, expiry)
 
 	resp, err := client.QueryAskPrice(
 		ctx, tc.assetId, tc.assetGroupKey, assetAmount,
-		fn.Some(inAssetRate),
+		fn.Some(assetRateHint),
 	)
 
 	// If we expect an error, ensure that it is returned.

rfqmsg/buy_request.go

@@ -2,6 +2,8 @@ package rfqmsg
 
 import (
 	"fmt"
+	"math"
+	"time"
 
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/lightninglabs/taproot-assets/asset"
@@ -40,33 +42,39 @@ type BuyRequest struct {
 	// requesting a quote.
 	AssetAmount uint64
 
-	// SuggestedAssetRate represents a proposed conversion rate between the
+	// AssetRateHint represents a proposed conversion rate between the
 	// subject asset and BTC. This rate is an initial suggestion intended to
 	// initiate the RFQ negotiation process and may differ from the final
 	// agreed rate.
-	SuggestedAssetRate fn.Option[rfqmath.BigIntFixedPoint]
+	AssetRateHint fn.Option[AssetRate]
 }
 
 // NewBuyRequest creates a new asset buy quote request.
 func NewBuyRequest(peer route.Vertex, assetID *asset.ID,
 	assetGroupKey *btcec.PublicKey, assetAmount uint64,
-	suggestedAssetRate fn.Option[rfqmath.BigIntFixedPoint]) (*BuyRequest,
-	error) {
+	rateHint fn.Option[rfqmath.BigIntFixedPoint]) (*BuyRequest, error) {
 
 	id, err := NewID()
 	if err != nil {
 		return nil, fmt.Errorf("unable to generate random "+
 			"quote request id: %w", err)
 	}
 
+	// Construct a suggested asset rate if a rate hint is provided.
+	var assetRateHint fn.Option[AssetRate]
+	rateHint.WhenSome(func(rate rfqmath.BigIntFixedPoint) {
+		expiry := time.Now().Add(DefaultQuoteLifetime).UTC()
+		assetRateHint = fn.Some(NewAssetRate(rate, expiry))
+	})
+
 	return &BuyRequest{
-		Peer:               peer,
-		Version:            latestBuyRequestVersion,
-		ID:                 id,
-		AssetID:            assetID,
-		AssetGroupKey:      assetGroupKey,
-		AssetAmount:        assetAmount,
-		SuggestedAssetRate: suggestedAssetRate,
+		Peer:          peer,
+		Version:       latestBuyRequestVersion,
+		ID:            id,
+		AssetID:       assetID,
+		AssetGroupKey: assetGroupKey,
+		AssetAmount:   assetAmount,
+		AssetRateHint: assetRateHint,
 	}, nil
 }
 
@@ -102,24 +110,30 @@ func NewBuyRequestFromWire(wireMsg WireMessage,
 			"request")
 	}
 
+	// Convert the wire message expiration time to a time.Time.
+	if msgData.Expiry.Val > math.MaxInt64 {
+		return nil, fmt.Errorf("expiry time exceeds maximum int64")
+	}
+
+	expiry := time.Unix(int64(msgData.Expiry.Val), 0)
+
 	// Extract the suggested asset to BTC rate if provided.
-	var suggestedAssetRate fn.Option[rfqmath.BigIntFixedPoint]
+	var assetRateHint fn.Option[AssetRate]
 	msgData.SuggestedAssetRate.WhenSome(
 		func(rate tlv.RecordT[tlv.TlvType19, TlvFixedPoint]) {
 			fp := rate.Val.IntoBigIntFixedPoint()
-			suggestedAssetRate =
-				fn.Some[rfqmath.BigIntFixedPoint](fp)
+			assetRateHint = fn.Some(NewAssetRate(fp, expiry))
 		},
 	)
 
 	req := BuyRequest{
-		Peer:               wireMsg.Peer,
-		Version:            msgData.Version.Val,
-		ID:                 msgData.ID.Val,
-		AssetID:            assetID,
-		AssetGroupKey:      assetGroupKey,
-		AssetAmount:        msgData.AssetMaxAmount.Val,
-		SuggestedAssetRate: suggestedAssetRate,
+		Peer:          wireMsg.Peer,
+		Version:       msgData.Version.Val,
+		ID:            msgData.ID.Val,
+		AssetID:       assetID,
+		AssetGroupKey: assetGroupKey,
+		AssetAmount:   msgData.AssetMaxAmount.Val,
+		AssetRateHint: assetRateHint,
 	}
 
 	// Perform basic sanity checks on the quote request.
@@ -148,6 +162,17 @@ func (q *BuyRequest) Validate() error {
 			q.Version)
 	}
 
+	// Ensure that the suggested asset rate has not expired.
+	err := fn.MapOptionZ(q.AssetRateHint, func(rate AssetRate) error {
+		if rate.Expiry.Before(time.Now()) {
+			return fmt.Errorf("suggested asset rate has expired")
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -195,10 +220,19 @@ func (q *BuyRequest) String() string {
 		groupKeyBytes = q.AssetGroupKey.SerializeCompressed()
 	}
 
+	// Convert the asset rate hint to a string representation. Use empty
+	// string if the hint is not set.
+	assetRateHintStr := fn.MapOptionZ(
+		q.AssetRateHint,
+		func(rate AssetRate) string {
+			return rate.String()
+		},
+	)
+
 	return fmt.Sprintf("BuyRequest(peer=%x, id=%x, asset_id=%s, "+
-		"asset_group_key=%x, asset_amount=%d, "+
-		"suggested_asset_rate=%v)", q.Peer[:], q.ID[:], q.AssetID,
-		groupKeyBytes, q.AssetAmount, q.SuggestedAssetRate)
+		"asset_group_key=%x, asset_amount=%d, asset_rate_hint=%s)",
+		q.Peer[:], q.ID[:], q.AssetID, groupKeyBytes, q.AssetAmount,
+		assetRateHintStr)
 }
 
 // Ensure that the message type implements the OutgoingMsg interface.

rfqmsg/request.go

@@ -107,24 +107,13 @@ func newRequestWireMsgDataFromBuy(q BuyRequest) (requestWireMsgData, error) {
 	version := tlv.NewRecordT[tlv.TlvType0](q.Version)
 	id := tlv.NewRecordT[tlv.TlvType2](q.ID)
 
-	// Calculate the expiration unix timestamp in seconds.
-	// TODO(ffranr): The expiry timestamp should be obtained from the
-	//  request message.
-	expiry := tlv.NewPrimitiveRecord[tlv.TlvType6](
-		uint64(time.Now().Add(DefaultQuoteLifetime).Unix()),
-	)
-
-	assetMaxAmount := tlv.NewPrimitiveRecord[tlv.TlvType16](q.AssetAmount)
-
-	// Convert the suggested asset to BTC rate to a TLV record.
-	var suggestedAssetRate requestSuggestedAssetRate
-	q.SuggestedAssetRate.WhenSome(func(rate rfqmath.BigIntFixedPoint) {
-		// Convert the BigIntFixedPoint to a Uint64FixedPoint.
-		wireRate := NewTlvFixedPointFromBigInt(rate)
-		suggestedAssetRate = tlv.SomeRecordT[tlv.TlvType19](
-			tlv.NewRecordT[tlv.TlvType19](wireRate),
-		)
+	// Set the expiry to the default request lifetime unless an asset rate
+	// hint is provided.
+	expiry := time.Now().Add(DefaultQuoteLifetime).Unix()
+	q.AssetRateHint.WhenSome(func(assetRate AssetRate) {
+		expiry = assetRate.Expiry.Unix()
 	})
+	expiryTlv := tlv.NewPrimitiveRecord[tlv.TlvType6](uint64(expiry))
 
 	var inAssetID requestInAssetID
 	if q.AssetID != nil {
@@ -151,11 +140,23 @@ func newRequestWireMsgDataFromBuy(q BuyRequest) (requestWireMsgData, error) {
 
 	outAssetGroupKey := requestOutAssetGroupKey{}
 
+	// Convert the suggested asset to BTC rate to a TLV record.
+	var suggestedAssetRate requestSuggestedAssetRate
+	q.AssetRateHint.WhenSome(func(assetRate AssetRate) {
+		// Convert the BigIntFixedPoint to a TlvFixedPoint.
+		wireRate := NewTlvFixedPointFromBigInt(assetRate.Rate)
+		suggestedAssetRate = tlv.SomeRecordT[tlv.TlvType19](
+			tlv.NewRecordT[tlv.TlvType19](wireRate),
+		)
+	})
+
+	assetMaxAmount := tlv.NewPrimitiveRecord[tlv.TlvType16](q.AssetAmount)
+
 	// Encode message data component as TLV bytes.
 	return requestWireMsgData{
 		Version:            version,
 		ID:                 id,
-		Expiry:             expiry,
+		Expiry:             expiryTlv,
 		AssetMaxAmount:     assetMaxAmount,
 		SuggestedAssetRate: suggestedAssetRate,
 		InAssetID:          inAssetID,