minting: fix re-issuing into existing group with external key

itest/mint_fund_seal_test.go

@@ -577,6 +577,9 @@ func testMintExternalGroupKeyChantools(t *harnessTest) {
 	mintReq2 := CopyRequest(issuableAssets[0])
 	mintReq2.Asset.Name = "itestbuxx-money-printer-brrr-tranche-2"
 	mintReq2.Asset.ExternalGroupKey = externalGroupKey
+	mintReq2.Asset.GroupedAsset = true
+	mintReq2.Asset.NewGroupedAsset = false
+	mintReq2.Asset.GroupKey = batchAssets[0].AssetGroup.TweakedGroupKey
 
 	assetReqs2 := []*mintrpc.MintAssetRequest{mintReq2}
 

rpcserver.go

@@ -443,19 +443,19 @@ func (r *rpcServer) MintAsset(ctx context.Context,
 	// Using a specific group key or anchor implies disabling emission.
 	case req.Asset.NewGroupedAsset:
 		if specificGroupKey || specificGroupAnchor {
-			return nil, fmt.Errorf("must disable emission to " +
-				"specify a group")
+			return nil, fmt.Errorf("must not create new grouped " +
+				"asset to specify an existing group")
 		}
 
 	// A group tapscript root cannot be specified if emission is disabled.
 	case !req.Asset.NewGroupedAsset && groupTapscriptRootSize != 0:
 		return nil, fmt.Errorf("cannot specify a group tapscript root" +
-			"with emission disabled")
+			"when not creating a new grouped asset")
 
 	// A group internal key cannot be specified if emission is disabled.
 	case !req.Asset.NewGroupedAsset && specificGroupInternalKey:
 		return nil, fmt.Errorf("cannot specify a group internal key" +
-			"with emission disabled")
+			"when not creating a new grouped asset")
 
 	// If the asset is intended to be part of an existing group, a group key
 	// or anchor must be specified, but not both. Neither a group tapscript
@@ -473,12 +473,14 @@ func (r *rpcServer) MintAsset(ctx context.Context,
 
 		if groupTapscriptRootSize != 0 {
 			return nil, fmt.Errorf("cannot specify a group " +
-				"tapscript root with emission disabled")
+				"tapscript root when not creating a new " +
+				"grouped asset")
 		}
 
 		if specificGroupInternalKey {
 			return nil, fmt.Errorf("cannot specify a group " +
-				"internal key with emission disabled")
+				"internal key when not creating a new " +
+				"grouped asset")
 		}
 
 	// A group was specified without GroupedAsset being set.
@@ -608,8 +610,9 @@ func (r *rpcServer) MintAsset(ctx context.Context,
 	}
 
 	rpcsLog.Infof("[MintAsset]: version=%v, type=%v, name=%v, amt=%v, "+
-		"enable_emission=%v", seedling.AssetVersion, seedling.AssetType,
-		seedling.AssetName, seedling.Amount, seedling.EnableEmission)
+		"new_grouped_asset=%v", seedling.AssetVersion,
+		seedling.AssetType, seedling.AssetName, seedling.Amount,
+		seedling.EnableEmission)
 
 	if scriptKey != nil {
 		seedling.ScriptKey = *scriptKey

tapgarden/planter.go

@@ -2668,14 +2668,19 @@ func (c *ChainPlanter) prepAssetSeedling(ctx context.Context,
 	// If a group internal key or tapscript root is specified, emission must
 	// also be enabled.
 	if !req.EnableEmission {
-		if req.GroupInternalKey != nil {
+		// For re-issuing grouped assets or regular (non-grouped)
+		// assets, the group internal key shouldn't be set. It is,
+		// however, set for re-issuance with an external key, because
+		// the internal group key is the key we compare the external key
+		// against.
+		if req.GroupInternalKey != nil && req.ExternalKey.IsNone() {
 			return fmt.Errorf("cannot specify group internal key " +
-				"without enabling emission")
+				"without creating a new grouped asset")
 		}
 
 		if req.GroupTapscriptRoot != nil {
 			return fmt.Errorf("cannot specify group tapscript " +
-				"root without enabling emission")
+				"root without creating a new grouped asset")
 		}
 	}
 

tapgarden/seedling.go

@@ -183,10 +183,49 @@ func (c Seedling) validateFields() error {
 func (c Seedling) validateGroupKey(group asset.AssetGroup,
 	anchorMeta *proof.MetaReveal) error {
 
-	// We must be able to sign with the group key.
-	if !group.GroupKey.IsLocal() {
-		groupKeyBytes := c.GroupInfo.GroupPubKey.SerializeCompressed()
-		return fmt.Errorf("can't sign with group key %x", groupKeyBytes)
+	switch {
+	// If we have an external key, we need to check that the group key
+	// matches the external key.
+	case c.ExternalKey.IsSome():
+		err := fn.MapOptionZ(
+			c.ExternalKey, func(extKey asset.ExternalKey) error {
+				if group.GroupKey == nil {
+					return fmt.Errorf("group key is nil")
+				}
+
+				if group.GroupKey.RawKey.PubKey == nil {
+					return fmt.Errorf("group raw key is " +
+						"nil")
+				}
+
+				pk, err := extKey.PubKey()
+				if err != nil {
+					return fmt.Errorf("error getting "+
+						"external key: %w", err)
+				}
+
+				if !pk.IsEqual(group.RawKey.PubKey) {
+					return fmt.Errorf("external key " +
+						"does not match group key")
+				}
+
+				return nil
+			},
+		)
+		if err != nil {
+			return fmt.Errorf("error validating external key: %w",
+				err)
+		}
+
+	// If it's not an external key, we need to check that we can actually
+	// sign with the group key.
+	default:
+		if !group.GroupKey.IsLocal() {
+			groupPubKey := c.GroupInfo.GroupPubKey
+			groupKeyBytes := groupPubKey.SerializeCompressed()
+			return fmt.Errorf("can't sign with group key %x",
+				groupKeyBytes)
+		}
 	}
 
 	// The seedling asset type must match the group asset type.