tapdb+tapfreighter: correctly identify pedersen keys

Author: guggero

tapdb/assets_store.go

@@ -3167,17 +3167,22 @@ func (a *AssetStore) LogAnchorTxConfirm(ctx context.Context,
 			isBurn := !isNumsKey && len(witnessData) > 0 &&
 				asset.IsBurnKey(scriptPubKey, witnessData[0])
 			isKnown := fullScriptKey.Type != asset.ScriptKeyUnknown
+			isRemotePedersen := fullScriptKey.Type ==
+				asset.ScriptKeyUniquePedersen &&
+				!out.ScriptKeyLocal
 			skipAssetCreation := !isTombstone && !isBurn &&
-				!out.ScriptKeyLocal && !isKnown
+				!out.ScriptKeyLocal &&
+				(!isKnown || isRemotePedersen)
 
 			log.Tracef("Skip asset creation for "+
 				"output %d?: %v,  position=%v, scriptKey=%x, "+
 				"isTombstone=%v, isBurn=%v, "+
-				"scriptKeyLocal=%v, scriptKeyKnown=%v",
-				idx, skipAssetCreation, out.Position,
-				scriptPubKey.SerializeCompressed(),
-				isTombstone, isBurn, out.ScriptKeyLocal,
-				isKnown)
+				"scriptKeyLocal=%v, scriptKeyKnown=%v, "+
+				"isRemotePedersen=%v", idx, skipAssetCreation,
+				out.Position,
+				scriptPubKey.SerializeCompressed(), isTombstone,
+				isBurn, out.ScriptKeyLocal, isKnown,
+				isRemotePedersen)
 
 			// If this is an outbound transfer (meaning that our
 			// node doesn't control the script key, and it isn't a

tapfreighter/chain_porter.go

@@ -16,6 +16,7 @@ import (
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/davecgh/go-spew/spew"
+	"github.com/lightninglabs/taproot-assets/address"
 	"github.com/lightninglabs/taproot-assets/asset"
 	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/proof"
@@ -1457,9 +1458,41 @@ func (p *ChainPorter) stateStep(currentPkg sendPackage) (*sendPackage, error) {
 		// (e.g. a change output) or an outbound transfer. A key being
 		// local means the lnd node connected to this daemon knows how
 		// to derive the key.
-		isLocalKey := func(key asset.ScriptKey) bool {
+		isLocalKey := func(key asset.ScriptKey) (bool, error) {
+			// To make sure we have the correct internal key with
+			// the family and index set, we attempt to fetch it
+			// from the database. If it exists, then we know we
+			// stored it with the correct information.
+			dbKey, err := p.cfg.AssetWallet.FetchScriptKey(
+				ctx, key.PubKey,
+			)
+			switch {
+			// If this isn't an output that goes to us, we won't
+			// find it, which is okay. Only for other database
+			// errors do we return the error.
+			case err != nil &&
+				!errors.Is(err, address.ErrScriptKeyNotFound):
+
+				return false, fmt.Errorf("error fetching "+
+					"script key: %w", err)
+
+			// We did find the key, so we can check if it's a local
+			// key with the key ring.
+			case err == nil:
+				return p.cfg.KeyRing.IsLocalKey(
+					ctx, dbKey.RawKey,
+				), nil
+			}
+
+			// As a fallback, in case only the internal key was
+			// declared, we can check if the key is local by
+			// using the info we have, with a potential for a false
+			// negative if the key family and index isn't set at
+			// this point. But if it isn't set, then we didn't
+			// import/declare the key before, so it's very likely
+			// not ours anyway.
 			return key.TweakedScriptKey != nil &&
-				p.cfg.KeyRing.IsLocalKey(ctx, key.RawKey)
+				p.cfg.KeyRing.IsLocalKey(ctx, key.RawKey), nil
 		}
 
 		// We need to prepare the parcel for storage.

tapfreighter/parcel.go

@@ -538,7 +538,7 @@ type sendPackage struct {
 // they were already committed at.
 func ConvertToTransfer(currentHeight uint32, activeTransfers []*tappsbt.VPacket,
 	anchorTx *tapsend.AnchorTransaction, passiveAssets []*tappsbt.VPacket,
-	isLocalKey func(asset.ScriptKey) bool, label string,
+	isLocalKey func(asset.ScriptKey) (bool, error), label string,
 	skipAnchorTxBroadcast bool) (*OutboundParcel, error) {
 
 	var passiveAssetAnchor *Anchor
@@ -650,7 +650,8 @@ func transferInput(vIn *tappsbt.VInput) (*TransferInput, error) {
 // packet.
 func transferOutput(vPkt *tappsbt.VPacket, vOutIdx int, position uint64,
 	anchorTx *tapsend.AnchorTransaction, passiveAssets []*tappsbt.VPacket,
-	isLocalKey func(asset.ScriptKey) bool) (*TransferOutput, error) {
+	isLocalKey func(asset.ScriptKey) (bool, error)) (*TransferOutput,
+	error) {
 
 	vOut := vPkt.Outputs[vOutIdx]
 
@@ -680,6 +681,12 @@ func transferOutput(vPkt *tappsbt.VPacket, vOutIdx int, position uint64,
 		return nil, fmt.Errorf("unable to create anchor: %w", err)
 	}
 
+	scriptKeyLocal, err := isLocalKey(vOut.ScriptKey)
+	if err != nil {
+		return nil, fmt.Errorf("unable to determine if script key "+
+			"is local: %w", err)
+	}
+
 	out := TransferOutput{
 		Anchor:              *anchor,
 		Type:                vOut.Type,
@@ -692,7 +699,7 @@ func transferOutput(vPkt *tappsbt.VPacket, vOutIdx int, position uint64,
 		SplitCommitmentRoot: vOut.Asset.SplitCommitmentRoot,
 		ProofSuffix:         proofSuffixBytes,
 		ProofCourierAddr:    proofCourierAddrBytes,
-		ScriptKeyLocal:      isLocalKey(vOut.ScriptKey),
+		ScriptKeyLocal:      scriptKeyLocal,
 		Position:            position,
 	}