tapdb: use embeddings for script key

Author: guggero

tapdb/addrs.go

@@ -404,22 +404,13 @@ func (t *TapAddressBook) QueryAddrs(ctx context.Context,
 				}
 			}
 
-			rawScriptKey, err := btcec.ParsePubKey(
-				addr.RawScriptKey,
+			scriptKey, err := parseScriptKey(
+				addr.InternalKey, addr.ScriptKey,
 			)
 			if err != nil {
 				return fmt.Errorf("unable to decode "+
 					"script key: %w", err)
 			}
-			rawScriptKeyDesc := keychain.KeyDescriptor{
-				KeyLocator: keychain.KeyLocator{
-					Family: keychain.KeyFamily(
-						addr.ScriptKeyFamily,
-					),
-					Index: uint32(addr.ScriptKeyIndex),
-				},
-				PubKey: rawScriptKey,
-			}
 
 			internalKey, err := btcec.ParsePubKey(addr.RawTaprootKey)
 			if err != nil {
@@ -436,11 +427,6 @@ func (t *TapAddressBook) QueryAddrs(ctx context.Context,
 				PubKey: internalKey,
 			}
 
-			scriptKey, err := btcec.ParsePubKey(addr.TweakedScriptKey)
-			if err != nil {
-				return err
-			}
-
 			taprootOutputKey, err := schnorr.ParsePubKey(
 				addr.TaprootOutputKey,
 			)
@@ -467,8 +453,8 @@ func (t *TapAddressBook) QueryAddrs(ctx context.Context,
 
 			tapAddr, err := address.New(
 				address.Version(addr.Version), assetGenesis,
-				groupKey, groupWitness,
-				*scriptKey, *internalKey, uint64(addr.Amount),
+				groupKey, groupWitness, *scriptKey.PubKey,
+				*internalKey, uint64(addr.Amount),
 				tapscriptSibling, t.params, *proofCourierAddr,
 				address.WithAssetVersion(
 					asset.Version(addr.AssetVersion),
@@ -478,16 +464,9 @@ func (t *TapAddressBook) QueryAddrs(ctx context.Context,
 				return fmt.Errorf("unable to make addr: %w", err)
 			}
 
-			declaredKnown := extractBool(
-				addr.ScriptKeyDeclaredKnown,
-			)
 			addrs = append(addrs, address.AddrWithKeyInfo{
-				Tap: tapAddr,
-				ScriptKeyTweak: asset.TweakedScriptKey{
-					RawKey:        rawScriptKeyDesc,
-					Tweak:         addr.ScriptKeyTweak,
-					DeclaredKnown: declaredKnown,
-				},
+				Tap:              tapAddr,
+				ScriptKeyTweak:   *scriptKey.TweakedScriptKey,
 				InternalKeyDesc:  internalKeyDesc,
 				TaprootOutputKey: *taprootOutputKey,
 				CreationTime:     addr.CreationTime.UTC(),
@@ -571,21 +550,7 @@ func fetchAddr(ctx context.Context, db AddrBook, params *address.ChainParams,
 		}
 	}
 
-	rawScriptKey, err := btcec.ParsePubKey(dbAddr.RawScriptKey)
-	if err != nil {
-		return nil, fmt.Errorf("unable to decode script key: %w", err)
-	}
-	scriptKeyDesc := keychain.KeyDescriptor{
-		KeyLocator: keychain.KeyLocator{
-			Family: keychain.KeyFamily(
-				dbAddr.ScriptKeyFamily,
-			),
-			Index: uint32(dbAddr.ScriptKeyIndex),
-		},
-		PubKey: rawScriptKey,
-	}
-
-	scriptKey, err := btcec.ParsePubKey(dbAddr.TweakedScriptKey)
+	scriptKey, err := parseScriptKey(dbAddr.InternalKey, dbAddr.ScriptKey)
 	if err != nil {
 		return nil, fmt.Errorf("unable to decode script key: %w", err)
 	}
@@ -622,23 +587,18 @@ func fetchAddr(ctx context.Context, db AddrBook, params *address.ChainParams,
 
 	tapAddr, err := address.New(
 		address.Version(dbAddr.Version), genesis, groupKey,
-		groupWitness, *scriptKey, *internalKey, uint64(dbAddr.Amount),
-		tapscriptSibling, params, *proofCourierAddr,
+		groupWitness, *scriptKey.PubKey, *internalKey,
+		uint64(dbAddr.Amount), tapscriptSibling, params,
+		*proofCourierAddr,
 		address.WithAssetVersion(asset.Version(dbAddr.AssetVersion)),
 	)
 	if err != nil {
 		return nil, fmt.Errorf("unable to make addr: %w", err)
 	}
 
 	return &address.AddrWithKeyInfo{
-		Tap: tapAddr,
-		ScriptKeyTweak: asset.TweakedScriptKey{
-			RawKey: scriptKeyDesc,
-			Tweak:  dbAddr.ScriptKeyTweak,
-			DeclaredKnown: extractBool(
-				dbAddr.ScriptKeyDeclaredKnown,
-			),
-		},
+		Tap:              tapAddr,
+		ScriptKeyTweak:   *scriptKey.TweakedScriptKey,
 		InternalKeyDesc:  internalKeyDesc,
 		TaprootOutputKey: *taprootOutputKey,
 		CreationTime:     dbAddr.CreationTime.UTC(),

tapdb/asset_minting.go

@@ -853,35 +853,12 @@ func fetchAssetSprouts(ctx context.Context, q PendingAssetStore,
 	for i, sprout := range dbSprout {
 		// First, we'll decode the script key which very asset must
 		// specify, and populate the key locator information
-		tweakedScriptKey, err := btcec.ParsePubKey(
-			sprout.TweakedScriptKey,
+		scriptKey, err := parseScriptKey(
+			sprout.InternalKey, sprout.ScriptKey,
 		)
 		if err != nil {
-			return nil, err
-		}
-
-		internalScriptKey, err := btcec.ParsePubKey(
-			sprout.ScriptKeyRaw,
-		)
-		if err != nil {
-			return nil, err
-		}
-
-		scriptKeyDesc := keychain.KeyDescriptor{
-			PubKey: internalScriptKey,
-			KeyLocator: keychain.KeyLocator{
-				Index:  uint32(sprout.ScriptKeyIndex),
-				Family: keychain.KeyFamily(sprout.ScriptKeyFam),
-			},
-		}
-		declaredKnown := extractBool(sprout.ScriptKeyDeclaredKnown)
-		scriptKey := asset.ScriptKey{
-			PubKey: tweakedScriptKey,
-			TweakedScriptKey: &asset.TweakedScriptKey{
-				RawKey:        scriptKeyDesc,
-				Tweak:         sprout.Tweak,
-				DeclaredKnown: declaredKnown,
-			},
+			return nil, fmt.Errorf("unable to decode script key: "+
+				"%w", err)
 		}
 
 		// Not all assets have a key group, so we only need to

tapdb/assets_common.go

@@ -480,26 +480,58 @@ func fetchScriptKey(ctx context.Context, q FetchScriptKeyStore,
 		return nil, err
 	}
 
-	rawKey, err := btcec.ParsePubKey(dbKey.RawKey)
+	scriptKey, err := parseScriptKey(dbKey.InternalKey, dbKey.ScriptKey)
 	if err != nil {
-		return nil, fmt.Errorf("unable to parse raw key: %w", err)
-	}
-
-	scriptKey := &asset.TweakedScriptKey{
-		Tweak: dbKey.Tweak,
-		RawKey: keychain.KeyDescriptor{
-			PubKey: rawKey,
-			KeyLocator: keychain.KeyLocator{
-				Family: keychain.KeyFamily(
-					dbKey.KeyFamily,
-				),
-				Index: uint32(dbKey.KeyIndex),
+		return nil, err
+	}
+
+	return scriptKey.TweakedScriptKey, nil
+}
+
+// parseScriptKey maps a script key and internal key from the database into a
+// ScriptKey struct. Both the internal raw public key and the tweaked public key
+// must be set and valid.
+func parseScriptKey(ik sqlc.InternalKey, sk sqlc.ScriptKey) (asset.ScriptKey,
+	error) {
+
+	var (
+		locator = keychain.KeyLocator{
+			Index:  uint32(ik.KeyIndex),
+			Family: keychain.KeyFamily(ik.KeyFamily),
+		}
+		result = asset.ScriptKey{
+			TweakedScriptKey: &asset.TweakedScriptKey{
+				RawKey: keychain.KeyDescriptor{
+					KeyLocator: locator,
+				},
+				Tweak:         sk.Tweak,
+				DeclaredKnown: extractBool(sk.DeclaredKnown),
 			},
-		},
-		DeclaredKnown: extractBool(dbKey.DeclaredKnown),
+		}
+		err error
+	)
+
+	if len(sk.TweakedScriptKey) == 0 {
+		return result, fmt.Errorf("tweaked script key is empty")
+	}
+
+	if len(ik.RawKey) == 0 {
+		return result, fmt.Errorf("internal raw key is empty")
+	}
+
+	result.PubKey, err = btcec.ParsePubKey(sk.TweakedScriptKey)
+	if err != nil {
+		return result, fmt.Errorf("error parsing tweaked "+
+			"script key: %w", err)
+	}
+
+	result.RawKey.PubKey, err = btcec.ParsePubKey(ik.RawKey)
+	if err != nil {
+		return result, fmt.Errorf("error parsing internal "+
+			"raw key: %w", err)
 	}
 
-	return scriptKey, nil
+	return result, nil
 }
 
 // FetchGenesisStore houses the methods related to fetching genesis assets.