sweepremoteclosed: implement ancient channel lookup

Author: guggero

cmd/chantools/rescueclosed.go

@@ -32,7 +32,7 @@ var (
 
 type cacheEntry struct {
 	privKey *btcec.PrivateKey
-	pubKey  *btcec.PublicKey
+	keyDesc *keychain.KeyDescriptor
 }
 
 type rescueClosedCommand struct {
@@ -403,7 +403,7 @@ func addrInCache(numKeys uint32, addr string,
 		for i := range numKeys {
 			cacheEntry := cache[i]
 			hashedPubKey := btcutil.Hash160(
-				cacheEntry.pubKey.SerializeCompressed(),
+				cacheEntry.keyDesc.PubKey.SerializeCompressed(),
 			)
 			equal := subtle.ConstantTimeCompare(
 				targetPubKeyHash, hashedPubKey,
@@ -431,7 +431,7 @@ func addrInCache(numKeys uint32, addr string,
 	// corresponds to the target pubKeyHash of the given address.
 	for i := range numKeys {
 		cacheEntry := cache[i]
-		basePoint := cacheEntry.pubKey
+		basePoint := cacheEntry.keyDesc.PubKey
 		tweakedPubKey := input.TweakPubKey(basePoint, perCommitPoint)
 		tweakBytes := input.SingleTweakBytes(perCommitPoint, basePoint)
 		tweakedPrivKey := input.TweakPrivKey(
@@ -460,6 +460,29 @@ func addrInCache(numKeys uint32, addr string,
 	return "", errAddrNotFound
 }
 
+func keyInCache(numKeys uint32, targetPubKeyHash []byte,
+	perCommitPoint *btcec.PublicKey) (*keychain.KeyDescriptor, []byte,
+	error) {
+
+	for i := range numKeys {
+		cacheEntry := cache[i]
+		basePoint := cacheEntry.keyDesc.PubKey
+		tweakedPubKey := input.TweakPubKey(basePoint, perCommitPoint)
+		tweakBytes := input.SingleTweakBytes(perCommitPoint, basePoint)
+		hashedPubKey := btcutil.Hash160(
+			tweakedPubKey.SerializeCompressed(),
+		)
+		equal := subtle.ConstantTimeCompare(
+			targetPubKeyHash, hashedPubKey,
+		)
+		if equal == 1 {
+			return cacheEntry.keyDesc, tweakBytes, nil
+		}
+	}
+
+	return nil, nil, errAddrNotFound
+}
+
 func fillCache(numKeys uint32, extendedKey *hdkeychain.ExtendedKey) error {
 	cache = make([]*cacheEntry, numKeys)
 
@@ -484,7 +507,13 @@ func fillCache(numKeys uint32, extendedKey *hdkeychain.ExtendedKey) error {
 		}
 		cache[i] = &cacheEntry{
 			privKey: privKey,
-			pubKey:  pubKey,
+			keyDesc: &keychain.KeyDescriptor{
+				KeyLocator: keychain.KeyLocator{
+					Family: keychain.KeyFamilyPaymentBase,
+					Index:  i,
+				},
+				PubKey: pubKey,
+			},
 		}
 
 		if i > 0 && i%10000 == 0 {

cmd/chantools/sweepremoteclosed.go

@@ -2,12 +2,16 @@ package main
 
 import (
 	"bytes"
+	_ "embed"
 	"encoding/hex"
+	"encoding/json"
+	"errors"
 	"fmt"
 
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/btcutil/hdkeychain"
+	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
@@ -19,6 +23,9 @@ import (
 	"github.com/spf13/cobra"
 )
 
+//go:embed sweepremoteclosed_ancient.json
+var ancientChannelPoints []byte
+
 const (
 	sweepRemoteClosedDefaultRecoveryWindow = 200
 	sweepDustLimit                         = 600
@@ -121,9 +128,8 @@ func (c *sweepRemoteClosedCommand) Execute(_ *cobra.Command, _ []string) error {
 
 type targetAddr struct {
 	addr       btcutil.Address
-	pubKey     *btcec.PublicKey
-	path       string
 	keyDesc    *keychain.KeyDescriptor
+	tweak      []byte
 	vouts      []*btc.Vout
 	script     []byte
 	scriptTree *input.CommitScriptTree
@@ -154,9 +160,7 @@ func sweepRemoteClosed(extendedKey *hdkeychain.ExtendedKey, apiURL,
 			return fmt.Errorf("error parsing path: %w", err)
 		}
 
-		hdKey, err := lnd.DeriveChildren(
-			extendedKey, parsedPath,
-		)
+		hdKey, err := lnd.DeriveChildren(extendedKey, parsedPath)
 		if err != nil {
 			return fmt.Errorf("eror deriving children: %w", err)
 		}
@@ -168,7 +172,7 @@ func sweepRemoteClosed(extendedKey *hdkeychain.ExtendedKey, apiURL,
 		}
 
 		foundTargets, err := queryAddressBalances(
-			privKey.PubKey(), path, &keychain.KeyDescriptor{
+			privKey.PubKey(), &keychain.KeyDescriptor{
 				PubKey: privKey.PubKey(),
 				KeyLocator: keychain.KeyLocator{
 					Family: keychain.KeyFamilyPaymentBase,
@@ -183,6 +187,20 @@ func sweepRemoteClosed(extendedKey *hdkeychain.ExtendedKey, apiURL,
 		targets = append(targets, foundTargets...)
 	}
 
+	// Also check if there are any funds in channels with the initial,
+	// tweaked channel type that requires a channel point.
+	ancientChannelTargets, err := checkAncientChannelPoints(
+		api, recoveryWindow, extendedKey,
+	)
+	if err != nil && !errors.Is(err, errAddrNotFound) {
+		return fmt.Errorf("could not check ancient channel points: %w",
+			err)
+	}
+
+	if len(ancientChannelTargets) > 0 {
+		targets = append(targets, ancientChannelTargets...)
+	}
+
 	// Create estimator and transaction template.
 	var (
 		signDescs        []*input.SignDescriptor
@@ -235,6 +253,7 @@ func sweepRemoteClosed(extendedKey *hdkeychain.ExtendedKey, apiURL,
 				signDesc = &input.SignDescriptor{
 					KeyDesc:           *target.keyDesc,
 					WitnessScript:     target.script,
+					SingleTweak:       target.tweak,
 					Output:            prevTxOut,
 					HashType:          txscript.SigHashAll,
 					PrevOutputFetcher: prevOutFetcher,
@@ -383,7 +402,7 @@ func sweepRemoteClosed(extendedKey *hdkeychain.ExtendedKey, apiURL,
 	return nil
 }
 
-func queryAddressBalances(pubKey *btcec.PublicKey, path string,
+func queryAddressBalances(pubKey *btcec.PublicKey,
 	keyDesc *keychain.KeyDescriptor, api *btc.ExplorerAPI) ([]*targetAddr,
 	error) {
 
@@ -401,8 +420,6 @@ func queryAddressBalances(pubKey *btcec.PublicKey, path string,
 				len(unspent), address.EncodeAddress())
 			targets = append(targets, &targetAddr{
 				addr:       address,
-				pubKey:     pubKey,
-				path:       path,
 				keyDesc:    keyDesc,
 				vouts:      unspent,
 				script:     script,
@@ -439,3 +456,125 @@ func queryAddressBalances(pubKey *btcec.PublicKey, path string,
 
 	return targets, nil
 }
+
+type ancientChannel struct {
+	OP   string `json:"close_outpoint"`
+	Addr string `json:"close_addr"`
+	CP   string `json:"commit_point"`
+}
+
+func findAncientChannels(channels []ancientChannel, numKeys uint32,
+	key *hdkeychain.ExtendedKey) ([]ancientChannel, error) {
+
+	if err := fillCache(numKeys, key); err != nil {
+		return nil, err
+	}
+
+	var foundChannels []ancientChannel
+	for _, channel := range channels {
+		// Decode the commit point.
+		commitPointBytes, err := hex.DecodeString(channel.CP)
+		if err != nil {
+			return nil, fmt.Errorf("unable to decode commit "+
+				"point: %w", err)
+		}
+		commitPoint, err := btcec.ParsePubKey(commitPointBytes)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse commit "+
+				"point: %w", err)
+		}
+
+		// Create the address for the commit key. The addresses in the
+		// file are always for mainnet.
+		targetPubKeyHash, _, err := lnd.DecodeAddressHash(
+			channel.Addr, &chaincfg.MainNetParams,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("error parsing addr: %w", err)
+		}
+
+		_, _, err = keyInCache(numKeys, targetPubKeyHash, commitPoint)
+		switch {
+		case err == nil:
+			foundChannels = append(foundChannels, channel)
+
+		case errors.Is(err, errAddrNotFound):
+			// Try next address.
+
+		default:
+			return nil, err
+		}
+	}
+
+	return foundChannels, nil
+}
+
+func checkAncientChannelPoints(api *btc.ExplorerAPI, numKeys uint32,
+	key *hdkeychain.ExtendedKey) ([]*targetAddr, error) {
+
+	var channels []ancientChannel
+	err := json.Unmarshal(ancientChannelPoints, &channels)
+	if err != nil {
+		return nil, err
+	}
+
+	ancientChannels, err := findAncientChannels(channels, numKeys, key)
+	if err != nil {
+		return nil, err
+	}
+
+	targets := make([]*targetAddr, 0, len(ancientChannels))
+	for _, ancientChannel := range ancientChannels {
+		// Decode the commit point.
+		commitPointBytes, err := hex.DecodeString(ancientChannel.CP)
+		if err != nil {
+			return nil, fmt.Errorf("unable to decode commit "+
+				"point: %w", err)
+		}
+		commitPoint, err := btcec.ParsePubKey(commitPointBytes)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse commit point: "+
+				"%w", err)
+		}
+
+		// Create the address for the commit key. The addresses in the
+		// file are always for mainnet.
+		targetPubKeyHash, _, err := lnd.DecodeAddressHash(
+			ancientChannel.Addr, &chaincfg.MainNetParams,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("error parsing addr: %w", err)
+		}
+		addr, err := lnd.ParseAddress(
+			ancientChannel.Addr, &chaincfg.MainNetParams,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("error parsing addr: %w", err)
+		}
+
+		log.Infof("Found private key for address %v in list of "+
+			"ancient channels!", addr)
+
+		unspent, err := api.Unspent(addr.EncodeAddress())
+		if err != nil {
+			return nil, fmt.Errorf("could not query unspent: %w",
+				err)
+		}
+
+		keyDesc, tweak, err := keyInCache(
+			numKeys, targetPubKeyHash, commitPoint,
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		targets = append(targets, &targetAddr{
+			addr:    addr,
+			keyDesc: keyDesc,
+			tweak:   tweak,
+			vouts:   unspent,
+		})
+	}
+
+	return targets, nil
+}

cmd/chantools/sweepremoteclosed_ancient.json

@@ -0,0 +1,7 @@
+[
+  {
+    "close_outpoint": "35e5aafcc03a4eacaed492d44815fea553f5434b881ecb5d9edcd094c899c074:0",
+    "close_addr": "bc1q43tqzm23a8ld9qdpfp7feut5yc20rtewhtpz40",
+    "commit_point": "023fc323c1768102c214f550551a102f88c0f261a4b8e7cc998c0dce28b6998d3c"
+  }
+]