funding: persist ConfirmationHeight upon first funding confirmation

This change ensures that a channel's ConfirmationHeight is recorded in the
database once its funding transaction receives its initial confirmation.
By doing so, we establish a reliable reference point to monitor the
channel's progress toward the required confirmation depth.

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

Author: NishantBansal2003

funding/manager.go

@@ -3079,7 +3079,8 @@ func makeFundingScript(channel *channeldb.OpenChannel) ([]byte, error) {
 // process once the funding transaction has been broadcast. The primary
 // function of waitForFundingConfirmation is to wait for blockchain
 // confirmation, and then to notify the other systems that must be notified
-// when a channel has become active for lightning transactions.
+// when a channel has become active for lightning transactions. It also updates
+// the channel’s opening transaction block height in the database.
 // The wait can be canceled by closing the cancelChan. In case of success,
 // a *lnwire.ShortChannelID will be passed to confChan.
 //
@@ -3123,55 +3124,120 @@ func (f *Manager) waitForFundingConfirmation(
 	log.Infof("Waiting for funding tx (%v) to reach %v confirmations",
 		txid, numConfs)
 
-	var confDetails *chainntnfs.TxConfirmation
-	var ok bool
+	// Monitor the confirmation event for the funding transaction. And
+	// return when the funding tx has received the required number of
+	// confirmations.
+	for {
+		select {
+		case updDetails := <-confNtfn.Updates:
+			log.Tracef("funding tx %s received a confirmation, %d "+
+				" number of confirmations still required", txid,
+				updDetails.NumConfsLeft)
+
+			// Handle first confirmation of the funding transaction.
+			if updDetails.NumConfsLeft == numConfs-1 {
+				log.Infof("funding tx %s received first "+
+					"confirmation", txid)
+
+				err := completeChan.MarkConfirmationHeight(
+					updDetails.BlockHeight,
+				)
+				if err != nil {
+					log.Errorf("failed to mark "+
+						"confirmation height: %v", err)
 
-	// Wait until the specified number of confirmations has been reached,
-	// we get a cancel signal, or the wallet signals a shutdown.
-	select {
-	case confDetails, ok = <-confNtfn.Confirmed:
-		// fallthrough
+					return
+				}
+			}
 
-	case <-cancelChan:
-		log.Warnf("canceled waiting for funding confirmation, "+
-			"stopping funding flow for ChannelPoint(%v)",
-			completeChan.FundingOutpoint)
-		return
+			// If we haven't reached final confirmation, continue
+			// waiting for confirmations.
+			if updDetails.NumConfsLeft > 0 {
+				continue
+			}
 
-	case <-f.quit:
-		log.Warnf("fundingManager shutting down, stopping funding "+
-			"flow for ChannelPoint(%v)",
-			completeChan.FundingOutpoint)
-		return
-	}
+			log.Infof("funding tx %s received all confirmations",
+				txid)
 
-	if !ok {
-		log.Warnf("ChainNotifier shutting down, cannot complete "+
-			"funding flow for ChannelPoint(%v)",
-			completeChan.FundingOutpoint)
-		return
-	}
+			// We've reached final confirmation. Wait for the
+			// confirmation event to trigger and then send the
+			// result to the confirmation channel.
+			err := f.handleFinalConfirmation(
+				confNtfn, confChan, completeChan,
+			)
+			if err != nil {
+				log.Errorf("failed to handle final "+
+					"confirmation: %v", err)
+			}
 
-	fundingPoint := completeChan.FundingOutpoint
-	log.Infof("ChannelPoint(%v) is now active: ChannelID(%v)",
-		fundingPoint, lnwire.NewChanIDFromOutPoint(fundingPoint))
+			return
+
+		case <-confNtfn.NegativeConf:
+			log.Warnf("funding tx %s was reorged out; channel "+
+				"point: %s", txid, completeChan.FundingOutpoint)
+
+			// Reset the confirmation height to 0 because the
+			// funding transaction was reorged out.
+			err := completeChan.MarkConfirmationHeight(uint32(0))
+			if err != nil {
+				log.Errorf("failed to update state for "+
+					"ChannelPoint(%v): %v",
+					completeChan.FundingOutpoint, err)
+
+				return
+			}
+
+		case <-cancelChan:
+			log.Warnf("canceled waiting for funding confirmation, "+
+				"stopping funding flow for ChannelPoint(%v)",
+				completeChan.FundingOutpoint)
+
+			return
 
-	// With the block height and the transaction index known, we can
-	// construct the compact chanID which is used on the network to unique
-	// identify channels.
-	shortChanID := lnwire.ShortChannelID{
-		BlockHeight: confDetails.BlockHeight,
-		TxIndex:     confDetails.TxIndex,
-		TxPosition:  uint16(fundingPoint.Index),
+		case <-f.quit:
+			log.Warnf("fundingManager shutting down, stopping "+
+				"funding flow for ChannelPoint(%v)",
+				completeChan.FundingOutpoint)
+
+			return
+		}
 	}
+}
+
+// handleFinalConfirmation is a helper function that listens for the final
+// confirmation event and sends the final confirmation to the confirmation
+// channel which was provided by the caller.
+func (f *Manager) handleFinalConfirmation(
+	confNtfn *chainntnfs.ConfirmationEvent,
+	confChan chan<- *confirmedChannel,
+	completeChan *channeldb.OpenChannel) error {
 
 	select {
-	case confChan <- &confirmedChannel{
-		shortChanID: shortChanID,
-		fundingTx:   confDetails.Tx,
-	}:
+	case confDetails, ok := <-confNtfn.Confirmed:
+		if !ok {
+			return fmt.Errorf("confirmation channel closed " +
+				"unexpectedly")
+		}
+
+		// Send the result to the confirmation channel.
+		shortChanID := lnwire.ShortChannelID{
+			BlockHeight: confDetails.BlockHeight,
+			TxIndex:     confDetails.TxIndex,
+			TxPosition:  uint16(completeChan.FundingOutpoint.Index),
+		}
+
+		if !fn.SendOrQuit(confChan, &confirmedChannel{
+			shortChanID: shortChanID,
+			fundingTx:   confDetails.Tx,
+		}, f.quit) {
+
+			return fmt.Errorf("failed to send confirmation")
+		}
+
+		return nil
+
 	case <-f.quit:
-		return
+		return fmt.Errorf("funding manager shutting down")
 	}
 }