mirrors/lnd
1
0
Fork 0
mirror of https://github.com/lightningnetwork/lnd.git synced 2025-02-23 22:46:40 +01:00
Code Issues Projects Releases Wiki Activity

itest: flatten testMultiHopHtlcRemoteChainClaim

Browse source
This commit is contained in:
yyforyongyu 2024-10-23 02:30:44 +08:00
parent 8dd73a08a9
commit 52e6fb1161
No known key found for this signature in database
GPG key ID: 9BCD95C4FF296868
3 changed files with 640 additions and 299 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
itest/list_on_test.go
View file

@ -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,

640
itest/lnd_multi-hop_force_close_test.go
View file

@ -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)
}

295
itest/lnd_multi-hop_test.go
View file

@ -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