lnd/itest/lnd_zero_conf_test.go
yyforyongyu 9d1d629001
itest+lntest: migrate lntemp to lntest
This commit performs the takeover that `lntemp` is now promoted to be
`lntest`, and the scaffolding is now removed as all the refactoring is
finished!
2023-02-23 21:56:09 +08:00

1056 lines
31 KiB
Go

package itest
import (
"context"
"testing"
"time"
"github.com/btcsuite/btcd/btcjson"
"github.com/btcsuite/btcd/btcutil"
"github.com/btcsuite/btcd/integration/rpctest"
"github.com/go-errors/errors"
"github.com/lightningnetwork/lnd/aliasmgr"
"github.com/lightningnetwork/lnd/chainreg"
"github.com/lightningnetwork/lnd/lnrpc"
"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
"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/lnwire"
"github.com/stretchr/testify/require"
)
// testZeroConfChannelOpen tests that opening a zero-conf channel works and
// sending payments also works.
func testZeroConfChannelOpen(ht *lntest.HarnessTest) {
// Since option-scid-alias is opt-in, the provided harness nodes will
// not have the feature bit set. Also need to set anchors as those are
// default-off in itests.
scidAliasArgs := []string{
"--protocol.option-scid-alias",
"--protocol.zero-conf",
"--protocol.anchors",
}
bob := ht.Bob
carol := ht.NewNode("Carol", scidAliasArgs)
ht.EnsureConnected(bob, carol)
// We'll open a regular public channel between Bob and Carol here.
chanAmt := btcutil.Amount(1_000_000)
p := lntest.OpenChannelParams{
Amt: chanAmt,
}
chanPoint := ht.OpenChannel(bob, carol, p)
// Spin-up Dave so Carol can open a zero-conf channel to him.
dave := ht.NewNode("Dave", scidAliasArgs)
// We'll give Carol some coins in order to fund the channel.
ht.FundCoins(btcutil.SatoshiPerBitcoin, carol)
// Ensure that both Carol and Dave are connected.
ht.EnsureConnected(carol, dave)
// Setup a ChannelAcceptor for Dave.
acceptStream, cancel := dave.RPC.ChannelAcceptor()
go acceptChannel(ht.T, true, acceptStream)
// Open a private zero-conf anchors channel of 1M satoshis.
params := lntest.OpenChannelParams{
Amt: chanAmt,
Private: true,
CommitmentType: lnrpc.CommitmentType_ANCHORS,
ZeroConf: true,
}
stream := ht.OpenChannelAssertStream(carol, dave, params)
// Remove the ChannelAcceptor.
cancel()
// We should receive the OpenStatusUpdate_ChanOpen update without
// having to mine any blocks.
fundingPoint2 := ht.WaitForChannelOpenEvent(stream)
ht.AssertTopologyChannelOpen(carol, fundingPoint2)
ht.AssertTopologyChannelOpen(dave, fundingPoint2)
// Attempt to send a 10K satoshi payment from Carol to Dave.
daveInvoiceParams := &lnrpc.Invoice{
Value: int64(10_000),
Private: true,
}
daveInvoiceResp := dave.RPC.AddInvoice(daveInvoiceParams)
ht.CompletePaymentRequests(
carol, []string{daveInvoiceResp.PaymentRequest},
)
// Now attempt to send a multi-hop payment from Bob to Dave. This tests
// that Dave issues an invoice with an alias SCID that Carol knows and
// uses to forward to Dave.
daveInvoiceResp2 := dave.RPC.AddInvoice(daveInvoiceParams)
ht.CompletePaymentRequests(
bob, []string{daveInvoiceResp2.PaymentRequest},
)
// Check that Dave has a zero-conf alias SCID in the graph.
descReq := &lnrpc.ChannelGraphRequest{
IncludeUnannounced: true,
}
err := waitForZeroConfGraphChange(dave, descReq, true)
require.NoError(ht, err)
// We'll now confirm the zero-conf channel between Carol and Dave and
// assert that sending is still possible.
block := ht.MineBlocksAndAssertNumTxes(6, 1)[0]
// Dave should still have the alias edge in his db.
err = waitForZeroConfGraphChange(dave, descReq, true)
require.NoError(ht, err)
fundingTxID := ht.GetChanPointFundingTxid(fundingPoint2)
ht.Miner.AssertTxInBlock(block, fundingTxID)
daveInvoiceResp3 := dave.RPC.AddInvoice(daveInvoiceParams)
ht.CompletePaymentRequests(
bob, []string{daveInvoiceResp3.PaymentRequest},
)
// Eve will now initiate a zero-conf channel with Carol. This tests
// that the ChannelUpdates sent are correct since they will be
// referring to different alias SCIDs.
eve := ht.NewNode("Eve", scidAliasArgs)
ht.EnsureConnected(eve, carol)
// Give Eve some coins to fund the channel.
ht.FundCoins(btcutil.SatoshiPerBitcoin, eve)
// Setup a ChannelAcceptor.
acceptStream, cancel = carol.RPC.ChannelAcceptor()
go acceptChannel(ht.T, true, acceptStream)
// We'll open a public zero-conf anchors channel of 1M satoshis.
params.Private = false
stream = ht.OpenChannelAssertStream(eve, carol, params)
// Remove the ChannelAcceptor.
cancel()
// Wait to receive the OpenStatusUpdate_ChanOpen update.
fundingPoint3 := ht.WaitForChannelOpenEvent(stream)
ht.AssertTopologyChannelOpen(eve, fundingPoint3)
ht.AssertTopologyChannelOpen(carol, fundingPoint3)
// Attempt to send a 20K satoshi payment from Eve to Dave.
daveInvoiceParams.Value = int64(20_000)
daveInvoiceResp4 := dave.RPC.AddInvoice(daveInvoiceParams)
ht.CompletePaymentRequests(
eve, []string{daveInvoiceResp4.PaymentRequest},
)
// Assert that Eve has stored the zero-conf alias in her graph.
err = waitForZeroConfGraphChange(eve, descReq, true)
require.NoError(ht, err, "expected to not receive error")
// We'll confirm the zero-conf channel between Eve and Carol and assert
// that sending is still possible.
block = ht.MineBlocksAndAssertNumTxes(6, 1)[0]
fundingTxID = ht.GetChanPointFundingTxid(fundingPoint3)
ht.Miner.AssertTxInBlock(block, fundingTxID)
// Wait until Eve's ZeroConf channel is replaced by the confirmed SCID
// in her graph.
err = waitForZeroConfGraphChange(eve, descReq, false)
require.NoError(ht, err, "expected to not receive error")
// Attempt to send a 6K satoshi payment from Dave to Eve.
eveInvoiceParams := &lnrpc.Invoice{
Value: int64(6_000),
Private: true,
}
eveInvoiceResp := eve.RPC.AddInvoice(eveInvoiceParams)
// Assert that route hints is empty since the channel is public.
payReq := eve.RPC.DecodePayReq(eveInvoiceResp.PaymentRequest)
require.Len(ht, payReq.RouteHints, 0)
// Make sure Dave is aware of this channel and send the payment.
ht.AssertTopologyChannelOpen(dave, fundingPoint3)
ht.CompletePaymentRequests(
dave, []string{eveInvoiceResp.PaymentRequest},
)
// Close standby node's channels.
ht.CloseChannel(bob, chanPoint)
}
// testOptionScidAlias checks that opening an option_scid_alias channel-type
// channel or w/o the channel-type works properly.
func testOptionScidAlias(ht *lntest.HarnessTest) {
type scidTestCase struct {
name string
// If this is false, then the channel will be a regular non
// channel-type option-scid-alias-feature-bit channel.
chantype bool
private bool
}
var testCases = []scidTestCase{
{
name: "private chan-type",
chantype: true,
private: true,
},
{
name: "public no chan-type",
chantype: false,
private: false,
},
{
name: "private no chan-type",
chantype: false,
private: true,
},
}
for _, testCase := range testCases {
testCase := testCase
success := ht.Run(testCase.name, func(t *testing.T) {
st := ht.Subtest(t)
optionScidAliasScenario(
st, testCase.chantype, testCase.private,
)
})
if !success {
break
}
}
}
func optionScidAliasScenario(ht *lntest.HarnessTest, chantype, private bool) {
// Option-scid-alias is opt-in, as is anchors.
scidAliasArgs := []string{
"--protocol.option-scid-alias",
"--protocol.anchors",
}
bob := ht.Bob
carol := ht.NewNode("Carol", scidAliasArgs)
dave := ht.NewNode("Dave", scidAliasArgs)
// Ensure Bob, Carol are connected.
ht.EnsureConnected(bob, carol)
// Ensure Carol, Dave are connected.
ht.EnsureConnected(carol, dave)
// Give Carol some coins so she can open the channel.
ht.FundCoins(btcutil.SatoshiPerBitcoin, carol)
chanAmt := btcutil.Amount(1_000_000)
params := lntest.OpenChannelParams{
Amt: chanAmt,
Private: private,
CommitmentType: lnrpc.CommitmentType_ANCHORS,
ScidAlias: chantype,
}
fundingPoint := ht.OpenChannel(carol, dave, params)
// Make sure Bob knows this channel if it's public.
if !private {
ht.AssertTopologyChannelOpen(bob, fundingPoint)
}
// Assert that a payment from Carol to Dave works as expected.
daveInvoiceParams := &lnrpc.Invoice{
Value: int64(10_000),
Private: true,
}
daveInvoiceResp := dave.RPC.AddInvoice(daveInvoiceParams)
ht.CompletePaymentRequests(
carol, []string{daveInvoiceResp.PaymentRequest},
)
// We'll now open a regular public channel between Bob and Carol and
// assert that Bob can pay Dave. We'll also assert that the invoice
// Dave issues has the startingAlias as a hop hint.
p := lntest.OpenChannelParams{
Amt: chanAmt,
}
fundingPoint2 := ht.OpenChannel(bob, carol, p)
defer func() {
// TODO(yy): remove the sleep once the following bug is fixed.
// When the payment is reported as settled by Bob, it's
// expected the commitment dance is finished and all subsequent
// states have been updated. Yet we'd receive the error `cannot
// co-op close channel with active htlcs` or `link failed to
// shutdown` if we close the channel. We need to investigate
// the order of settling the payments and updating commitments
// to understand and fix.
time.Sleep(2 * time.Second)
// Close standby node's channels.
ht.CloseChannel(bob, fundingPoint2)
}()
// Wait until Dave receives the Bob<->Carol channel.
ht.AssertTopologyChannelOpen(dave, fundingPoint2)
daveInvoiceResp2 := dave.RPC.AddInvoice(daveInvoiceParams)
decodedReq := dave.RPC.DecodePayReq(daveInvoiceResp2.PaymentRequest)
if !private {
require.Len(ht, decodedReq.RouteHints, 0)
payReq := daveInvoiceResp2.PaymentRequest
ht.CompletePaymentRequests(bob, []string{payReq})
return
}
require.Len(ht, decodedReq.RouteHints, 1)
require.Len(ht, decodedReq.RouteHints[0].HopHints, 1)
startingAlias := lnwire.ShortChannelID{
BlockHeight: 16_000_000,
TxIndex: 0,
TxPosition: 0,
}
daveHopHint := decodedReq.RouteHints[0].HopHints[0].ChanId
require.Equal(ht, startingAlias.ToUint64(), daveHopHint)
ht.CompletePaymentRequests(
bob, []string{daveInvoiceResp2.PaymentRequest},
)
}
// waitForZeroConfGraphChange waits for the zero-conf channel to be visible in
// the graph after confirmation or not. The expect argument denotes whether the
// zero-conf is expected in the graph or not. There should always be at least
// one channel of the passed HarnessNode, zero-conf or not.
func waitForZeroConfGraphChange(hn *node.HarnessNode,
req *lnrpc.ChannelGraphRequest, expect bool) error {
return wait.NoError(func() error {
graph := hn.RPC.DescribeGraph(req)
if expect {
// If we expect a zero-conf channel, we'll assert that
// one exists, both policies exist, and we are party to
// the channel.
for _, e := range graph.Edges {
// The BlockHeight will be less than 16_000_000
// if this is not a zero-conf channel.
scid := lnwire.NewShortChanIDFromInt(
e.ChannelId,
)
if scid.BlockHeight < 16_000_000 {
continue
}
// Both edge policies must exist in the zero
// conf case.
if e.Node1Policy == nil ||
e.Node2Policy == nil {
continue
}
// Check if we are party to the zero-conf
// channel.
if e.Node1Pub == hn.PubKeyStr ||
e.Node2Pub == hn.PubKeyStr {
return nil
}
}
return errors.New("failed to find zero-conf channel " +
"in graph")
}
// If we don't expect a zero-conf channel, we'll assert that
// none exist, that we have a non-zero-conf channel with at
// both policies, and one of the policies in the database is
// ours.
for _, e := range graph.Edges {
scid := lnwire.NewShortChanIDFromInt(e.ChannelId)
if scid.BlockHeight == 16_000_000 {
return errors.New("found zero-conf channel")
}
// One of the edge policies must exist.
if e.Node1Policy == nil || e.Node2Policy == nil {
continue
}
// If we are part of this channel, exit gracefully.
if e.Node1Pub == hn.PubKeyStr ||
e.Node2Pub == hn.PubKeyStr {
return nil
}
}
return errors.New(
"failed to find non-zero-conf channel in graph",
)
}, defaultTimeout)
}
// testUpdateChannelPolicyScidAlias checks that option-scid-alias, zero-conf
// channel-types, and option-scid-alias feature-bit-only channels have the
// expected graph and that payments work when updating the channel policy.
func testUpdateChannelPolicyScidAlias(ht *lntest.HarnessTest) {
tests := []struct {
name string
// The option-scid-alias channel type.
scidAliasType bool
// The zero-conf channel type.
zeroConf bool
private bool
}{
{
name: "private scid-alias chantype update",
scidAliasType: true,
private: true,
},
{
name: "private zero-conf update",
zeroConf: true,
private: true,
},
{
name: "public zero-conf update",
zeroConf: true,
},
{
name: "public no-chan-type update",
},
{
name: "private no-chan-type update",
private: true,
},
}
for _, test := range tests {
test := test
success := ht.Run(test.name, func(t *testing.T) {
st := ht.Subtest(t)
testPrivateUpdateAlias(
st, test.zeroConf, test.scidAliasType,
test.private,
)
})
if !success {
return
}
}
}
func testPrivateUpdateAlias(ht *lntest.HarnessTest,
zeroConf, scidAliasType, private bool) {
// We'll create a new node Eve that will not have option-scid-alias
// channels.
eve := ht.NewNode("Eve", nil)
ht.FundCoins(btcutil.SatoshiPerBitcoin, eve)
// Since option-scid-alias is opt-in we'll need to specify the protocol
// arguments when creating a new node.
scidAliasArgs := []string{
"--protocol.option-scid-alias",
"--protocol.zero-conf",
"--protocol.anchors",
}
carol := ht.NewNode("Carol", scidAliasArgs)
// Spin-up Dave who will have an option-scid-alias feature-bit-only or
// channel-type channel with Carol.
dave := ht.NewNode("Dave", scidAliasArgs)
// We'll give Carol some coins in order to fund the channel.
ht.FundCoins(btcutil.SatoshiPerBitcoin, carol)
// Ensure that Carol and Dave are connected.
ht.EnsureConnected(carol, dave)
// We'll open a regular public channel between Eve and Carol here. Eve
// will be the one receiving the onion-encrypted ChannelUpdate.
ht.EnsureConnected(eve, carol)
chanAmt := btcutil.Amount(1_000_000)
p := lntest.OpenChannelParams{
Amt: chanAmt,
PushAmt: chanAmt / 2,
}
fundingPoint := ht.OpenChannel(eve, carol, p)
// Make sure Dave has seen this public channel.
ht.AssertTopologyChannelOpen(dave, fundingPoint)
// Setup a ChannelAcceptor for Dave.
acceptStream, cancel := dave.RPC.ChannelAcceptor()
go acceptChannel(ht.T, zeroConf, acceptStream)
// Open a private channel, optionally specifying a channel-type.
params := lntest.OpenChannelParams{
Amt: chanAmt,
Private: private,
CommitmentType: lnrpc.CommitmentType_ANCHORS,
ZeroConf: zeroConf,
ScidAlias: scidAliasType,
PushAmt: chanAmt / 2,
}
fundingPoint2 := ht.OpenChannelNoAnnounce(carol, dave, params)
// Remove the ChannelAcceptor.
cancel()
// Carol will now update the channel edge policy for her channel with
// Dave.
baseFeeMSat := 33000
feeRate := int64(5)
timeLockDelta := uint32(chainreg.DefaultBitcoinTimeLockDelta)
updateFeeReq := &lnrpc.PolicyUpdateRequest{
BaseFeeMsat: int64(baseFeeMSat),
FeeRate: float64(feeRate),
TimeLockDelta: timeLockDelta,
Scope: &lnrpc.PolicyUpdateRequest_ChanPoint{
ChanPoint: fundingPoint2,
},
}
carol.RPC.UpdateChannelPolicy(updateFeeReq)
expectedPolicy := &lnrpc.RoutingPolicy{
FeeBaseMsat: int64(baseFeeMSat),
FeeRateMilliMsat: testFeeBase * feeRate,
TimeLockDelta: timeLockDelta,
MinHtlc: 1000, // default value
MaxHtlcMsat: lntest.CalculateMaxHtlc(chanAmt),
}
// Assert that Dave receives Carol's policy update.
ht.AssertChannelPolicyUpdate(
dave, carol, expectedPolicy, fundingPoint2, true,
)
// Have Dave also update his policy.
baseFeeMSat = 15000
feeRate = int64(4)
updateFeeReq = &lnrpc.PolicyUpdateRequest{
BaseFeeMsat: int64(baseFeeMSat),
FeeRate: float64(feeRate),
TimeLockDelta: timeLockDelta,
Scope: &lnrpc.PolicyUpdateRequest_ChanPoint{
ChanPoint: fundingPoint2,
},
}
dave.RPC.UpdateChannelPolicy(updateFeeReq)
expectedPolicy = &lnrpc.RoutingPolicy{
FeeBaseMsat: int64(baseFeeMSat),
FeeRateMilliMsat: testFeeBase * feeRate,
TimeLockDelta: timeLockDelta,
MinHtlc: 1000,
MaxHtlcMsat: lntest.CalculateMaxHtlc(chanAmt),
}
// Assert that Carol receives Dave's policy update.
ht.AssertChannelPolicyUpdate(
carol, dave, expectedPolicy, fundingPoint2, true,
)
// Assert that if Dave disables the channel, Carol sees it.
disableReq := &routerrpc.UpdateChanStatusRequest{
ChanPoint: fundingPoint2,
Action: routerrpc.ChanStatusAction_DISABLE,
}
dave.RPC.UpdateChanStatus(disableReq)
expectedPolicy.Disabled = true
ht.AssertChannelPolicyUpdate(
carol, dave, expectedPolicy, fundingPoint2, true,
)
// Assert that if Dave enables the channel, Carol sees it.
enableReq := &routerrpc.UpdateChanStatusRequest{
ChanPoint: fundingPoint2,
Action: routerrpc.ChanStatusAction_ENABLE,
}
dave.RPC.UpdateChanStatus(enableReq)
expectedPolicy.Disabled = false
ht.AssertChannelPolicyUpdate(
carol, dave, expectedPolicy, fundingPoint2, true,
)
// Create an invoice for Carol to pay.
invoiceParams := &lnrpc.Invoice{
Value: int64(10_000),
Private: true,
}
daveInvoiceResp := dave.RPC.AddInvoice(invoiceParams)
// Carol will attempt to send Dave an HTLC.
payReqs := []string{daveInvoiceResp.PaymentRequest}
ht.CompletePaymentRequests(carol, payReqs)
// Now Eve will create an invoice that Dave will pay.
eveInvoiceResp := eve.RPC.AddInvoice(invoiceParams)
payReqs = []string{eveInvoiceResp.PaymentRequest}
ht.CompletePaymentRequests(dave, payReqs)
// If this is a public channel, it won't be included in the hop hints,
// so we'll mine enough for 6 confs here. We only expect a tx in the
// mempool for the zero-conf case.
if !private {
var expectTx int
if zeroConf {
expectTx = 1
}
ht.MineBlocksAndAssertNumTxes(6, expectTx)
// Sleep here so that the edge can be deleted and re-inserted.
// This is necessary since the edge may have a policy for the
// peer that is "correct" but has an invalid signature from the
// PoV of BOLT#7.
//
// TODO(yy): further investigate this sleep.
time.Sleep(time.Second * 5)
}
// Dave creates an invoice that Eve will pay.
daveInvoiceResp2 := dave.RPC.AddInvoice(invoiceParams)
// Carol then updates the channel policy again.
feeRate = int64(2)
updateFeeReq = &lnrpc.PolicyUpdateRequest{
BaseFeeMsat: int64(baseFeeMSat),
FeeRate: float64(feeRate),
TimeLockDelta: timeLockDelta,
Scope: &lnrpc.PolicyUpdateRequest_ChanPoint{
ChanPoint: fundingPoint2,
},
}
carol.RPC.UpdateChannelPolicy(updateFeeReq)
expectedPolicy = &lnrpc.RoutingPolicy{
FeeBaseMsat: int64(baseFeeMSat),
FeeRateMilliMsat: testFeeBase * feeRate,
TimeLockDelta: timeLockDelta,
MinHtlc: 1000,
MaxHtlcMsat: lntest.CalculateMaxHtlc(chanAmt),
}
// Assert Dave receives Carol's policy update.
ht.AssertChannelPolicyUpdate(
dave, carol, expectedPolicy, fundingPoint2, true,
)
// If the channel is public, check that Eve receives Carol's policy
// update.
if !private {
ht.AssertChannelPolicyUpdate(
eve, carol, expectedPolicy, fundingPoint2, true,
)
}
// Eve will pay Dave's invoice and should use the updated base fee.
payReqs = []string{daveInvoiceResp2.PaymentRequest}
ht.CompletePaymentRequests(eve, payReqs)
// Eve will issue an invoice that Dave will pay.
eveInvoiceResp2 := eve.RPC.AddInvoice(invoiceParams)
payReqs = []string{eveInvoiceResp2.PaymentRequest}
ht.CompletePaymentRequests(dave, payReqs)
// If this is a private channel, we'll mine 6 blocks here to test the
// funding manager logic that deals with ChannelUpdates. If this is not
// a zero-conf channel, we don't expect a tx in the mempool.
if private {
var expectTx int
if zeroConf {
expectTx = 1
}
ht.MineBlocksAndAssertNumTxes(6, expectTx)
}
// Dave will issue an invoice and Eve will pay it.
daveInvoiceResp3 := dave.RPC.AddInvoice(invoiceParams)
payReqs = []string{daveInvoiceResp3.PaymentRequest}
ht.CompletePaymentRequests(eve, payReqs)
// Carol will disable the channel, assert that Dave sees it and Eve as
// well if the channel is public.
carol.RPC.UpdateChanStatus(disableReq)
expectedPolicy.Disabled = true
ht.AssertChannelPolicyUpdate(
dave, carol, expectedPolicy, fundingPoint2, true,
)
if !private {
ht.AssertChannelPolicyUpdate(
eve, carol, expectedPolicy, fundingPoint2, true,
)
}
// Carol will enable the channel, assert the same as above.
carol.RPC.UpdateChanStatus(enableReq)
expectedPolicy.Disabled = false
ht.AssertChannelPolicyUpdate(
dave, carol, expectedPolicy, fundingPoint2, true,
)
if !private {
ht.AssertChannelPolicyUpdate(
eve, carol, expectedPolicy, fundingPoint2, true,
)
}
// Dave will issue an invoice and Eve should pay it after Carol updates
// her channel policy.
daveInvoiceResp4 := dave.RPC.AddInvoice(invoiceParams)
feeRate = int64(3)
updateFeeReq = &lnrpc.PolicyUpdateRequest{
BaseFeeMsat: int64(baseFeeMSat),
FeeRate: float64(feeRate),
TimeLockDelta: timeLockDelta,
Scope: &lnrpc.PolicyUpdateRequest_ChanPoint{
ChanPoint: fundingPoint2,
},
}
carol.RPC.UpdateChannelPolicy(updateFeeReq)
expectedPolicy = &lnrpc.RoutingPolicy{
FeeBaseMsat: int64(baseFeeMSat),
FeeRateMilliMsat: testFeeBase * feeRate,
TimeLockDelta: timeLockDelta,
MinHtlc: 1000,
MaxHtlcMsat: lntest.CalculateMaxHtlc(chanAmt),
}
// Assert Dave and optionally Eve receives Carol's update.
ht.AssertChannelPolicyUpdate(
dave, carol, expectedPolicy, fundingPoint2, true,
)
if !private {
ht.AssertChannelPolicyUpdate(
eve, carol, expectedPolicy, fundingPoint2, true,
)
}
payReqs = []string{daveInvoiceResp4.PaymentRequest}
ht.CompletePaymentRequests(eve, payReqs)
}
// testOptionScidUpgrade tests that toggling the option-scid-alias feature bit
// correctly upgrades existing channels.
func testOptionScidUpgrade(ht *lntest.HarnessTest) {
bob := ht.Bob
// Start carol with anchors only.
carolArgs := []string{
"--protocol.anchors",
}
carol := ht.NewNode("carol", carolArgs)
// Start dave with anchors + scid-alias.
daveArgs := []string{
"--protocol.anchors",
"--protocol.option-scid-alias",
}
dave := ht.NewNode("dave", daveArgs)
// Give carol some coins.
ht.FundCoins(btcutil.SatoshiPerBitcoin, carol)
// Ensure carol and are connected.
ht.EnsureConnected(carol, dave)
chanAmt := btcutil.Amount(1_000_000)
p := lntest.OpenChannelParams{
Amt: chanAmt,
PushAmt: chanAmt / 2,
Private: true,
}
ht.OpenChannel(carol, dave, p)
// Bob will open a channel to Carol now.
ht.EnsureConnected(bob, carol)
p = lntest.OpenChannelParams{
Amt: chanAmt,
}
fundingPoint2 := ht.OpenChannel(bob, carol, p)
// Make sure Dave knows this channel.
ht.AssertTopologyChannelOpen(dave, fundingPoint2)
// Carol will now set the option-scid-alias feature bit and restart.
carolArgs = append(carolArgs, "--protocol.option-scid-alias")
ht.RestartNodeWithExtraArgs(carol, carolArgs)
// Dave will create an invoice for Carol to pay, it should contain an
// alias in the hop hints.
daveParams := &lnrpc.Invoice{
Value: int64(10_000),
Private: true,
}
var daveInvoice *lnrpc.AddInvoiceResponse
var startingAlias lnwire.ShortChannelID
startingAlias.BlockHeight = 16_000_000
err := wait.Predicate(func() bool {
invoiceResp := dave.RPC.AddInvoice(daveParams)
decodedReq := dave.RPC.DecodePayReq(invoiceResp.PaymentRequest)
if len(decodedReq.RouteHints) != 1 {
return false
}
if len(decodedReq.RouteHints[0].HopHints) != 1 {
return false
}
hopHint := decodedReq.RouteHints[0].HopHints[0].ChanId
if startingAlias.ToUint64() == hopHint {
daveInvoice = invoiceResp
return true
}
return false
}, defaultTimeout)
require.NoError(ht, err)
// Carol should be able to pay it.
ht.CompletePaymentRequests(carol, []string{daveInvoice.PaymentRequest})
// TODO(yy): remove this connection once the following bug is fixed.
// When Carol restarts, she will try to make a persistent connection to
// Bob. Meanwhile, Bob will also make a conn request as he notices the
// connection is broken. If they make these conn requests at the same
// time, they both have an outbound conn request, and will close the
// inbound conn they receives, which ends up in no conn.
ht.EnsureConnected(bob, carol)
daveInvoice2 := dave.RPC.AddInvoice(daveParams)
ht.CompletePaymentRequests(bob, []string{daveInvoice2.PaymentRequest})
// TODO(yy): remove the sleep once the following bug is fixed. When
// the payment is reported as settled by Bob, it's expected the
// commitment dance is finished and all subsequent states have been
// updated. Yet we'd receive the error `cannot co-op close channel with
// active htlcs` or `link failed to shutdown` if we close the channel.
// We need to investigate the order of settling the payments and
// updating commitments to understand and fix.
time.Sleep(2 * time.Second)
// Close standby node's channels.
ht.CloseChannel(bob, fundingPoint2)
}
// acceptChannel is used to accept a single channel that comes across. This
// should be run in a goroutine and is used to test nodes with the zero-conf
// feature bit.
func acceptChannel(t *testing.T, zeroConf bool, stream rpc.AcceptorClient) {
t.Helper()
req, err := stream.Recv()
require.NoError(t, err)
resp := &lnrpc.ChannelAcceptResponse{
Accept: true,
PendingChanId: req.PendingChanId,
ZeroConf: zeroConf,
}
err = stream.Send(resp)
require.NoError(t, err)
}
// testZeroConfReorg tests that a reorg does not cause a zero-conf channel to
// be deleted from the channel graph. This was previously the case due to logic
// in the function DisconnectBlockAtHeight.
func testZeroConfReorg(ht *lntest.HarnessTest) {
if ht.IsNeutrinoBackend() {
ht.Skipf("skipping zero-conf reorg test for neutrino backend")
}
var (
ctxb = context.Background()
temp = "temp"
)
// Since zero-conf is opt in, the harness nodes provided won't be able
// to open zero-conf channels. In that case, we just spin up new nodes.
zeroConfArgs := []string{
"--protocol.option-scid-alias",
"--protocol.zero-conf",
"--protocol.anchors",
}
carol := ht.NewNode("Carol", zeroConfArgs)
// Spin-up Dave so Carol can open a zero-conf channel to him.
dave := ht.NewNode("Dave", zeroConfArgs)
// We'll give Carol some coins in order to fund the channel.
ht.FundCoins(btcutil.SatoshiPerBitcoin, carol)
// Ensure that both Carol and Dave are connected.
ht.EnsureConnected(carol, dave)
// Setup a ChannelAcceptor for Dave.
acceptStream, cancel := dave.RPC.ChannelAcceptor()
go acceptChannel(ht.T, true, acceptStream)
// Open a private zero-conf anchors channel of 1M satoshis.
params := lntest.OpenChannelParams{
Amt: btcutil.Amount(1_000_000),
CommitmentType: lnrpc.CommitmentType_ANCHORS,
ZeroConf: true,
}
_ = ht.OpenChannelNoAnnounce(carol, dave, params)
// Remove the ChannelAcceptor.
cancel()
// Attempt to send a 10K satoshi payment from Carol to Dave. This
// requires that the edge exists in the graph.
daveInvoiceParams := &lnrpc.Invoice{
Value: int64(10_000),
}
daveInvoiceResp := dave.RPC.AddInvoice(daveInvoiceParams)
payReqs := []string{daveInvoiceResp.PaymentRequest}
ht.CompletePaymentRequests(carol, payReqs)
// We will now attempt to query for the alias SCID in Carol's graph.
// We will query for the starting alias, which is exported by the
// aliasmgr package.
_, err := carol.RPC.LN.GetChanInfo(ctxb, &lnrpc.ChanInfoRequest{
ChanId: aliasmgr.StartingAlias.ToUint64(),
})
require.NoError(ht.T, err)
// Now we will trigger a reorg and we'll assert that the edge still
// exists in the graph.
//
// First, we'll setup a new miner that we can use to cause a reorg.
tempLogDir := ".tempminerlogs"
logFilename := "output-open_channel_reorg-temp_miner.log"
tempMiner := lntest.NewTempMiner(
ht.Context(), ht.T, tempLogDir, logFilename,
)
defer tempMiner.Stop()
require.NoError(
ht.T, tempMiner.SetUp(false, 0), "unable to setup mining node",
)
// We start by connecting the new miner to our original miner, such
// that it will sync to our original chain.
err = ht.Miner.Client.Node(
btcjson.NConnect, tempMiner.P2PAddress(), &temp,
)
require.NoError(ht.T, err, "unable to connect node")
nodeSlice := []*rpctest.Harness{ht.Miner.Harness, tempMiner.Harness}
err = rpctest.JoinNodes(nodeSlice, rpctest.Blocks)
require.NoError(ht.T, err, "unable to join node on blocks")
// The two miners should be on the same block height.
assertMinerBlockHeightDelta(ht, ht.Miner, tempMiner, 0)
// We disconnect the two miners, such that we can mine two chains and
// cause a reorg later.
err = ht.Miner.Client.Node(
btcjson.NDisconnect, tempMiner.P2PAddress(), &temp,
)
require.NoError(ht.T, err, "unable to remove node")
// We now cause a fork, by letting our original miner mine 1 block and
// our new miner will mine 2.
ht.MineBlocks(1)
_, err = tempMiner.Client.Generate(2)
require.NoError(ht.T, err, "unable to generate blocks")
// Ensure the temp miner is one block ahead.
assertMinerBlockHeightDelta(ht, ht.Miner, tempMiner, 1)
// Wait for Carol to sync to the original miner's chain.
_, minerHeight, err := ht.Miner.Client.GetBestBlock()
require.NoError(ht.T, err, "unable to get current blockheight")
ht.WaitForNodeBlockHeight(carol, minerHeight)
// Now we'll disconnect Carol's chain backend from the original miner
// so that we can connect the two miners together and let the original
// miner sync to the temp miner's chain.
ht.DisconnectMiner()
// Connecting to the temporary miner should cause the original miner to
// reorg to the longer chain.
err = ht.Miner.Client.Node(
btcjson.NConnect, tempMiner.P2PAddress(), &temp,
)
require.NoError(ht.T, err, "unable to remove node")
nodes := []*rpctest.Harness{tempMiner.Harness, ht.Miner.Harness}
err = rpctest.JoinNodes(nodes, rpctest.Blocks)
require.NoError(ht.T, err, "unable to join node on blocks")
// They should now be on the same chain.
assertMinerBlockHeightDelta(ht, ht.Miner, tempMiner, 0)
// Now we disconnect the two miners and reconnect our original chain
// backend.
err = ht.Miner.Client.Node(
btcjson.NDisconnect, tempMiner.P2PAddress(), &temp,
)
require.NoError(ht.T, err, "unable to remove node")
ht.ConnectMiner()
// This should have caused a reorg and Alice should sync to the new
// chain.
_, tempMinerHeight, err := tempMiner.Client.GetBestBlock()
require.NoError(ht.T, err, "unable to get current blockheight")
ht.WaitForNodeBlockHeight(carol, tempMinerHeight)
err = wait.Predicate(func() bool {
ctxt, _ := context.WithTimeout(ctxb, defaultTimeout)
_, err = carol.RPC.LN.GetChanInfo(ctxt, &lnrpc.ChanInfoRequest{
ChanId: aliasmgr.StartingAlias.ToUint64(),
})
return err == nil
}, defaultTimeout)
require.NoError(ht.T, err, "carol doesn't have zero-conf edge")
// Mine the zero-conf funding transaction so the test doesn't fail.
ht.MineBlocks(1)
}