tapgarden: add delegation key filtering for mint supply commits

This commit enhances the BatchCaretaker to filter mint events based on
delegation key ownership. The sendSupplyCommitEvents method now uses
functional filtering to ensure supply commitment events are only sent
for assets where we control the delegation key.

Similar to the burn event filtering in tapfreighter, this change ensures
the caretaker respects delegation authority when creating supply proofs
for newly minted assets. The filtering happens early in the process to
avoid unnecessary proof construction and event submission for assets
we're not authorized to manage.

Author: Roasbeef

tapgarden/caretaker.go

@@ -1148,6 +1148,17 @@ func (b *BatchCaretaker) stateStep(currentState BatchState) (BatchState, error)
 			return 0, fmt.Errorf("unable to confirm batch: %w", err)
 		}
 
+		// Send supply commitment events for all minted assets before
+		// finalizing the batch. This ensures that supply commitments
+		// are tracked before the batch is considered complete.
+		err = b.sendSupplyCommitEvents(
+			ctx, anchorAssets, nonAnchorAssets, mintingProofs,
+		)
+		if err != nil {
+			return 0, fmt.Errorf("unable to send supply commit "+
+				"events: %w", err)
+		}
+
 		// Now that we've confirmed the batch, we'll hand over the
 		// proofs to the re-org watcher.
 		if err := b.cfg.ProofWatcher.WatchProofs(
@@ -1432,6 +1443,116 @@ func GenHeaderVerifier(ctx context.Context,
 	}
 }
 
+// sendSupplyCommitEvents sends supply commitment events for all minted assets
+// in the batch to track them in the supply commitment state machine.
+func (b *BatchCaretaker) sendSupplyCommitEvents(ctx context.Context,
+	anchorAssets, nonAnchorAssets []*asset.Asset,
+	mintingProofs proof.AssetProofs) error {
+
+	// If no supply commit manager is configured, skip this step.
+	if b.cfg.MintSupplyCommitter == nil {
+		return nil
+	}
+
+	// If no delegation key checker is configured, skip this step. As if we
+	// need this to figure out if we made the asset or not.
+	if b.cfg.DelegationKeyChecker == nil {
+		return nil
+	}
+
+	// We'll combine the anchor and non-anchor assets into a single slice
+	// that we'll run through below.
+	allAssets := append(anchorAssets, nonAnchorAssets...)
+
+	delChecker := b.cfg.DelegationKeyChecker
+
+	// We filter the assets to only include those that have a delegation
+	// key. As only those have a supply commitment maintained.
+	assetsWithDelegation := fn.Filter(allAssets, func(a *asset.Asset) bool {
+		hasDelegationKey, err := delChecker.HasDelegationKey(
+			ctx, a.ID(),
+		)
+		if err != nil {
+			log.Debugf("Error checking delegation key for "+
+				"asset %x: %v", a.ID(), err)
+			return false
+		}
+		if !hasDelegationKey {
+			log.Debugf("Skipping supply commit event for "+
+				"asset %x: delegation key not controlled "+
+				"locally",
+				a.ID())
+		}
+		return hasDelegationKey
+	})
+
+	// For each of the assets that we just created with a delegation key,
+	// we'll create then send a supply commit event so the committer can
+	// take care of it.
+	for _, mintedAsset := range assetsWithDelegation {
+		// First, we'll extract the minting proof based on the srcipt
+		// key, and extract the very last proof from that.
+		scriptKey := asset.ToSerialized(mintedAsset.ScriptKey.PubKey)
+		mintingProof, ok := mintingProofs[scriptKey]
+		if !ok {
+			return fmt.Errorf("missing minting proof for asset "+
+				"with script key %x", scriptKey[:])
+		}
+
+		proofBlob, err := proof.EncodeAsProofFile(mintingProof)
+		if err != nil {
+			return fmt.Errorf("unable to encode proof as "+
+				"file: %w", err)
+		}
+		proofFile, err := proof.DecodeFile(proofBlob)
+		if err != nil {
+			return fmt.Errorf("unable to decode proof "+
+				"file: %w", err)
+		}
+		leafProof, err := proofFile.LastProof()
+		if err != nil {
+			return fmt.Errorf("unable to get leaf proof: %w", err)
+		}
+
+		// With the proof extracted, we can now create the universe
+		// key and leaf.
+		universeKey := universe.BaseLeafKey{
+			OutPoint:  mintedAsset.Genesis.FirstPrevOut,
+			ScriptKey: &mintedAsset.ScriptKey,
+		}
+		uniqueLeafKey := universe.AssetLeafKey{
+			BaseLeafKey: universeKey,
+			AssetID:     mintedAsset.ID(),
+		}
+		universeLeaf := universe.Leaf{
+			GenesisWithGroup: universe.GenesisWithGroup{
+				Genesis:  mintedAsset.Genesis,
+				GroupKey: mintedAsset.GroupKey,
+			},
+			RawProof: proofBlob,
+			Asset:    &leafProof.Asset,
+			Amt:      mintedAsset.Amount,
+		}
+		assetSpec := asset.NewSpecifierOptionalGroupKey(
+			mintedAsset.ID(), mintedAsset.GroupKey,
+		)
+
+		// Finally we send all of the above to the supply commiter.
+		err = b.cfg.MintSupplyCommitter.SendMintEvent(
+			ctx, assetSpec, uniqueLeafKey, universeLeaf,
+		)
+		if err != nil {
+			return fmt.Errorf("unable to send mint event for "+
+				"asset %x: %w", mintedAsset.ID(), err)
+		}
+
+		log.Debugf("Sent supply commit mint event for asset %x",
+			mintedAsset.ID())
+	}
+
+	return nil
+}
+
 // assetGroupCacheSize is the size of the cache for group keys.
 const assetGroupCacheSize = 10000