itest: enhance multi-rfq itest with sending

Author: GeorgeTsagk

itest/assets_test.go

@@ -1355,7 +1355,7 @@ func sendAssetKeySendPayment(t *testing.T, src, dst *HarnessNode, amt uint64,
 		return
 	}
 
-	result, err := getAssetPaymentResult(stream, false)
+	result, _, err := getAssetPaymentResult(t, stream, false)
 	require.NoError(t, err)
 	if result.Status == lnrpc.Payment_FAILED {
 		t.Logf("Failure reason: %v", result.FailureReason)
@@ -1719,7 +1719,13 @@ func payInvoiceWithAssets(t *testing.T, payer, rfqPeer *HarnessNode,
 	// was established, no network or auth error), we expect the error to be
 	// returned on the first read on the stream.
 	if cfg.errSubStr != "" {
-		_, err := stream.Recv()
+		msg, err := stream.Recv()
+
+		// On errors we still get an empty set of RFQs as a response.
+		if msg.GetAcceptedSellOrders() != nil {
+			_, err = stream.Recv()
+		}
+
 		require.ErrorContains(t, err, cfg.errSubStr)
 
 		return 0, rfqmath.BigIntFixedPoint{}
@@ -1729,39 +1735,18 @@ func payInvoiceWithAssets(t *testing.T, payer, rfqPeer *HarnessNode,
 		numUnits uint64
 		rateVal  rfqmath.FixedPoint[rfqmath.BigInt]
 	)
-	if cfg.rfq.IsNone() {
-		// We want to receive the accepted quote message first, so we
-		// know how many assets we're going to pay.
-		quoteMsg, err := stream.Recv()
-		require.NoError(t, err)
-		acceptedQuote := quoteMsg.GetAcceptedSellOrder()
-		require.NotNil(t, acceptedQuote)
-
-		rpcRate := acceptedQuote.BidAssetRate
-		rate, err := rpcutils.UnmarshalRfqFixedPoint(rpcRate)
-		require.NoError(t, err)
 
-		rateVal = *rate
-
-		t.Logf("Got quote for %v asset units per BTC", rate)
-
-		amountMsat := lnwire.MilliSatoshi(decodedInvoice.NumMsat)
-		milliSatsFP := rfqmath.MilliSatoshiToUnits(amountMsat, *rate)
-		numUnits = milliSatsFP.ScaleTo(0).ToUint64()
-		msatPerUnit := float64(decodedInvoice.NumMsat) /
-			float64(numUnits)
-		t.Logf("Got quote for %v asset units at %3f msat/unit from "+
-			"peer %s with SCID %d", numUnits, msatPerUnit,
-			peerPubKey, acceptedQuote.Scid)
-	}
-
-	result, err := getAssetPaymentResult(
-		stream, cfg.payStatus == lnrpc.Payment_IN_FLIGHT,
+	result, rateVal, err := getAssetPaymentResult(
+		t, stream, cfg.payStatus == lnrpc.Payment_IN_FLIGHT,
 	)
 	require.NoError(t, err)
 	require.Equal(t, cfg.payStatus, result.Status)
 	require.Equal(t, cfg.failureReason, result.FailureReason)
 
+	amountMsat := lnwire.MilliSatoshi(decodedInvoice.NumMsat)
+	milliSatsFP := rfqmath.MilliSatoshiToUnits(amountMsat, rateVal)
+	numUnits = milliSatsFP.ScaleTo(0).ToUint64()
+
 	return numUnits, rateVal
 }
 

itest/litd_accounts_test.go

@@ -10,6 +10,8 @@ import (
 
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/lightninglabs/lightning-terminal/litrpc"
+	"github.com/lightninglabs/taproot-assets/rfqmath"
+	"github.com/lightninglabs/taproot-assets/rpcutils"
 	"github.com/lightninglabs/taproot-assets/taprpc/tapchannelrpc"
 	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
@@ -443,43 +445,75 @@ func getPaymentResult(stream routerrpc.Router_SendPaymentV2Client,
 	}
 }
 
-func getAssetPaymentResult(
+func getAssetPaymentResult(t *testing.T,
 	s tapchannelrpc.TaprootAssetChannels_SendPaymentClient,
-	isHodl bool) (*lnrpc.Payment, error) {
+	isHodl bool) (*lnrpc.Payment, rfqmath.FixedPoint[rfqmath.BigInt],
+	error) {
 
 	// No idea why it makes a difference whether we wait before calling
 	// s.Recv() or not, but it does. Without the sleep, the test will fail
 	// with "insufficient local balance"... ¯\_(ツ)_/¯
 	// Probably something weird within lnd itself.
 	time.Sleep(time.Second)
 
+	var rateVal rfqmath.FixedPoint[rfqmath.BigInt]
+
 	for {
 		msg, err := s.Recv()
 		if err != nil {
-			return nil, err
+			return nil, rateVal, err
 		}
 
 		// Ignore RFQ quote acceptance messages read from the send
 		// payment stream, as they are not relevant.
 		quote := msg.GetAcceptedSellOrder()
 		if quote != nil {
+			rpcRate := quote.BidAssetRate
+			rate, err := rpcutils.UnmarshalRfqFixedPoint(rpcRate)
+			require.NoError(t, err)
+
+			rateVal = *rate
+
+			t.Logf("Got quote for %v asset units per BTC from "+
+				"peer %v", rate, quote.Peer)
+			continue
+		}
+
+		// Ignore the new RFQ array message from the stream, it is also
+		// not relevant.
+		quotes := msg.GetAcceptedSellOrders()
+		if quotes != nil {
+			for _, quote := range quotes.AcceptedSellOrders {
+				rpcRate := quote.BidAssetRate
+				rate, err := rpcutils.UnmarshalRfqFixedPoint(
+					rpcRate,
+				)
+				require.NoError(t, err)
+
+				rateVal = *rate
+
+				t.Logf("Got quote for %v asset units per BTC "+
+					"from peer %v", rate, quote.Peer)
+			}
+
 			continue
 		}
 
 		payment := msg.GetPaymentResult()
 		if payment == nil {
-			return nil, fmt.Errorf("unexpected message: %v", msg)
+			return nil, rateVal,
+				fmt.Errorf("unexpected message: %v", msg)
 		}
 
 		// If this is a hodl payment, then we'll return the first
 		// expected response. Otherwise, we'll wait until the in flight
 		// clears to we can observe the other payment states.
 		switch {
 		case isHodl:
-			return payment, nil
+			return payment, rateVal, nil
 
 		case payment.Status != lnrpc.Payment_IN_FLIGHT:
-			return payment, nil
+			return payment, rateVal, nil
 		}
 	}
 }

itest/litd_custom_channels_test.go

@@ -2613,9 +2613,9 @@ func testCustomChannelsLiquidityEdgeCasesCore(ctx context.Context,
 
 	payInvoiceWithAssets(
 		t.t, charlie, dave, btcInvoiceResp.PaymentRequest, assetID,
-		withFeeLimit(2_000), withPayErrSubStr(
-			"rejecting payment of 20000 mSAT",
-		), withGroupKey(groupID),
+		withFeeLimit(2_000), withGroupKey(groupID), withPayErrSubStr(
+			"failed to acquire any quotes",
+		),
 	)
 
 	// When we override the uneconomical payment, it should succeed.
@@ -2640,7 +2640,7 @@ func testCustomChannelsLiquidityEdgeCasesCore(ctx context.Context,
 	payInvoiceWithAssets(
 		t.t, charlie, dave, btcInvoiceResp.PaymentRequest, assetID,
 		withFeeLimit(1_000), withAllowOverpay(), withPayErrSubStr(
-			"rejecting payment of 2000 mSAT",
+			"failed to acquire any quotes",
 		), withGroupKey(groupID),
 	)
 
@@ -2971,10 +2971,11 @@ func testCustomChannelsLiquidityEdgeCasesGroup(ctx context.Context,
 	testCustomChannelsLiquidityEdgeCasesCore(ctx, net, t, true)
 }
 
-// testCustomChannelsMultiRFQReceive tests that a node creating an invoice with
-// multiple RFQ quotes can actually guide the payer into using multiple private
-// taproot asset channels to pay the invoice.
-func testCustomChannelsMultiRFQReceive(ctx context.Context, net *NetworkHarness,
+// testCustomChannelsMultiRFQ tests that sending and receiving payments works
+// when using the multi-rfq features of tapd. This means that liquidity across
+// multiple channels and peers can be used to send out a payment, or receive to
+// an invoice.
+func testCustomChannelsMultiRFQ(ctx context.Context, net *NetworkHarness,
 	t *harnessTest) {
 
 	lndArgs := slices.Clone(lndArgsTemplate)
@@ -3068,7 +3069,6 @@ func testCustomChannelsMultiRFQReceive(ctx context.Context, net *NetworkHarness,
 		t.t, charlie, &lnrpc.AddInvoiceResponse{
 			PaymentRequest: hodlInv.payReq,
 		},
-		withGroupKey(groupID),
 		withFailure(lnrpc.Payment_IN_FLIGHT, failureNone),
 	)
 
@@ -3100,13 +3100,88 @@ func testCustomChannelsMultiRFQReceive(ctx context.Context, net *NetworkHarness,
 	// Now let's create a normal invoice that will be settled once all the
 	// HTLCs have been received. This is only possible because the payer
 	// uses multiple bolt11 hop hints to reach the destination.
-	invoiceResp := createAssetInvoice(t.t, nil, fabia, 15_000, assetID)
+	invoiceResp := createAssetInvoice(
+		t.t, nil, fabia, 15_000, nil, withInvGroupKey(groupID),
+	)
 
 	payInvoiceWithSatoshi(
-		t.t, charlie, invoiceResp, withGroupKey(groupID),
+		t.t, charlie, invoiceResp,
 	)
 
 	logBalance(t.t, nodes, assetID, "after multi-rfq receive")
+
+	// Now we'll test that sending with multiple rfq quotes works.
+
+	// Let's start by providing some liquidity to Charlie's peers, in order
+	// for them to be able to push some amount if Fabia picks them as part
+	// of the route.
+	sendKeySendPayment(t.t, charlie, erin, 800_000)
+	sendKeySendPayment(t.t, charlie, dave, 800_000)
+	sendKeySendPayment(t.t, charlie, yara, 800_000)
+
+	// Let's ask for the rough equivalent of ~15k assets. Fabia, who's going
+	// to pay the invoice, only has parts of assets that are less than 10k
+	// in channels with one of the 3 intermediate peers. The only way to
+	// pay this invoice is by splitting the payment across multiple peers by
+	// using multiple RFQ quotes.
+	invAmt := int64(15_000 * 17)
+
+	iResp, err := charlie.AddHoldInvoice(
+		ctx, &invoicesrpc.AddHoldInvoiceRequest{
+			Memo:  "",
+			Value: invAmt,
+			Hash:  payHash[:],
+		},
+	)
+	require.NoError(t.t, err)
+
+	payReq := iResp.PaymentRequest
+
+	payInvoiceWithAssets(
+		t.t, fabia, nil, payReq, assetID,
+		withFailure(lnrpc.Payment_IN_FLIGHT, failureNone),
+	)
+
+	assertMinNumHtlcs(t.t, charlie, 2)
+	assertMinNumHtlcs(t.t, fabia, 2)
+
+	logBalance(t.t, nodes, assetID, "multi-rfq send in-flight")
+
+	_, err = charlie.SettleInvoice(ctx, &invoicesrpc.SettleInvoiceMsg{
+		Preimage: hodlInv.preimage[:],
+	})
+	require.NoError(t.t, err)
+
+	assertNumHtlcs(t.t, charlie, 0)
+	assertNumHtlcs(t.t, fabia, 0)
+
+	logBalance(t.t, nodes, assetID, "after multi-rfq send")
+
+	// Let's make another round-trip involving multi-rfq functionality.
+	// Let's have Fabia receive another large payment and send it back
+	// again, this time with a greater amount.
+	invoiceResp = createAssetInvoice(t.t, nil, fabia, 25_000, assetID)
+
+	payInvoiceWithSatoshi(
+		t.t, charlie, invoiceResp,
+	)
+
+	logBalance(t.t, nodes, assetID, "after multi-rfq receive (2nd)")
+
+	// Let's bump up the invoice amount a bit, to roughly ~22k assets.
+	invAmt = 22_000 * 17
+	inv, err := charlie.AddInvoice(ctx, &lnrpc.Invoice{
+		Value: invAmt,
+	})
+	require.NoError(t.t, err)
+
+	payReq = inv.PaymentRequest
+
+	payInvoiceWithAssets(
+		t.t, fabia, nil, payReq, nil, withGroupKey(groupID),
+	)
+
+	logBalance(t.t, nodes, assetID, "after multi-rfq send (2nd)")
 }
 
 // testCustomChannelsStrictForwarding is a test that tests the strict forwarding

itest/litd_test_list_on_test.go

@@ -130,7 +130,7 @@ var allTestCases = []*testCase{
 	},
 	{
 		name:       "custom channels multi rfq",
-		test:       testCustomChannelsMultiRFQReceive,
+		test:       testCustomChannelsMultiRFQ,
 		noAliceBob: true,
 	},
 	{