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

@@ -485,26 +485,59 @@ 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 emptyKey asset.ScriptKey
+	if len(sk.TweakedScriptKey) == 0 {
+		return emptyKey, fmt.Errorf("tweaked script key is empty")
+	}
+
+	if len(ik.RawKey) == 0 {
+		return emptyKey, fmt.Errorf("internal raw key is empty")
+	}
+
+	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
+	)
+
+	result.PubKey, err = btcec.ParsePubKey(sk.TweakedScriptKey)
+	if err != nil {
+		return emptyKey, fmt.Errorf("error parsing tweaked script "+
+			"key: %w", err)
+	}
+
+	result.RawKey.PubKey, err = btcec.ParsePubKey(ik.RawKey)
+	if err != nil {
+		return emptyKey, fmt.Errorf("error parsing internal raw "+
+			"key: %w", err)
 	}
 
-	return scriptKey, nil
+	return result, nil
 }
 
 // FetchGenesisStore houses the methods related to fetching genesis assets.

tapdb/assets_store.go

@@ -633,16 +633,12 @@ func (a *AssetStore) dbAssetsToChainAssets(dbAssets []ConfirmedAsset,
 
 		// First, we'll decode the script key which every asset must
 		// specify, and populate the key locator information.
-		rawScriptKeyPub, err := btcec.ParsePubKey(sprout.ScriptKeyRaw)
+		scriptKey, err := parseScriptKey(
+			sprout.InternalKey, sprout.ScriptKey,
+		)
 		if err != nil {
-			return nil, err
-		}
-		rawScriptKeyDesc := keychain.KeyDescriptor{
-			PubKey: rawScriptKeyPub,
-			KeyLocator: keychain.KeyLocator{
-				Index:  uint32(sprout.ScriptKeyIndex),
-				Family: keychain.KeyFamily(sprout.ScriptKeyFam),
-			},
+			return nil, fmt.Errorf("unable to decode script key: "+
+				"%w", err)
 		}
 
 		// Not all assets have a key group, so we only need to
@@ -726,20 +722,6 @@ func (a *AssetStore) dbAssetsToChainAssets(dbAssets []ConfirmedAsset,
 			amount = 1
 		}
 
-		scriptKeyPub, err := btcec.ParsePubKey(sprout.TweakedScriptKey)
-		if err != nil {
-			return nil, err
-		}
-		declaredKnown := extractBool(sprout.ScriptKeyDeclaredKnown)
-		scriptKey := asset.ScriptKey{
-			PubKey: scriptKeyPub,
-			TweakedScriptKey: &asset.TweakedScriptKey{
-				RawKey:        rawScriptKeyDesc,
-				Tweak:         sprout.ScriptKeyTweak,
-				DeclaredKnown: declaredKnown,
-			},
-		}
-
 		assetSprout, err := asset.New(
 			assetGenesis, amount, lockTime, relativeLocktime,
 			scriptKey, groupKey,
@@ -753,7 +735,9 @@ func (a *AssetStore) dbAssetsToChainAssets(dbAssets []ConfirmedAsset,
 		// We cannot use 0 as the amount when creating a new asset with
 		// the New function above. But if this is a tombstone asset, we
 		// actually have to set the amount to 0.
-		if scriptKeyPub.IsEqual(asset.NUMSPubKey) && sprout.Amount == 0 {
+		if scriptKey.PubKey.IsEqual(asset.NUMSPubKey) &&
+			sprout.Amount == 0 {
+
 			assetSprout.Amount = 0
 		}
 
@@ -2787,29 +2771,14 @@ func fetchAssetTransferOutputs(ctx context.Context, q ActiveAssetsStore,
 				"key: %w", err)
 		}
 
-		scriptKey, err := btcec.ParsePubKey(dbOut.ScriptKeyBytes)
+		scriptKey, err := parseScriptKey(
+			dbOut.InternalKey, dbOut.ScriptKey,
+		)
 		if err != nil {
 			return nil, fmt.Errorf("unable to decode script key: "+
 				"%w", err)
 		}
 
-		rawScriptKey, err := btcec.ParsePubKey(
-			dbOut.ScriptKeyRawKeyBytes,
-		)
-		if err != nil {
-			return nil, fmt.Errorf("unable to decode raw script "+
-				"key: %w", err)
-		}
-
-		scriptKeyLocator := keychain.KeyLocator{
-			Family: keychain.KeyFamily(
-				dbOut.ScriptKeyFamily,
-			),
-			Index: uint32(
-				dbOut.ScriptKeyIndex,
-			),
-		}
-
 		var splitRootHash mssmt.NodeHash
 		copy(splitRootHash[:], dbOut.SplitCommitmentRootHash)
 
@@ -2824,7 +2793,6 @@ func fetchAssetTransferOutputs(ctx context.Context, q ActiveAssetsStore,
 				err)
 		}
 
-		declaredKnown := extractBool(dbOut.ScriptKeyDeclaredKnown)
 		outputAnchor := tapfreighter.Anchor{
 			Value: btcutil.Amount(
 				dbOut.AnchorValue,
@@ -2876,19 +2844,9 @@ func fetchAssetTransferOutputs(ctx context.Context, q ActiveAssetsStore,
 			LockTime:         uint64(dbOut.LockTime.Int32),
 			RelativeLockTime: uint64(dbOut.RelativeLockTime.Int32),
 			AssetVersion:     asset.Version(dbOut.AssetVersion),
-			ScriptKey: asset.ScriptKey{
-				PubKey: scriptKey,
-				TweakedScriptKey: &asset.TweakedScriptKey{
-					RawKey: keychain.KeyDescriptor{
-						PubKey:     rawScriptKey,
-						KeyLocator: scriptKeyLocator,
-					},
-					Tweak:         dbOut.ScriptKeyTweak,
-					DeclaredKnown: declaredKnown,
-				},
-			},
-			ScriptKeyLocal: dbOut.ScriptKeyLocal,
-			WitnessData:    witnessData,
+			ScriptKey:        scriptKey,
+			ScriptKeyLocal:   dbOut.ScriptKeyLocal,
+			WitnessData:      witnessData,
 			SplitCommitmentRoot: mssmt.NewComputedNode(
 				splitRootHash,
 				uint64(dbOut.SplitCommitmentRootValue.Int64),
@@ -3167,21 +3125,22 @@ func (a *AssetStore) LogAnchorTxConfirm(ctx context.Context,
 					"witness: %w", err)
 			}
 
-			scriptPubKey, err := btcec.ParsePubKey(
-				out.ScriptKeyBytes,
+			fullScriptKey, err := parseScriptKey(
+				out.InternalKey, out.ScriptKey,
 			)
 			if err != nil {
 				return fmt.Errorf("unable to decode script "+
 					"key: %w", err)
 			}
+			scriptPubKey := fullScriptKey.PubKey
 
 			isNumsKey := scriptPubKey.IsEqual(asset.NUMSPubKey)
 			isTombstone := isNumsKey &&
 				out.Amount == 0 &&
 				out.OutputType == int16(tappsbt.TypeSplitRoot)
 			isBurn := !isNumsKey && len(witnessData) > 0 &&
 				asset.IsBurnKey(scriptPubKey, witnessData[0])
-			isKnown := extractBool(out.ScriptKeyDeclaredKnown)
+			isKnown := fullScriptKey.DeclaredKnown
 			skipAssetCreation := !isTombstone && !isBurn &&
 				!out.ScriptKeyLocal && !isKnown
 
@@ -3235,7 +3194,7 @@ func (a *AssetStore) LogAnchorTxConfirm(ctx context.Context,
 			}
 
 			params := ApplyPendingOutput{
-				ScriptKeyID: out.ScriptKeyID,
+				ScriptKeyID: out.ScriptKey.ScriptKeyID,
 				AnchorUtxoID: sqlInt64(
 					out.AnchorUtxoID,
 				),
@@ -3277,7 +3236,7 @@ func (a *AssetStore) LogAnchorTxConfirm(ctx context.Context,
 			if !ok {
 				return fmt.Errorf("no proof found for output "+
 					"with script key %x",
-					out.ScriptKeyBytes)
+					scriptPubKey.SerializeCompressed())
 			}
 			localProofKeys = append(localProofKeys, outKey)