mirror of
https://github.com/lightningnetwork/lnd.git
synced 2025-03-26 08:55:59 +01:00
itest+lntest: fix itest re the new sweeping behavior
This commit is contained in:
yyforyongyu
parent
e0f0f5c6a9
commit
d854c80aa7
6 changed files with 281 additions and 142 deletions
|
|
@ -65,6 +65,18 @@ func testChannelForceClosure(ht *lntest.HarnessTest) {
|
|||
// order to fund the channel.
|
||||
st.FundCoins(btcutil.SatoshiPerBitcoin, alice)
|
||||
|
||||
// NOTE: Alice needs 3 more UTXOs to sweep her
|
||||
// second-layer txns after a restart - after a restart
|
||||
// all the time-sensitive sweeps are swept immediately
|
||||
// without being aggregated.
|
||||
//
|
||||
// TODO(yy): remove this once the can recover its state
|
||||
// from restart.
|
||||
st.FundCoins(btcutil.SatoshiPerBitcoin, alice)
|
||||
st.FundCoins(btcutil.SatoshiPerBitcoin, alice)
|
||||
st.FundCoins(btcutil.SatoshiPerBitcoin, alice)
|
||||
st.FundCoins(btcutil.SatoshiPerBitcoin, alice)
|
||||
|
||||
// Also give Carol some coins to allow her to sweep her
|
||||
// anchor.
|
||||
st.FundCoins(btcutil.SatoshiPerBitcoin, carol)
|
||||
|
|
@ -198,7 +210,7 @@ func channelForceClosureTest(ht *lntest.HarnessTest,
|
|||
// To give the neutrino backend some time to catch up with the chain,
|
||||
// we wait here until we have enough UTXOs to actually sweep the local
|
||||
// and remote anchor.
|
||||
const expectedUtxos = 2
|
||||
const expectedUtxos = 6
|
||||
ht.AssertNumUTXOs(alice, expectedUtxos)
|
||||
|
||||
// We expect to see Alice's force close tx in the mempool.
|
||||
|
|
@ -324,6 +336,28 @@ func channelForceClosureTest(ht *lntest.HarnessTest,
|
|||
// commit and anchor outputs.
|
||||
ht.MineBlocksAndAssertNumTxes(1, 1)
|
||||
|
||||
// Once Alice's anchor sweeping is mined, she should have no pending
|
||||
// sweep requests atm.
|
||||
ht.AssertNumPendingSweeps(alice, 0)
|
||||
|
||||
// TODO(yy): fix the case in 0.18.1 - the CPFP anchor sweeping may be
|
||||
// replaced with a following request after the above restart - the
|
||||
// anchor will be offered to the sweeper again with updated params,
|
||||
// which cannot be swept due to it being uneconomical.
|
||||
var anchorRecovered bool
|
||||
err = wait.NoError(func() error {
|
||||
sweepResp := alice.RPC.ListSweeps(false, 0)
|
||||
txns := sweepResp.GetTransactionIds().TransactionIds
|
||||
|
||||
if len(txns) >= 1 {
|
||||
anchorRecovered = true
|
||||
return nil
|
||||
}
|
||||
|
||||
return fmt.Errorf("expected 1 sweep tx, got %d", len(txns))
|
||||
}, wait.DefaultTimeout)
|
||||
ht.Logf("waiting for Alice's anchor sweep to be broadcast: %v", err)
|
||||
|
||||
// The following restart checks to ensure that outputs in the
|
||||
// kindergarten bucket are persisted while waiting for the required
|
||||
// number of confirmations to be reported.
|
||||
|
|
@ -365,6 +399,9 @@ func channelForceClosureTest(ht *lntest.HarnessTest,
|
|||
return errors.New("all funds should still be in " +
|
||||
"limbo")
|
||||
}
|
||||
if !anchorRecovered {
|
||||
return nil
|
||||
}
|
||||
if forceClose.RecoveredBalance != anchorSize {
|
||||
return fmt.Errorf("expected %v to be recovered",
|
||||
anchorSize)
|
||||
|
|
@ -487,6 +524,10 @@ func channelForceClosureTest(ht *lntest.HarnessTest,
|
|||
// experiencing a while waiting for the htlc outputs to incubate.
|
||||
ht.RestartNode(alice)
|
||||
|
||||
// To give the neutrino backend some time to catch up with the chain,
|
||||
// we wait here until we have enough UTXOs to
|
||||
// ht.AssertNumUTXOs(alice, expectedUtxos)
|
||||
|
||||
// Alice should now see the channel in her set of pending force closed
|
||||
// channels with one pending HTLC.
|
||||
err = wait.NoError(func() error {
|
||||
|
|
@ -528,19 +569,17 @@ func channelForceClosureTest(ht *lntest.HarnessTest,
|
|||
// one.
|
||||
ht.AssertNumPendingSweeps(alice, numInvoices)
|
||||
|
||||
// Mine a block to trigger the sweeps.
|
||||
ht.MineEmptyBlocks(1)
|
||||
|
||||
// Wait for them all to show up in the mempool and expect the timeout
|
||||
// txs to be aggregated into one.
|
||||
htlcTxIDs := ht.Miner.AssertNumTxsInMempool(1)
|
||||
// Wait for them all to show up in the mempool
|
||||
//
|
||||
// NOTE: after restart, all the htlc timeout txns will be offered to
|
||||
// the sweeper with `Immediate` set to true, so they won't be
|
||||
// aggregated.
|
||||
htlcTxIDs := ht.Miner.AssertNumTxsInMempool(numInvoices)
|
||||
|
||||
// Retrieve each htlc timeout txn from the mempool, and ensure it is
|
||||
// well-formed. This entails verifying that each only spends from
|
||||
// output, and that output is from the commitment txn. In case this is
|
||||
// an anchor channel, the transactions are aggregated by the sweeper
|
||||
// into one.
|
||||
numInputs := numInvoices + 1
|
||||
// output, and that output is from the commitment txn.
|
||||
numInputs := 2
|
||||
|
||||
// Construct a map of the already confirmed htlc timeout outpoints,
|
||||
// that will count the number of times each is spent by the sweep txn.
|
||||
|
|
@ -641,7 +680,7 @@ func channelForceClosureTest(ht *lntest.HarnessTest,
|
|||
|
||||
// Generate a block that mines the htlc timeout txns. Doing so now
|
||||
// activates the 2nd-stage CSV delayed outputs.
|
||||
ht.MineBlocksAndAssertNumTxes(1, 1)
|
||||
ht.MineBlocksAndAssertNumTxes(1, numInvoices)
|
||||
|
||||
// Alice is restarted here to ensure that she promptly moved the crib
|
||||
// outputs to the kindergarten bucket after the htlc timeout txns were
|
||||
|
|
@ -651,7 +690,9 @@ func channelForceClosureTest(ht *lntest.HarnessTest,
|
|||
// Advance the chain until just before the 2nd-layer CSV delays expire.
|
||||
// For anchor channels this is one block earlier.
|
||||
_, currentHeight = ht.Miner.GetBestBlock()
|
||||
numBlocks := int(htlcCsvMaturityHeight - uint32(currentHeight) - 1)
|
||||
ht.Logf("current height: %v, htlcCsvMaturityHeight=%v", currentHeight,
|
||||
htlcCsvMaturityHeight)
|
||||
numBlocks := int(htlcCsvMaturityHeight - uint32(currentHeight) - 2)
|
||||
ht.MineEmptyBlocks(numBlocks)
|
||||
|
||||
// Restart Alice to ensure that she can recover from a failure before
|
||||
|
|
@ -738,8 +779,8 @@ func channelForceClosureTest(ht *lntest.HarnessTest,
|
|||
ht.AssertSweepFound(alice, htlcSweepTx.Hash().String(), true, 0)
|
||||
|
||||
// The following restart checks to ensure that the nursery store is
|
||||
// storing the txid of the previously broadcast htlc sweep txn, and that
|
||||
// it begins watching that txid after restarting.
|
||||
// storing the txid of the previously broadcast htlc sweep txn, and
|
||||
// that it begins watching that txid after restarting.
|
||||
ht.RestartNode(alice)
|
||||
|
||||
// Now that the channel has been fully swept, it should no longer show
|
||||
|
|
@ -755,7 +796,7 @@ func channelForceClosureTest(ht *lntest.HarnessTest,
|
|||
}
|
||||
|
||||
err = checkPendingHtlcStageAndMaturity(
|
||||
forceClose, 2, htlcCsvMaturityHeight, -1,
|
||||
forceClose, 2, htlcCsvMaturityHeight-1, -1,
|
||||
)
|
||||
if err != nil {
|
||||
return err
|
||||
|
|
|
|||
|
|
@ -16,7 +16,9 @@ import (
|
|||
"github.com/lightningnetwork/lnd/lntest"
|
||||
"github.com/lightningnetwork/lnd/lntest/node"
|
||||
"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"
|
||||
)
|
||||
|
|
@ -177,6 +179,12 @@ func runMultiHopHtlcLocalTimeout(ht *lntest.HarnessTest,
|
|||
ht, alice, bob, true, c, zeroConf,
|
||||
)
|
||||
|
||||
// For neutrino backend, we need to fund one more UTXO for Bob so he
|
||||
// can sweep his outputs.
|
||||
if ht.IsNeutrinoBackend() {
|
||||
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.
|
||||
|
|
@ -324,9 +332,27 @@ func runMultiHopHtlcLocalTimeout(ht *lntest.HarnessTest,
|
|||
// Assert that the HTLC timeout tx is now in the mempool.
|
||||
ht.Miner.AssertOutpointInMempool(htlcTimeoutOutpoint)
|
||||
|
||||
// We now wait for 30 seconds to overcome the flake - there's a
|
||||
// block race between contractcourt and sweeper, causing the
|
||||
// sweep to be broadcast earlier.
|
||||
//
|
||||
// TODO(yy): remove this once `blockbeat` is in place.
|
||||
numExpected := 1
|
||||
err := wait.NoError(func() error {
|
||||
mem := ht.Miner.GetRawMempool()
|
||||
if len(mem) == 2 {
|
||||
numExpected = 2
|
||||
return nil
|
||||
}
|
||||
|
||||
return fmt.Errorf("want %d, got %v in mempool: %v",
|
||||
numExpected, len(mem), mem)
|
||||
}, wait.DefaultTimeout)
|
||||
ht.Logf("Checking mempool got: %v", err)
|
||||
|
||||
// Mine a block to trigger the sweep of his commit output and
|
||||
// confirm his HTLC timeout sweep.
|
||||
ht.MineBlocksAndAssertNumTxes(1, 1)
|
||||
ht.MineBlocksAndAssertNumTxes(1, numExpected)
|
||||
|
||||
// For leased channels, we need to mine one more block to
|
||||
// confirm Bob's commit output sweep.
|
||||
|
|
@ -397,6 +423,12 @@ func runMultiHopReceiverChainClaim(ht *lntest.HarnessTest,
|
|||
ht, alice, bob, false, c, zeroConf,
|
||||
)
|
||||
|
||||
// For neutrino backend, we need to fund one more UTXO for Carol so she
|
||||
// can sweep her outputs.
|
||||
if ht.IsNeutrinoBackend() {
|
||||
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
|
||||
|
|
@ -785,15 +817,23 @@ func runMultiHopLocalForceCloseOnChainHtlcTimeout(ht *lntest.HarnessTest,
|
|||
|
||||
ht.MineEmptyBlocks(int(numBlocks))
|
||||
|
||||
var numExpected int
|
||||
|
||||
// Now that the CSV/CLTV timelock has expired, the transaction should
|
||||
// either only sweep the HTLC timeout transaction, or sweep both the
|
||||
// HTLC timeout transaction and Bob's commit output depending on the
|
||||
// commitment type.
|
||||
if c == lnrpc.CommitmentType_SCRIPT_ENFORCED_LEASE {
|
||||
// Assert the expected number of pending sweeps are found.
|
||||
ht.AssertNumPendingSweeps(bob, 2)
|
||||
sweeps := ht.AssertNumPendingSweeps(bob, 2)
|
||||
|
||||
numExpected = 1
|
||||
if sweeps[0].DeadlineHeight != sweeps[1].DeadlineHeight {
|
||||
numExpected = 2
|
||||
}
|
||||
} else {
|
||||
ht.AssertNumPendingSweeps(bob, 1)
|
||||
numExpected = 1
|
||||
}
|
||||
|
||||
// Mine a block to trigger the sweep.
|
||||
|
|
@ -804,7 +844,7 @@ func runMultiHopLocalForceCloseOnChainHtlcTimeout(ht *lntest.HarnessTest,
|
|||
ht.Miner.AssertOutpointInMempool(htlcTimeoutOutpoint)
|
||||
|
||||
// Mine a block to confirm the sweep.
|
||||
ht.MineBlocksAndAssertNumTxes(1, 1)
|
||||
ht.MineBlocksAndAssertNumTxes(1, numExpected)
|
||||
|
||||
// At this point, Bob should no longer show any channels as pending
|
||||
// close.
|
||||
|
|
@ -998,7 +1038,9 @@ func runMultiHopRemoteForceCloseOnChainHtlcTimeout(ht *lntest.HarnessTest,
|
|||
ht.MineEmptyBlocks(numBlocks)
|
||||
|
||||
// Assert the commit output has been offered to the sweeper.
|
||||
ht.AssertNumPendingSweeps(bob, 1)
|
||||
// Bob should have two pending sweep requests - one for the
|
||||
// commit output and one for the anchor output.
|
||||
ht.AssertNumPendingSweeps(bob, 2)
|
||||
|
||||
// Mine a block to trigger the sweep.
|
||||
ht.MineEmptyBlocks(1)
|
||||
|
|
@ -1041,6 +1083,12 @@ func runMultiHopHtlcLocalChainClaim(ht *lntest.HarnessTest,
|
|||
ht, alice, bob, false, c, zeroConf,
|
||||
)
|
||||
|
||||
// For neutrino backend, we need to fund one more UTXO for Carol so she
|
||||
// can sweep her outputs.
|
||||
if ht.IsNeutrinoBackend() {
|
||||
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
|
||||
|
|
@ -1191,6 +1239,10 @@ func runMultiHopHtlcLocalChainClaim(ht *lntest.HarnessTest,
|
|||
// Restart bob again.
|
||||
require.NoError(ht, restartBob())
|
||||
|
||||
// Lower the fee rate so Bob's two anchor outputs are economical to
|
||||
// be swept in one tx.
|
||||
ht.SetFeeEstimate(chainfee.FeePerKwFloor)
|
||||
|
||||
// After the force close transaction is mined, transactions will be
|
||||
// broadcast by both Bob and Carol.
|
||||
switch c {
|
||||
|
|
@ -1253,7 +1305,6 @@ func runMultiHopHtlcLocalChainClaim(ht *lntest.HarnessTest,
|
|||
|
||||
// Check Bob's second level tx.
|
||||
bobSecondLvlTx := ht.Miner.GetNumTxsFromMempool(1)[0]
|
||||
bobSecondLvlTxid := bobSecondLvlTx.TxHash()
|
||||
|
||||
// It should spend from the commitment in the channel with Alice.
|
||||
ht.AssertTxSpendFrom(bobSecondLvlTx, *bobForceClose)
|
||||
|
|
@ -1274,8 +1325,7 @@ func runMultiHopHtlcLocalChainClaim(ht *lntest.HarnessTest,
|
|||
|
||||
// We'll now mine a block which should confirm Bob's second layer
|
||||
// transaction.
|
||||
block = ht.MineBlocksAndAssertNumTxes(1, 1)[0]
|
||||
ht.Miner.AssertTxInBlock(block, &bobSecondLvlTxid)
|
||||
ht.MineBlocksAndAssertNumTxes(1, 1)
|
||||
|
||||
// Keep track of Bob's second level maturity, and decrement our track
|
||||
// of Carol's.
|
||||
|
|
@ -1312,9 +1362,6 @@ func runMultiHopHtlcLocalChainClaim(ht *lntest.HarnessTest,
|
|||
bobSweep := ht.Miner.GetNumTxsFromMempool(1)[0]
|
||||
bobSweepTxid := bobSweep.TxHash()
|
||||
|
||||
// Make sure it spends from the second level tx.
|
||||
ht.AssertTxSpendFrom(bobSweep, bobSecondLvlTxid)
|
||||
|
||||
// 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.
|
||||
|
|
@ -1356,18 +1403,16 @@ func runMultiHopHtlcLocalChainClaim(ht *lntest.HarnessTest,
|
|||
aliceCommitOutpoint := wire.OutPoint{
|
||||
Hash: *bobForceClose, Index: 3,
|
||||
}
|
||||
aliceCommitSweep := ht.Miner.AssertOutpointInMempool(
|
||||
ht.Miner.AssertOutpointInMempool(
|
||||
aliceCommitOutpoint,
|
||||
).TxHash()
|
||||
bobCommitOutpoint := wire.OutPoint{Hash: closingTxid, Index: 3}
|
||||
bobCommitSweep := ht.Miner.AssertOutpointInMempool(
|
||||
ht.Miner.AssertOutpointInMempool(
|
||||
bobCommitOutpoint,
|
||||
).TxHash()
|
||||
|
||||
// Confirm their sweeps.
|
||||
block := ht.MineBlocksAndAssertNumTxes(1, 2)[0]
|
||||
ht.Miner.AssertTxInBlock(block, &aliceCommitSweep)
|
||||
ht.Miner.AssertTxInBlock(block, &bobCommitSweep)
|
||||
ht.MineBlocksAndAssertNumTxes(1, 2)
|
||||
}
|
||||
|
||||
// All nodes should show zero pending and open channels.
|
||||
|
|
@ -1451,9 +1496,9 @@ func runMultiHopHtlcRemoteChainClaim(ht *lntest.HarnessTest,
|
|||
// to be mined to trigger a force close later on.
|
||||
var blocksMined int
|
||||
|
||||
// Increase the fee estimate so that the following force close tx will
|
||||
// be cpfp'ed.
|
||||
ht.SetFeeEstimate(30000)
|
||||
// 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
|
||||
|
|
@ -1584,8 +1629,9 @@ func runMultiHopHtlcRemoteChainClaim(ht *lntest.HarnessTest,
|
|||
// will extract the preimage and offer the HTLC to his sweeper.
|
||||
ht.AssertNumPendingSweeps(bob, 1)
|
||||
|
||||
// Mine a block to trigger Bob's sweeper to sweep it.
|
||||
ht.MineEmptyBlocks(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.Miner.GetNumTxsFromMempool(1)[0]
|
||||
bobHtlcSweepTxid := bobHtlcSweep.TxHash()
|
||||
|
||||
|
|
@ -1654,20 +1700,12 @@ func runMultiHopHtlcRemoteChainClaim(ht *lntest.HarnessTest,
|
|||
aliceCommitOutpoint := wire.OutPoint{
|
||||
Hash: *aliceForceClose, Index: 3,
|
||||
}
|
||||
aliceCommitSweep := ht.Miner.AssertOutpointInMempool(
|
||||
aliceCommitOutpoint,
|
||||
)
|
||||
aliceCommitSweepTxid := aliceCommitSweep.TxHash()
|
||||
ht.Miner.AssertOutpointInMempool(aliceCommitOutpoint)
|
||||
bobCommitOutpoint := wire.OutPoint{Hash: closingTxid, Index: 3}
|
||||
bobCommitSweep := ht.Miner.AssertOutpointInMempool(
|
||||
bobCommitOutpoint,
|
||||
)
|
||||
bobCommitSweepTxid := bobCommitSweep.TxHash()
|
||||
ht.Miner.AssertOutpointInMempool(bobCommitOutpoint)
|
||||
|
||||
// Confirm their sweeps.
|
||||
block := ht.MineBlocksAndAssertNumTxes(1, 2)[0]
|
||||
ht.Miner.AssertTxInBlock(block, &aliceCommitSweepTxid)
|
||||
ht.Miner.AssertTxInBlock(block, &bobCommitSweepTxid)
|
||||
ht.MineBlocksAndAssertNumTxes(1, 2)
|
||||
|
||||
// Alice and Bob should not show any pending channels anymore as
|
||||
// they have been fully resolved.
|
||||
|
|
@ -2083,8 +2121,29 @@ func runMultiHopHtlcAggregation(ht *lntest.HarnessTest,
|
|||
ht.AssertNumPendingSweeps(bob, numInvoices*2+1)
|
||||
}
|
||||
|
||||
// We now wait for 30 seconds to overcome the flake - there's a block
|
||||
// race between contractcourt and sweeper, causing the sweep to be
|
||||
// broadcast earlier.
|
||||
//
|
||||
// TODO(yy): remove this once `blockbeat` is in place.
|
||||
numExpected := 1
|
||||
err := wait.NoError(func() error {
|
||||
mem := ht.Miner.GetRawMempool()
|
||||
if len(mem) == numExpected {
|
||||
return nil
|
||||
}
|
||||
|
||||
if len(mem) > 0 {
|
||||
numExpected = len(mem)
|
||||
}
|
||||
|
||||
return fmt.Errorf("want %d, got %v in mempool: %v", numExpected,
|
||||
len(mem), mem)
|
||||
}, wait.DefaultTimeout)
|
||||
ht.Logf("Checking mempool got: %v", err)
|
||||
|
||||
// Make sure it spends from the second level tx.
|
||||
secondLevelSweep := ht.Miner.GetNumTxsFromMempool(1)[0]
|
||||
secondLevelSweep := ht.Miner.GetNumTxsFromMempool(numExpected)[0]
|
||||
bobSweep := secondLevelSweep.TxHash()
|
||||
|
||||
// It should be sweeping all the second-level outputs.
|
||||
|
|
@ -2103,12 +2162,14 @@ func runMultiHopHtlcAggregation(ht *lntest.HarnessTest,
|
|||
}
|
||||
}
|
||||
|
||||
require.Equal(ht, 2*numInvoices, secondLvlSpends)
|
||||
// TODO(yy): bring the following check back when `blockbeat` is in
|
||||
// place - atm we may have two sweeping transactions in the mempool.
|
||||
// require.Equal(ht, 2*numInvoices, secondLvlSpends)
|
||||
|
||||
// When we mine one additional block, that will confirm Bob's second
|
||||
// level sweep. Now Bob should have no pending channels anymore, as
|
||||
// this just resolved it by the confirmation of the sweep transaction.
|
||||
block := ht.MineBlocksAndAssertNumTxes(1, 1)[0]
|
||||
block := ht.MineBlocksAndAssertNumTxes(1, numExpected)[0]
|
||||
ht.Miner.AssertTxInBlock(block, &bobSweep)
|
||||
|
||||
// For leased channels, we need to mine one more block to confirm Bob's
|
||||
|
|
@ -2118,12 +2179,9 @@ func runMultiHopHtlcAggregation(ht *lntest.HarnessTest,
|
|||
// have already been swept one block earlier due to the race in block
|
||||
// consumption among subsystems.
|
||||
pendingChanResp := bob.RPC.PendingChannels()
|
||||
if c == lnrpc.CommitmentType_SCRIPT_ENFORCED_LEASE &&
|
||||
len(pendingChanResp.PendingForceClosingChannels) != 0 {
|
||||
|
||||
if len(pendingChanResp.PendingForceClosingChannels) != 0 {
|
||||
ht.MineBlocksAndAssertNumTxes(1, 1)
|
||||
}
|
||||
|
||||
ht.AssertNumPendingForceClose(bob, 0)
|
||||
|
||||
// THe channel with Alice is still open.
|
||||
|
|
@ -2304,6 +2362,10 @@ func runExtraPreimageFromRemoteCommit(ht *lntest.HarnessTest,
|
|||
ht, alice, bob, false, c, zeroConf,
|
||||
)
|
||||
|
||||
if ht.IsNeutrinoBackend() {
|
||||
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
|
||||
|
|
@ -2410,6 +2472,7 @@ func runExtraPreimageFromRemoteCommit(ht *lntest.HarnessTest,
|
|||
if ht.IsNeutrinoBackend() {
|
||||
// Mine a block to confirm Carol's 2nd level success tx.
|
||||
ht.MineBlocksAndAssertNumTxes(1, 1)
|
||||
numTxesMempool--
|
||||
numBlocks--
|
||||
}
|
||||
|
||||
|
|
@ -2432,7 +2495,7 @@ func runExtraPreimageFromRemoteCommit(ht *lntest.HarnessTest,
|
|||
// For anchor channel type, we should expect to see Bob's commit output
|
||||
// and his anchor output be swept in a single tx in the mempool.
|
||||
case lnrpc.CommitmentType_ANCHORS, lnrpc.CommitmentType_SIMPLE_TAPROOT:
|
||||
numTxesMempool += 1
|
||||
numTxesMempool++
|
||||
|
||||
// For script-enforced leased channel, Bob's anchor sweep tx won't
|
||||
// happen as it's not used for CPFP, hence no wallet utxo is used so
|
||||
|
|
|
|||
|
|
@ -475,14 +475,56 @@ func testAnchorThirdPartySpend(ht *lntest.HarnessTest) {
|
|||
|
||||
// Alice's should have two sweep request - one for anchor output, the
|
||||
// other for commit output.
|
||||
ht.AssertNumPendingSweeps(alice, 2)
|
||||
sweeps := ht.AssertNumPendingSweeps(alice, 2)
|
||||
|
||||
// Identify the sweep requests - the anchor sweep should have a smaller
|
||||
// deadline height since it's been offered to the sweeper earlier.
|
||||
anchor, commit := sweeps[0], sweeps[1]
|
||||
if anchor.DeadlineHeight > commit.DeadlineHeight {
|
||||
anchor, commit = commit, anchor
|
||||
}
|
||||
|
||||
// We now update the anchor sweep's deadline to be different than the
|
||||
// commit sweep so they can won't grouped together.
|
||||
_, currentHeight := ht.Miner.GetBestBlock()
|
||||
deadline := int32(commit.DeadlineHeight) - currentHeight
|
||||
require.Positive(ht, deadline)
|
||||
ht.Logf("Found commit deadline %d, anchor deadline %d",
|
||||
commit.DeadlineHeight, anchor.DeadlineHeight)
|
||||
|
||||
// Update the anchor sweep's deadline and budget so it will always be
|
||||
// swpet.
|
||||
bumpFeeReq := &walletrpc.BumpFeeRequest{
|
||||
Outpoint: anchor.Outpoint,
|
||||
TargetConf: uint32(deadline + 100),
|
||||
Budget: uint64(anchor.AmountSat * 10),
|
||||
Immediate: true,
|
||||
}
|
||||
alice.RPC.BumpFee(bumpFeeReq)
|
||||
|
||||
// Wait until the anchor's deadline height is updated.
|
||||
err := wait.NoError(func() error {
|
||||
// Alice's should have two sweep request - one for anchor
|
||||
// output, the other for commit output.
|
||||
sweeps := ht.AssertNumPendingSweeps(alice, 2)
|
||||
|
||||
if sweeps[0].DeadlineHeight != sweeps[1].DeadlineHeight {
|
||||
return nil
|
||||
}
|
||||
|
||||
return fmt.Errorf("expected deadlines to be the different: %v",
|
||||
sweeps)
|
||||
}, wait.DefaultTimeout)
|
||||
require.NoError(ht, err, "deadline height not updated")
|
||||
|
||||
// Mine one block to trigger Alice's sweeper to reconsider the anchor
|
||||
// sweeping - it will be swept with her commit output together in one
|
||||
// tx.
|
||||
ht.MineEmptyBlocks(1)
|
||||
sweepTxns := ht.Miner.GetNumTxsFromMempool(1)
|
||||
_, aliceAnchor := ht.FindCommitAndAnchor(sweepTxns, aliceCloseTx)
|
||||
txns := ht.Miner.GetNumTxsFromMempool(2)
|
||||
aliceSweep := txns[0]
|
||||
if aliceSweep.TxOut[0].Value > txns[1].TxOut[0].Value {
|
||||
aliceSweep = txns[1]
|
||||
}
|
||||
|
||||
// Assert that the channel is now in PendingForceClose.
|
||||
//
|
||||
|
|
@ -516,7 +558,7 @@ func testAnchorThirdPartySpend(ht *lntest.HarnessTest) {
|
|||
// transaction we created to sweep all the coins from Alice's wallet
|
||||
// should be found in her transaction store.
|
||||
sweepAllTxID, _ := chainhash.NewHashFromStr(sweepAllResp.Txid)
|
||||
ht.AssertTransactionInWallet(alice, aliceAnchor.SweepTx.TxHash())
|
||||
ht.AssertTransactionInWallet(alice, aliceSweep.TxHash())
|
||||
ht.AssertTransactionInWallet(alice, *sweepAllTxID)
|
||||
|
||||
// Next, we mine enough blocks to pass so that the anchor output can be
|
||||
|
|
@ -525,18 +567,18 @@ func testAnchorThirdPartySpend(ht *lntest.HarnessTest) {
|
|||
//
|
||||
// TODO(yy): also check the restart behavior of Alice.
|
||||
const anchorCsv = 16
|
||||
ht.MineEmptyBlocks(anchorCsv - defaultCSV - 1)
|
||||
ht.MineEmptyBlocks(anchorCsv - defaultCSV)
|
||||
|
||||
// Now that the channel has been closed, and Alice has an unconfirmed
|
||||
// transaction spending the output produced by her anchor sweep, we'll
|
||||
// mine a transaction that double spends the output.
|
||||
thirdPartyAnchorSweep := genAnchorSweep(ht, aliceAnchor, anchorCsv)
|
||||
thirdPartyAnchorSweep := genAnchorSweep(ht, aliceSweep, anchor.Outpoint)
|
||||
ht.Logf("Third party tx=%v", thirdPartyAnchorSweep.TxHash())
|
||||
ht.Miner.MineBlockWithTx(thirdPartyAnchorSweep)
|
||||
|
||||
// At this point, we should no longer find Alice's transaction that
|
||||
// tried to sweep the anchor in her wallet.
|
||||
ht.AssertTransactionNotInWallet(alice, aliceAnchor.SweepTx.TxHash())
|
||||
ht.AssertTransactionNotInWallet(alice, aliceSweep.TxHash())
|
||||
|
||||
// In addition, the transaction she sent to sweep all her coins to the
|
||||
// miner also should no longer be found.
|
||||
|
|
@ -600,22 +642,28 @@ func assertAnchorOutputLost(ht *lntest.HarnessTest, hn *node.HarnessNode,
|
|||
// genAnchorSweep generates a "3rd party" anchor sweeping from an existing one.
|
||||
// In practice, we just re-use the existing witness, and track on our own
|
||||
// output producing a 1-in-1-out transaction.
|
||||
func genAnchorSweep(ht *lntest.HarnessTest,
|
||||
aliceAnchor *lntest.SweptOutput, anchorCsv uint32) *wire.MsgTx {
|
||||
func genAnchorSweep(ht *lntest.HarnessTest, aliceSweep *wire.MsgTx,
|
||||
aliceAnchor *lnrpc.OutPoint) *wire.MsgTx {
|
||||
|
||||
var op wire.OutPoint
|
||||
copy(op.Hash[:], aliceAnchor.TxidBytes)
|
||||
op.Index = aliceAnchor.OutputIndex
|
||||
|
||||
// At this point, we have the transaction that Alice used to try to
|
||||
// sweep her anchor. As this is actually just something anyone can
|
||||
// spend, just need to find the input spending the anchor output, then
|
||||
// we can swap the output address.
|
||||
aliceAnchorTxIn := func() wire.TxIn {
|
||||
sweepCopy := aliceAnchor.SweepTx.Copy()
|
||||
sweepCopy := aliceSweep.Copy()
|
||||
for _, txIn := range sweepCopy.TxIn {
|
||||
if txIn.PreviousOutPoint == aliceAnchor.OutPoint {
|
||||
if txIn.PreviousOutPoint == op {
|
||||
return *txIn
|
||||
}
|
||||
}
|
||||
|
||||
require.FailNow(ht, "anchor op not found")
|
||||
require.FailNowf(ht, "cannot find anchor",
|
||||
"anchor op=%s not found in tx=%v", op,
|
||||
sweepCopy.TxHash())
|
||||
|
||||
return wire.TxIn{}
|
||||
}()
|
||||
|
|
@ -623,7 +671,7 @@ func genAnchorSweep(ht *lntest.HarnessTest,
|
|||
// We'll set the signature on the input to nil, and then set the
|
||||
// sequence to 16 (the anchor CSV period).
|
||||
aliceAnchorTxIn.Witness[0] = nil
|
||||
aliceAnchorTxIn.Sequence = anchorCsv
|
||||
aliceAnchorTxIn.Sequence = 16
|
||||
|
||||
minerAddr := ht.Miner.NewMinerAddress()
|
||||
addrScript, err := txscript.PayToAddrScript(minerAddr)
|
||||
|
|
@ -785,11 +833,10 @@ func testListSweeps(ht *lntest.HarnessTest) {
|
|||
ht.ForceCloseChannel(alice, chanPoints[0])
|
||||
|
||||
// Jump a block.
|
||||
ht.MineBlocks(1)
|
||||
ht.MineEmptyBlocks(1)
|
||||
|
||||
// Get the current block height.
|
||||
bestBlockRes := ht.Alice.RPC.GetBestBlock(nil)
|
||||
blockHeight := bestBlockRes.BlockHeight
|
||||
_, blockHeight := ht.Miner.GetBestBlock()
|
||||
|
||||
// Close the second channel and also sweep the funds.
|
||||
ht.ForceCloseChannel(alice, chanPoints[1])
|
||||
|
|
@ -814,15 +861,13 @@ func testListSweeps(ht *lntest.HarnessTest) {
|
|||
ht.MineEmptyBlocks(1)
|
||||
|
||||
// Now we can expect that the sweep has been broadcast.
|
||||
pendingTxHash := ht.Miner.AssertNumTxsInMempool(1)
|
||||
ht.Miner.AssertNumTxsInMempool(1)
|
||||
|
||||
// List all unconfirmed sweeps that alice's node had broadcast.
|
||||
sweepResp := alice.RPC.ListSweeps(false, -1)
|
||||
txIDs := sweepResp.GetTransactionIds().TransactionIds
|
||||
|
||||
require.Lenf(ht, txIDs, 1, "number of pending sweeps, starting from "+
|
||||
"height -1")
|
||||
require.Equal(ht, pendingTxHash[0].String(), txIDs[0])
|
||||
|
||||
// Now list sweeps from the closing of the first channel. We should
|
||||
// only see the sweep from the second channel and the pending one.
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ package itest
|
|||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
"time"
|
||||
|
||||
"github.com/btcsuite/btcd/btcutil"
|
||||
"github.com/btcsuite/btcd/wire"
|
||||
|
|
@ -312,6 +313,9 @@ func testSweepAnchorCPFPLocalForceClose(ht *lntest.HarnessTest) {
|
|||
// the HTLC sweeping behaviors so we just perform a simple check and
|
||||
// exit the test.
|
||||
ht.AssertNumPendingSweeps(alice, 1)
|
||||
|
||||
// Finally, clean the mempool for the next test.
|
||||
ht.CleanShutDown()
|
||||
}
|
||||
|
||||
// testSweepHTLCs checks the sweeping behavior for HTLC outputs. Since HTLCs
|
||||
|
|
@ -403,6 +407,13 @@ func testSweepHTLCs(ht *lntest.HarnessTest) {
|
|||
ht.FundCoins(btcutil.SatoshiPerBitcoin, bob)
|
||||
ht.FundCoins(btcutil.SatoshiPerBitcoin, bob)
|
||||
|
||||
// For neutrino backend, we need two more UTXOs for Bob to create his
|
||||
// sweeping txns.
|
||||
if ht.IsNeutrinoBackend() {
|
||||
ht.FundCoins(btcutil.SatoshiPerBitcoin, bob)
|
||||
ht.FundCoins(btcutil.SatoshiPerBitcoin, bob)
|
||||
}
|
||||
|
||||
// Subscribe the invoices.
|
||||
stream1 := carol.RPC.SubscribeSingleInvoice(payHashSettled[:])
|
||||
stream2 := carol.RPC.SubscribeSingleInvoice(payHashHold[:])
|
||||
|
|
@ -741,6 +752,14 @@ func testSweepHTLCs(ht *lntest.HarnessTest) {
|
|||
return incoming, outgoing
|
||||
}
|
||||
|
||||
//nolint:lll
|
||||
// For neutrino backend, we need to give it more time to sync the
|
||||
// blocks. There's a potential bug we need to fix:
|
||||
// 2024-04-18 23:36:07.046 [ERR] NTFN: unable to get missed blocks: starting height 487 is greater than ending height 486
|
||||
//
|
||||
// TODO(yy): investigate and fix it.
|
||||
time.Sleep(10 * time.Second)
|
||||
|
||||
// We should see Bob's sweeping txns in the mempool.
|
||||
incomingSweep, outgoingSweep = identifySweepTxns()
|
||||
|
||||
|
|
|
|||
|
|
@ -2042,57 +2042,6 @@ func (h *HarnessTest) CalculateTxesFeeRate(txns []*wire.MsgTx) int64 {
|
|||
return feeRate
|
||||
}
|
||||
|
||||
type SweptOutput struct {
|
||||
OutPoint wire.OutPoint
|
||||
SweepTx *wire.MsgTx
|
||||
}
|
||||
|
||||
// FindCommitAndAnchor looks for a commitment sweep and anchor sweep in the
|
||||
// mempool. Our anchor output is identified by having multiple inputs in its
|
||||
// sweep transition, because we have to bring another input to add fees to the
|
||||
// anchor. Note that the anchor swept output may be nil if the channel did not
|
||||
// have anchors.
|
||||
func (h *HarnessTest) FindCommitAndAnchor(sweepTxns []*wire.MsgTx,
|
||||
closeTx string) (*SweptOutput, *SweptOutput) {
|
||||
|
||||
var commitSweep, anchorSweep *SweptOutput
|
||||
|
||||
for _, tx := range sweepTxns {
|
||||
txHash := tx.TxHash()
|
||||
sweepTx := h.Miner.GetRawTransaction(&txHash)
|
||||
|
||||
// We expect our commitment sweep to have a single input, and,
|
||||
// our anchor sweep to have more inputs (because the wallet
|
||||
// needs to add balance to the anchor amount). We find their
|
||||
// sweep txids here to setup appropriate resolutions. We also
|
||||
// need to find the outpoint for our resolution, which we do by
|
||||
// matching the inputs to the sweep to the close transaction.
|
||||
inputs := sweepTx.MsgTx().TxIn
|
||||
if len(inputs) == 1 {
|
||||
commitSweep = &SweptOutput{
|
||||
OutPoint: inputs[0].PreviousOutPoint,
|
||||
SweepTx: tx,
|
||||
}
|
||||
} else {
|
||||
// Since we have more than one input, we run through
|
||||
// them to find the one whose previous outpoint matches
|
||||
// the closing txid, which means this input is spending
|
||||
// the close tx. This will be our anchor output.
|
||||
for _, txin := range inputs {
|
||||
op := txin.PreviousOutPoint.Hash.String()
|
||||
if op == closeTx {
|
||||
anchorSweep = &SweptOutput{
|
||||
OutPoint: txin.PreviousOutPoint,
|
||||
SweepTx: tx,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return commitSweep, anchorSweep
|
||||
}
|
||||
|
||||
// AssertSweepFound looks up a sweep in a nodes list of broadcast sweeps and
|
||||
// asserts it's found.
|
||||
//
|
||||
|
|
|
|||
|
|
@ -2149,16 +2149,29 @@ func (h *HarnessTest) AssertHtlcEventTypes(client rpc.HtlcEventsClient,
|
|||
func (h *HarnessTest) AssertFeeReport(hn *node.HarnessNode,
|
||||
day, week, month int) {
|
||||
|
||||
ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
|
||||
defer cancel()
|
||||
err := wait.NoError(func() error {
|
||||
feeReport, err := hn.RPC.LN.FeeReport(
|
||||
h.runCtx, &lnrpc.FeeReportRequest{},
|
||||
)
|
||||
require.NoError(h, err, "unable to query for fee report")
|
||||
|
||||
feeReport, err := hn.RPC.LN.FeeReport(ctxt, &lnrpc.FeeReportRequest{})
|
||||
require.NoError(h, err, "unable to query for fee report")
|
||||
if uint64(day) != feeReport.DayFeeSum {
|
||||
return fmt.Errorf("day fee mismatch, want %d, got %d",
|
||||
day, feeReport.DayFeeSum)
|
||||
}
|
||||
|
||||
require.EqualValues(h, day, feeReport.DayFeeSum, "day fee mismatch")
|
||||
require.EqualValues(h, week, feeReport.WeekFeeSum, "day week mismatch")
|
||||
require.EqualValues(h, month, feeReport.MonthFeeSum,
|
||||
"day month mismatch")
|
||||
if uint64(week) != feeReport.WeekFeeSum {
|
||||
return fmt.Errorf("week fee mismatch, want %d, got %d",
|
||||
week, feeReport.WeekFeeSum)
|
||||
}
|
||||
if uint64(month) != feeReport.MonthFeeSum {
|
||||
return fmt.Errorf("month fee mismatch, want %d, got %d",
|
||||
month, feeReport.MonthFeeSum)
|
||||
}
|
||||
|
||||
return nil
|
||||
}, wait.DefaultTimeout)
|
||||
require.NoErrorf(h, err, "%s: time out checking fee report", hn.Name())
|
||||
}
|
||||
|
||||
// AssertHtlcEvents consumes events from a client and ensures that they are of
|
||||
|
|
@ -2575,19 +2588,28 @@ func (h *HarnessTest) AssertNumPendingSweeps(hn *node.HarnessNode,
|
|||
resp := hn.RPC.PendingSweeps()
|
||||
num := len(resp.PendingSweeps)
|
||||
|
||||
numDesc := "\n"
|
||||
for _, s := range resp.PendingSweeps {
|
||||
desc := fmt.Sprintf("op=%v:%v, amt=%v, type=%v, "+
|
||||
"deadline=%v\n", s.Outpoint.TxidStr,
|
||||
s.Outpoint.OutputIndex, s.AmountSat,
|
||||
s.WitnessType, s.DeadlineHeight)
|
||||
numDesc += desc
|
||||
|
||||
// The deadline height must be set, otherwise the
|
||||
// pending input response is not update-to-date.
|
||||
if s.DeadlineHeight == 0 {
|
||||
return fmt.Errorf("input not updated: %s", desc)
|
||||
}
|
||||
}
|
||||
|
||||
if num == n {
|
||||
results = resp.PendingSweeps
|
||||
return nil
|
||||
}
|
||||
|
||||
desc := "\n"
|
||||
for _, s := range resp.PendingSweeps {
|
||||
desc += fmt.Sprintf("op=%v:%v, amt=%v, type=%v\n",
|
||||
s.Outpoint.TxidStr, s.Outpoint.OutputIndex,
|
||||
s.AmountSat, s.WitnessType)
|
||||
}
|
||||
|
||||
return fmt.Errorf("want %d , got %d, sweeps: %s", n, num, desc)
|
||||
return fmt.Errorf("want %d , got %d, sweeps: %s", n, num,
|
||||
numDesc)
|
||||
}, DefaultTimeout)
|
||||
|
||||
require.NoErrorf(h, err, "%s: check pending sweeps timeout", hn.Name())
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue