multi: allow valid single backups to be skipped

In case we have a channel.backup file which as partly valid
channels we skip over them.

Author: ziggie1984

cmd/chantools/fixoldbackup.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/lightninglabs/chantools/lnd"
 	"github.com/lightningnetwork/lnd/chanbackup"
+	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/keychain"
 	"github.com/spf13/cobra"
 )
@@ -77,10 +78,61 @@ func fixOldChannelBackup(multiFile *chanbackup.MultiFile,
 	for idx, single := range multi.StaticBackups {
 		err := ring.CheckDescriptor(single.ShaChainRootDesc)
 		switch {
-		case err == nil:
+		// If the descriptor is correct or the error is because no
+		// public key is provided, skip the channel. This can happen
+		// if the backup file has partially valid and invalid channels.
+		case err == nil || errors.Is(err, lnd.ErrNoPublicKeyProvided):
+			log.Infof("The shachain root for channel %s is "+
+				"correct, skipping...",
+				single.FundingOutpoint.String())
+
 			continue
 
 		case errors.Is(err, keychain.ErrCannotDerivePrivKey):
+			// Before fixing the descriptor, print the funding multisig
+			// P2WSH witness program hash. Derive the local multisig pubkey
+			// via its locator if needed (and possible), similar to
+			// CheckDescriptor.
+			localPub, err := ring.PubKeyForDescriptor(
+				single.LocalChanCfg.MultiSigKey,
+			)
+			if err != nil {
+				return fmt.Errorf("could not derive local "+
+					"multisig pubkey for channel %s: %w",
+					single.FundingOutpoint.String(), err)
+			}
+
+			remotePub, err := ring.PubKeyForDescriptor(
+				single.RemoteChanCfg.MultiSigKey,
+			)
+			if err != nil {
+				return fmt.Errorf("could not derive remote "+
+					"multisig pubkey for channel %s: %w",
+					single.FundingOutpoint.String(), err)
+			}
+
+			a := localPub.SerializeCompressed()
+			b := remotePub.SerializeCompressed()
+			msScript, err := input.GenMultiSigScript(a, b)
+			if err != nil {
+				return fmt.Errorf("could not generate "+
+					"multisig script for channel "+
+					"%s: %w",
+					single.FundingOutpoint.String(),
+					err)
+			}
+
+			msHash, err := input.WitnessScriptHash(msScript)
+			if err != nil {
+				return fmt.Errorf("could not compute"+
+					"multisig script hash: %w", err)
+			}
+
+			log.Infof("Channel %s funding multisig P2WSH "+
+				"(pubkey): %x",
+				single.FundingOutpoint.String(),
+				msHash[:])
+
 			// Fix the incorrect descriptor by deriving a default
 			// one and overwriting it in the backup.
 			log.Infof("The shachain root for channel %s could "+

lnd/hdkeychain.go

@@ -21,6 +21,10 @@ import (
 	"github.com/lightningnetwork/lnd/shachain"
 )
 
+// ErrNoPublicKeyProvided is returned when a key descriptor check is attempted
+// without a public key present in the descriptor.
+var ErrNoPublicKeyProvided = errors.New("no public key provided to check")
+
 const (
 	HardenedKeyStart            = uint32(hdkeychain.HardenedKeyStart)
 	WalletDefaultDerivationPath = "m/84'/0'/0'"
@@ -609,7 +613,7 @@ func (r *HDKeyRing) CheckDescriptor(
 
 	// A check doesn't make sense if there is no public key set.
 	if keyDesc.PubKey == nil {
-		return errors.New("no public key provided to check")
+		return ErrNoPublicKeyProvided
 	}
 
 	// Performance fix, derive static path only once.
@@ -658,3 +662,21 @@ func (r *HDKeyRing) NodePubKey() (*btcec.PublicKey, error) {
 
 	return keyDesc.PubKey, nil
 }
+
+// PubKeyForDescriptor returns the public key for a given key descriptor. If the
+// descriptor already contains a public key, it is returned as-is. Otherwise,
+// the public key is derived using the descriptor's key locator.
+func (r *HDKeyRing) PubKeyForDescriptor(desc keychain.KeyDescriptor) (
+	*btcec.PublicKey, error) {
+
+	if desc.PubKey != nil {
+		return desc.PubKey, nil
+	}
+
+	// Attempt to derive using the provided key locator.
+	kd, err := r.DeriveKey(desc.KeyLocator)
+	if err != nil {
+		return nil, err
+	}
+	return kd.PubKey, nil
+}