lnwallet+channeldb: add anchor resolutions, fetch anchor resolutions from confirmed bucket

Co-authored-by: Joost Jager <[email protected]>

Author: halseth

channeldb/channel.go

@@ -1768,11 +1768,17 @@ func (c *OpenChannel) AppendRemoteCommitChain(diff *CommitDiff) error {
 // this new pending commitment. Once they revoked their prior state, we'll swap
 // these pointers, causing the tip and the tail to point to the same entry.
 func (c *OpenChannel) RemoteCommitChainTip() (*CommitDiff, error) {
+	return c.RemoteCommitChainTipFrom(false)
+}
+
+// RemoteCommitChainTip returns the "tip" of the current remote commitment
+// chain. The confirmed bool indicates which bucket to retrieve the data from.
+func (c *OpenChannel) RemoteCommitChainTipFrom(confirmed bool) (*CommitDiff,
+	error) {
+
 	var cd *CommitDiff
 	err := c.Db.View(func(tx *bbolt.Tx) error {
-		chanBucket, err := fetchChanBucket(
-			tx, c.IdentityPub, &c.FundingOutpoint, c.ChainHash,
-		)
+		chanBucket, err := c.fetchChanBucket(tx, confirmed)
 		switch err {
 		case nil:
 		case ErrNoChanDBExists, ErrNoActiveChannels, ErrChannelNotFound:
@@ -2439,15 +2445,63 @@ func (c *OpenChannel) Snapshot() *ChannelSnapshot {
 	return snapshot
 }
 
+// fetchPendingCloseChanBucket is a helper function that returns the bucket
+// where a channel's pending close data resides in given the outpoint.
+func fetchPendingCloseChanBucket(tx *bbolt.Tx, outPoint *wire.OutPoint) (
+	*bbolt.Bucket, error) {
+
+	// First fetch the top level bucket which stores all data related to
+	// current, active channels.
+	historicalBucket := tx.Bucket(historicalChannelBucket)
+	if historicalBucket == nil {
+		return nil, ErrNoChanDBExists
+	}
+
+	// With the bucket for the node and chain fetched, we can now go down
+	// another level, for this channel itself.
+	var chanPointBuf bytes.Buffer
+	if err := writeOutpoint(&chanPointBuf, outPoint); err != nil {
+		return nil, err
+	}
+	chanBucket := historicalBucket.Bucket(chanPointBuf.Bytes())
+	if chanBucket == nil {
+		return nil, ErrChannelNotFound
+	}
+
+	return chanBucket, nil
+}
+
+// fetchChanBucket returns either the open or the confirmed channel bucket.
+func (c *OpenChannel) fetchChanBucket(tx *bbolt.Tx, confirmed bool) (
+	*bbolt.Bucket, error) {
+
+	if confirmed {
+		return fetchPendingCloseChanBucket(tx, &c.FundingOutpoint)
+	}
+
+	return fetchChanBucket(
+		tx, c.IdentityPub, &c.FundingOutpoint, c.ChainHash,
+	)
+}
+
 // LatestCommitments returns the two latest commitments for both the local and
 // remote party. These commitments are read from disk to ensure that only the
 // latest fully committed state is returned. The first commitment returned is
 // the local commitment, and the second returned is the remote commitment.
-func (c *OpenChannel) LatestCommitments() (*ChannelCommitment, *ChannelCommitment, error) {
+func (c *OpenChannel) LatestCommitments() (*ChannelCommitment,
+	*ChannelCommitment, error) {
+
+	return c.LatestCommitmentsFrom(false)
+}
+
+// LatestCommitmentsFrom returns the two latest commitments for both the local
+// and remote party. The confirmed boolean indicates the bucket to read the data
+// from.
+func (c *OpenChannel) LatestCommitmentsFrom(confirmed bool) (*ChannelCommitment,
+	*ChannelCommitment, error) {
+
 	err := c.Db.View(func(tx *bbolt.Tx) error {
-		chanBucket, err := fetchChanBucket(
-			tx, c.IdentityPub, &c.FundingOutpoint, c.ChainHash,
-		)
+		chanBucket, err := c.fetchChanBucket(tx, confirmed)
 		if err != nil {
 			return err
 		}

lnwallet/channel.go

@@ -5659,6 +5659,105 @@ func (lc *LightningChannel) CompleteCooperativeClose(localSig, remoteSig []byte,
 	return closeTx, ourBalance, nil
 }
 
+// AnchorResolutions holds the informations necessary to spend the anchors in
+// play.
+type AnchorResolutions struct {
+	// AnchorSignDescriptor is the sign descriptor for all variants of our
+	// anchor.
+	AnchorSignDescriptor *input.SignDescriptor
+
+	// LocalCommitAnchor is the anchor outpoint on our local commitment.
+	// This is nil if the current channel type doesn't have anchor outputs.
+	LocalCommitAnchor *wire.OutPoint
+
+	// RemoteCommitAnchor is the anchor outpoint on the acked remote
+	// commitment. This is nil if the current channel type doesn't have
+	// anchor outputs.
+	RemoteCommitAnchor *wire.OutPoint
+
+	// RemotePendingCommitAnchor is the anchor outpoint on the pending ack
+	// remote commitment. This is nil if the current channel type doesn't
+	// have anchor outputs or there are no pending commit.
+	RemotePendingCommitAnchor *wire.OutPoint
+}
+
+// NewAnchorResolutions returns the anchor resolutions for the channel state.
+// The confirmed boolean indicates where to get the channel data from.
+func NewAnchorResolutions(chanState *channeldb.OpenChannel, confirmed bool) (
+	*AnchorResolutions, error) {
+
+	// Derive our local anchor script, which will be found on each of the
+	// commitments.
+	localAnchor, _, err := CommitScriptAnchors(
+		&chanState.LocalChanCfg, &chanState.RemoteChanCfg,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	// Similarly the sign descriptor will be the same for all commitments.
+	anchorSignDesc := &input.SignDescriptor{
+		SingleTweak:   nil,
+		KeyDesc:       chanState.LocalChanCfg.MultiSigKey,
+		WitnessScript: localAnchor.WitnessScript,
+		Output: &wire.TxOut{
+			PkScript: localAnchor.PkScript,
+			Value:    int64(anchorSize),
+		},
+		HashType: txscript.SigHashAll,
+	}
+
+	// locateAnchor is a helper method that finds the local anchor outpoint
+	// on the given commitment. If not found nil is returned.
+	locateAnchor := func(commit *channeldb.ChannelCommitment) *wire.OutPoint {
+		tx := commit.CommitTx
+
+		for i, txOut := range tx.TxOut {
+			if !bytes.Equal(txOut.PkScript, localAnchor.PkScript) {
+				continue
+			}
+
+			return &wire.OutPoint{
+				Hash:  tx.TxHash(),
+				Index: uint32(i),
+			}
+		}
+
+		// Not found.
+		return nil
+	}
+
+	// Fetch the two latest commitments.
+	localCommit, remoteCommit, err := chanState.LatestCommitmentsFrom(
+		confirmed,
+	)
+	if err != nil {
+		return nil, err
+	}
+	resolutions := &AnchorResolutions{
+		AnchorSignDescriptor:      anchorSignDesc,
+		LocalCommitAnchor:         locateAnchor(localCommit),
+		RemoteCommitAnchor:        locateAnchor(remoteCommit),
+		RemotePendingCommitAnchor: nil,
+	}
+
+	// Get their pending commit, if any.
+	remotePendingCommit, err := chanState.RemoteCommitChainTipFrom(
+		confirmed,
+	)
+	if err != nil && err != channeldb.ErrNoPendingCommit {
+		return nil, err
+	}
+
+	if remotePendingCommit != nil {
+		resolutions.RemotePendingCommitAnchor = locateAnchor(
+			&remotePendingCommit.Commitment,
+		)
+	}
+
+	return resolutions, nil
+}
+
 // AvailableBalance returns the current available balance within the channel.
 // By available balance, we mean that if at this very instance s new commitment
 // were to be created which evals all the log entries, what would our available