wip

Author: sputn1ck

assets/client.go

@@ -2,9 +2,11 @@ package assets
 
 import (
 	"context"
+	"encoding/hex"
 	"fmt"
 	"math/big"
 	"os"
+	"sync"
 	"time"
 
 	"github.com/btcsuite/btcd/btcutil"
@@ -13,6 +15,7 @@ import (
 	"github.com/lightninglabs/taproot-assets/taprpc/priceoraclerpc"
 	"github.com/lightninglabs/taproot-assets/taprpc/rfqrpc"
 	"github.com/lightninglabs/taproot-assets/taprpc/tapchannelrpc"
+	"github.com/lightninglabs/taproot-assets/taprpc/universerpc"
 	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/lightningnetwork/lnd/macaroons"
 	"google.golang.org/grpc"
@@ -44,11 +47,14 @@ func DefaultTapdConfig() *TapdConfig {
 
 // TapdClient is a client for the Tap daemon.
 type TapdClient struct {
-	cc *grpc.ClientConn
+	sync.Mutex
+	assetNameCache map[string]string
+	cc             *grpc.ClientConn
 	taprpc.TaprootAssetsClient
 	tapchannelrpc.TaprootAssetChannelsClient
 	priceoraclerpc.PriceOracleClient
 	rfqrpc.RfqClient
+	universerpc.UniverseClient
 }
 
 // NewTapdClient retusn a new taproot assets client.
@@ -61,11 +67,13 @@ func NewTapdClient(config *TapdConfig) (*TapdClient, error) {
 
 	// Create the TapdClient.
 	client := &TapdClient{
+		assetNameCache:             make(map[string]string),
 		cc:                         conn,
 		TaprootAssetsClient:        taprpc.NewTaprootAssetsClient(conn),
 		TaprootAssetChannelsClient: tapchannelrpc.NewTaprootAssetChannelsClient(conn),
 		PriceOracleClient:          priceoraclerpc.NewPriceOracleClient(conn),
 		RfqClient:                  rfqrpc.NewRfqClient(conn),
+		UniverseClient:             universerpc.NewUniverseClient(conn),
 	}
 
 	return client, nil
@@ -104,12 +112,12 @@ func GetSatAmtFromRfq(assetAmt btcutil.Amount,
 // GetRfqForAsset returns a RFQ for the given asset with the given amount and
 // to the given peer.
 func (c *TapdClient) GetRfqForAsset(ctx context.Context,
-	amt btcutil.Amount, assetId, peerPubkey []byte) (
+	satAmount btcutil.Amount, assetId, peerPubkey []byte) (
 	*rfqrpc.PeerAcceptedSellQuote, error) {
 
 	// TODO(sputn1ck): magic value, should be configurable?
 	feeLimit, err := lnrpc.UnmarshallAmt(
-		int64(amt)+int64(amt.MulF64(1.1)), 0,
+		int64(satAmount)+int64(satAmount.MulF64(1.1)), 0,
 	)
 	if err != nil {
 		return nil, err
@@ -148,6 +156,44 @@ func (c *TapdClient) GetRfqForAsset(ctx context.Context,
 	return nil, fmt.Errorf("no accepted quote")
 }
 
+// GetAssetName returns the human readable name of the asset.
+func (c *TapdClient) GetAssetName(ctx context.Context,
+	assetId []byte) (string, error) {
+
+	c.Lock()
+	defer c.Unlock()
+	assetIdStr := hex.EncodeToString(assetId)
+	if name, ok := c.assetNameCache[assetIdStr]; ok {
+		return name, nil
+	}
+
+	assetStats, err := c.UniverseClient.QueryAssetStats(
+		ctx, &universerpc.AssetStatsQuery{
+			AssetIdFilter: assetId,
+		},
+	)
+	if err != nil {
+		return "", err
+	}
+
+	if len(assetStats.AssetStats) == 0 {
+		return "", fmt.Errorf("asset not found")
+	}
+
+	var assetName string
+
+	// If the asset belongs to a group, return the group name.
+	if assetStats.AssetStats[0].GroupAnchor != nil {
+		assetName = assetStats.AssetStats[0].GroupAnchor.AssetName
+	} else {
+		assetName = assetStats.AssetStats[0].Asset.AssetName
+	}
+
+	c.assetNameCache[assetIdStr] = assetName
+
+	return assetName, nil
+}
+
 func getClientConn(config *TapdConfig) (*grpc.ClientConn, error) {
 	// Load the specified TLS certificate and build transport credentials.
 	creds, err := credentials.NewClientTLSFromFile(config.TLSPath, "")

client.go

@@ -97,8 +97,9 @@ type Client struct {
 	executor    *executor
 	assetClient *assets.TapdClient
 
-	resumeReady chan struct{}
-	wg          sync.WaitGroup
+	resumeReady    chan struct{}
+	wg             sync.WaitGroup
+	assetNameCache map[string]string
 
 	clientConfig
 }
@@ -342,6 +343,10 @@ func (s *Client) FetchSwaps(ctx context.Context) ([]*SwapInfo, error) {
 			return nil, swap.ErrInvalidOutputType
 		}
 
+		if swp.Contract.AssetSwapInfo != nil {
+			swapInfo.AssetSwapInfo = swp.Contract.AssetSwapInfo
+		}
+
 		swaps = append(swaps, swapInfo)
 	}
 
@@ -507,43 +512,31 @@ 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")
+		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")
 		}
 
-		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, request.DestAddr,
+			request.OutgoingChanSet, request.AssetId,
+		)
+	} else {
+		log.Infof("LoopOut %v to %v (channels: %v)",
+			request.Amount, request.DestAddr,
+			request.OutgoingChanSet,
 		)
-		request.Amount = satAmt
 	}
 
-	log.Infof("LoopOut %v to %v (channels: %v)",
-		request.Amount, request.DestAddr, request.OutgoingChanSet,
-	)
-
 	if err := s.waitForInitialized(globalCtx); err != nil {
 		return nil, err
 	}
@@ -563,7 +556,9 @@ 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,
@@ -609,36 +604,26 @@ func (s *Client) getExpiry(height int32, terms *LoopOutTerms,
 func (s *Client) LoopOutQuote(ctx context.Context,
 	request *LoopOutQuoteRequest) (*LoopOutQuote, error) {
 
-	terms, err := s.Server.GetLoopOutTerms(ctx, request.Initiator)
-	if err != nil {
-		return nil, err
+	if request.AssetId != nil && request.AssetEdgeNode == nil {
+		return nil, errors.New("asset edge node must be set " +
+			"when using an asset id")
 	}
 
-	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
-		}
+	if request.AssetEdgeNode != nil && request.AssetId == nil {
+		return nil, errors.New("asset id must be set " +
+			"when using an asset edge node")
+	}
 
-		invoiceAmountSat, err = assets.GetSatAmtFromRfq(
-			request.Amount, rfq.BidAssetRate,
-		)
-		if err != nil {
-			return nil, err
-		}
+	terms, err := s.Server.GetLoopOutTerms(ctx, request.Initiator)
+	if err != nil {
+		return nil, err
 	}
 
-	if invoiceAmountSat < terms.MinSwapAmount {
+	if request.Amount < terms.MinSwapAmount {
 		return nil, ErrSwapAmountTooLow
 	}
 
-	if invoiceAmountSat > terms.MaxSwapAmount {
+	if request.Amount > terms.MaxSwapAmount {
 		return nil, ErrSwapAmountTooHigh
 	}
 
@@ -649,7 +634,7 @@ func (s *Client) LoopOutQuote(ctx context.Context,
 	}
 
 	quote, err := s.Server.GetLoopOutQuote(
-		ctx, invoiceAmountSat, expiry, request.SwapPublicationDeadline,
+		ctx, request.Amount, expiry, request.SwapPublicationDeadline,
 		request.Initiator,
 	)
 	if err != nil {
@@ -663,13 +648,56 @@ 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,
-		InvoiceAmtSat:   invoiceAmountSat,
-	}, 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

cmd/loop/loopout.go

@@ -149,6 +149,10 @@ func loopOut(ctx *cli.Context) error {
 	// element.
 	var outgoingChanSet []uint64
 	if ctx.IsSet("channel") {
+		if ctx.IsSet("asset_id") {
+			return fmt.Errorf("channel flag is not supported when " +
+				"looping out assets")
+		}
 		chanStrings := strings.Split(ctx.String("channel"), ",")
 		for _, chanString := range chanStrings {
 			chanID, err := strconv.ParseUint(chanString, 10, 64)
@@ -201,7 +205,7 @@ func loopOut(ctx *cli.Context) error {
 		}
 	}
 
-	var assetLoopOutInfo *looprpc.AssetLoopOutInfo
+	var assetLoopOutInfo *looprpc.AssetLoopOutRequest
 
 	var assetId []byte
 	if ctx.IsSet("asset_id") {
@@ -222,7 +226,7 @@ func loopOut(ctx *cli.Context) error {
 			return err
 		}
 
-		assetLoopOutInfo = &looprpc.AssetLoopOutInfo{
+		assetLoopOutInfo = &looprpc.AssetLoopOutRequest{
 			AssetId:       assetId,
 			AssetEdgeNode: assetEdgeNode,
 		}
@@ -325,6 +329,7 @@ func loopOut(ctx *cli.Context) error {
 		Initiator:               defaultInitiator,
 		PaymentTimeout:          uint32(paymentTimeout),
 		AssetInfo:               assetLoopOutInfo,
+		AssetRfqInfo:            quote.AssetRfqInfo,
 	})
 	if err != nil {
 		return err

cmd/loop/main.go

@@ -96,6 +96,13 @@ const (
 	//      Estimated on-chain fee:                      7262 sat
 	satAmtFmt = "%-36s %12d sat\n"
 
+	// assetAmtFormat formats a value into a one line string, intended to
+	// prettify the terminal output. For Instance,
+	// 	fmt.Printf(f, "Amount:", amt, "USD")
+	// prints out as,
+	//      Amount:                                    50 USD
+	assetAmtFmt = "%-36s %12d %s\n"
+
 	// blkFmt formats the number of blocks into a one line string, intended
 	// to prettify the terminal output. For Instance,
 	// 	fmt.Printf(f, "Conf target", target)