tapdb: refactor BindMintingBatchWithTx into insertMintAnchorTx

Refactor BindMintingBatchWithTx into insertMintAnchorTx, which
will also handle inserting pre-commitment information into the
database.

insertMintAnchorTx will also ensure that the genesis point is in the
database.

Author: ffranr

tapdb/asset_minting.go

@@ -127,6 +127,10 @@ type (
 	// NewAssetMeta wraps the params needed to insert a new asset meta on
 	// disk.
 	NewAssetMeta = sqlc.UpsertAssetMetaParams
+
+	// MintAnchorUniCommitParams wraps the params needed to insert a new
+	// mint anchor uni commitment on disk.
+	MintAnchorUniCommitParams = sqlc.UpsertMintAnchorUniCommitmentParams
 )
 
 // PendingAssetStore is a sub-set of the main sqlc.Querier interface that
@@ -244,6 +248,11 @@ type PendingAssetStore interface {
 	// for a given batch.
 	FetchMintAnchorUniCommitment(ctx context.Context,
 		batchID int32) (sqlc.MintAnchorUniCommitment, error)
+
+	// UpsertMintAnchorUniCommitment inserts a new or updates an existing
+	// mint anchor uni commitment on disk.
+	UpsertMintAnchorUniCommitment(ctx context.Context,
+		arg MintAnchorUniCommitParams) (int64, error)
 }
 
 var (
@@ -317,6 +326,77 @@ type OptionalSeedlingFields struct {
 	GroupAnchorID      sql.NullInt64
 }
 
+// insertMintAnchorTx inserts a mint anchor transaction into the database.
+func insertMintAnchorTx(ctx context.Context, q PendingAssetStore,
+	anchorPackage tapgarden.FundedMintAnchorPsbt,
+	batchKey btcec.PublicKey, genesisOutpoint wire.OutPoint) error {
+
+	// Ensure that the genesis point is in the database.
+	genesisPointDbID, err := upsertGenesisPoint(
+		ctx, q, genesisOutpoint,
+	)
+	if err != nil {
+		return fmt.Errorf("%w: %w", ErrUpsertGenesisPoint, err)
+	}
+
+	var psbtBuf bytes.Buffer
+	err = anchorPackage.Pkt.Serialize(&psbtBuf)
+	if err != nil {
+		return fmt.Errorf("%w: %w", ErrEncodePsbt, err)
+	}
+
+	rawBatchKey := batchKey.SerializeCompressed()
+	enableUniverseCommitments := anchorPackage.PreCommitmentOutput.IsSome()
+
+	batchID, err := q.BindMintingBatchWithTx(ctx, BatchChainUpdate{
+		RawKey:              rawBatchKey,
+		MintingTxPsbt:       psbtBuf.Bytes(),
+		ChangeOutputIndex:   sqlInt32(anchorPackage.ChangeOutputIndex),
+		AssetsOutputIndex:   sqlInt32(anchorPackage.AssetAnchorOutIdx),
+		GenesisID:           sqlInt64(genesisPointDbID),
+		UniverseCommitments: enableUniverseCommitments,
+	})
+	if err != nil {
+		return fmt.Errorf("%w: %w", ErrBindBatchTx, err)
+	}
+
+	// If universe commitments are not enabled for this batch, we can
+	// return early.
+	if !enableUniverseCommitments {
+		return nil
+	}
+
+	// At this point, universe commitments are enabled for this batch, so
+	// we'll insert the mint anchor uni commitment record.
+	preCommitOut, err := anchorPackage.PreCommitmentOutput.UnwrapOrErr(
+		fmt.Errorf("pre-commitment outpoint bundle not set"),
+	)
+	if err != nil {
+		return err
+	}
+
+	// Serialize internal key.
+	internalKey := preCommitOut.InternalKey.SerializeCompressed()
+
+	// Serialize group key.
+	groupPubKey := preCommitOut.GroupPubKey.SerializeCompressed()
+
+	_, err = q.UpsertMintAnchorUniCommitment(
+		ctx, MintAnchorUniCommitParams{
+			BatchID:            int32(batchID),
+			TxOutputIndex:      int32(preCommitOut.OutIdx),
+			TaprootInternalKey: internalKey,
+			GroupKey:           groupPubKey,
+		},
+	)
+	if err != nil {
+		return fmt.Errorf("unable to insert mint anchor uni "+
+			"commitment: %w", err)
+	}
+
+	return nil
+}
+
 // CommitMintingBatch commits a new minting batch to disk along with any
 // seedlings specified as part of the batch. A new internal key is also
 // created, with the batch referencing that internal key. This internal key
@@ -371,31 +451,16 @@ func (a *AssetMintingStore) CommitMintingBatch(ctx context.Context,
 		if newBatch.GenesisPacket != nil {
 			genesisPacket := newBatch.GenesisPacket
 			genesisTx := genesisPacket.Pkt.UnsignedTx
-			changeIdx := genesisPacket.ChangeOutputIndex
 			genesisOutpoint := genesisTx.TxIn[0].PreviousOutPoint
 
-			var psbtBuf bytes.Buffer
-			err := genesisPacket.Pkt.Serialize(&psbtBuf)
-			if err != nil {
-				return fmt.Errorf("%w: %w", ErrEncodePsbt, err)
-			}
-
-			genesisPointID, err := upsertGenesisPoint(
-				ctx, q, genesisOutpoint,
+			// Insert the batch transaction.
+			err = insertMintAnchorTx(
+				ctx, q, *genesisPacket,
+				*newBatch.BatchKey.PubKey, genesisOutpoint,
 			)
 			if err != nil {
-				return fmt.Errorf("%w: %w",
-					ErrUpsertGenesisPoint, err)
-			}
-
-			_, err = q.BindMintingBatchWithTx(ctx, BatchChainUpdate{
-				RawKey:            rawBatchKey,
-				MintingTxPsbt:     psbtBuf.Bytes(),
-				ChangeOutputIndex: sqlInt32(changeIdx),
-				GenesisID:         sqlInt64(genesisPointID),
-			})
-			if err != nil {
-				return fmt.Errorf("%w: %w", ErrBindBatchTx, err)
+				return fmt.Errorf("unable to insert mint "+
+					"anchor tx: %w", err)
 			}
 		}
 
@@ -1340,31 +1405,19 @@ func (a *AssetMintingStore) CommitBatchTx(ctx context.Context,
 	genesisPacket tapgarden.FundedMintAnchorPsbt) error {
 
 	genesisOutpoint := genesisPacket.Pkt.UnsignedTx.TxIn[0].PreviousOutPoint
-	rawBatchKey := batchKey.SerializeCompressed()
-
-	var psbtBuf bytes.Buffer
-	if err := genesisPacket.Pkt.Serialize(&psbtBuf); err != nil {
-		return fmt.Errorf("%w: %w", ErrEncodePsbt, err)
-	}
 
 	var writeTxOpts AssetStoreTxOptions
 	return a.db.ExecTx(ctx, &writeTxOpts, func(q PendingAssetStore) error {
-		genesisPointID, err := upsertGenesisPoint(
-			ctx, q, genesisOutpoint,
+		// Insert the batch transaction.
+		err := insertMintAnchorTx(
+			ctx, q, genesisPacket, *batchKey, genesisOutpoint,
 		)
 		if err != nil {
-			return fmt.Errorf("%w: %w", ErrUpsertGenesisPoint, err)
+			return fmt.Errorf("unable to insert mint anchor "+
+				"tx: %w", err)
 		}
 
-		_, err = q.BindMintingBatchWithTx(ctx, BatchChainUpdate{
-			RawKey:        rawBatchKey,
-			MintingTxPsbt: psbtBuf.Bytes(),
-			ChangeOutputIndex: sqlInt32(
-				genesisPacket.ChangeOutputIndex,
-			),
-			GenesisID: sqlInt64(genesisPointID),
-		})
-		return err
+		return nil
 	})
 }
 
@@ -1501,31 +1554,22 @@ func (a *AssetMintingStore) AddSproutsToBatch(ctx context.Context,
 
 	var writeTxOpts AssetStoreTxOptions
 	return a.db.ExecTx(ctx, &writeTxOpts, func(q PendingAssetStore) error {
-		genesisPointID, _, err := upsertAssetsWithGenesis(
+		// Upsert the assets with genesis.
+		_, _, err := upsertAssetsWithGenesis(
 			ctx, q, genesisOutpoint, sortedAssets, nil,
 		)
 		if err != nil {
 			return fmt.Errorf("error inserting assets with "+
 				"genesis: %w", err)
 		}
 
-		// With all the assets inserted, we'll now update the
-		// corresponding batch that references all these assets with
-		// the genesis packet, and genesis point information.
-		var psbtBuf bytes.Buffer
-		if err := genesisPacket.Pkt.Serialize(&psbtBuf); err != nil {
-			return fmt.Errorf("%w: %w", ErrEncodePsbt, err)
-		}
-		_, err = q.BindMintingBatchWithTx(ctx, BatchChainUpdate{
-			RawKey:        rawBatchKey,
-			MintingTxPsbt: psbtBuf.Bytes(),
-			ChangeOutputIndex: sqlInt32(
-				genesisPacket.ChangeOutputIndex,
-			),
-			GenesisID: sqlInt64(genesisPointID),
-		})
+		// Insert the batch transaction.
+		err = insertMintAnchorTx(
+			ctx, q, *genesisPacket, *batchKey, genesisOutpoint,
+		)
 		if err != nil {
-			return fmt.Errorf("%w: %w", ErrBindBatchTx, err)
+			return fmt.Errorf("unable to insert mint anchor "+
+				"tx: %w", err)
 		}
 
 		// Finally, update the batch state to BatchStateCommitted.