itest: add new strict forwarding test

Author: guggero

itest/assets_test.go

@@ -928,13 +928,14 @@ func payInvoiceWithSatoshiLastHop(t *testing.T, payer *HarnessNode,
 }
 
 type payConfig struct {
-	smallShards   bool
-	errSubStr     string
-	allowOverpay  bool
-	feeLimit      lnwire.MilliSatoshi
-	payStatus     lnrpc.Payment_PaymentStatus
-	failureReason lnrpc.PaymentFailureReason
-	rfq           fn.Option[rfqmsg.ID]
+	smallShards       bool
+	errSubStr         string
+	allowOverpay      bool
+	feeLimit          lnwire.MilliSatoshi
+	destCustomRecords map[uint64][]byte
+	payStatus         lnrpc.Payment_PaymentStatus
+	failureReason     lnrpc.PaymentFailureReason
+	rfq               fn.Option[rfqmsg.ID]
 }
 
 func defaultPayConfig() *payConfig {
@@ -982,6 +983,12 @@ func withFeeLimit(limit lnwire.MilliSatoshi) payOpt {
 	}
 }
 
+func withDestCustomRecords(records map[uint64][]byte) payOpt {
+	return func(c *payConfig) {
+		c.destCustomRecords = records
+	}
+}
+
 func withAllowOverpay() payOpt {
 	return func(c *payConfig) {
 		c.allowOverpay = true
@@ -1009,9 +1016,10 @@ func payInvoiceWithAssets(t *testing.T, payer, rfqPeer *HarnessNode,
 	require.NoError(t, err)
 
 	sendReq := &routerrpc.SendPaymentRequest{
-		PaymentRequest: payReq,
-		TimeoutSeconds: int32(PaymentTimeout.Seconds()),
-		FeeLimitMsat:   int64(cfg.feeLimit),
+		PaymentRequest:    payReq,
+		TimeoutSeconds:    int32(PaymentTimeout.Seconds()),
+		FeeLimitMsat:      int64(cfg.feeLimit),
+		DestCustomRecords: cfg.destCustomRecords,
 	}
 
 	if cfg.smallShards {
@@ -2135,3 +2143,69 @@ func newCloseExpiryInfo(t *testing.T, node *HarnessNode) forceCloseExpiryInfo {
 		node:               node,
 	}
 }
+
+// AssertHLTCNotActive asserts the node doesn't have a pending HTLC in the
+// given channel, which mean either the HTLC never exists, or it was pending
+// and now settled. Returns the HTLC if found and active.
+func assertHTLCNotActive(t *testing.T, hn *HarnessNode,
+	cp *lnrpc.ChannelPoint, payHash []byte) *lnrpc.HTLC {
+
+	var result *lnrpc.HTLC
+	target := hex.EncodeToString(payHash)
+
+	err := wait.NoError(func() error {
+		// We require the RPC call to be succeeded and won't wait for
+		// it as it's an unexpected behavior.
+		ch := fetchChannel(t, hn, cp)
+
+		// Check all payment hashes active for this channel.
+		for _, htlc := range ch.PendingHtlcs {
+			h := hex.EncodeToString(htlc.HashLock)
+
+			// Break if found the htlc.
+			if h == target {
+				result = htlc
+				break
+			}
+		}
+
+		// If we've found nothing, we're done.
+		if result == nil {
+			return nil
+		}
+
+		// Otherwise return an error.
+		return fmt.Errorf("node [%s:%x] still has: the payHash %x",
+			hn.Name(), hn.PubKey[:], payHash)
+	}, defaultTimeout)
+	require.NoError(t, err, "timeout checking pending HTLC")
+
+	return result
+}
+
+func assertInvoiceState(t *testing.T, hn *HarnessNode, payAddr []byte,
+	expectedState lnrpc.Invoice_InvoiceState) {
+
+	msg := &invoicesrpc.LookupInvoiceMsg{
+		InvoiceRef: &invoicesrpc.LookupInvoiceMsg_PaymentAddr{
+			PaymentAddr: payAddr,
+		},
+	}
+
+	err := wait.NoError(func() error {
+		invoice, err := hn.InvoicesClient.LookupInvoiceV2(
+			context.Background(), msg,
+		)
+		if err != nil {
+			return err
+		}
+
+		if invoice.State == expectedState {
+			return nil
+		}
+
+		return fmt.Errorf("%s: invoice with payment address %x not "+
+			"in state %s", hn.Name(), payAddr, expectedState)
+	}, defaultTimeout)
+	require.NoError(t, err, "timeout waiting for invoice settled state")
+}

itest/litd_custom_channels_test.go

@@ -2026,32 +2026,6 @@ func testCustomChannelsLiquidityEdgeCases(ctx context.Context,
 		),
 	)
 
-	// Edge case: Now Dave creates an asset invoice to be paid for by
-	// Yara with satoshi. For the last hop we try to settle the invoice in
-	// satoshi, where we will check whether Dave's strict forwarding works
-	// as expected. Charlie is only used as a dummy RFQ peer in this case,
-	// Yara totally ignored the RFQ hint and pays agnostically with sats.
-	invoiceResp = createAssetInvoice(t.t, charlie, dave, 22, assetID)
-
-	stream, err := dave.InvoicesClient.SubscribeSingleInvoice(
-		ctx, &invoicesrpc.SubscribeSingleInvoiceRequest{
-			RHash: invoiceResp.RHash,
-		},
-	)
-	require.NoError(t.t, err)
-
-	// Yara pays Dave with enough satoshis, but Charlie will not settle as
-	// he expects assets.
-	hops := [][]byte{dave.PubKey[:]}
-	payInvoiceWithSatoshiLastHop(t.t, yara, invoiceResp, hops, withFailure(
-		lnrpc.Payment_FAILED, 0,
-	))
-
-	t.lndHarness.LNDHarness.AssertInvoiceState(stream, lnrpc.Invoice_OPEN)
-
-	logBalance(t.t, nodes, assetID, "after failed payment (asset "+
-		"invoice, strict forwarding)")
-
 	// Edge case: Check if the RFQ HTLC tracking accounts for cancelled
 	// HTLCs. We achieve this by manually creating & using an RFQ quote with
 	// a set max amount. We first pay to a hodl invoice that we eventually
@@ -2192,6 +2166,221 @@ func testCustomChannelsLiquidityEdgeCases(ctx context.Context,
 	logBalance(t.t, nodes, assetID, "after small manual rfq")
 }
 
+// testCustomChannelsStrictForwarding is a test that tests the strict forwarding
+// behavior of a node when it comes to paying asset invoices with assets and
+// BTC invoices with satoshis.
+func testCustomChannelsStrictForwarding(ctx context.Context,
+	net *NetworkHarness, t *harnessTest) {
+
+	lndArgs := slices.Clone(lndArgsTemplate)
+	litdArgs := slices.Clone(litdArgsTemplate)
+
+	// Explicitly set the proof courier as Zane (now has no other role
+	// other than proof shuffling), otherwise a hashmail courier will be
+	// used. For the funding transaction, we're just posting it and don't
+	// expect a true receiver.
+	zane, err := net.NewNode(
+		t.t, "Zane", lndArgs, false, true, litdArgs...,
+	)
+	require.NoError(t.t, err)
+
+	litdArgs = append(litdArgs, fmt.Sprintf(
+		"--taproot-assets.proofcourieraddr=%s://%s",
+		proof.UniverseRpcCourierType, zane.Cfg.LitAddr(),
+	))
+
+	// The topology we are going for looks like the following:
+	//
+	// Charlie  --[assets]-->  Dave  --[sats]-->  Erin  --[assets]-->  Fabia
+	//                          |
+	//                          |
+	//                       [assets]
+	//                          |
+	//                          v
+	//                        Yara
+	//
+	// With [assets] being a custom channel and [sats] being a normal, BTC
+	// only channel.
+	// All 5 nodes need to be full litd nodes running in integrated mode
+	// with tapd included. We also need specific flags to be enabled, so we
+	// create 5 completely new nodes, ignoring the two default nodes that
+	// are created by the harness.
+	charlie, err := net.NewNode(
+		t.t, "Charlie", lndArgs, false, true, litdArgs...,
+	)
+	require.NoError(t.t, err)
+
+	dave, err := net.NewNode(t.t, "Dave", lndArgs, false, true, litdArgs...)
+	require.NoError(t.t, err)
+	erin, err := net.NewNode(t.t, "Erin", lndArgs, false, true, litdArgs...)
+	require.NoError(t.t, err)
+	fabia, err := net.NewNode(
+		t.t, "Fabia", lndArgs, false, true, litdArgs...,
+	)
+	require.NoError(t.t, err)
+	yara, err := net.NewNode(
+		t.t, "Yara", lndArgs, false, true, litdArgs...,
+	)
+	require.NoError(t.t, err)
+
+	nodes := []*HarnessNode{charlie, dave, erin, fabia, yara}
+	connectAllNodes(t.t, net, nodes)
+	fundAllNodes(t.t, net, nodes)
+
+	// Create the normal channel between Dave and Erin.
+	t.Logf("Opening normal channel between Dave and Erin...")
+	channelOp := openChannelAndAssert(
+		t, net, dave, erin, lntest.OpenChannelParams{
+			Amt:         10_000_000,
+			SatPerVByte: 5,
+		},
+	)
+	defer closeChannelAndAssert(t, net, dave, channelOp, true)
+
+	// This is the only public channel, we need everyone to be aware of it.
+	assertChannelKnown(t.t, charlie, channelOp)
+	assertChannelKnown(t.t, fabia, channelOp)
+
+	universeTap := newTapClient(t.t, zane)
+	charlieTap := newTapClient(t.t, charlie)
+	daveTap := newTapClient(t.t, dave)
+	erinTap := newTapClient(t.t, erin)
+	fabiaTap := newTapClient(t.t, fabia)
+	yaraTap := newTapClient(t.t, yara)
+
+	// Mint an asset on Charlie and sync all nodes to Charlie as the
+	// universe.
+	mintedAssets := itest.MintAssetsConfirmBatch(
+		t.t, t.lndHarness.Miner.Client, charlieTap,
+		[]*mintrpc.MintAssetRequest{
+			{
+				Asset: itestAsset,
+			},
+		},
+	)
+	cents := mintedAssets[0]
+	assetID := cents.AssetGenesis.AssetId
+
+	t.Logf("Minted %d lightning cents, syncing universes...", cents.Amount)
+	syncUniverses(t.t, charlieTap, dave, erin, fabia, yara)
+	t.Logf("Universes synced between all nodes, distributing assets...")
+
+	const (
+		daveFundingAmount = uint64(400_000)
+		erinFundingAmount = uint64(200_000)
+	)
+	charlieFundingAmount := cents.Amount - uint64(2*400_000)
+
+	_, _, _ = createTestAssetNetwork(
+		t, net, charlieTap, daveTap, erinTap, fabiaTap, yaraTap,
+		universeTap, cents, 400_000, charlieFundingAmount,
+		daveFundingAmount, erinFundingAmount, 0,
+	)
+
+	// Before we start sending out payments, let's make sure each node can
+	// see the other one in the graph and has all required features.
+	require.NoError(t.t, t.lndHarness.AssertNodeKnown(charlie, dave))
+	require.NoError(t.t, t.lndHarness.AssertNodeKnown(dave, charlie))
+	require.NoError(t.t, t.lndHarness.AssertNodeKnown(dave, yara))
+	require.NoError(t.t, t.lndHarness.AssertNodeKnown(yara, dave))
+	require.NoError(t.t, t.lndHarness.AssertNodeKnown(erin, fabia))
+	require.NoError(t.t, t.lndHarness.AssertNodeKnown(fabia, erin))
+	require.NoError(t.t, t.lndHarness.AssertNodeKnown(charlie, erin))
+
+	logBalance(t.t, nodes, assetID, "initial")
+
+	// Do a payment from Charlie to Erin to shift the balances in all
+	// channels enough to allow for the following payments in any direction.
+	// Pay a normal bolt11 invoice involving RFQ flow.
+	_ = createAndPayNormalInvoice(
+		t.t, charlie, dave, erin, 500_000, assetID, withSmallShards(),
+	)
+
+	logBalance(t.t, nodes, assetID, "after payment")
+
+	// Edge case: Now Dave creates an asset invoice to be paid for by Erin
+	// with satoshi. For the last hop we try to settle the invoice in
+	// satoshi, where we will check whether Daves's strict forwarding
+	// works as expected. Charlie is only used as a dummy RFQ peer in this
+	// case, Erin totally ignores the RFQ hint and just pays with sats.
+	assetInvoice := createAssetInvoice(t.t, charlie, dave, 40, assetID)
+
+	assetInvoiceStream, err := dave.InvoicesClient.SubscribeSingleInvoice(
+		ctx, &invoicesrpc.SubscribeSingleInvoiceRequest{
+			RHash: assetInvoice.RHash,
+		},
+	)
+	require.NoError(t.t, err)
+
+	// Erin pays Dave with enough satoshis, but Charlie will not settle as
+	// he expects assets.
+	hops := [][]byte{dave.PubKey[:]}
+	payInvoiceWithSatoshiLastHop(
+		t.t, erin, assetInvoice, hops, withFailure(
+			lnrpc.Payment_FAILED, 0,
+		),
+	)
+
+	// Make sure the invoice hasn't been settled and there's no HTLC on the
+	// channel between Erin and Dave.
+	t.lndHarness.LNDHarness.AssertInvoiceState(
+		assetInvoiceStream, lnrpc.Invoice_OPEN,
+	)
+	assertHTLCNotActive(t.t, erin, channelOp, assetInvoice.RHash)
+	assertInvoiceState(
+		t.t, dave, assetInvoice.PaymentAddr, lnrpc.Invoice_OPEN,
+	)
+
+	logBalance(t.t, nodes, assetID, "after failed payment (asset "+
+		"invoice, strict forwarding)")
+
+	// Now let's make sure that we can actually still pay the invoice with
+	// assets from Charlie.
+	payInvoiceWithAssets(
+		t.t, charlie, dave, assetInvoice.PaymentRequest, assetID,
+	)
+	t.lndHarness.LNDHarness.AssertInvoiceState(
+		assetInvoiceStream, lnrpc.Invoice_SETTLED,
+	)
+	assertInvoiceState(
+		t.t, dave, assetInvoice.PaymentAddr, lnrpc.Invoice_SETTLED,
+	)
+
+	// Edge case: We now try the opposite: Dave creates a BTC invoice but
+	// Charlie tries to pay it with assets. This should fail as well.
+	btcInvoice := createNormalInvoice(t.t, dave, 1_000)
+	btcInvoiceStream, err := dave.InvoicesClient.SubscribeSingleInvoice(
+		ctx, &invoicesrpc.SubscribeSingleInvoiceRequest{
+			RHash: btcInvoice.RHash,
+		},
+	)
+	require.NoError(t.t, err)
+
+	payInvoiceWithAssets(
+		t.t, charlie, dave, btcInvoice.PaymentRequest, assetID,
+		withFailure(lnrpc.Payment_FAILED, failureIncorrectDetails),
+	)
+	t.lndHarness.LNDHarness.AssertInvoiceState(
+		btcInvoiceStream, lnrpc.Invoice_OPEN,
+	)
+	assertHTLCNotActive(t.t, erin, channelOp, btcInvoice.RHash)
+	assertInvoiceState(
+		t.t, dave, btcInvoice.PaymentAddr, lnrpc.Invoice_OPEN,
+	)
+
+	// And finally we make sure that we can still pay the invoice with
+	// satoshis from Erin, using custom records.
+	payInvoiceWithSatoshi(t.t, erin, btcInvoice, withDestCustomRecords(
+		map[uint64][]byte{106823: {0x01}},
+	))
+	t.lndHarness.LNDHarness.AssertInvoiceState(
+		btcInvoiceStream, lnrpc.Invoice_SETTLED,
+	)
+	assertInvoiceState(
+		t.t, dave, btcInvoice.PaymentAddr, lnrpc.Invoice_SETTLED,
+	)
+}
+
 // testCustomChannelsBalanceConsistency is a test that test the balance of nodes
 // under channel opening circumstances.
 func testCustomChannelsBalanceConsistency(ctx context.Context,

itest/litd_test_list_on_test.go

@@ -72,6 +72,10 @@ var allTestCases = []*testCase{
 		name: "test custom channels forward bandwidth",
 		test: testCustomChannelsForwardBandwidth,
 	},
+	{
+		name: "test custom channels strict forwarding",
+		test: testCustomChannelsStrictForwarding,
+	},
 	{
 		name: "test custom channels decode payreq",
 		test: testCustomChannelsDecodeAssetInvoice,