tapdb: use group verifiers in tests

Author: jharveyb

tapdb/asset_minting_test.go

@@ -21,6 +21,7 @@ import (
 	"github.com/lightninglabs/taproot-assets/tapdb/sqlc"
 	"github.com/lightninglabs/taproot-assets/tapgarden"
 	"github.com/lightninglabs/taproot-assets/tapscript"
+	"github.com/lightninglabs/taproot-assets/vm"
 	"github.com/lightningnetwork/lnd/build"
 	"github.com/lightningnetwork/lnd/clock"
 	"github.com/lightningnetwork/lnd/keychain"
@@ -332,7 +333,7 @@ func seedlingsToAssetRoot(t *testing.T, genesisPoint wire.OutPoint,
 	groupKeys map[string]*btcec.PrivateKey) *commitment.TapCommitment {
 
 	orderedSeedlings := tapgarden.SortSeedlings(maps.Values(seedlings))
-	assetRoots := make([]*commitment.AssetCommitment, 0, len(seedlings))
+	newAssets := make([]*asset.Asset, 0, len(seedlings))
 	newGroupPrivs := make(map[string]*btcec.PrivateKey)
 	newGroupInfo := make(map[string]*asset.AssetGroup)
 
@@ -421,17 +422,18 @@ func seedlingsToAssetRoot(t *testing.T, genesisPoint wire.OutPoint,
 		)
 		require.NoError(t, err)
 
-		// Finally make a new asset commitment (the inner SMT tree) for
-		// this newly created asset.
-		assetRoot, err := commitment.NewAssetCommitment(
-			newAsset,
-		)
-		require.NoError(t, err)
+		if groupKey != nil {
+			engine, err := vm.New(newAsset, nil, nil)
+			require.NoError(t, err)
+
+			err = engine.Execute()
+			require.NoError(t, err)
+		}
 
-		assetRoots = append(assetRoots, assetRoot)
+		newAssets = append(newAssets, newAsset)
 	}
 
-	tapCommitment, err := commitment.NewTapCommitment(assetRoots...)
+	tapCommitment, err := commitment.FromAssets(newAssets...)
 	require.NoError(t, err)
 
 	return tapCommitment
@@ -1059,6 +1061,9 @@ func TestGroupAnchors(t *testing.T) {
 	ctx := context.Background()
 	const numSeedlings = 10
 	assetStore, _, _ := newAssetStore(t)
+	groupVerifier := tapgarden.GenGroupVerifier(ctx, assetStore)
+	groupAnchorVerifier := tapgarden.GenGroupAnchorVerifier(ctx, assetStore)
+	rawGroupAnchorVerifier := tapgarden.GenRawGroupAnchorVerifier(ctx)
 
 	// First, we'll write a new minting batch to disk, including an
 	// internal key and a set of seedlings. One random seedling will
@@ -1113,6 +1118,19 @@ func TestGroupAnchors(t *testing.T) {
 	)
 	seedlings[secondGrouped].GroupAnchor = &secondAnchor
 
+	// Record the number of seedlings set as group anchors and members.
+	// These counts should not change after sprouting.
+	batchSeedlings := maps.Values(mintingBatch.Seedlings)
+	isGroupAnchor := func(s *tapgarden.Seedling) bool {
+		return s.EnableEmission == true
+	}
+	isGroupMember := func(s *tapgarden.Seedling) bool {
+		return s.GroupAnchor != nil || s.GroupInfo != nil
+	}
+
+	anchorCount := fn.Count(batchSeedlings, isGroupAnchor)
+	memberCount := fn.Count(batchSeedlings, isGroupMember)
+
 	// Now we'll map these seedlings to an asset commitment and insert them
 	// into the DB as sprouts.
 	genesisPacket := randGenesisPacket(t)
@@ -1135,6 +1153,30 @@ func TestGroupAnchors(t *testing.T) {
 	assertBatchState(t, mintingBatches[0], tapgarden.BatchStateCommitted)
 	assertPsbtEqual(t, genesisPacket, mintingBatches[0].GenesisPacket)
 	assertAssetsEqual(t, assetRoot, mintingBatches[0].RootAssetCommitment)
+
+	// Check that the number of group anchors and members matches the batch
+	// state when frozen.
+	storedAssets := mintingBatches[0].RootAssetCommitment.CommittedAssets()
+	groupedAssets := fn.Filter(storedAssets, func(a *asset.Asset) bool {
+		return a.GroupKey != nil
+	})
+	require.Equal(t, anchorCount+memberCount, len(groupedAssets))
+	require.True(t, fn.All(groupedAssets, func(a *asset.Asset) bool {
+		return groupVerifier(&a.GroupKey.GroupPubKey) == nil
+	}))
+
+	// Both group anchor verifiers must return the same result.
+	groupAnchors := fn.Filter(groupedAssets, func(a *asset.Asset) bool {
+		return groupAnchorVerifier(&a.Genesis, a.GroupKey) == nil
+	})
+	require.Equal(t, anchorCount, len(groupAnchors))
+
+	rawGroupAnchors := fn.Filter(groupAnchors, func(a *asset.Asset) bool {
+		return rawGroupAnchorVerifier(&a.Genesis, a.GroupKey) == nil
+	})
+	require.Equal(t, anchorCount, len(rawGroupAnchors))
+	require.Equal(t, groupAnchors, rawGroupAnchors)
+
 }
 
 func init() {