cmd+itest: use new tapchannelrpc.AddInvoice RPC

Author: guggero

cmd/litcli/ln.go

@@ -9,18 +9,16 @@ import (
 	"errors"
 	"fmt"
 	"strconv"
-	"time"
 
 	"github.com/lightninglabs/taproot-assets/asset"
+	"github.com/lightninglabs/taproot-assets/rfq"
 	"github.com/lightninglabs/taproot-assets/rfqmsg"
 	"github.com/lightninglabs/taproot-assets/taprpc"
-	"github.com/lightninglabs/taproot-assets/taprpc/rfqrpc"
 	tchrpc "github.com/lightninglabs/taproot-assets/taprpc/tapchannelrpc"
 	"github.com/lightningnetwork/lnd/cmd/commands"
 	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
 	"github.com/lightningnetwork/lnd/lntypes"
-	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/record"
 	"github.com/urfave/cli"
 	"google.golang.org/grpc"
@@ -550,6 +548,8 @@ func addInvoice(ctx *cli.Context) error {
 
 	var (
 		assetAmount uint64
+		preimage    []byte
+		descHash    []byte
 		err         error
 	)
 	switch {
@@ -565,148 +565,53 @@ func addInvoice(ctx *cli.Context) error {
 		return fmt.Errorf("asset_amount argument missing")
 	}
 
-	expiry := time.Now().Add(300 * time.Second)
-	if ctx.IsSet("expiry") {
-		expirySeconds := ctx.Uint64("expiry")
-		expiry = time.Now().Add(
-			time.Duration(expirySeconds) * time.Second,
-		)
+	if ctx.IsSet("preimage") {
+		preimage, err = hex.DecodeString(ctx.String("preimage"))
+		if err != nil {
+			return fmt.Errorf("unable to parse preimage: %w", err)
+		}
 	}
 
-	lndConn, cleanup, err := connectClient(ctx, false)
+	descHash, err = hex.DecodeString(ctx.String("description_hash"))
 	if err != nil {
-		return fmt.Errorf("unable to make rpc con: %w", err)
+		return fmt.Errorf("unable to parse description_hash: %w", err)
 	}
 
-	defer cleanup()
-
-	lndClient := lnrpc.NewLightningClient(lndConn)
+	expirySeconds := int64(rfq.DefaultInvoiceExpiry.Seconds())
+	if ctx.IsSet("expiry") {
+		expirySeconds = ctx.Int64("expiry")
+	}
 
 	assetIDBytes, err := hex.DecodeString(assetIDStr)
 	if err != nil {
 		return fmt.Errorf("unable to decode assetID: %v", err)
 	}
 
-	// First, based on the asset ID and amount, we'll make sure that this
-	// channel even has enough funds to send.
-	assetBalances, err := computeAssetBalances(lndClient)
-	if err != nil {
-		return fmt.Errorf("unable to compute asset balances: %w", err)
-	}
-
-	balance, ok := assetBalances.Assets[assetIDStr]
-	if !ok {
-		return fmt.Errorf("unable to send asset_id=%v, not in "+
-			"channel", assetIDStr)
-	}
-
-	if balance.RemoteBalance == 0 {
-		return fmt.Errorf("no remote asset balance available for "+
-			"receiving asset_id=%v", assetIDStr)
-	}
-
 	var assetID asset.ID
 	copy(assetID[:], assetIDBytes)
 
 	tapdConn, cleanup, err := connectTapdClient(ctx)
 	if err != nil {
 		return fmt.Errorf("error creating tapd connection: %w", err)
 	}
-
 	defer cleanup()
 
-	peerPubKey, err := hex.DecodeString(balance.Channel.RemotePubkey)
-	if err != nil {
-		return fmt.Errorf("unable to decode peer pubkey: %w", err)
-	}
-
-	rfqClient := rfqrpc.NewRfqClient(tapdConn)
-
-	timeoutSeconds := uint32(60)
-	fmt.Printf("Asking peer %x for quote to buy assets to receive for "+
-		"invoice over %d units; waiting up to %ds\n", peerPubKey,
-		assetAmount, timeoutSeconds)
-
-	resp, err := rfqClient.AddAssetBuyOrder(
-		ctxb, &rfqrpc.AddAssetBuyOrderRequest{
-			AssetSpecifier: &rfqrpc.AssetSpecifier{
-				Id: &rfqrpc.AssetSpecifier_AssetIdStr{
-					AssetIdStr: assetIDStr,
-				},
-			},
-			MinAssetAmount: assetAmount,
-			Expiry:         uint64(expiry.Unix()),
-			PeerPubKey:     peerPubKey,
-			TimeoutSeconds: timeoutSeconds,
+	channelsClient := tchrpc.NewTaprootAssetChannelsClient(tapdConn)
+	resp, err := channelsClient.AddInvoice(ctxb, &tchrpc.AddInvoiceRequest{
+		AssetId:     assetIDBytes,
+		AssetAmount: assetAmount,
+		InvoiceRequest: &lnrpc.Invoice{
+			Memo:            ctx.String("memo"),
+			RPreimage:       preimage,
+			DescriptionHash: descHash,
+			FallbackAddr:    ctx.String("fallback_addr"),
+			Expiry:          expirySeconds,
+			Private:         ctx.Bool("private"),
+			IsAmp:           ctx.Bool("amp"),
 		},
-	)
-	if err != nil {
-		return fmt.Errorf("error adding sell order: %w", err)
-	}
-
-	var acceptedQuote *rfqrpc.PeerAcceptedBuyQuote
-	switch r := resp.Response.(type) {
-	case *rfqrpc.AddAssetBuyOrderResponse_AcceptedQuote:
-		acceptedQuote = r.AcceptedQuote
-
-	case *rfqrpc.AddAssetBuyOrderResponse_InvalidQuote:
-		return fmt.Errorf("peer %v sent back an invalid quote, "+
-			"status: %v", r.InvalidQuote.Peer,
-			r.InvalidQuote.Status.String())
-
-	case *rfqrpc.AddAssetBuyOrderResponse_RejectedQuote:
-		return fmt.Errorf("peer %v rejected the quote, code: %v, "+
-			"error message: %v", r.RejectedQuote.Peer,
-			r.RejectedQuote.ErrorCode, r.RejectedQuote.ErrorMessage)
-
-	default:
-		return fmt.Errorf("unexpected response type: %T", r)
-	}
-
-	msatPerUnit := acceptedQuote.AskPrice
-	numMSats := lnwire.MilliSatoshi(assetAmount * msatPerUnit)
-
-	descHash, err := hex.DecodeString(ctx.String("description_hash"))
-	if err != nil {
-		return fmt.Errorf("unable to parse description_hash: %w", err)
-	}
-
-	ourPolicy, err := getOurPolicy(
-		lndClient, balance.Channel.ChanId, balance.Channel.RemotePubkey,
-	)
-	if err != nil {
-		return fmt.Errorf("unable to get our policy: %w", err)
-	}
-
-	hopHint := &lnrpc.HopHint{
-		NodeId:                    balance.Channel.RemotePubkey,
-		ChanId:                    acceptedQuote.Scid,
-		FeeBaseMsat:               uint32(ourPolicy.FeeBaseMsat),
-		FeeProportionalMillionths: uint32(ourPolicy.FeeRateMilliMsat),
-		CltvExpiryDelta:           ourPolicy.TimeLockDelta,
-	}
-
-	invoice := &lnrpc.Invoice{
-		Memo:            ctx.String("memo"),
-		ValueMsat:       int64(numMSats),
-		DescriptionHash: descHash,
-		FallbackAddr:    ctx.String("fallback_addr"),
-		Expiry:          int64(ctx.Uint64("expiry")),
-		Private:         ctx.Bool("private"),
-		IsAmp:           ctx.Bool("amp"),
-		RouteHints: []*lnrpc.RouteHint{
-			{
-				HopHints: []*lnrpc.HopHint{hopHint},
-			},
-		},
-	}
-
-	invoiceResp, err := lndClient.AddInvoice(ctxb, invoice)
-	if err != nil {
-		return err
-	}
+	})
 
-	printRespJSON(invoiceResp)
+	printRespJSON(resp)
 
 	return nil
 }

itest/assets_test.go

@@ -19,6 +19,7 @@ import (
 	"github.com/davecgh/go-spew/spew"
 	"github.com/lightninglabs/taproot-assets/itest"
 	"github.com/lightninglabs/taproot-assets/proof"
+	"github.com/lightninglabs/taproot-assets/rfq"
 	"github.com/lightninglabs/taproot-assets/rfqmsg"
 	"github.com/lightninglabs/taproot-assets/tapchannel"
 	"github.com/lightninglabs/taproot-assets/tapfreighter"
@@ -779,91 +780,40 @@ func createAssetInvoice(t *testing.T, dstRfqPeer, dst *HarnessNode,
 	ctxt, cancel := context.WithTimeout(ctxb, defaultTimeout)
 	defer cancel()
 
-	timeoutSeconds := uint32(60)
-	expiry := time.Now().Add(time.Duration(timeoutSeconds) * time.Second)
+	timeoutSeconds := int64(rfq.DefaultInvoiceExpiry.Seconds())
 
 	t.Logf("Asking peer %x for quote to buy assets to receive for "+
 		"invoice over %d units; waiting up to %ds",
 		dstRfqPeer.PubKey[:], assetAmount, timeoutSeconds)
 
 	dstTapd := newTapClient(t, dst)
-	resp, err := dstTapd.AddAssetBuyOrder(
-		ctxt, &rfqrpc.AddAssetBuyOrderRequest{
-			AssetSpecifier: &rfqrpc.AssetSpecifier{
-				Id: &rfqrpc.AssetSpecifier_AssetId{
-					AssetId: assetID,
-				},
-			},
-			MinAssetAmount: assetAmount,
-			Expiry:         uint64(expiry.Unix()),
-			PeerPubKey:     dstRfqPeer.PubKey[:],
-			TimeoutSeconds: timeoutSeconds,
-		},
-	)
-	require.NoError(t, err)
-
-	var acceptedQuote *rfqrpc.PeerAcceptedBuyQuote
-	switch r := resp.Response.(type) {
-	case *rfqrpc.AddAssetBuyOrderResponse_AcceptedQuote:
-		acceptedQuote = r.AcceptedQuote
-
-	case *rfqrpc.AddAssetBuyOrderResponse_InvalidQuote:
-		t.Fatalf("peer %v sent back an invalid quote, "+
-			"status: %v", r.InvalidQuote.Peer,
-			r.InvalidQuote.Status.String())
-
-	case *rfqrpc.AddAssetBuyOrderResponse_RejectedQuote:
-		t.Fatalf("peer %v rejected the quote, code: %v, "+
-			"error message: %v", r.RejectedQuote.Peer,
-			r.RejectedQuote.ErrorCode, r.RejectedQuote.ErrorMessage)
 
-	default:
-		t.Fatalf("unexpected response type: %T", r)
-	}
-
-	mSatPerUnit := acceptedQuote.AskPrice
-	numMSats := lnwire.MilliSatoshi(assetAmount * mSatPerUnit)
-
-	t.Logf("Got quote for %d sats at %v msat/unit from peer %x with SCID "+
-		"%d", numMSats.ToSatoshis(), mSatPerUnit, dstRfqPeer.PubKey[:],
-		acceptedQuote.Scid)
-
-	peerChannels, err := dst.ListChannels(ctxt, &lnrpc.ListChannelsRequest{
-		Peer: dstRfqPeer.PubKey[:],
+	resp, err := dstTapd.AddInvoice(ctxt, &tchrpc.AddInvoiceRequest{
+		AssetId:     assetID,
+		AssetAmount: assetAmount,
+		InvoiceRequest: &lnrpc.Invoice{
+			Memo: fmt.Sprintf("this is an asset invoice over "+
+				"%d units", assetAmount),
+			Expiry: timeoutSeconds,
+		},
 	})
 	require.NoError(t, err)
-	require.Len(t, peerChannels.Channels, 1)
-	peerChannel := peerChannels.Channels[0]
 
-	ourPolicy, err := getOurPolicy(
-		dst, peerChannel.ChanId, dstRfqPeer.PubKeyStr,
-	)
+	decodedInvoice, err := dst.DecodePayReq(ctxt, &lnrpc.PayReqString{
+		PayReq: resp.InvoiceResult.PaymentRequest,
+	})
 	require.NoError(t, err)
 
-	hopHint := &lnrpc.HopHint{
-		NodeId:                    dstRfqPeer.PubKeyStr,
-		ChanId:                    acceptedQuote.Scid,
-		FeeBaseMsat:               uint32(ourPolicy.FeeBaseMsat),
-		FeeProportionalMillionths: uint32(ourPolicy.FeeRateMilliMsat),
-		CltvExpiryDelta:           ourPolicy.TimeLockDelta,
-	}
+	mSatPerUnit := resp.AcceptedBuyQuote.AskPrice
+	numMSats := lnwire.MilliSatoshi(assetAmount * mSatPerUnit)
 
-	invoice := &lnrpc.Invoice{
-		Memo: fmt.Sprintf("this is an asset invoice over "+
-			"%d units", assetAmount),
-		ValueMsat: int64(numMSats),
-		Expiry:    int64(timeoutSeconds),
-		RouteHints: []*lnrpc.RouteHint{
-			{
-				HopHints: []*lnrpc.HopHint{hopHint},
-			},
-		},
-	}
+	require.EqualValues(t, numMSats, decodedInvoice.NumMsat)
 
-	invoiceResp, err := dst.AddInvoice(ctxb, invoice)
-	require.NoError(t, err)
+	t.Logf("Got quote for %d sats at %v msat/unit from peer %x with SCID "+
+		"%d", decodedInvoice.NumMsat, mSatPerUnit, dstRfqPeer.PubKey[:],
+		resp.AcceptedBuyQuote.Scid)
 
-	return invoiceResp
+	return resp.InvoiceResult
 }
 
 func waitForSendEvent(t *testing.T,