taprpc+rpcserver: allow user to set script key type

Specifying a script key as known now requires the user to set a specific
type.

Author: guggero

rpcserver.go

@@ -8137,11 +8137,21 @@ func (r *rpcServer) DeclareScriptKey(ctx context.Context,
 	}
 
 	// Because we've been given the key over the RPC interface, we can't be
-	// 100% sure of the type. But we can make a best effort guess based on
-	// the fields the user has set.
-	keyType := scriptKey.DetermineType()
+	// 100% sure of the type, if it wasn't declared. But we can make a
+	// best-effort guess based on the fields the user has set. This is a
+	// no-op if the type is already set.
+	scriptKey.Type = scriptKey.DetermineType()
 
-	err = r.cfg.TapAddrBook.InsertScriptKey(ctx, *scriptKey, true, keyType)
+	// The user is declaring the key, so they should know what type it is.
+	// So if they didn't set it, and it wasn't an obvious one, we'll require
+	// them to set it.
+	if scriptKey.Type == asset.ScriptKeyUnknown {
+		return nil, fmt.Errorf("script key type must be set")
+	}
+
+	err = r.cfg.TapAddrBook.InsertScriptKey(
+		ctx, *scriptKey, true, scriptKey.Type,
+	)
 	if err != nil {
 		return nil, fmt.Errorf("error inserting script key: %w", err)
 	}

taprpc/assetwalletrpc/assetwallet.swagger.json

@@ -1046,9 +1046,26 @@
           "type": "string",
           "format": "byte",
           "description": "The optional Taproot tweak to apply to the above internal key. If this is\nempty then a BIP-86 style tweak is applied to the internal key."
+        },
+        "type": {
+          "$ref": "#/definitions/taprpcScriptKeyType",
+          "description": "The type of the script key. This type is either user-declared when custom\nscript keys are added, or automatically determined by the daemon for\nstandard operations (e.g. BIP-86 keys, burn keys, tombstone keys, channel\nrelated keys)."
         }
       }
     },
+    "taprpcScriptKeyType": {
+      "type": "string",
+      "enum": [
+        "SCRIPT_KEY_UNKNOWN",
+        "SCRIPT_KEY_BIP86",
+        "SCRIPT_KEY_SCRIPT_PATH_EXTERNAL",
+        "SCRIPT_KEY_BURN",
+        "SCRIPT_KEY_TOMBSTONE",
+        "SCRIPT_KEY_CHANNEL"
+      ],
+      "default": "SCRIPT_KEY_UNKNOWN",
+      "description": " - SCRIPT_KEY_UNKNOWN: The type of script key is not known. This should only be stored for assets\nwhere we don't know the internal key of the script key (e.g. for\nimported proofs).\n - SCRIPT_KEY_BIP86: The script key is a normal BIP-86 key. This means that the internal key is\nturned into a Taproot output key by applying a BIP-86 tweak to it.\n - SCRIPT_KEY_SCRIPT_PATH_EXTERNAL: The script key is a key that contains a script path that is defined by the\nuser and is therefore external to the tapd wallet. Spending this key\nrequires providing a specific witness and must be signed through the vPSBT\nsigning flow.\n - SCRIPT_KEY_BURN: The script key is a specific un-spendable key that indicates a burnt asset.\nAssets with this key type can never be spent again, as a burn key is a\ntweaked NUMS key that nobody knows the private key for.\n - SCRIPT_KEY_TOMBSTONE: The script key is a specific un-spendable key that indicates a tombstone\noutput. This is only the case for zero-value assets that result from a\nnon-interactive (TAP address) send where no change was left over.\n - SCRIPT_KEY_CHANNEL: The script key is used for an asset that resides within a Taproot Asset\nChannel. That means the script key is either a funding key (OP_TRUE), a\ncommitment output key (to_local, to_remote, htlc), or a HTLC second-level\ntransaction output key. Keys related to channels are not shown in asset\nbalances (unless specifically requested) and are never used for coin\nselection."
+    },
     "taprpcSendAssetResponse": {
       "type": "object",
       "properties": {

taprpc/marshal.go

@@ -85,8 +85,14 @@ func UnmarshalKeyDescriptor(rpcDesc *KeyDescriptor) (keychain.KeyDescriptor,
 // UnmarshalScriptKey parses the RPC script key into the native counterpart.
 func UnmarshalScriptKey(rpcKey *ScriptKey) (*asset.ScriptKey, error) {
 	var (
-		scriptKey asset.ScriptKey
-		err       error
+		scriptKey = asset.ScriptKey{
+			TweakedScriptKey: &asset.TweakedScriptKey{
+				// The tweak is optional, if it's empty it means
+				// the key is derived using BIP-0086.
+				Tweak: rpcKey.TapTweak,
+			},
+		}
+		err error
 	)
 
 	// The script public key is a Taproot key, so 32-byte x-only.
@@ -98,17 +104,15 @@ func UnmarshalScriptKey(rpcKey *ScriptKey) (*asset.ScriptKey, error) {
 	// The key descriptor is optional for script keys that are completely
 	// independent of the backing wallet.
 	if rpcKey.KeyDesc != nil {
-		keyDesc, err := UnmarshalKeyDescriptor(rpcKey.KeyDesc)
+		scriptKey.RawKey, err = UnmarshalKeyDescriptor(rpcKey.KeyDesc)
 		if err != nil {
 			return nil, err
 		}
-		scriptKey.TweakedScriptKey = &asset.TweakedScriptKey{
-			RawKey: keyDesc,
+	}
 
-			// The tweak is optional, if it's empty it means the key
-			// is derived using BIP-0086.
-			Tweak: rpcKey.TapTweak,
-		}
+	scriptKey.Type, err = UnmarshalScriptKeyType(rpcKey.Type)
+	if err != nil {
+		return nil, err
 	}
 
 	return &scriptKey, nil
@@ -125,11 +129,63 @@ func MarshalScriptKey(scriptKey asset.ScriptKey) *ScriptKey {
 			scriptKey.TweakedScriptKey.RawKey,
 		)
 		rpcScriptKey.TapTweak = scriptKey.TweakedScriptKey.Tweak
+		rpcScriptKey.Type = MarshalScriptKeyType(scriptKey.Type)
 	}
 
 	return rpcScriptKey
 }
 
+// UnmarshalScriptKeyType parses the script key type from the RPC variant.
+func UnmarshalScriptKeyType(rpcType ScriptKeyType) (asset.ScriptKeyType,
+	error) {
+
+	switch rpcType {
+	case ScriptKeyType_SCRIPT_KEY_UNKNOWN:
+		return asset.ScriptKeyUnknown, nil
+
+	case ScriptKeyType_SCRIPT_KEY_BIP86:
+		return asset.ScriptKeyBip86, nil
+
+	case ScriptKeyType_SCRIPT_KEY_SCRIPT_PATH_EXTERNAL:
+		return asset.ScriptKeyScriptPathExternal, nil
+
+	case ScriptKeyType_SCRIPT_KEY_BURN:
+		return asset.ScriptKeyBurn, nil
+
+	case ScriptKeyType_SCRIPT_KEY_TOMBSTONE:
+		return asset.ScriptKeyTombstone, nil
+
+	case ScriptKeyType_SCRIPT_KEY_CHANNEL:
+		return asset.ScriptKeyScriptPathChannel, nil
+
+	default:
+		return 0, fmt.Errorf("unknown script key type: %v", rpcType)
+	}
+}
+
+// MarshalScriptKeyType marshals the script key type from the RPC variant.
+func MarshalScriptKeyType(typ asset.ScriptKeyType) ScriptKeyType {
+	switch typ {
+	case asset.ScriptKeyBip86:
+		return ScriptKeyType_SCRIPT_KEY_BIP86
+
+	case asset.ScriptKeyScriptPathExternal:
+		return ScriptKeyType_SCRIPT_KEY_SCRIPT_PATH_EXTERNAL
+
+	case asset.ScriptKeyBurn:
+		return ScriptKeyType_SCRIPT_KEY_BURN
+
+	case asset.ScriptKeyTombstone:
+		return ScriptKeyType_SCRIPT_KEY_TOMBSTONE
+
+	case asset.ScriptKeyScriptPathChannel:
+		return ScriptKeyType_SCRIPT_KEY_CHANNEL
+
+	default:
+		return ScriptKeyType_SCRIPT_KEY_UNKNOWN
+	}
+}
+
 // UnmarshalAssetVersion parses an asset version from the RPC variant.
 func UnmarshalAssetVersion(version AssetVersion) (asset.Version, error) {
 	// For now, we'll only support two asset versions. The ones in the

taprpc/mintrpc/mint.swagger.json

@@ -899,9 +899,26 @@
           "type": "string",
           "format": "byte",
           "description": "The optional Taproot tweak to apply to the above internal key. If this is\nempty then a BIP-86 style tweak is applied to the internal key."
+        },
+        "type": {
+          "$ref": "#/definitions/taprpcScriptKeyType",
+          "description": "The type of the script key. This type is either user-declared when custom\nscript keys are added, or automatically determined by the daemon for\nstandard operations (e.g. BIP-86 keys, burn keys, tombstone keys, channel\nrelated keys)."
         }
       }
     },
+    "taprpcScriptKeyType": {
+      "type": "string",
+      "enum": [
+        "SCRIPT_KEY_UNKNOWN",
+        "SCRIPT_KEY_BIP86",
+        "SCRIPT_KEY_SCRIPT_PATH_EXTERNAL",
+        "SCRIPT_KEY_BURN",
+        "SCRIPT_KEY_TOMBSTONE",
+        "SCRIPT_KEY_CHANNEL"
+      ],
+      "default": "SCRIPT_KEY_UNKNOWN",
+      "description": " - SCRIPT_KEY_UNKNOWN: The type of script key is not known. This should only be stored for assets\nwhere we don't know the internal key of the script key (e.g. for\nimported proofs).\n - SCRIPT_KEY_BIP86: The script key is a normal BIP-86 key. This means that the internal key is\nturned into a Taproot output key by applying a BIP-86 tweak to it.\n - SCRIPT_KEY_SCRIPT_PATH_EXTERNAL: The script key is a key that contains a script path that is defined by the\nuser and is therefore external to the tapd wallet. Spending this key\nrequires providing a specific witness and must be signed through the vPSBT\nsigning flow.\n - SCRIPT_KEY_BURN: The script key is a specific un-spendable key that indicates a burnt asset.\nAssets with this key type can never be spent again, as a burn key is a\ntweaked NUMS key that nobody knows the private key for.\n - SCRIPT_KEY_TOMBSTONE: The script key is a specific un-spendable key that indicates a tombstone\noutput. This is only the case for zero-value assets that result from a\nnon-interactive (TAP address) send where no change was left over.\n - SCRIPT_KEY_CHANNEL: The script key is used for an asset that resides within a Taproot Asset\nChannel. That means the script key is either a funding key (OP_TRUE), a\ncommitment output key (to_local, to_remote, htlc), or a HTLC second-level\ntransaction output key. Keys related to channels are not shown in asset\nbalances (unless specifically requested) and are never used for coin\nselection."
+    },
     "taprpcTapBranch": {
       "type": "object",
       "properties": {