Merge pull request #1638 from lightninglabs/wip/supplycommit/seedling-db-delegation-key

tapdb: support delegation key and universe commitment flag in seedlings

Author: Roasbeef

tapdb/asset_minting.go

@@ -330,6 +330,45 @@ type OptionalSeedlingFields struct {
 	GroupAnchorID      sql.NullInt64
 }
 
+// upsertDelegationKey inserts the given delegation key descriptor into
+// the internal_keys SQL table and returns its ID.
+func upsertDelegationKey(ctx context.Context, q PendingAssetStore,
+	keyDescOpt fn.Option[keychain.KeyDescriptor]) (sql.NullInt64, error) {
+
+	var zero sql.NullInt64
+
+	// If the delegation key is not set, we can return a zero value.
+	if keyDescOpt.IsNone() {
+		return zero, nil
+	}
+
+	// Unwrap the key descriptor to get the actual key.
+	keyDesc, err := keyDescOpt.UnwrapOrErr(
+		fmt.Errorf("delegation key is unexpectedly not set"),
+	)
+	if err != nil {
+		return zero, err
+	}
+
+	// Sanity check the key descriptor.
+	if keyDesc.PubKey == nil {
+		return zero, fmt.Errorf("delegation key pubkey is nil")
+	}
+
+	// Insert the key descriptor into the internal_keys table.
+	keyID, err := q.UpsertInternalKey(ctx, InternalKey{
+		RawKey:    keyDesc.PubKey.SerializeCompressed(),
+		KeyFamily: int32(keyDesc.Family),
+		KeyIndex:  int32(keyDesc.Index),
+	})
+	if err != nil {
+		return zero, fmt.Errorf("unable to insert internal key: %w",
+			err)
+	}
+
+	return sqlInt64(keyID), nil
+}
+
 // insertMintAnchorTx inserts a mint anchor transaction into the database.
 func insertMintAnchorTx(ctx context.Context, q PendingAssetStore,
 	anchorPackage tapgarden.FundedMintAnchorPsbt,
@@ -442,9 +481,10 @@ func (a *AssetMintingStore) CommitMintingBatch(ctx context.Context,
 		// With our internal key inserted, we can now insert a new
 		// batch which references the target internal key.
 		if err := q.NewMintingBatch(ctx, MintingBatchInit{
-			BatchID:          batchID,
-			HeightHint:       int32(newBatch.HeightHint),
-			CreationTimeUnix: newBatch.CreationTime.UTC(),
+			BatchID:             batchID,
+			HeightHint:          int32(newBatch.HeightHint),
+			CreationTimeUnix:    newBatch.CreationTime.UTC(),
+			UniverseCommitments: newBatch.UniverseCommitments,
 		}); err != nil {
 			return fmt.Errorf("unable to insert minting "+
 				"batch: %w", err)
@@ -510,6 +550,9 @@ func (a *AssetMintingStore) CommitMintingBatch(ctx context.Context,
 				AssetSupply:     int64(seedling.Amount),
 				AssetMetaID:     assetMetaID,
 				EmissionEnabled: seedling.EnableEmission,
+
+				// nolint: lll
+				UniverseCommitments: seedling.UniverseCommitments,
 			}
 
 			scriptKeyID, err := upsertScriptKey(
@@ -544,6 +587,17 @@ func (a *AssetMintingStore) CommitMintingBatch(ctx context.Context,
 			dbSeedling.GroupGenesisID = optionalDbIDs.GroupGenesisID
 			dbSeedling.GroupAnchorID = optionalDbIDs.GroupAnchorID
 
+			// Upsert the seedling's delegation key if present.
+			delegationKeyID, err := upsertDelegationKey(
+				ctx, q, seedling.DelegationKey,
+			)
+			if err != nil {
+				return fmt.Errorf("unable to insert "+
+					"delegation key: %w", err)
+			}
+
+			dbSeedling.DelegationKeyID = delegationKeyID
+
 			err = q.InsertAssetSeedling(ctx, dbSeedling)
 			if err != nil {
 				return err
@@ -641,6 +695,9 @@ func (a *AssetMintingStore) AddSeedlingsToBatch(ctx context.Context,
 				AssetSupply:     int64(seedling.Amount),
 				AssetMetaID:     assetMetaID,
 				EmissionEnabled: seedling.EnableEmission,
+
+				// nolint: lll
+				UniverseCommitments: seedling.UniverseCommitments,
 			}
 
 			scriptKeyID, err := upsertScriptKey(
@@ -675,6 +732,18 @@ func (a *AssetMintingStore) AddSeedlingsToBatch(ctx context.Context,
 			dbSeedling.GroupGenesisID = optionalDbIDs.GroupGenesisID
 			dbSeedling.GroupAnchorID = optionalDbIDs.GroupAnchorID
 
+			// Handle delegation key: upsert to internal_keys and
+			// reference in seedling.
+			delegationKeyID, err := upsertDelegationKey(
+				ctx, q, seedling.DelegationKey,
+			)
+			if err != nil {
+				return fmt.Errorf("unable to insert "+
+					"delegation key: %w", err)
+			}
+
+			dbSeedling.DelegationKeyID = delegationKeyID
+
 			err = q.InsertAssetSeedlingIntoBatch(ctx, dbSeedling)
 			if err != nil {
 				return fmt.Errorf("unable to insert "+
@@ -724,7 +793,8 @@ func fetchAssetSeedlings(ctx context.Context, q PendingAssetStore,
 			Amount: uint64(
 				dbSeedling.AssetSupply,
 			),
-			EnableEmission: dbSeedling.EmissionEnabled,
+			EnableEmission:      dbSeedling.EmissionEnabled,
+			UniverseCommitments: dbSeedling.UniverseCommitments,
 		}
 
 		if dbSeedling.TweakedScriptKey != nil {
@@ -792,6 +862,31 @@ func fetchAssetSeedlings(ctx context.Context, q PendingAssetStore,
 			}
 		}
 
+		// If the seedling has a delegation key, we'll parse it and
+		// store it in the seedling.
+		if dbSeedling.DelegationKeyRaw != nil {
+			delegationKeyPub, err := btcec.ParsePubKey(
+				dbSeedling.DelegationKeyRaw,
+			)
+			if err != nil {
+				return nil, err
+			}
+
+			locator := keychain.KeyLocator{
+				Index: extractSqlInt32[uint32](
+					dbSeedling.DelegationKeyIndex,
+				),
+				Family: extractSqlInt32[keychain.KeyFamily](
+					dbSeedling.DelegationKeyFam,
+				),
+			}
+
+			seedling.DelegationKey = fn.Some(keychain.KeyDescriptor{
+				KeyLocator: locator,
+				PubKey:     delegationKeyPub,
+			})
+		}
+
 		if len(dbSeedling.GroupTapscriptRoot) != 0 {
 			seedling.GroupTapscriptRoot = dbSeedling.
 				GroupTapscriptRoot
@@ -1203,8 +1298,9 @@ func marshalMintingBatch(ctx context.Context, q PendingAssetStore,
 			},
 			PubKey: batchKey,
 		},
-		HeightHint:   uint32(dbBatch.HeightHint),
-		CreationTime: dbBatch.CreationTimeUnix.UTC(),
+		HeightHint:          uint32(dbBatch.HeightHint),
+		CreationTime:        dbBatch.CreationTimeUnix.UTC(),
+		UniverseCommitments: dbBatch.UniverseCommitments,
 	}
 
 	batchState, err := tapgarden.NewBatchState(uint8(dbBatch.BatchState))
@@ -1336,12 +1432,9 @@ func marshalMintingBatch(ctx context.Context, q PendingAssetStore,
 				"genesis packet")
 		}
 
-		anchorOutputIndex := uint32(0)
-		if batch.GenesisPacket.ChangeOutputIndex == 0 {
-			anchorOutputIndex = 1
-		}
+		assetAnchorOutIdx := batch.GenesisPacket.AssetAnchorOutIdx
 		genesisTx := batch.GenesisPacket.Pkt.UnsignedTx
-		genesisScript := genesisTx.TxOut[anchorOutputIndex].PkScript
+		genesisScript := genesisTx.TxOut[assetAnchorOutIdx].PkScript
 		tapscriptSibling := batch.TapSibling()
 		batch.RootAssetCommitment, err = fetchAssetSprouts(
 			ctx, q, dbBatch.RawKey, tapscriptSibling, genesisScript,

tapdb/asset_minting_test.go

@@ -93,6 +93,7 @@ func assertBatchEqual(t *testing.T, a, b *tapgarden.MintingBatch) {
 		t, &a.GenesisPacket.FundedPsbt, &b.GenesisPacket.FundedPsbt,
 	)
 	require.Equal(t, a.RootAssetCommitment, b.RootAssetCommitment)
+	require.Equal(t, a.UniverseCommitments, b.UniverseCommitments)
 }
 
 func assertSeedlingBatchLen(t *testing.T, batches []*tapgarden.MintingBatch,
@@ -608,6 +609,62 @@ func TestCommitMintingBatchSeedlings(t *testing.T) {
 	assertSeedlingBatchLen(t, mintingBatches, 1, numSeedlings)
 }
 
+// TestInsertFetchUniCommitBatch tests that we're able to properly write
+// and read a minting batch that has universe commitments enabled.
+func TestInsertFetchUniCommitBatch(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	assetStore, _, _ := newAssetStore(t)
+
+	// Generate a batch with a single seedling, we will set the group
+	// information later.
+	batch := tapgarden.RandMintingBatch(
+		t, tapgarden.WithTotalGroups([]int{1}),
+		tapgarden.WithUniverseCommitments(true),
+	)
+	require.True(t, batch.UniverseCommitments)
+
+	// Generate the group genesis, persist it, and assign the group details
+	// to the seedling.
+	assetName := maps.Keys(batch.Seedlings)[0]
+	assetType := batch.Seedlings[assetName].AssetType
+
+	privDesc, groupPriv := test.RandKeyDesc(t)
+	randGenesis := asset.RandGenesis(t, assetType)
+	_, _, group := storeGroupGenesis(
+		t, ctx, randGenesis, nil, assetStore, privDesc, groupPriv,
+	)
+
+	batch.Seedlings[assetName].GroupInfo = group
+
+	// Assert that the seedling is in the expected state.
+	seedling := batch.Seedlings[assetName]
+	require.True(t, seedling.UniverseCommitments)
+	require.True(t, seedling.DelegationKey.IsSome())
+
+	// Commit the minting batch to the database.
+	err := assetStore.CommitMintingBatch(ctx, batch)
+	require.NoError(t, err)
+
+	// Fetch the same batch from the database.
+	dbBatch, err := assetStore.FetchMintingBatch(
+		ctx, batch.BatchKey.PubKey,
+	)
+	require.NoError(t, err)
+
+	// Assert that the batch is in the expected state.
+	require.True(t, dbBatch.UniverseCommitments)
+
+	// Assert that the seedling is in the expected state.
+	require.Len(t, dbBatch.Seedlings, 1)
+
+	dbSeedling := dbBatch.Seedlings[assetName]
+	require.True(t, dbSeedling.UniverseCommitments)
+	require.True(t, dbSeedling.DelegationKey.IsSome())
+	require.Equal(t, dbSeedling.DelegationKey, seedling.DelegationKey)
+}
+
 // seedlingsToAssetRoot maps a set of seedlings to an asset root.
 //
 // TODO(roasbeef): same func in tapgarden can just re-use?

tapdb/migrations.go

@@ -24,7 +24,7 @@ const (
 	// daemon.
 	//
 	// NOTE: This MUST be updated when a new migration is added.
-	LatestMigrationVersion = 40
+	LatestMigrationVersion = 41
 )
 
 // DatabaseBackend is an interface that contains all methods our different