itest: add test for ConfirmationsUntilActive and ConfirmationHeight

Signed-off-by: Nishant Bansal <[email protected]>

Author: NishantBansal2003

itest/list_on_test.go

@@ -62,6 +62,10 @@ var allTestCases = []*lntest.TestCase{
 		Name:     "funding expiry blocks on pending",
 		TestFunc: testFundingExpiryBlocksOnPending,
 	},
+	{
+		Name:     "pending channel confirmation until active",
+		TestFunc: testPendingChannelConfirmationUntilActive,
+	},
 	{
 		Name:     "list channels",
 		TestFunc: testListChannels,

itest/lnd_open_channel_test.go

@@ -877,6 +877,124 @@ func testFundingExpiryBlocksOnPending(ht *lntest.HarnessTest) {
 	ht.MineBlocksAndAssertNumTxes(1, 1)
 }
 
+// testPendingChannelConfirmationUntilActive verifies the value for the rpc
+// field ConfirmationUntilActive updates correctly as soon as blocks are
+// confirmed.
+func testPendingChannelConfirmationUntilActive(ht *lntest.HarnessTest) {
+	var (
+		numConfs uint32         = 5
+		chanAmt  btcutil.Amount = 100000
+	)
+
+	// Since we want Bob's channels to require more than 1 on-chain
+	// confirmation before becoming active, we will launch Bob with the
+	// custom defaultchanconfs flag.
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNode("Bob", []string{
+		fmt.Sprintf("--bitcoin.defaultchanconfs=%v", numConfs),
+	})
+
+	// Ensure Alice and Bob are connected.
+	ht.EnsureConnected(alice, bob)
+
+	// Alice initiates a channel opening to Bob.
+	param := lntest.OpenChannelParams{Amt: chanAmt}
+	ht.OpenChannelAssertPending(alice, bob, param)
+
+	// Both Alice and Bob have one pending open channel.
+	ht.AssertNumPendingOpenChannels(alice, 1)
+	ht.AssertNumPendingOpenChannels(bob, 1)
+
+	// assertConfirmation is a helper closure to assert the
+	// ConfirmationsUntilActive and ConfirmationHeight has been updated to
+	// the expected value.
+	assertConfirmation := func(hn *node.HarnessNode, expConfLeft uint32,
+		expConfHeight uint32) {
+
+		err := wait.NoError(func() error {
+			// Node should have one pending open channel.
+			pendingChan := ht.AssertNumPendingOpenChannels(hn, 1)[0]
+
+			// Check if the ConfirmationsUntilActive is updated to
+			// the expected value.
+			if expConfLeft != pendingChan.ConfirmationsUntilActive {
+				return fmt.Errorf("remaining confirmations "+
+					"mismatch, want %v, got %v",
+					expConfLeft,
+					pendingChan.ConfirmationsUntilActive)
+			}
+
+			// Check if the ConfirmationHeight is updated to the
+			// expected value.
+			if expConfHeight != pendingChan.ConfirmationHeight {
+				return fmt.Errorf("confirmation height "+
+					"mismatch, want %v, got %v",
+					expConfLeft,
+					pendingChan.ConfirmationsUntilActive)
+			}
+
+			return nil
+		}, defaultTimeout)
+		require.NoError(ht, err)
+	}
+
+	// Since the funding transaction is not confirmed yet,
+	// ConfirmationsUntilActive will always be numConfs, and confirmation
+	// height will be 0.
+	assertConfirmation(alice, numConfs, 0)
+	assertConfirmation(bob, numConfs, 0)
+
+	// Mine the first block containing the funding transaction, This
+	// confirms the funding transaction but the channel should still remain
+	// pending.
+	ht.MineBlocksAndAssertNumTxes(1, 1)
+
+	// Decrement numConfs to reflect that one confirmation has been
+	// received.
+	numConfs--
+
+	// Since the funding transaction has been mined, the best block height
+	// corresponds to the confirmation height of the channel's opening tx.
+	_, expConfHeight := ht.GetBestBlock()
+
+	// Channel remains pending after the first confirmation.
+	ht.AssertNumPendingOpenChannels(alice, 1)
+	ht.AssertNumPendingOpenChannels(bob, 1)
+
+	// Make sure the ConfirmationsUntilActive and ConfirmationHeight
+	// fields have been updated to the expected values before restarting the
+	// nodes.
+	assertConfirmation(alice, numConfs, uint32(expConfHeight))
+	assertConfirmation(bob, numConfs, uint32(expConfHeight))
+
+	// Restart both nodes to test that the appropriate state has been
+	// persisted and that both nodes recover gracefully.
+	ht.RestartNode(alice)
+	ht.RestartNode(bob)
+	ht.EnsureConnected(alice, bob)
+
+	// ConfirmationsUntilActive field should decrease as each block is
+	// mined until the required number of confirmations is reached. Let's
+	// mine a few blocks and verify the value of ConfirmationsUntilActive at
+	// each step.
+	for i := numConfs; i > 0; i-- {
+		expConfLeft := i
+
+		// Retrieve pending channels for both Alice and Bob and verify
+		// the remaining confirmations and confirmation height.
+		assertConfirmation(alice, expConfLeft, uint32(expConfHeight))
+		assertConfirmation(bob, expConfLeft, uint32(expConfHeight))
+
+		// Mine the next block.
+		ht.MineBlocks(1)
+	}
+
+	// After the required number of confirmations, the channel should be
+	// marked as active.
+	ht.AssertNumPendingOpenChannels(alice, 0)
+	ht.AssertNumPendingOpenChannels(bob, 0)
+}
+
 // testSimpleTaprootChannelActivation ensures that a simple taproot channel is
 // active if the initiator disconnects and reconnects in between channel opening
 // and channel confirmation.