itest: flatten testMultiHopHtlcRemoteChainClaim

itest/list_on_test.go

@@ -297,10 +297,6 @@ var allTestCases = []*lntest.TestCase{
 		Name:     "REST API",
 		TestFunc: testRestAPI,
 	},
-	{
-		Name:     "multi hop htlc remote chain claim",
-		TestFunc: testMultiHopHtlcRemoteChainClaim,
-	},
 	{
 		Name:     "multi hop htlc aggregation",
 		TestFunc: testMultiHopHtlcAggregation,

itest/lnd_multi-hop_force_close_test.go

@@ -89,6 +89,18 @@ var multiHopForceCloseTestCases = []*lntest.TestCase{
 		Name:     "multihop local claim incoming htlc leased",
 		TestFunc: testLocalClaimIncomingHTLCLeased,
 	},
+	{
+		Name:     "multihop local preimage claim anchor",
+		TestFunc: testLocalPreimageClaimAnchor,
+	},
+	{
+		Name:     "multihop local preimage claim simple taproot",
+		TestFunc: testLocalPreimageClaimSimpleTaproot,
+	},
+	{
+		Name:     "multihop local preimage claim leased",
+		TestFunc: testLocalPreimageClaimLeased,
+	},
 }
 
 // testLocalClaimOutgoingHTLCAnchor tests `runLocalClaimOutgoingHTLC` with
@@ -255,6 +267,14 @@ func runLocalClaimOutgoingHTLC(ht *lntest.HarnessTest,
 		ht.FundCoins(btcutil.SatoshiPerBitcoin, bob)
 	}
 
+	// Bob should have enough wallet UTXOs here to sweep the HTLC in the
+	// end of this test. However, due to a known issue, Bob's wallet may
+	// report there's no UTXO available. For details,
+	// - https://github.com/lightningnetwork/lnd/issues/8786
+	//
+	// TODO(yy): remove this step once the issue is resolved.
+	ht.FundCoins(btcutil.SatoshiPerBitcoin, bob)
+
 	// Now that our channels are set up, we'll send two HTLC's from Alice
 	// to Carol. The first HTLC will be universally considered "dust",
 	// while the second will be a proper fully valued HTLC.
@@ -2078,3 +2098,623 @@ func runLocalClaimIncomingHTLCLeased(ht *lntest.HarnessTest,
 	// succeeded.
 	ht.AssertPaymentStatus(alice, preimage, lnrpc.Payment_SUCCEEDED)
 }
+
+// testLocalPreimageClaimAnchor tests `runLocalPreimageClaim` with anchor
+// channel.
+func testLocalPreimageClaimAnchor(ht *lntest.HarnessTest) {
+	success := ht.Run("no zero conf", func(t *testing.T) {
+		st := ht.Subtest(t)
+
+		// Create a three hop network: Alice -> Bob -> Carol, using
+		// anchor channels.
+		//
+		// Prepare params.
+		params := lntest.OpenChannelParams{Amt: chanAmt}
+
+		cfg := node.CfgAnchor
+		cfgs := [][]string{cfg, cfg, cfg}
+
+		runLocalPreimageClaim(st, cfgs, params)
+	})
+	if !success {
+		return
+	}
+
+	ht.Run("zero conf", func(t *testing.T) {
+		st := ht.Subtest(t)
+
+		// Create a three hop network: Alice -> Bob -> Carol, using
+		// zero-conf anchor channels.
+		//
+		// Prepare params.
+		params := lntest.OpenChannelParams{
+			Amt:            chanAmt,
+			ZeroConf:       true,
+			CommitmentType: lnrpc.CommitmentType_ANCHORS,
+		}
+
+		// Prepare Carol's node config to enable zero-conf and anchor.
+		cfg := node.CfgZeroConf
+		cfgs := [][]string{cfg, cfg, cfg}
+
+		runLocalPreimageClaim(st, cfgs, params)
+	})
+}
+
+// testLocalPreimageClaimSimpleTaproot tests `runLocalClaimIncomingHTLC` with
+// simple taproot channel.
+func testLocalPreimageClaimSimpleTaproot(ht *lntest.HarnessTest) {
+	c := lnrpc.CommitmentType_SIMPLE_TAPROOT
+
+	success := ht.Run("no zero conf", func(t *testing.T) {
+		st := ht.Subtest(t)
+
+		// Create a three hop network: Alice -> Bob -> Carol, using
+		// simple taproot channels.
+		//
+		// Prepare params.
+		params := lntest.OpenChannelParams{
+			Amt:            chanAmt,
+			CommitmentType: c,
+			Private:        true,
+		}
+
+		cfg := node.CfgSimpleTaproot
+		cfgs := [][]string{cfg, cfg, cfg}
+
+		runLocalPreimageClaim(st, cfgs, params)
+	})
+	if !success {
+		return
+	}
+
+	ht.Run("zero conf", func(t *testing.T) {
+		st := ht.Subtest(t)
+
+		// Create a three hop network: Alice -> Bob -> Carol, using
+		// zero-conf simple taproot channels.
+		//
+		// Prepare params.
+		params := lntest.OpenChannelParams{
+			Amt:            chanAmt,
+			ZeroConf:       true,
+			CommitmentType: c,
+			Private:        true,
+		}
+
+		// Prepare Carol's node config to enable zero-conf and leased
+		// channel.
+		cfg := node.CfgSimpleTaproot
+		cfg = append(cfg, node.CfgZeroConf...)
+		cfgs := [][]string{cfg, cfg, cfg}
+
+		runLocalPreimageClaim(st, cfgs, params)
+	})
+}
+
+// runLocalPreimageClaim tests that in the multi-hop HTLC scenario, if the
+// remote party goes to chain while we have an incoming HTLC, then when we
+// found out the preimage via the witness beacon, we properly settle the HTLC
+// directly on-chain using the preimage in order to ensure that we don't lose
+// any funds.
+func runLocalPreimageClaim(ht *lntest.HarnessTest,
+	cfgs [][]string, params lntest.OpenChannelParams) {
+
+	// Set the min relay feerate to be 10 sat/vbyte so the non-CPFP anchor
+	// is never swept.
+	//
+	// TODO(yy): delete this line once the normal anchor sweeping is
+	// removed.
+	ht.SetMinRelayFeerate(10_000)
+
+	// Create a three hop network: Alice -> Bob -> Carol.
+	chanPoints, nodes := ht.CreateSimpleNetwork(cfgs, params)
+	alice, bob, carol := nodes[0], nodes[1], nodes[2]
+	aliceChanPoint := chanPoints[0]
+
+	// Fund Carol one UTXO so she can sweep outputs.
+	ht.FundCoins(btcutil.SatoshiPerBitcoin, carol)
+
+	// Carol should have enough wallet UTXOs here to sweep the HTLC in the
+	// end of this test. However, due to a known issue, Carol's wallet may
+	// report there's no UTXO available. For details,
+	// - https://github.com/lightningnetwork/lnd/issues/8786
+	//
+	// TODO(yy): remove this step once the issue is resolved.
+	ht.FundCoins(btcutil.SatoshiPerBitcoin, carol)
+
+	// If this is a taproot channel, then we'll need to make some manual
+	// route hints so Alice can actually find a route.
+	var routeHints []*lnrpc.RouteHint
+	if params.CommitmentType == lnrpc.CommitmentType_SIMPLE_TAPROOT {
+		routeHints = makeRouteHints(bob, carol, params.ZeroConf)
+	}
+
+	// With the network active, we'll now add a new hodl invoice at Carol's
+	// end. Make sure the cltv expiry delta is large enough, otherwise Bob
+	// won't send out the outgoing htlc.
+	preimage := ht.RandomPreimage()
+	payHash := preimage.Hash()
+
+	invoiceReq := &invoicesrpc.AddHoldInvoiceRequest{
+		Value:      invoiceAmt,
+		CltvExpiry: finalCltvDelta,
+		Hash:       payHash[:],
+		RouteHints: routeHints,
+	}
+	carolInvoice := carol.RPC.AddHoldInvoice(invoiceReq)
+
+	// Subscribe the invoice.
+	stream := carol.RPC.SubscribeSingleInvoice(payHash[:])
+
+	// Now that we've created the invoice, we'll send a single payment from
+	// Alice to Carol. We won't wait for the response however, as Carol
+	// will not immediately settle the payment.
+	req := &routerrpc.SendPaymentRequest{
+		PaymentRequest: carolInvoice.PaymentRequest,
+		TimeoutSeconds: 60,
+		FeeLimitMsat:   noFeeLimitMsat,
+	}
+	alice.RPC.SendPayment(req)
+
+	// At this point, all 3 nodes should now have an active channel with
+	// the created HTLC pending on all of them.
+	ht.AssertActiveHtlcs(alice, payHash[:])
+	ht.AssertActiveHtlcs(bob, payHash[:])
+	ht.AssertActiveHtlcs(carol, payHash[:])
+
+	// Wait for carol to mark invoice as accepted. There is a small gap to
+	// bridge between adding the htlc to the channel and executing the exit
+	// hop logic.
+	ht.AssertInvoiceState(stream, lnrpc.Invoice_ACCEPTED)
+
+	// Record the height which the invoice will expire.
+	invoiceExpiry := ht.CurrentHeight() + uint32(invoiceReq.CltvExpiry)
+
+	// Next, Alice decides that she wants to exit the channel, so she'll
+	// immediately force close the channel by broadcast her commitment
+	// transaction.
+	closeStream, _ := ht.CloseChannelAssertPending(
+		alice, aliceChanPoint, true,
+	)
+	aliceForceClose := ht.AssertStreamChannelForceClosed(
+		alice, aliceChanPoint, true, closeStream,
+	)
+
+	// Wait for the channel to be marked pending force close.
+	ht.AssertChannelPendingForceClose(alice, aliceChanPoint)
+
+	// Once the force closing tx is mined, Alice should offer the anchor
+	// output to her sweeper.
+	ht.AssertNumPendingSweeps(alice, 1)
+
+	// Bob should offer his anchor output to his sweeper.
+	ht.AssertNumPendingSweeps(bob, 1)
+
+	// Mine enough blocks for Alice to sweep her funds from the force
+	// closed channel. AssertStreamChannelForceClosed() already mined a
+	// block, so mine one less than defaultCSV in order to perform mempool
+	// assertions.
+	ht.MineBlocks(defaultCSV - 1)
+
+	// Mine Alice's commit sweeping tx.
+	ht.MineBlocksAndAssertNumTxes(1, 1)
+
+	// Suspend bob, so Carol is forced to go on chain.
+	restartBob := ht.SuspendNode(bob)
+
+	// Settle invoice. This will just mark the invoice as settled, as there
+	// is no link anymore to remove the htlc from the commitment tx. For
+	// this test, it is important to actually settle and not leave the
+	// invoice in the accepted state, because without a known preimage, the
+	// channel arbitrator won't go to chain.
+	carol.RPC.SettleInvoice(preimage[:])
+
+	ht.Logf("Invoice expire height: %d, current: %d", invoiceExpiry,
+		ht.CurrentHeight())
+
+	// We'll now mine enough blocks so Carol decides that she needs to go
+	// on-chain to claim the HTLC as Bob has been inactive.
+	numBlocks := padCLTV(
+		invoiceExpiry - ht.CurrentHeight() - incomingBroadcastDelta,
+	)
+	ht.MineBlocks(int(numBlocks))
+
+	// Since Carol has time-sensitive HTLCs, she will use the anchor for
+	// CPFP purpose. Assert the anchor output is offered to the sweeper.
+	//
+	// For neutrino backend, Carol still have the two anchors - one from
+	// local commitment and the other from the remote.
+	if ht.IsNeutrinoBackend() {
+		ht.AssertNumPendingSweeps(carol, 2)
+	} else {
+		ht.AssertNumPendingSweeps(carol, 1)
+	}
+
+	// We should see two txns in the mempool, we now a block to confirm,
+	// - Carol's force close tx.
+	// - Carol's anchor sweeping tx.
+	ht.MineBlocksAndAssertNumTxes(1, 2)
+
+	// Once the force close tx is confirmed, Carol should offer her
+	// incoming HTLC to her sweeper.
+	ht.AssertNumPendingSweeps(carol, 1)
+
+	// Restart bob again.
+	require.NoError(ht, restartBob())
+
+	// Bob should have three sweeping requests,
+	// - the anchor output from channel Alice=>Bob, uneconomical.
+	// - the anchor output from channel Bob=>Carol, uneconomical.
+	// - the commit output sweep from the channel with Carol, no timelock.
+	ht.AssertNumPendingSweeps(bob, 3)
+
+	// Mine an empty block the for neutrino backend. We need this step to
+	// trigger Bob's chain watcher to detect the force close tx. Deep down,
+	// this happens because the notification system for neutrino is very
+	// different from others. Specifically, when a block contains the force
+	// close tx is notified, these two calls,
+	// - RegisterBlockEpochNtfn, will notify the block first.
+	// - RegisterSpendNtfn, will wait for the neutrino notifier to sync to
+	//   the block, then perform a GetUtxo, which, by the time the spend
+	//   details are sent, the blockbeat is considered processed in Bob's
+	//   chain watcher.
+	//
+	// TODO(yy): refactor txNotifier to fix the above issue.
+	if ht.IsNeutrinoBackend() {
+		ht.MineEmptyBlocks(1)
+	}
+
+	// We mine one block to confirm,
+	// - Carol's sweeping tx of the incoming HTLC.
+	// - Bob's sweeping tx of his commit output.
+	ht.MineBlocksAndAssertNumTxes(1, 2)
+
+	// When Bob notices Carol's second level tx in the block, he will
+	// extract the preimage and offer the HTLC to his sweeper. So he has,
+	// - the anchor output from channel Alice=>Bob, uneconomical.
+	// - the anchor output from channel Bob=>Carol, uneconomical.
+	// - the htlc sweeping tx.
+	ht.AssertNumPendingSweeps(bob, 3)
+
+	// Mine an empty block the for neutrino backend. We need this step to
+	// trigger Bob's chain watcher to detect the force close tx. Deep down,
+	// this happens because the notification system for neutrino is very
+	// different from others. Specifically, when a block contains the force
+	// close tx is notified, these two calls,
+	// - RegisterBlockEpochNtfn, will notify the block first.
+	// - RegisterSpendNtfn, will wait for the neutrino notifier to sync to
+	//   the block, then perform a GetUtxo, which, by the time the spend
+	//   details are sent, the blockbeat is considered processed in Bob's
+	//   chain watcher.
+	//
+	// TODO(yy): refactor txNotifier to fix the above issue.
+	if ht.IsNeutrinoBackend() {
+		ht.MineEmptyBlocks(1)
+	}
+
+	// Mine a block to trigger the sweep. This is needed because the
+	// preimage extraction logic from the link is not managed by the
+	// blockbeat, which means the preimage may be sent to the contest
+	// resolver after it's launched.
+	//
+	// TODO(yy): Expose blockbeat to the link layer.
+	ht.MineEmptyBlocks(1)
+
+	// Bob should broadcast the sweeping of the direct preimage spent now.
+	bobHtlcSweep := ht.GetNumTxsFromMempool(1)[0]
+
+	// It should spend from the commitment in the channel with Alice.
+	ht.AssertTxSpendFrom(bobHtlcSweep, aliceForceClose)
+
+	// We'll now mine a block which should confirm Bob's HTLC sweep tx.
+	ht.MineBlocksAndAssertNumTxes(1, 1)
+
+	// Now that the sweeping tx has been confirmed, Bob should recognize
+	// that all contracts for the Bob-Carol channel have been fully
+	// resolved.
+	ht.AssertNumPendingForceClose(bob, 0)
+
+	// Mine blocks till Carol's second level tx matures.
+	resp := ht.AssertNumPendingForceClose(carol, 1)[0]
+	require.Equal(ht, 1, len(resp.PendingHtlcs))
+
+	ht.Logf("Carol's timelock to_local output=%v, timelock on second "+
+		"stage htlc=%v", resp.BlocksTilMaturity,
+		resp.PendingHtlcs[0].BlocksTilMaturity)
+
+	ht.MineBlocks(int(resp.PendingHtlcs[0].BlocksTilMaturity))
+
+	// Carol should offer the htlc output to her sweeper.
+	ht.AssertNumPendingSweeps(carol, 1)
+
+	// Mine a block to confirm Carol's sweeping tx.
+	ht.MineBlocksAndAssertNumTxes(1, 1)
+
+	// When Carol's sweep gets confirmed, she should have no more pending
+	// channels.
+	ht.AssertNumPendingForceClose(carol, 0)
+
+	// The invoice should show as settled for Carol, indicating that it was
+	// swept on-chain.
+	ht.AssertInvoiceState(stream, lnrpc.Invoice_SETTLED)
+
+	// Finally, check that the Alice's payment is correctly marked
+	// succeeded.
+	ht.AssertPaymentStatus(alice, preimage, lnrpc.Payment_SUCCEEDED)
+}
+
+// testLocalPreimageClaimLeased tests `runLocalPreimageClaim` with script
+// enforced lease channel.
+func testLocalPreimageClaimLeased(ht *lntest.HarnessTest) {
+	success := ht.Run("no zero conf", func(t *testing.T) {
+		st := ht.Subtest(t)
+
+		// Create a three hop network: Alice -> Bob -> Carol, using
+		// leased channels.
+		//
+		// Prepare params.
+		params := lntest.OpenChannelParams{
+			Amt:            chanAmt,
+			CommitmentType: leasedType,
+		}
+
+		cfg := node.CfgLeased
+		cfgs := [][]string{cfg, cfg, cfg}
+
+		runLocalPreimageClaimLeased(st, cfgs, params)
+	})
+	if !success {
+		return
+	}
+
+	ht.Run("zero conf", func(t *testing.T) {
+		st := ht.Subtest(t)
+
+		// Create a three hop network: Alice -> Bob -> Carol, using
+		// zero-conf anchor channels.
+		//
+		// Prepare params.
+		params := lntest.OpenChannelParams{
+			Amt:            chanAmt,
+			ZeroConf:       true,
+			CommitmentType: leasedType,
+		}
+
+		// Prepare Carol's node config to enable zero-conf and leased
+		// channel.
+		cfg := node.CfgLeased
+		cfg = append(cfg, node.CfgZeroConf...)
+		cfgs := [][]string{cfg, cfg, cfg}
+
+		runLocalPreimageClaimLeased(st, cfgs, params)
+	})
+}
+
+// runLocalPreimageClaimLeased tests that in the multi-hop HTLC scenario, if
+// the remote party goes to chain while we have an incoming HTLC, then when we
+// found out the preimage via the witness beacon, we properly settle the HTLC
+// directly on-chain using the preimage in order to ensure that we don't lose
+// any funds.
+func runLocalPreimageClaimLeased(ht *lntest.HarnessTest,
+	cfgs [][]string, params lntest.OpenChannelParams) {
+
+	// Set the min relay feerate to be 10 sat/vbyte so the non-CPFP anchor
+	// is never swept.
+	//
+	// TODO(yy): delete this line once the normal anchor sweeping is
+	// removed.
+	ht.SetMinRelayFeerate(10_000)
+
+	// Create a three hop network: Alice -> Bob -> Carol.
+	chanPoints, nodes := ht.CreateSimpleNetwork(cfgs, params)
+	alice, bob, carol := nodes[0], nodes[1], nodes[2]
+	aliceChanPoint, bobChanPoint := chanPoints[0], chanPoints[1]
+
+	// Fund Carol one UTXO so she can sweep outputs.
+	ht.FundCoins(btcutil.SatoshiPerBitcoin, carol)
+
+	// With the network active, we'll now add a new hodl invoice at Carol's
+	// end. Make sure the cltv expiry delta is large enough, otherwise Bob
+	// won't send out the outgoing htlc.
+	preimage := ht.RandomPreimage()
+	payHash := preimage.Hash()
+
+	invoiceReq := &invoicesrpc.AddHoldInvoiceRequest{
+		Value:      invoiceAmt,
+		CltvExpiry: finalCltvDelta,
+		Hash:       payHash[:],
+	}
+	carolInvoice := carol.RPC.AddHoldInvoice(invoiceReq)
+
+	// Subscribe the invoice.
+	stream := carol.RPC.SubscribeSingleInvoice(payHash[:])
+
+	// Now that we've created the invoice, we'll send a single payment from
+	// Alice to Carol. We won't wait for the response however, as Carol
+	// will not immediately settle the payment.
+	req := &routerrpc.SendPaymentRequest{
+		PaymentRequest: carolInvoice.PaymentRequest,
+		TimeoutSeconds: 60,
+		FeeLimitMsat:   noFeeLimitMsat,
+	}
+	alice.RPC.SendPayment(req)
+
+	// At this point, all 3 nodes should now have an active channel with
+	// the created HTLC pending on all of them.
+	ht.AssertActiveHtlcs(alice, payHash[:])
+	ht.AssertActiveHtlcs(bob, payHash[:])
+	ht.AssertActiveHtlcs(carol, payHash[:])
+
+	// Wait for carol to mark invoice as accepted. There is a small gap to
+	// bridge between adding the htlc to the channel and executing the exit
+	// hop logic.
+	ht.AssertInvoiceState(stream, lnrpc.Invoice_ACCEPTED)
+
+	// Record the height which the invoice will expire.
+	invoiceExpiry := ht.CurrentHeight() + uint32(invoiceReq.CltvExpiry)
+
+	// Next, Alice decides that she wants to exit the channel, so she'll
+	// immediately force close the channel by broadcast her commitment
+	// transaction.
+	closeStream, _ := ht.CloseChannelAssertPending(
+		alice, aliceChanPoint, true,
+	)
+	aliceForceClose := ht.AssertStreamChannelForceClosed(
+		alice, aliceChanPoint, true, closeStream,
+	)
+
+	// Wait for the channel to be marked pending force close.
+	ht.AssertChannelPendingForceClose(alice, aliceChanPoint)
+
+	// Once the force closing tx is mined, Alice should offer the anchor
+	// output to her sweeper.
+	ht.AssertNumPendingSweeps(alice, 1)
+
+	// Bob should offer his anchor output to his sweeper.
+	ht.AssertNumPendingSweeps(bob, 1)
+
+	// Suspend bob, so Carol is forced to go on chain.
+	restartBob := ht.SuspendNode(bob)
+
+	// Settle invoice. This will just mark the invoice as settled, as there
+	// is no link anymore to remove the htlc from the commitment tx. For
+	// this test, it is important to actually settle and not leave the
+	// invoice in the accepted state, because without a known preimage, the
+	// channel arbitrator won't go to chain.
+	carol.RPC.SettleInvoice(preimage[:])
+
+	ht.Logf("Invoice expire height: %d, current: %d", invoiceExpiry,
+		ht.CurrentHeight())
+
+	// We'll now mine enough blocks so Carol decides that she needs to go
+	// on-chain to claim the HTLC as Bob has been inactive.
+	numBlocks := padCLTV(
+		invoiceExpiry - ht.CurrentHeight() - incomingBroadcastDelta - 1,
+	)
+	ht.MineBlocks(int(numBlocks))
+
+	// Since Carol has time-sensitive HTLCs, she will use the anchor for
+	// CPFP purpose. Assert the anchor output is offered to the sweeper.
+	//
+	// For neutrino backend, there's no way to know the sweeping of the
+	// remote anchor is failed, so Carol still sees two pending sweeps.
+	if ht.IsNeutrinoBackend() {
+		ht.AssertNumPendingSweeps(carol, 2)
+	} else {
+		ht.AssertNumPendingSweeps(carol, 1)
+	}
+
+	// We should see two txns in the mempool, we now a block to confirm,
+	// - Carol's force close tx.
+	// - Carol's anchor sweeping tx.
+	ht.MineBlocksAndAssertNumTxes(1, 2)
+
+	// Once the force close tx is confirmed, Carol should offer her
+	// incoming HTLC to her sweeper.
+	ht.AssertNumPendingSweeps(carol, 1)
+
+	// Restart bob again.
+	require.NoError(ht, restartBob())
+
+	// Bob should have two sweeping requests,
+	// - the anchor output from channel Alice=>Bob, uneconomical.
+	// - the anchor output from channel Bob=>Carol, uneconomical.
+	// - the commit output sweep from the channel with Carol, which is CLTV
+	//   locked so it won't show up the pending sweeps.
+	ht.AssertNumPendingSweeps(bob, 2)
+
+	// We mine one block to confirm,
+	// - Carol's sweeping tx of the incoming HTLC.
+	ht.MineBlocksAndAssertNumTxes(1, 1)
+
+	// When Bob notices Carol's second level tx in the block, he will
+	// extract the preimage and offer the HTLC to his sweeper. So he has,
+	// - the anchor output from channel Alice=>Bob, uneconomical.
+	// - the anchor output from channel Bob=>Carol, uneconomical.
+	// - the htlc sweeping tx.
+	ht.AssertNumPendingSweeps(bob, 3)
+
+	// Mine a block to trigger the sweep. This is needed because the
+	// preimage extraction logic from the link is not managed by the
+	// blockbeat, which means the preimage may be sent to the contest
+	// resolver after it's launched.
+	//
+	// TODO(yy): Expose blockbeat to the link layer.
+	ht.MineEmptyBlocks(1)
+
+	// Bob should broadcast the sweeping of the direct preimage spent now.
+	bobHtlcSweep := ht.GetNumTxsFromMempool(1)[0]
+
+	// It should spend from the commitment in the channel with Alice.
+	ht.AssertTxSpendFrom(bobHtlcSweep, aliceForceClose)
+
+	// We'll now mine a block which should confirm Bob's HTLC sweep tx.
+	ht.MineBlocksAndAssertNumTxes(1, 1)
+
+	// Now that the sweeping tx has been confirmed, Bob should recognize
+	// that all contracts for the Bob-Carol channel have been fully
+	// resolved.
+	ht.AssertNumPendingForceClose(bob, 1)
+	ht.AssertChannelPendingForceClose(bob, bobChanPoint)
+
+	// Mine blocks till Carol's second level tx matures.
+	resp := ht.AssertNumPendingForceClose(carol, 1)[0]
+	require.Equal(ht, 1, len(resp.PendingHtlcs))
+
+	ht.Logf("Carol's timelock to_local output=%v, timelock on second "+
+		"stage htlc=%v", resp.BlocksTilMaturity,
+		resp.PendingHtlcs[0].BlocksTilMaturity)
+
+	ht.MineBlocks(int(resp.PendingHtlcs[0].BlocksTilMaturity))
+
+	// Carol should offer the htlc output to her sweeper.
+	ht.AssertNumPendingSweeps(carol, 1)
+
+	// Mine a block to confirm Carol's sweeping tx.
+	ht.MineBlocksAndAssertNumTxes(1, 1)
+
+	// When Carol's sweep gets confirmed, she should have no more pending
+	// channels.
+	ht.AssertNumPendingForceClose(carol, 0)
+
+	// The invoice should show as settled for Carol, indicating that it was
+	// swept on-chain.
+	ht.AssertInvoiceState(stream, lnrpc.Invoice_SETTLED)
+
+	// Check that the Alice's payment is correctly marked succeeded.
+	ht.AssertPaymentStatus(alice, preimage, lnrpc.Payment_SUCCEEDED)
+
+	// With the script-enforced lease commitment type, Alice and Bob still
+	// haven't been able to sweep their respective commit outputs due to
+	// the additional CLTV. We'll need to mine enough blocks for the
+	// timelock to expire and prompt their sweep.
+	//
+	// Get num of blocks to mine.
+	resp = ht.AssertNumPendingForceClose(alice, 1)[0]
+	require.Equal(ht, 1, len(resp.PendingHtlcs))
+
+	ht.Logf("Alice's timelock to_local output=%v, timelock on second "+
+		"stage htlc=%v", resp.BlocksTilMaturity,
+		resp.PendingHtlcs[0].BlocksTilMaturity)
+
+	ht.MineBlocks(int(resp.BlocksTilMaturity))
+
+	// Alice should two sweeping requests,
+	// - the anchor output from channel Alice=>Bob, uneconomical.
+	// - the commit output sweep from the channel with Bob.
+	ht.AssertNumPendingSweeps(alice, 2)
+
+	// Bob should have three sweeping requests,
+	// - the anchor output from channel Alice=>Bob, uneconomical.
+	// - the anchor output from channel Bob=>Carol, uneconomical.
+	// - the commit output sweep from the channel with Carol.
+	ht.AssertNumPendingSweeps(bob, 3)
+
+	// Confirm their sweeps.
+	ht.MineBlocksAndAssertNumTxes(1, 2)
+
+	// Both nodes should consider the channel fully closed.
+	ht.AssertNumPendingForceClose(alice, 0)
+	ht.AssertNumPendingForceClose(bob, 0)
+}

itest/lnd_multi-hop_test.go

@@ -18,7 +18,6 @@ import (
 	"github.com/lightningnetwork/lnd/lntest/rpc"
 	"github.com/lightningnetwork/lnd/lntest/wait"
 	"github.com/lightningnetwork/lnd/lntypes"
-	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
 	"github.com/lightningnetwork/lnd/routing"
 	"github.com/stretchr/testify/require"
 )
@@ -160,300 +159,6 @@ func runMultiHopHtlcClaimTest(ht *lntest.HarnessTest, tester caseRunner) {
 	}
 }
 
-// testMultiHopHtlcRemoteChainClaim tests that in the multi-hop HTLC scenario,
-// if the remote party goes to chain while we have an incoming HTLC, then when
-// we found out the preimage via the witness beacon, we properly settle the
-// HTLC directly on-chain using the preimage in order to ensure that we don't
-// lose any funds.
-func testMultiHopHtlcRemoteChainClaim(ht *lntest.HarnessTest) {
-	runMultiHopHtlcClaimTest(ht, runMultiHopHtlcRemoteChainClaim)
-}
-
-func runMultiHopHtlcRemoteChainClaim(ht *lntest.HarnessTest,
-	alice, bob *node.HarnessNode, c lnrpc.CommitmentType, zeroConf bool) {
-
-	// First, we'll create a three hop network: Alice -> Bob -> Carol, with
-	// Carol refusing to actually settle or directly cancel any HTLC's
-	// self.
-	aliceChanPoint, bobChanPoint, carol := createThreeHopNetwork(
-		ht, alice, bob, false, c, zeroConf,
-	)
-
-	// If this is a taproot channel, then we'll need to make some manual
-	// route hints so Alice can actually find a route.
-	var routeHints []*lnrpc.RouteHint
-	if c == lnrpc.CommitmentType_SIMPLE_TAPROOT {
-		routeHints = makeRouteHints(bob, carol, zeroConf)
-	}
-
-	// With the network active, we'll now add a new hodl invoice at Carol's
-	// end. Make sure the cltv expiry delta is large enough, otherwise Bob
-	// won't send out the outgoing htlc.
-	const invoiceAmt = 100000
-	var preimage lntypes.Preimage
-	copy(preimage[:], ht.Random32Bytes())
-	payHash := preimage.Hash()
-	invoiceReq := &invoicesrpc.AddHoldInvoiceRequest{
-		Value:      invoiceAmt,
-		CltvExpiry: finalCltvDelta,
-		Hash:       payHash[:],
-		RouteHints: routeHints,
-	}
-	carolInvoice := carol.RPC.AddHoldInvoice(invoiceReq)
-
-	// Subscribe the invoice.
-	stream := carol.RPC.SubscribeSingleInvoice(payHash[:])
-
-	// Now that we've created the invoice, we'll send a single payment from
-	// Alice to Carol. We won't wait for the response however, as Carol
-	// will not immediately settle the payment.
-	req := &routerrpc.SendPaymentRequest{
-		PaymentRequest: carolInvoice.PaymentRequest,
-		TimeoutSeconds: 60,
-		FeeLimitMsat:   noFeeLimitMsat,
-	}
-	alice.RPC.SendPayment(req)
-
-	// At this point, all 3 nodes should now have an active channel with
-	// the created HTLC pending on all of them.
-	ht.AssertActiveHtlcs(alice, payHash[:])
-	ht.AssertActiveHtlcs(bob, payHash[:])
-	ht.AssertActiveHtlcs(carol, payHash[:])
-
-	// Wait for carol to mark invoice as accepted. There is a small gap to
-	// bridge between adding the htlc to the channel and executing the exit
-	// hop logic.
-	ht.AssertInvoiceState(stream, lnrpc.Invoice_ACCEPTED)
-
-	// blocksMined records how many blocks have mined after the creation of
-	// the invoice so it can be used to calculate how many more blocks need
-	// to be mined to trigger a force close later on.
-	var blocksMined int
-
-	// Lower the fee rate so Bob's two anchor outputs are economical to
-	// be swept in one tx.
-	ht.SetFeeEstimate(chainfee.FeePerKwFloor)
-
-	// Next, Alice decides that she wants to exit the channel, so she'll
-	// immediately force close the channel by broadcast her commitment
-	// transaction.
-	closeStream, _ := ht.CloseChannelAssertPending(
-		alice, aliceChanPoint, true,
-	)
-	aliceForceClose := ht.AssertStreamChannelForceClosed(
-		alice, aliceChanPoint, true, closeStream,
-	)
-
-	// Increase the blocks mined. At this step
-	// AssertStreamChannelForceClosed mines one block.
-	blocksMined++
-
-	// Wait for the channel to be marked pending force close.
-	ht.AssertChannelPendingForceClose(alice, aliceChanPoint)
-
-	// After AssertStreamChannelForceClosed returns, it has mined a block
-	// so now bob will attempt to redeem his anchor output. Check the
-	// anchor is offered to the sweeper.
-	ht.AssertNumPendingSweeps(bob, 1)
-	ht.AssertNumPendingSweeps(alice, 1)
-
-	// Mine enough blocks for Alice to sweep her funds from the force
-	// closed channel. AssertStreamChannelForceClosed() already mined a
-	// block containing the commitment tx and the commit sweep tx will be
-	// broadcast immediately before it can be included in a block, so mine
-	// one less than defaultCSV in order to perform mempool assertions.
-	if c != lnrpc.CommitmentType_SCRIPT_ENFORCED_LEASE {
-		ht.MineEmptyBlocks(defaultCSV - blocksMined)
-		blocksMined = defaultCSV
-
-		// Alice should now sweep her funds.
-		ht.AssertNumPendingSweeps(alice, 2)
-
-		// Mine a block to trigger the sweep.
-		ht.MineEmptyBlocks(1)
-		blocksMined++
-
-		// Mine Alice's commit sweeping tx.
-		ht.MineBlocksAndAssertNumTxes(1, 1)
-		blocksMined++
-	}
-
-	// Suspend bob, so Carol is forced to go on chain.
-	restartBob := ht.SuspendNode(bob)
-
-	// Settle invoice. This will just mark the invoice as settled, as there
-	// is no link anymore to remove the htlc from the commitment tx. For
-	// this test, it is important to actually settle and not leave the
-	// invoice in the accepted state, because without a known preimage, the
-	// channel arbitrator won't go to chain.
-	carol.RPC.SettleInvoice(preimage[:])
-
-	// We'll now mine enough blocks so Carol decides that she needs to go
-	// on-chain to claim the HTLC as Bob has been inactive.
-	numBlocks := padCLTV(uint32(
-		invoiceReq.CltvExpiry - lncfg.DefaultIncomingBroadcastDelta,
-	))
-	ht.MineEmptyBlocks(int(numBlocks) - blocksMined)
-
-	// Carol's commitment transaction should now be in the mempool.
-	ht.AssertNumTxsInMempool(1)
-
-	// The closing transaction should be spending from the funding
-	// transaction.
-	closingTx := ht.AssertOutpointInMempool(
-		ht.OutPointFromChannelPoint(bobChanPoint),
-	)
-	closingTxid := closingTx.TxHash()
-
-	// Since Carol has time-sensitive HTLCs, she will use the anchor for
-	// CPFP purpose. Assert she has two pending anchor sweep requests - one
-	// from local commit and the other from remote commit.
-	ht.AssertNumPendingSweeps(carol, 2)
-
-	// Mine a block, which should contain: the commitment.
-	block := ht.MineBlocksAndAssertNumTxes(1, 1)[0]
-	ht.AssertTxInBlock(block, closingTxid)
-
-	// After the force close transaction is mined, Carol should offer her
-	// second level HTLC tx to the sweeper, along with her anchor output.
-	ht.AssertNumPendingSweeps(carol, 2)
-
-	// Restart bob again.
-	require.NoError(ht, restartBob())
-
-	// After the force close transaction is mined, we should expect Bob and
-	// Carol to broadcast some transactions depending on the channel
-	// commitment type.
-	switch c {
-	// Carol should broadcast her second level HTLC transaction and Bob
-	// should broadcast a sweeping tx to sweep his commitment output and
-	// anchor outputs from the two channels.
-	case lnrpc.CommitmentType_ANCHORS, lnrpc.CommitmentType_SIMPLE_TAPROOT:
-		ht.AssertNumPendingSweeps(bob, 3)
-
-	// Carol should broadcast her second level HTLC transaction and Bob
-	// should broadcast a transaction to sweep his anchor outputs. Bob
-	// can't sweep his commitment output yet as he has incurred an
-	// additional CLTV due to being the channel initiator of a force closed
-	// script-enforced leased channel.
-	case lnrpc.CommitmentType_SCRIPT_ENFORCED_LEASE:
-		ht.AssertNumPendingSweeps(bob, 2)
-
-	default:
-		ht.Fatalf("unhandled commitment type %v", c)
-	}
-
-	// Keep track of the second level tx maturity.
-	carolSecondLevelCSV := uint32(defaultCSV)
-
-	// Mine a block to trigger the sweeps, also confirms Carol's CPFP
-	// anchor sweeping.
-	ht.MineBlocksAndAssertNumTxes(1, 1)
-	carolSecondLevelCSV--
-	ht.AssertNumTxsInMempool(2)
-
-	// Mine a block to confirm the expected transactions.
-	ht.MineBlocksAndAssertNumTxes(1, 2)
-
-	// When Bob notices Carol's second level transaction in the block, he
-	// will extract the preimage and offer the HTLC to his sweeper.
-	ht.AssertNumPendingSweeps(bob, 1)
-
-	// NOTE: after Bob is restarted, the sweeping of the direct preimage
-	// spent will happen immediately so we don't need to mine a block to
-	// trigger Bob's sweeper to sweep it.
-	bobHtlcSweep := ht.GetNumTxsFromMempool(1)[0]
-	bobHtlcSweepTxid := bobHtlcSweep.TxHash()
-
-	// It should spend from the commitment in the channel with Alice.
-	ht.AssertTxSpendFrom(bobHtlcSweep, aliceForceClose)
-
-	// We'll now mine a block which should confirm Bob's HTLC sweep
-	// transaction.
-	block = ht.MineBlocksAndAssertNumTxes(1, 1)[0]
-	ht.AssertTxInBlock(block, bobHtlcSweepTxid)
-	carolSecondLevelCSV--
-
-	// Now that the sweeping transaction has been confirmed, Bob should now
-	// recognize that all contracts for the Bob-Carol channel have been
-	// fully resolved
-	aliceBobPendingChansLeft := 0
-	if c == lnrpc.CommitmentType_SCRIPT_ENFORCED_LEASE {
-		aliceBobPendingChansLeft = 1
-	}
-	for _, node := range []*node.HarnessNode{alice, bob} {
-		ht.AssertNumPendingForceClose(
-			node, aliceBobPendingChansLeft,
-		)
-	}
-
-	// If we then mine 3 additional blocks, Carol's second level tx will
-	// mature, and she should pull the funds.
-	ht.MineEmptyBlocks(int(carolSecondLevelCSV))
-	ht.AssertNumPendingSweeps(carol, 1)
-
-	// Mine a block to trigger the sweep of the second level tx.
-	ht.MineEmptyBlocks(1)
-	carolSweep := ht.AssertNumTxsInMempool(1)[0]
-
-	// When Carol's sweep gets confirmed, she should have no more pending
-	// channels.
-	block = ht.MineBlocksAndAssertNumTxes(1, 1)[0]
-	ht.AssertTxInBlock(block, carolSweep)
-	ht.AssertNumPendingForceClose(carol, 0)
-
-	// With the script-enforced lease commitment type, Alice and Bob still
-	// haven't been able to sweep their respective commit outputs due to the
-	// additional CLTV. We'll need to mine enough blocks for the timelock to
-	// expire and prompt their sweep.
-	if c == lnrpc.CommitmentType_SCRIPT_ENFORCED_LEASE {
-		// Due to the way the test is set up, Alice and Bob share the
-		// same CLTV for their commit outputs even though it's enforced
-		// on different channels (Alice-Bob and Bob-Carol).
-		resp := alice.RPC.PendingChannels()
-		require.Len(ht, resp.PendingForceClosingChannels, 1)
-		forceCloseChan := resp.PendingForceClosingChannels[0]
-		require.Positive(ht, forceCloseChan.BlocksTilMaturity)
-
-		// Mine enough blocks for the timelock to expire.
-		numBlocks := int(forceCloseChan.BlocksTilMaturity)
-		ht.MineEmptyBlocks(numBlocks)
-
-		// Both Alice and Bob should offer their commit sweeps.
-		ht.AssertNumPendingSweeps(alice, 2)
-		ht.AssertNumPendingSweeps(bob, 1)
-
-		// Mine a block to trigger the sweeps.
-		ht.MineEmptyBlocks(1)
-
-		// Both Alice and Bob should broadcast their commit sweeps.
-		aliceCommitOutpoint := wire.OutPoint{
-			Hash: aliceForceClose, Index: 3,
-		}
-		ht.AssertOutpointInMempool(aliceCommitOutpoint)
-		bobCommitOutpoint := wire.OutPoint{Hash: closingTxid, Index: 3}
-		ht.AssertOutpointInMempool(bobCommitOutpoint)
-
-		// Confirm their sweeps.
-		ht.MineBlocksAndAssertNumTxes(1, 2)
-
-		// Alice and Bob should not show any pending channels anymore as
-		// they have been fully resolved.
-		for _, node := range []*node.HarnessNode{alice, bob} {
-			ht.AssertNumPendingForceClose(node, 0)
-		}
-	}
-
-	// The invoice should show as settled for Carol, indicating that it was
-	// swept on-chain.
-	invoice := ht.AssertInvoiceState(stream, lnrpc.Invoice_SETTLED)
-	require.Equal(ht, int64(invoiceAmt), invoice.AmtPaidSat)
-
-	// Finally, check that the Alice's payment is correctly marked
-	// succeeded.
-	ht.AssertPaymentStatus(alice, preimage, lnrpc.Payment_SUCCEEDED)
-}
-
 // testMultiHopHtlcAggregation tests that in a multi-hop HTLC scenario, if we
 // force close a channel with both incoming and outgoing HTLCs, we can properly
 // resolve them using the second level timeout and success transactions. In