package itest import ( "context" "fmt" "time" "github.com/btcsuite/btcd/wire" "github.com/davecgh/go-spew/spew" "github.com/lightningnetwork/lnd" "github.com/lightningnetwork/lnd/lncfg" "github.com/lightningnetwork/lnd/lnrpc" "github.com/lightningnetwork/lnd/lnrpc/invoicesrpc" "github.com/lightningnetwork/lnd/lnrpc/routerrpc" "github.com/lightningnetwork/lnd/lntest" "github.com/lightningnetwork/lnd/lntest/wait" "github.com/lightningnetwork/lnd/lntypes" ) // testMultiHopHtlcLocalChainClaim tests that in a multi-hop HTLC scenario, if // we force close a channel with an incoming HTLC, and later find out the // preimage via the witness beacon, we properly settle the HTLC on-chain using // the HTLC success transaction in order to ensure we don't lose any funds. func testMultiHopHtlcLocalChainClaim(net *lntest.NetworkHarness, t *harnessTest, alice, bob *lntest.HarnessNode, c commitType) { ctxb := context.Background() // 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( t, net, alice, bob, false, c, ) // Clean up carol's node when the test finishes. defer shutdownAndAssert(net, t, 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. const invoiceAmt = 100000 preimage := lntypes.Preimage{1, 2, 3} payHash := preimage.Hash() invoiceReq := &invoicesrpc.AddHoldInvoiceRequest{ Value: invoiceAmt, CltvExpiry: 40, Hash: payHash[:], } ctxt, cancel := context.WithTimeout(ctxb, defaultTimeout) defer cancel() carolInvoice, err := carol.AddHoldInvoice(ctxt, invoiceReq) if err != nil { t.Fatalf("unable to add invoice: %v", err) } // 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. ctx, cancel := context.WithCancel(ctxb) defer cancel() _, err = alice.RouterClient.SendPaymentV2( ctx, &routerrpc.SendPaymentRequest{ PaymentRequest: carolInvoice.PaymentRequest, TimeoutSeconds: 60, FeeLimitMsat: noFeeLimitMsat, }, ) if err != nil { t.Fatalf("unable to send payment: %v", err) } // At this point, all 3 nodes should now have an active channel with // the created HTLC pending on all of them. var predErr error nodes := []*lntest.HarnessNode{alice, bob, carol} err = wait.Predicate(func() bool { predErr = assertActiveHtlcs(nodes, payHash[:]) if predErr != nil { return false } return true }, time.Second*15) if err != nil { t.Fatalf("htlc mismatch: %v", predErr) } // 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. waitForInvoiceAccepted(t, carol, payHash) // Increase the fee estimate so that the following force close tx will // be cpfp'ed. net.SetFeeEstimate(30000) // At this point, Bob decides that he wants to exit the channel // immediately, so he force closes his commitment transaction. ctxt, _ = context.WithTimeout(ctxb, channelCloseTimeout) bobForceClose := closeChannelAndAssertType(ctxt, t, net, bob, aliceChanPoint, c == commitTypeAnchors, true) // Alice will sweep her commitment output immediately. If there are // anchors, Alice will also sweep hers. expectedTxes := 1 if c == commitTypeAnchors { expectedTxes = 2 } _, err = waitForNTxsInMempool( net.Miner.Node, expectedTxes, minerMempoolTimeout, ) if err != nil { t.Fatalf("unable to find alice's sweep tx in miner mempool: %v", err) } // Suspend Bob to force Carol to go to chain. restartBob, err := net.SuspendNode(bob) if err != nil { t.Fatalf("unable to suspend bob: %v", err) } // 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. ctx, cancel = context.WithTimeout(ctxb, defaultTimeout) defer cancel() _, err = carol.SettleInvoice(ctx, &invoicesrpc.SettleInvoiceMsg{ Preimage: preimage[:], }) if err != nil { t.Fatalf("settle invoice: %v", err) } // 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)) if _, err := net.Miner.Node.Generate(numBlocks); err != nil { t.Fatalf("unable to generate blocks") } // Carol's commitment transaction should now be in the mempool. If there // is an anchor, Carol will sweep that too. _, err = waitForNTxsInMempool( net.Miner.Node, expectedTxes, minerMempoolTimeout, ) if err != nil { t.Fatalf("transactions not found in mempool: %v", err) } bobFundingTxid, err := lnd.GetChanPointFundingTxid(bobChanPoint) if err != nil { t.Fatalf("unable to get txid: %v", err) } carolFundingPoint := wire.OutPoint{ Hash: *bobFundingTxid, Index: bobChanPoint.OutputIndex, } // Look up the closing transaction. It should be spending from the // funding transaction, closingTx := getSpendingTxInMempool( t, net.Miner.Node, minerMempoolTimeout, carolFundingPoint, ) closingTxid := closingTx.TxHash() // Mine a block that should confirm the commit tx, the anchor if present // and the coinbase. block := mineBlocks(t, net, 1, expectedTxes)[0] if len(block.Transactions) != expectedTxes+1 { t.Fatalf("expected %v transactions in block, got %v", expectedTxes+1, len(block.Transactions)) } assertTxInBlock(t, block, &closingTxid) // Restart bob again. if err := restartBob(); err != nil { t.Fatalf("unable to restart bob: %v", err) } // After the force close transacion is mined, Carol should broadcast her // second level HTLC transacion. Bob will broadcast a sweep tx to sweep // his output in the channel with Carol. He can do this immediately, as // the output is not timelocked since Carol was the one force closing. // If there are anchors on the commitment, Bob will also sweep his // anchor. expectedTxes = 2 if c == commitTypeAnchors { expectedTxes = 3 } txes, err := getNTxsFromMempool( net.Miner.Node, expectedTxes, minerMempoolTimeout, ) if err != nil { t.Fatalf("transactions not found in mempool: %v", err) } // Both Carol's second level transaction and Bob's sweep should be // spending from the commitment transaction. assertAllTxesSpendFrom(t, txes, closingTxid) // At this point we suspend Alice to make sure she'll handle the // on-chain settle after a restart. restartAlice, err := net.SuspendNode(alice) if err != nil { t.Fatalf("unable to suspend alice: %v", err) } // Mine a block to confirm the two transactions (+ the coinbase). block = mineBlocks(t, net, 1, expectedTxes)[0] if len(block.Transactions) != expectedTxes+1 { t.Fatalf("expected 3 transactions in block, got %v", len(block.Transactions)) } // Keep track of the second level tx maturity. carolSecondLevelCSV := uint32(defaultCSV) // When Bob notices Carol's second level transaction in the block, he // will extract the preimage and broadcast a second level tx to claim // the HTLC in his (already closed) channel with Alice. bobSecondLvlTx, err := waitForTxInMempool(net.Miner.Node, minerMempoolTimeout) if err != nil { t.Fatalf("transactions not found in mempool: %v", err) } // It should spend from the commitment in the channel with Alice. tx, err := net.Miner.Node.GetRawTransaction(bobSecondLvlTx) if err != nil { t.Fatalf("unable to get txn: %v", err) } if tx.MsgTx().TxIn[0].PreviousOutPoint.Hash != *bobForceClose { t.Fatalf("tx did not spend from bob's force close tx") } // At this point, Bob should have broadcast his second layer success // transaction, and should have sent it to the nursery for incubation. pendingChansRequest := &lnrpc.PendingChannelsRequest{} err = wait.Predicate(func() bool { ctxt, _ = context.WithTimeout(ctxb, defaultTimeout) pendingChanResp, err := bob.PendingChannels( ctxt, pendingChansRequest, ) if err != nil { predErr = fmt.Errorf("unable to query for pending "+ "channels: %v", err) return false } if len(pendingChanResp.PendingForceClosingChannels) == 0 { predErr = fmt.Errorf("bob should have pending for " + "close chan but doesn't") return false } for _, forceCloseChan := range pendingChanResp.PendingForceClosingChannels { if forceCloseChan.Channel.LocalBalance != 0 { continue } if len(forceCloseChan.PendingHtlcs) != 1 { predErr = fmt.Errorf("bob should have pending htlc " + "but doesn't") return false } stage := forceCloseChan.PendingHtlcs[0].Stage if stage != 1 { predErr = fmt.Errorf("bob's htlc should have "+ "advanced to the first stage but was "+ "stage: %v", stage) return false } } return true }, time.Second*15) if err != nil { t.Fatalf("bob didn't hand off time-locked HTLC: %v", predErr) } // We'll now mine a block which should confirm Bob's second layer // transaction. block = mineBlocks(t, net, 1, 1)[0] if len(block.Transactions) != 2 { t.Fatalf("expected 2 transactions in block, got %v", len(block.Transactions)) } assertTxInBlock(t, block, bobSecondLvlTx) // Keep track of Bob's second level maturity, and decrement our track // of Carol's. bobSecondLevelCSV := uint32(defaultCSV) carolSecondLevelCSV-- // Now that the preimage from Bob has hit the chain, restart Alice to // ensure she'll pick it up. if err := restartAlice(); err != nil { t.Fatalf("unable to restart alice: %v", err) } // If we then mine 3 additional blocks, Carol's second level tx should // mature, and she can pull the funds from it with a sweep tx. if _, err := net.Miner.Node.Generate(carolSecondLevelCSV); err != nil { t.Fatalf("unable to generate block: %v", err) } bobSecondLevelCSV -= carolSecondLevelCSV carolSweep, err := waitForTxInMempool(net.Miner.Node, minerMempoolTimeout) if err != nil { t.Fatalf("unable to find Carol's sweeping transaction: %v", err) } // Mining one additional block, Bob's second level tx is mature, and he // can sweep the output. block = mineBlocks(t, net, bobSecondLevelCSV, 1)[0] assertTxInBlock(t, block, carolSweep) bobSweep, err := waitForTxInMempool(net.Miner.Node, minerMempoolTimeout) if err != nil { t.Fatalf("unable to find bob's sweeping transaction") } // Make sure it spends from the second level tx. tx, err = net.Miner.Node.GetRawTransaction(bobSweep) if err != nil { t.Fatalf("unable to get txn: %v", err) } if tx.MsgTx().TxIn[0].PreviousOutPoint.Hash != *bobSecondLvlTx { t.Fatalf("tx did not spend from bob's second level tx") } // When we mine one additional block, that will confirm Bob's sweep. // Now Bob should have no pending channels anymore, as this just // resolved it by the confirmation of the sweep transaction. block = mineBlocks(t, net, 1, 1)[0] assertTxInBlock(t, block, bobSweep) err = wait.Predicate(func() bool { ctxt, _ = context.WithTimeout(ctxb, defaultTimeout) pendingChanResp, err := bob.PendingChannels( ctxt, pendingChansRequest, ) if err != nil { predErr = fmt.Errorf("unable to query for pending "+ "channels: %v", err) return false } if len(pendingChanResp.PendingForceClosingChannels) != 0 { predErr = fmt.Errorf("bob still has pending channels "+ "but shouldn't: %v", spew.Sdump(pendingChanResp)) return false } req := &lnrpc.ListChannelsRequest{} ctxt, _ = context.WithTimeout(ctxb, defaultTimeout) chanInfo, err := bob.ListChannels(ctxt, req) if err != nil { predErr = fmt.Errorf("unable to query for open "+ "channels: %v", err) return false } if len(chanInfo.Channels) != 0 { predErr = fmt.Errorf("Bob should have no open "+ "channels, instead he has %v", len(chanInfo.Channels)) return false } return true }, time.Second*15) if err != nil { t.Fatalf(predErr.Error()) } // Also Carol should have no channels left (open nor pending). err = wait.Predicate(func() bool { ctxt, _ = context.WithTimeout(ctxb, defaultTimeout) pendingChanResp, err := carol.PendingChannels( ctxt, pendingChansRequest, ) if err != nil { predErr = fmt.Errorf("unable to query for pending "+ "channels: %v", err) return false } if len(pendingChanResp.PendingForceClosingChannels) != 0 { predErr = fmt.Errorf("bob carol has pending channels "+ "but shouldn't: %v", spew.Sdump(pendingChanResp)) return false } req := &lnrpc.ListChannelsRequest{} ctxt, _ = context.WithTimeout(ctxb, defaultTimeout) chanInfo, err := carol.ListChannels(ctxt, req) if err != nil { predErr = fmt.Errorf("unable to query for open "+ "channels: %v", err) return false } if len(chanInfo.Channels) != 0 { predErr = fmt.Errorf("carol should have no open "+ "channels, instead she has %v", len(chanInfo.Channels)) return false } return true }, time.Second*15) if err != nil { t.Fatalf(predErr.Error()) } // Finally, check that the Alice's payment is correctly marked // succeeded. ctxt, _ = context.WithTimeout(ctxt, defaultTimeout) err = checkPaymentStatus( ctxt, alice, preimage, lnrpc.Payment_SUCCEEDED, ) if err != nil { t.Fatalf(err.Error()) } }