WIP

Author: ffranr

tapdb/asset_minting_test.go

@@ -1920,6 +1920,33 @@ func TestUpsertMintAnchorUniCommitment(t *testing.T) {
 	)
 }
 
+// TestCommitMintingBatchSeedlings tests that we're able to properly write and
+// read a base minting batch on disk. This test covers the state when a batch
+// only has seedlings, without any fully formed assets.
+func TestBlah(t *testing.T) {
+	t.Parallel()
+
+	assetStore, _, _ := newAssetStore(t)
+
+	ctx := context.Background()
+	const numSeedlings = 5
+
+	// First, we'll write a new minting batch to disk, including an
+	// internal key and a set of seedlings. One random seedling will
+	// be a reissuance into a specific group.
+	mintingBatch := tapgarden.RandMintingBatch(
+		t, tapgarden.WithTotalSeedlings(1),
+		tapgarden.WithTotalGroups([]int{1}),
+		tapgarden.WithUniverseCommitments(true),
+	)
+	//_, randGroup, _ := addRandGroupToBatch(
+	//	t, assetStore, ctx, mintingBatch.Seedlings,
+	//)
+	//_, randSiblingHash := addRandSiblingToBatch(t, mintingBatch)
+	err := assetStore.CommitMintingBatch(ctx, mintingBatch)
+	require.NoError(t, err)
+}
+
 func init() {
 	rand.Seed(time.Now().Unix())
 

tapgarden/mock.go

@@ -21,6 +21,7 @@ import (
 	"github.com/btcsuite/btcwallet/waddrmgr"
 	"github.com/lightninglabs/lndclient"
 	"github.com/lightninglabs/taproot-assets/asset"
+	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/internal/test"
 	"github.com/lightninglabs/taproot-assets/proof"
 	"github.com/lightninglabs/taproot-assets/tapscript"
@@ -56,12 +57,110 @@ func RandSeedlings(t testing.TB, numSeedlings int) map[string]*Seedling {
 	return seedlings
 }
 
+// RandGroupSeedlings generates a random set of seedlings for a single asset
+// group.
+func RandGroupSeedlings(t testing.TB, numSeedlings int,
+	uniCommitments bool) map[string]*Seedling {
+
+	seedlings := make(map[string]*Seedling)
+
+	// Formulate group anchor seedling.
+	metaBlob := test.RandBytes(32)
+	groupAnchorName := hex.EncodeToString(test.RandBytes(32))
+	assetType := asset.Normal
+
+	// For now, we only test the v0 and v1 versions.
+	assetVersion := asset.Version(test.RandIntn(2))
+
+	scriptKey, _ := test.RandKeyDesc(t)
+
+	// If universe commitments are enabled, we generate a random key
+	// descriptor to use as the delegation key.
+	var delegationKey fn.Option[keychain.KeyDescriptor]
+	if uniCommitments {
+		keyDesc, _ := test.RandKeyDesc(t)
+		delegationKey = fn.Some(keyDesc)
+	}
+
+	assetGenesis := asset.RandGenesis(t, assetType)
+
+	// Create asset group key.
+	groupPrivateDesc, groupPrivateKey := test.RandKeyDesc(t)
+
+	// Generate the signature for our group genesis asset.
+	genSigner := asset.NewMockGenesisSigner(groupPrivateKey)
+	genTxBuilder := asset.MockGroupTxBuilder{}
+
+	genProtoAsset := asset.RandAssetWithValues(
+		t, assetGenesis, nil, asset.RandScriptKey(t),
+	)
+	groupKeyRequest := asset.NewGroupKeyRequestNoErr(
+		t, groupPrivateDesc, fn.None[asset.ExternalKey](), assetGenesis,
+		genProtoAsset, nil, fn.None[chainhash.Hash](),
+	)
+	genTx, err := groupKeyRequest.BuildGroupVirtualTx(&genTxBuilder)
+	require.NoError(t, err)
+
+	groupKey, err := asset.DeriveGroupKey(
+		genSigner, *genTx, *groupKeyRequest, nil,
+	)
+	require.NoError(t, err)
+
+	seedlings[groupAnchorName] = &Seedling{
+		AssetVersion: assetVersion,
+		AssetType:    assetType,
+		AssetName:    groupAnchorName,
+		Meta: &proof.MetaReveal{
+			Data: metaBlob,
+		},
+		Amount: uint64(test.RandInt[uint32]()),
+		GroupInfo: &asset.AssetGroup{
+			Genesis:  &assetGenesis,
+			GroupKey: groupKey,
+		},
+		ScriptKey:           asset.NewScriptKeyBip86(scriptKey),
+		EnableEmission:      true,
+		UniverseCommitments: uniCommitments,
+		DelegationKey:       delegationKey,
+	}
+
+	// Formulate non-anchor group seedlings.
+	for i := 0; i < numSeedlings-1; i++ {
+		seedlingName := hex.EncodeToString(test.RandBytes(32))
+
+		seedlings[groupAnchorName] = &Seedling{
+			AssetVersion: assetVersion,
+			AssetType:    assetType,
+			AssetName:    seedlingName,
+			GroupAnchor:  &groupAnchorName,
+			Meta: &proof.MetaReveal{
+				Data: metaBlob,
+			},
+			Amount:              uint64(test.RandInt[uint32]()),
+			ScriptKey:           asset.NewScriptKeyBip86(scriptKey),
+			EnableEmission:      true,
+			UniverseCommitments: uniCommitments,
+		}
+	}
+
+	return seedlings
+}
+
 // MintBatchOptions is a set of options for creating a new minting batch.
 type MintBatchOptions struct {
 	// totalSeedlings specifies the number of seedlings to generate in this
 	// minting batch. The seedlings are randomly assigned as grouped or
 	// ungrouped.
 	totalSeedlings int
+
+	// totalGroups specifies the number of asset groups to generate in this
+	// minting batch. Each element in the slice specifies the number of
+	// seedlings to generate for the corresponding asset group.
+	totalGroups []int
+
+	// universeCommitments specifies whether to generate universe
+	// commitments for the asset groups in this minting batch.
+	universeCommitments bool
 }
 
 // MintBatchOption is a functional option for creating a new minting batch.
@@ -80,6 +179,23 @@ func WithTotalSeedlings(count int) MintBatchOption {
 	}
 }
 
+// WithTotalGroups sets the total number of asset groups to populate in the
+// minting batch. Each element in the slice specifies the number of seedlings
+// to generate for the corresponding asset group.
+func WithTotalGroups(counts []int) MintBatchOption {
+	return func(options *MintBatchOptions) {
+		options.totalGroups = counts
+	}
+}
+
+// WithUniverseCommitments specifies whether to generate universe commitments
+// for the asset groups in the minting batch.
+func WithUniverseCommitments(enabled bool) MintBatchOption {
+	return func(options *MintBatchOptions) {
+		options.universeCommitments = enabled
+	}
+}
+
 // RandMintingBatch creates a new minting batch with only random seedlings
 // populated for testing.
 func RandMintingBatch(t testing.TB, opts ...MintBatchOption) *MintingBatch {
@@ -89,12 +205,49 @@ func RandMintingBatch(t testing.TB, opts ...MintBatchOption) *MintingBatch {
 		opt(&options)
 	}
 
+	// Formulate batch seedlings.
+	seedlings := make(map[string]*Seedling)
+
+	// Generate seedlings for each asset group.
+	for idx := range options.totalGroups {
+		countSeedlingsInGroup := options.totalGroups[idx]
+
+		groupSeedlings := RandGroupSeedlings(
+			t, countSeedlingsInGroup, options.universeCommitments,
+		)
+
+		// Add the seedlings to the total seedlings map.
+		for name, seedling := range groupSeedlings {
+			seedlings[name] = seedling
+		}
+	}
+
+	// If the total number of seedlings generated so far is less than the
+	// total number of seedlings requested, we generate the remaining
+	// seedlings at random.
+	if len(seedlings) < options.totalSeedlings {
+		remaining := options.totalSeedlings - len(seedlings)
+		randSeedlings := RandSeedlings(t, remaining)
+
+		// Add the seedlings to the total seedlings map.
+		for name, seedling := range randSeedlings {
+			seedlings[name] = seedling
+		}
+	}
+
+	// Randomly generating seedlings may result in overlaps with existing
+	// ones, leading to fewer seedlings than intended. Sanity check to
+	// ensure that the total number of seedlings generated matches the
+	// requested amount. This check might help debug flakes in tests.
+	require.Equal(t, options.totalSeedlings, len(seedlings))
+
 	batchKey, _ := test.RandKeyDesc(t)
 	batch := MintingBatch{
-		BatchKey:     batchKey,
-		Seedlings:    RandSeedlings(t, options.totalSeedlings),
-		HeightHint:   test.RandInt[uint32](),
-		CreationTime: time.Now(),
+		BatchKey:            batchKey,
+		Seedlings:           seedlings,
+		HeightHint:          test.RandInt[uint32](),
+		CreationTime:        time.Now(),
+		UniverseCommitments: options.universeCommitments,
 	}
 
 	walletFundPsbt := func(ctx context.Context,