mirror of
https://github.com/lightningnetwork/lnd.git
synced 2024-11-19 18:10:34 +01:00
228 lines
7.6 KiB
Go
228 lines
7.6 KiB
Go
package itest
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/lightningnetwork/lnd/chainreg"
|
|
"github.com/lightningnetwork/lnd/lnrpc"
|
|
"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
|
|
"github.com/lightningnetwork/lnd/lntest"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
type pendingChan *lnrpc.PendingChannelsResponse_PendingChannel
|
|
|
|
// testWipeForwardingPackagesLocal tests that when a channel is closed, either
|
|
// through local force close, remote close, or coop close, all the forwarding
|
|
// packages of that particular channel are deleted. The test creates a
|
|
// topology as Alice -> Bob -> Carol, and sends payments from Alice to Carol
|
|
// through Bob. It then performs the test in two steps,
|
|
// - Bob force closes the channel Alice->Bob, and checks from both Bob's
|
|
// PoV(local force close) and Alice's Pov(remote close) that the forwarding
|
|
// packages are wiped.
|
|
// - Bob coop closes the channel Bob->Carol, and checks from both Bob PoVs that
|
|
// the forwarding packages are wiped.
|
|
func testWipeForwardingPackages(net *lntest.NetworkHarness,
|
|
t *harnessTest) {
|
|
|
|
// Setup the test and get the channel points.
|
|
pointAB, pointBC, carol, cleanUp := setupFwdPkgTest(net, t)
|
|
defer cleanUp()
|
|
|
|
// Firstly, Bob force closes the channel.
|
|
_, _, err := net.CloseChannel(net.Bob, pointAB, true)
|
|
require.NoError(t.t, err, "unable to force close channel")
|
|
|
|
// Now that the channel has been force closed, it should show up in
|
|
// bob's PendingChannels RPC under the waiting close section.
|
|
pendingChan := assertWaitingCloseChannel(t.t, net.Bob)
|
|
|
|
// Check that Bob has created forwarding packages. We don't care the
|
|
// exact number here as long as these packages are deleted when the
|
|
// channel is closed.
|
|
require.NotZero(t.t, pendingChan.NumForwardingPackages)
|
|
|
|
// Mine 1 block to get the closing transaction confirmed.
|
|
_, err = net.Miner.Client.Generate(1)
|
|
require.NoError(t.t, err, "unable to mine blocks")
|
|
|
|
// Now that the closing transaction is confirmed, the above waiting
|
|
// close channel should now become pending force closed channel.
|
|
pendingChan = assertPendingForceClosedChannel(t.t, net.Bob)
|
|
|
|
// Check the forwarding packages are deleted.
|
|
require.Zero(t.t, pendingChan.NumForwardingPackages)
|
|
|
|
// For Alice, the forwarding packages should have been wiped too.
|
|
pendingChanAlice := assertPendingForceClosedChannel(t.t, net.Alice)
|
|
require.Zero(t.t, pendingChanAlice.NumForwardingPackages)
|
|
|
|
// Secondly, Bob coop closes the channel.
|
|
_, _, err = net.CloseChannel(net.Bob, pointBC, false)
|
|
require.NoError(t.t, err, "unable to coop close channel")
|
|
|
|
// Now that the channel has been coop closed, it should show up in
|
|
// bob's PendingChannels RPC under the waiting close section.
|
|
pendingChan = assertWaitingCloseChannel(t.t, net.Bob)
|
|
|
|
// Check that Bob has created forwarding packages. We don't care the
|
|
// exact number here as long as these packages are deleted when the
|
|
// channel is closed.
|
|
require.NotZero(t.t, pendingChan.NumForwardingPackages)
|
|
|
|
// Since it's a coop close, Carol should see the waiting close channel
|
|
// too.
|
|
pendingChanCarol := assertWaitingCloseChannel(t.t, carol)
|
|
require.NotZero(t.t, pendingChanCarol.NumForwardingPackages)
|
|
|
|
// Mine 1 block to get the closing transaction confirmed.
|
|
_, err = net.Miner.Client.Generate(1)
|
|
require.NoError(t.t, err, "unable to mine blocks")
|
|
|
|
// Now that the closing transaction is confirmed, the above waiting
|
|
// close channel should now become pending closed channel. Note that
|
|
// the name PendingForceClosingChannels is a bit confusing, what it
|
|
// really contains is channels whose closing tx has been broadcast.
|
|
pendingChan = assertPendingForceClosedChannel(t.t, net.Bob)
|
|
|
|
// Check the forwarding packages are deleted.
|
|
require.Zero(t.t, pendingChan.NumForwardingPackages)
|
|
|
|
// Mine a block to confirm sweep transactions such that they
|
|
// don't remain in the mempool for any subsequent tests.
|
|
_, err = net.Miner.Client.Generate(1)
|
|
require.NoError(t.t, err, "unable to mine blocks")
|
|
}
|
|
|
|
// setupFwdPkgTest prepares the wipe forwarding packages tests. It creates a
|
|
// network topology that has a channel direction: Alice -> Bob -> Carol, sends
|
|
// several payments from Alice to Carol, and returns the two channel points(one
|
|
// for Alice and Bob, the other for Bob and Carol), the node Carol, and a
|
|
// cleanup function to be used when the test finishes.
|
|
func setupFwdPkgTest(net *lntest.NetworkHarness,
|
|
t *harnessTest) (*lnrpc.ChannelPoint, *lnrpc.ChannelPoint,
|
|
*lntest.HarnessNode, func()) {
|
|
|
|
ctxb := context.Background()
|
|
|
|
const (
|
|
chanAmt = 10e6
|
|
paymentAmt = 10e4
|
|
finalCTLVDelta = chainreg.DefaultBitcoinTimeLockDelta
|
|
numInvoices = 3
|
|
)
|
|
|
|
// Grab Alice and Bob from harness net.
|
|
alice, bob := net.Alice, net.Bob
|
|
|
|
// Create a new node Carol, which will create invoices that require
|
|
// Alice to pay.
|
|
carol := net.NewNode(t.t, "Carol", nil)
|
|
|
|
// Connect Bob to Carol.
|
|
net.ConnectNodes(t.t, bob, carol)
|
|
|
|
// Open a channel between Alice and Bob.
|
|
chanPointAB := openChannelAndAssert(
|
|
t, net, alice, bob, lntest.OpenChannelParams{
|
|
Amt: chanAmt,
|
|
},
|
|
)
|
|
|
|
// Open a channel between Bob and Carol.
|
|
chanPointBC := openChannelAndAssert(
|
|
t, net, bob, carol, lntest.OpenChannelParams{
|
|
Amt: chanAmt,
|
|
},
|
|
)
|
|
|
|
ctxt, cancel := context.WithTimeout(ctxb, defaultTimeout)
|
|
defer cancel()
|
|
|
|
// Alice sends several payments to Carol through Bob, which triggers
|
|
// Bob to create forwarding packages.
|
|
for i := 0; i < numInvoices; i++ {
|
|
// Add an invoice for Carol.
|
|
invoice := &lnrpc.Invoice{Memo: "testing", Value: paymentAmt}
|
|
invoiceResp, err := carol.AddInvoice(ctxt, invoice)
|
|
require.NoError(t.t, err, "unable to add invoice")
|
|
|
|
// Alice sends a payment to Carol through Bob.
|
|
sendAndAssertSuccess(
|
|
t, net.Alice, &routerrpc.SendPaymentRequest{
|
|
PaymentRequest: invoiceResp.PaymentRequest,
|
|
TimeoutSeconds: 60,
|
|
FeeLimitSat: noFeeLimitMsat,
|
|
},
|
|
)
|
|
}
|
|
|
|
return chanPointAB, chanPointBC, carol, func() {
|
|
shutdownAndAssert(net, t, alice)
|
|
shutdownAndAssert(net, t, bob)
|
|
shutdownAndAssert(net, t, carol)
|
|
}
|
|
}
|
|
|
|
// assertWaitingCloseChannel checks there is a single channel that is waiting
|
|
// for close and returns the channel found.
|
|
func assertWaitingCloseChannel(t *testing.T,
|
|
node *lntest.HarnessNode) pendingChan {
|
|
|
|
ctxb := context.Background()
|
|
|
|
var channel pendingChan
|
|
require.Eventually(t, func() bool {
|
|
ctxt, cancel := context.WithTimeout(ctxb, defaultTimeout)
|
|
defer cancel()
|
|
|
|
req := &lnrpc.PendingChannelsRequest{}
|
|
resp, err := node.PendingChannels(ctxt, req)
|
|
|
|
// We require the RPC call to be succeeded and won't retry upon
|
|
// an error.
|
|
require.NoError(t, err, "unable to query for pending channels")
|
|
|
|
if err := checkNumWaitingCloseChannels(resp, 1); err != nil {
|
|
return false
|
|
}
|
|
|
|
channel = resp.WaitingCloseChannels[0].Channel
|
|
return true
|
|
}, defaultTimeout, 200*time.Millisecond)
|
|
|
|
return channel
|
|
}
|
|
|
|
// assertForceClosedChannel checks there is a single channel that is pending
|
|
// force closed and returns the channel found.
|
|
func assertPendingForceClosedChannel(t *testing.T,
|
|
node *lntest.HarnessNode) pendingChan {
|
|
|
|
ctxb := context.Background()
|
|
|
|
var channel pendingChan
|
|
require.Eventually(t, func() bool {
|
|
ctxt, cancel := context.WithTimeout(ctxb, defaultTimeout)
|
|
defer cancel()
|
|
|
|
req := &lnrpc.PendingChannelsRequest{}
|
|
resp, err := node.PendingChannels(ctxt, req)
|
|
|
|
// We require the RPC call to be succeeded and won't retry upon
|
|
// an error.
|
|
require.NoError(t, err, "unable to query for pending channels")
|
|
|
|
if err := checkNumForceClosedChannels(resp, 1); err != nil {
|
|
return false
|
|
}
|
|
|
|
channel = resp.PendingForceClosingChannels[0].Channel
|
|
return true
|
|
}, defaultTimeout, 200*time.Millisecond)
|
|
|
|
return channel
|
|
}
|