mintrpc+tapgarden: add universe announcement flag to asset minting

rpcserver.go

@@ -408,18 +408,15 @@ func (r *rpcServer) GetInfo(ctx context.Context,
 	}, nil
 }
 
-// MintAsset attempts to mint the set of assets (async by default to ensure
-// proper batching) specified in the request.
-func (r *rpcServer) MintAsset(ctx context.Context,
-	req *mintrpc.MintAssetRequest) (*mintrpc.MintAssetResponse, error) {
-
+// validateMintAssetRequest validates the given mint asset request.
+func validateMintAssetRequest(req *mintrpc.MintAssetRequest) error {
 	if req.Asset == nil {
-		return nil, fmt.Errorf("asset cannot be nil")
+		return fmt.Errorf("asset cannot be nil")
 	}
 
 	err := asset.ValidateAssetName(req.Asset.Name)
 	if err != nil {
-		return nil, fmt.Errorf("invalid asset name: %w", err)
+		return fmt.Errorf("invalid asset name: %w", err)
 	}
 
 	specificGroupKey := len(req.Asset.GroupKey) != 0
@@ -431,64 +428,98 @@ func (r *rpcServer) MintAsset(ctx context.Context,
 	if groupTapscriptRootSize != 0 &&
 		groupTapscriptRootSize != sha256.Size {
 
-		return nil, fmt.Errorf("group tapscript root must be %d bytes",
+		return fmt.Errorf("group tapscript root must be %d bytes",
 			sha256.Size)
 	}
 
 	switch {
 	// New grouped asset and grouped asset cannot both be set.
 	case req.Asset.NewGroupedAsset && req.Asset.GroupedAsset:
-		return nil, fmt.Errorf("cannot set both new grouped asset " +
+		return fmt.Errorf("cannot set both new grouped asset " +
 			"and grouped asset",
 		)
 
 	// 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 " +
+			return fmt.Errorf("must disable emission to " +
 				"specify a 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" +
+		return fmt.Errorf("cannot specify a group tapscript root" +
 			"with emission disabled")
 
 	// 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" +
+		return fmt.Errorf("cannot specify a group internal key" +
 			"with emission disabled")
 
 	// 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
 	// root nor group internal key can be specified.
 	case req.Asset.GroupedAsset:
 		if !specificGroupKey && !specificGroupAnchor {
-			return nil, fmt.Errorf("must specify a group key or" +
+			return fmt.Errorf("must specify a group key or" +
 				"group anchor")
 		}
 
 		if specificGroupKey && specificGroupAnchor {
-			return nil, fmt.Errorf("cannot specify both a group " +
+			return fmt.Errorf("cannot specify both a group " +
 				"key and a group anchor")
 		}
 
 		if groupTapscriptRootSize != 0 {
-			return nil, fmt.Errorf("cannot specify a group " +
+			return fmt.Errorf("cannot specify a group " +
 				"tapscript root with emission disabled")
 		}
 
 		if specificGroupInternalKey {
-			return nil, fmt.Errorf("cannot specify a group " +
+			return fmt.Errorf("cannot specify a group " +
 				"internal key with emission disabled")
 		}
 
 	// A group was specified without GroupedAsset being set.
 	case specificGroupKey || specificGroupAnchor:
-		return nil, fmt.Errorf("must set grouped asset to mint into " +
+		return fmt.Errorf("must set grouped asset to mint into " +
 			"a specific group")
 	}
 
+	// If a custom decimal display is set, the meta type must also be set to
+	// JSON.
+	if req.Asset.DecimalDisplay != 0 && req.Asset.AssetMeta == nil {
+		return fmt.Errorf("decimal display requires JSON asset " +
+			"metadata")
+	}
+
+	// Ensure that the universe announcement flag is used correctly.
+	if req.EnableUniAnnounce {
+		// If universe announcement is enabled, the asset must be a new
+		// grouped asset.
+		if !(specificGroupKey || specificGroupAnchor) {
+			return fmt.Errorf("universe announcement feature is "+
+				"only applicable for grouped assets ("+
+				"specific_group_key=%v,"+
+				"specific_group_anchor=%v)",
+				specificGroupKey, specificGroupAnchor)
+		}
+	}
+
+	return nil
+}
+
+// MintAsset attempts to mint the set of assets (async by default to ensure
+// proper batching) specified in the request.
+func (r *rpcServer) MintAsset(ctx context.Context,
+	req *mintrpc.MintAssetRequest) (*mintrpc.MintAssetResponse, error) {
+
+	// Validate the request.
+	err := validateMintAssetRequest(req)
+	if err != nil {
+		return nil, err
+	}
+
 	assetVersion, err := taprpc.UnmarshalAssetVersion(
 		req.Asset.AssetVersion,
 	)
@@ -497,14 +528,6 @@ func (r *rpcServer) MintAsset(ctx context.Context,
 	}
 
 	var seedlingMeta *proof.MetaReveal
-
-	// If a custom decimal display is set, the meta type must also be set to
-	// JSON.
-	if req.Asset.DecimalDisplay != 0 && req.Asset.AssetMeta == nil {
-		return nil, fmt.Errorf("decimal display requires JSON asset " +
-			"metadata")
-	}
-
 	if req.Asset.AssetMeta != nil {
 		// Ensure that the meta type is valid.
 		metaType, err := proof.IsValidMetaType(req.Asset.AssetMeta.Type)
@@ -574,7 +597,7 @@ func (r *rpcServer) MintAsset(ctx context.Context,
 		}
 	}
 
-	if specificGroupInternalKey {
+	if req.Asset.GroupInternalKey != nil {
 		groupInternalKey, err = taprpc.UnmarshalKeyDescriptor(
 			req.Asset.GroupInternalKey,
 		)
@@ -583,28 +606,31 @@ func (r *rpcServer) MintAsset(ctx context.Context,
 		}
 	}
 
+	groupTapscriptRootSize := len(req.Asset.GroupTapscriptRoot)
+
 	if groupTapscriptRootSize != 0 {
 		groupTapscriptRoot = bytes.Clone(req.Asset.GroupTapscriptRoot)
 	}
 
 	seedling := &tapgarden.Seedling{
-		AssetVersion:   assetVersion,
-		AssetType:      asset.Type(req.Asset.AssetType),
-		AssetName:      req.Asset.Name,
-		Amount:         req.Asset.Amount,
-		EnableEmission: req.Asset.NewGroupedAsset,
-		Meta:           seedlingMeta,
+		AssetVersion:      assetVersion,
+		AssetType:         asset.Type(req.Asset.AssetType),
+		AssetName:         req.Asset.Name,
+		Amount:            req.Asset.Amount,
+		EnableEmission:    req.Asset.NewGroupedAsset,
+		EnableUniAnnounce: req.EnableUniAnnounce,
+		Meta:              seedlingMeta,
 	}
 
 	rpcsLog.Infof("[MintAsset]: version=%v, type=%v, name=%v, amt=%v, "+
-		"issuance=%v", seedling.AssetVersion, seedling.AssetType,
+		"enable_emission=%v", seedling.AssetVersion, seedling.AssetType,
 		seedling.AssetName, seedling.Amount, seedling.EnableEmission)
 
 	if scriptKey != nil {
 		seedling.ScriptKey = *scriptKey
 	}
 
-	if specificGroupInternalKey {
+	if req.Asset.GroupInternalKey != nil {
 		seedling.GroupInternalKey = &groupInternalKey
 	}
 
@@ -615,7 +641,7 @@ func (r *rpcServer) MintAsset(ctx context.Context,
 	switch {
 	// If a group key is provided, parse the provided group public key
 	// before creating the asset seedling.
-	case specificGroupKey:
+	case len(req.Asset.GroupKey) != 0:
 		groupTweakedKey, err := btcec.ParsePubKey(req.Asset.GroupKey)
 		if err != nil {
 			return nil, fmt.Errorf("invalid group key: %w", err)
@@ -634,9 +660,9 @@ func (r *rpcServer) MintAsset(ctx context.Context,
 			},
 		}
 
-	// If a group anchor is provided, propoate the name to the seedling.
+	// If a group anchor is provided, propagate the name to the seedling.
 	// We cannot do any name validation from outside the minter.
-	case specificGroupAnchor:
+	case len(req.Asset.GroupAnchor) != 0:
 		seedling.GroupAnchor = &req.Asset.GroupAnchor
 	}
 

tapgarden/batch.go

@@ -64,6 +64,12 @@ type MintingBatch struct {
 	// reveal for that asset, if it has one.
 	AssetMetas AssetMetas
 
+	// EnableUniAnnounce is a flag that indicates whether the minting
+	// event should support universe announcements. If set to true,
+	// the batch must include only assets that share the same asset group
+	// key, which must also be set.
+	EnableUniAnnounce bool
+
 	// mintingPubKey is the top-level Taproot output key that will be used
 	// to commit to the Taproot Asset commitment above.
 	mintingPubKey *btcec.PublicKey
@@ -309,6 +315,35 @@ func (m *MintingBatch) HasSeedlings() bool {
 	return len(m.Seedlings) != 0
 }
 
+// ValidateSeedling checks if a seedling is valid for the batch.
+func (m *MintingBatch) ValidateSeedling(newSeedling Seedling) error {
+	// Ensure that the seedling and batch agree on the enabled universe
+	// announcements.
+	if m.EnableUniAnnounce != newSeedling.EnableUniAnnounce {
+		return fmt.Errorf("batch and seedling do not agree on " +
+			"enabled universe announcements")
+	}
+
+	// If the seedling supports universe announcements, it must have a group
+	// anchor or the same group key as all the other seedlings in the batch.
+	if newSeedling.EnableUniAnnounce {
+		if newSeedling.GroupAnchor == nil &&
+			newSeedling.GroupInfo == nil {
+
+			return fmt.Errorf("universe announcement enabled for " +
+				"seedling but group info/anchor is absent")
+		}
+
+		if newSeedling.GroupInfo != nil {
+			// TODO(ffranr): Add check to ensure that this new
+			//  seedling has the same group key as the other
+			//  seedlings in the batch.
+		}
+	}
+
+	return nil
+}
+
 // ToMintingBatch creates a new MintingBatch from a VerboseBatch.
 func (v *VerboseBatch) ToMintingBatch() *MintingBatch {
 	newBatch := v.MintingBatch.Copy()

tapgarden/planter.go

@@ -1179,6 +1179,10 @@ func (c *ChainPlanter) gardener() {
 			// After some basic validation, prepare the asset
 			// seedling (soon to be a sprout) by committing it to
 			// disk as part of the latest batch.
+			//
+			// This method will also include the seedling in any
+			// existing pending batch or create a new pending batch
+			// if necessary.
 			ctx, cancel := c.WithCtxQuit()
 			err := c.prepAssetSeedling(ctx, req)
 			cancel()
@@ -1755,8 +1759,8 @@ func (c *ChainPlanter) finalizeBatch(params FinalizeParams) (*BatchCaretaker,
 	return caretaker, nil
 }
 
-// PendingBatch returns the current pending batch. If there's no pending batch,
-// then an error is returned.
+// PendingBatch returns the current pending batch, or nil if no batch is
+// pending.
 func (c *ChainPlanter) PendingBatch() (*MintingBatch, error) {
 	req := newStateReq[*MintingBatch](reqTypePendingBatch)
 
@@ -1842,8 +1846,7 @@ func (c *ChainPlanter) CancelBatch() (*btcec.PublicKey, error) {
 }
 
 // prepAssetSeedling performs some basic validation for the Seedling, then
-// either adds it to an existing pending batch or creates a new batch for it. A
-// bool indicating if a new batch should immediately be created is returned.
+// either adds it to an existing pending batch or creates a new batch for it.
 func (c *ChainPlanter) prepAssetSeedling(ctx context.Context,
 	req *Seedling) error {
 
@@ -1964,6 +1967,10 @@ func (c *ChainPlanter) prepAssetSeedling(ctx context.Context,
 
 		newBatch.Seedlings[req.AssetName] = req
 
+		// The batch enable universe announcement flag inherits from the
+		// first seedling added to the batch.
+		newBatch.EnableUniAnnounce = req.EnableUniAnnounce
+
 		ctx, cancel := c.WithCtxQuit()
 		defer cancel()
 		err = c.cfg.Log.CommitMintingBatch(ctx, newBatch)
@@ -1978,12 +1985,26 @@ func (c *ChainPlanter) prepAssetSeedling(ctx context.Context,
 	case c.pendingBatch != nil:
 		log.Infof("Adding %v to existing MintingBatch", req)
 
+		// The batch already exist and may contain seedlings. Before
+		// adding the seedling to the batch, we'll ensure that the
+		// batch will still be valid after adding the seedling.
+		err := c.pendingBatch.ValidateSeedling(*req)
+		if err != nil {
+			return fmt.Errorf("seedling can not be added to "+
+				"pending batch: %w", err)
+		}
+
 		c.pendingBatch.Seedlings[req.AssetName] = req
 
+		// The batch may already exist, but it may not have any
+		// seedlings. If this is the first seedling, we'll inherit the
+		// universe announcement flag from it.
+		c.pendingBatch.EnableUniAnnounce = req.EnableUniAnnounce
+
 		// Now that we know the seedling is ok, we'll write it to disk.
 		ctx, cancel := c.WithCtxQuit()
 		defer cancel()
-		err := c.cfg.Log.AddSeedlingsToBatch(
+		err = c.cfg.Log.AddSeedlingsToBatch(
 			ctx, c.pendingBatch.BatchKey.PubKey, req,
 		)
 		if err != nil {

tapgarden/planter_test.go

@@ -1654,6 +1654,12 @@ func testFundSealBeforeFinalize(t *mintingTestHarness) {
 	// harness.
 	t.refreshChainPlanter()
 
+	// A pending batch should not exist yet. Therefore, `PendingBatch`
+	// should return nil and no error.
+	batch, err := t.planter.PendingBatch()
+	require.Nil(t, batch)
+	require.NoError(t, err)
+
 	var (
 		wg               sync.WaitGroup
 		respChan         = make(chan *FundBatchResp, 1)

tapgarden/seedling.go

@@ -91,6 +91,13 @@ type Seedling struct {
 	// for this asset meaning future assets linked to it can be created.
 	EnableEmission bool
 
+	// EnableUniAnnounce indicates whether the minting event which
+	// will be associated with the seedling supports universe announcements.
+	// If set to true, the seedling can only be included in a minting batch
+	// where all assets share the same asset group key, which must be
+	// specified.
+	EnableUniAnnounce bool
+
 	// GroupAnchor is the name of another seedling in the pending batch that
 	// will anchor an asset group. This seedling will be minted with the
 	// same group key as the anchor asset.