asset: add function to get asset price

Author: sputn1ck

assets/client.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/btcsuite/btcd/btcutil"
+	"github.com/lightninglabs/taproot-assets/rfqmath"
 	"github.com/lightninglabs/taproot-assets/tapcfg"
 	"github.com/lightninglabs/taproot-assets/taprpc"
 	"github.com/lightninglabs/taproot-assets/taprpc/priceoraclerpc"
@@ -184,6 +185,66 @@ func (c *TapdClient) GetAssetName(ctx context.Context,
 	return assetName, nil
 }
 
+// GetAssetPrice returns the price of an asset in satoshis. NOTE: this currently
+// uses the rfq process for the asset price. A future implementation should
+// use a price oracle to not spam a peer.
+func (c *TapdClient) GetAssetPrice(ctx context.Context, assetId string,
+	assetAmt uint64, satMinAmt btcutil.Amount) (btcutil.Amount,
+	error) {
+
+	// We'll allow a short rfq expiry as we'll only use this rfq to
+	// gauge a price.
+	rfqExpiry := time.Now().Add(time.Minute).Unix()
+
+	// First we'll rfq a random peer for the asset.
+	rfq, err := c.RfqClient.AddAssetSellOrder(
+		ctx, &rfqrpc.AddAssetSellOrderRequest{
+			AssetSpecifier: &rfqrpc.AssetSpecifier{
+				Id: &rfqrpc.AssetSpecifier_AssetIdStr{
+					AssetIdStr: assetId,
+				},
+			},
+			PaymentMaxAmt:  uint64(satMinAmt),
+			Expiry:         uint64(rfqExpiry),
+			TimeoutSeconds: uint32(c.cfg.RFQtimeout.Seconds()),
+		})
+	if err != nil {
+		return 0, err
+	}
+	if rfq.GetInvalidQuote() != nil {
+		return 0, fmt.Errorf("invalid RFQ: %v", rfq.GetInvalidQuote())
+	}
+
+	if rfq.GetRejectedQuote() != nil {
+		return 0, fmt.Errorf("rejected RFQ: %v", rfq.GetRejectedQuote())
+	}
+
+	acceptedRes := rfq.GetAcceptedQuote()
+	if acceptedRes == nil {
+		return 0, fmt.Errorf("no accepted quote")
+	}
+
+	// We'll use the accepted quote to calculate the price.
+	return getSatsFromAssetAmt(assetAmt, acceptedRes.BidAssetRate)
+}
+
+// getSatsFromAssetAmt returns the amount in satoshis for the given asset amount
+// and asset rate.
+func getSatsFromAssetAmt(assetAmt uint64, assetRate *rfqrpc.FixedPoint) (
+	btcutil.Amount, error) {
+
+	rateFP, err := rfqrpc.UnmarshalFixedPoint(assetRate)
+	if err != nil {
+		return 0, fmt.Errorf("cannot unmarshal asset rate: %w", err)
+	}
+
+	assetUnits := rfqmath.NewBigIntFixedPoint(assetAmt, 0)
+
+	msatAmt := rfqmath.UnitsToMilliSatoshi(assetUnits, *rateFP)
+
+	return msatAmt.ToSatoshis(), nil
+}
+
 // getPaymentMaxAmount returns the milisat amount we are willing to pay for the
 // payment.
 func getPaymentMaxAmount(satAmount btcutil.Amount, feeLimitMultiplier float64) (

assets/client_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/btcsuite/btcd/btcutil"
+	"github.com/lightninglabs/taproot-assets/taprpc/rfqrpc"
 	"github.com/lightningnetwork/lnd/lnwire"
 )
 
@@ -65,3 +66,53 @@ func TestGetPaymentMaxAmount(t *testing.T) {
 		}
 	}
 }
+
+func TestGetSatsFromAssetAmt(t *testing.T) {
+	tests := []struct {
+		assetAmt    uint64
+		assetRate   *rfqrpc.FixedPoint
+		expected    btcutil.Amount
+		expectError bool
+	}{
+		{
+			assetAmt:    1000000,
+			assetRate:   &rfqrpc.FixedPoint{Coefficient: "100000000", Scale: 8},
+			expected:    btcutil.Amount(1000000),
+			expectError: false,
+		},
+		{
+			assetAmt:    500000,
+			assetRate:   &rfqrpc.FixedPoint{Coefficient: "200000000", Scale: 8},
+			expected:    btcutil.Amount(1000000),
+			expectError: false,
+		},
+		{
+			assetAmt:    0,
+			assetRate:   &rfqrpc.FixedPoint{Coefficient: "100000000", Scale: 8},
+			expected:    btcutil.Amount(0),
+			expectError: false,
+		},
+		{
+			assetAmt:    1000000,
+			assetRate:   &rfqrpc.FixedPoint{Coefficient: "0", Scale: 8},
+			expected:    btcutil.Amount(0),
+			expectError: true,
+		},
+	}
+
+	for _, test := range tests {
+		result, err := getSatsFromAssetAmt(test.assetAmt, test.assetRate)
+		if test.expectError {
+			if err == nil {
+				t.Fatalf("expected error but got none")
+			}
+		} else {
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if result != test.expected {
+				t.Fatalf("expected %v, got %v", test.expected, result)
+			}
+		}
+	}
+}