tapdb: update minting queries to set batch sibling

Author: jharveyb

tapdb/asset_minting.go

@@ -312,6 +312,21 @@ func (a *AssetMintingStore) CommitMintingBatch(ctx context.Context,
 				"batch: %w", err)
 		}
 
+		// With the batch key and batch itself inserted, we can insert
+		// the batch tapscript sibling if present.
+		newBatchSibling := newBatch.TapSibling()
+		if newBatchSibling != nil {
+			tapSibling := BatchTapSiblingUpdate{
+				RawKey:           rawBatchKey,
+				TapscriptSibling: newBatchSibling,
+			}
+			err = q.BindMintingBatchWithTapSibling(ctx, tapSibling)
+			if err != nil {
+				return fmt.Errorf("unable to insert batch "+
+					"sibling: %w", err)
+			}
+		}
+
 		// Now that our minting batch is in place, which references the
 		// internal key inserted above, we can create the set of new
 		// seedlings. We insert group anchors before other assets.
@@ -862,6 +877,15 @@ func marshalMintingBatch(ctx context.Context, q PendingAssetStore,
 
 	batch.UpdateState(batchState)
 
+	if len(dbBatch.TapscriptSibling) != 0 {
+		batchSibling, err := chainhash.NewHash(dbBatch.TapscriptSibling)
+		if err != nil {
+			return nil, err
+		}
+
+		batch.UpdateTapSibling(batchSibling)
+	}
+
 	if dbBatch.MintingTxPsbt != nil {
 		genesisPkt, err := psbt.NewFromRawBytes(
 			bytes.NewReader(dbBatch.MintingTxPsbt), false,
@@ -929,6 +953,22 @@ func (a *AssetMintingStore) UpdateBatchState(ctx context.Context,
 	})
 }
 
+// CommitBatchTapSibling updates the tapscript sibling of a batch based on the
+// batch key.
+func (a *AssetMintingStore) CommitBatchTapSibling(ctx context.Context,
+	batchKey *btcec.PublicKey, batchSibling *chainhash.Hash) error {
+
+	siblingUpdate := BatchTapSiblingUpdate{
+		RawKey:           batchKey.SerializeCompressed(),
+		TapscriptSibling: batchSibling[:],
+	}
+
+	var writeTxOpts AssetStoreTxOptions
+	return a.db.ExecTx(ctx, &writeTxOpts, func(q PendingAssetStore) error {
+		return q.BindMintingBatchWithTapSibling(ctx, siblingUpdate)
+	})
+}
+
 // encodeOutpoint encodes the outpoint point in Bitcoin wire format, returning
 // the final result.
 func encodeOutpoint(outPoint wire.OutPoint) ([]byte, error) {
@@ -1019,7 +1059,8 @@ func (a *AssetMintingStore) AddSproutsToBatch(ctx context.Context,
 // root manually?
 func (a *AssetMintingStore) CommitSignedGenesisTx(ctx context.Context,
 	batchKey *btcec.PublicKey, genesisPkt *tapgarden.FundedPsbt,
-	anchorOutputIndex uint32, merkleRoot []byte) error {
+	anchorOutputIndex uint32, merkleRoot, tapTreeRoot []byte,
+	tapSibling []byte) error {
 
 	// The managed UTXO we'll insert only contains the raw tx of the
 	// genesis packet, so we'll extract that now.
@@ -1087,13 +1128,11 @@ func (a *AssetMintingStore) CommitSignedGenesisTx(ctx context.Context,
 		// batch, we'll create a new managed UTXO for this batch as
 		// this is where all the assets will be anchored within.
 		utxoID, err := q.UpsertManagedUTXO(ctx, RawManagedUTXO{
-			RawKey:   rawBatchKey,
-			Outpoint: anchorOutpoint,
-			AmtSats:  anchorOutput.Value,
-			// When minting, we never have a tapscript sibling, so
-			// the TaprootAssetRoot root is always equal to the
-			// merkle root.
-			TaprootAssetRoot: merkleRoot,
+			RawKey:           rawBatchKey,
+			Outpoint:         anchorOutpoint,
+			AmtSats:          anchorOutput.Value,
+			TaprootAssetRoot: tapTreeRoot,
+			TapscriptSibling: tapSibling,
 			MerkleRoot:       merkleRoot,
 			TxnID:            chainTXID,
 		})

tapdb/asset_minting_test.go

@@ -67,11 +67,18 @@ func assertBatchState(t *testing.T, batch *tapgarden.MintingBatch,
 	require.Equal(t, state, batch.State())
 }
 
+func assertBatchSibling(t *testing.T, batch *tapgarden.MintingBatch,
+	sibling chainhash.Hash) {
+
+	require.Equal(t, sibling[:], batch.TapSibling())
+}
+
 func assertBatchEqual(t *testing.T, a, b *tapgarden.MintingBatch) {
 	t.Helper()
 
 	require.Equal(t, a.CreationTime.Unix(), b.CreationTime.Unix())
 	require.Equal(t, a.State(), b.State())
+	require.Equal(t, a.TapSibling(), b.TapSibling())
 	require.Equal(t, a.BatchKey, b.BatchKey)
 	require.Equal(t, a.Seedlings, b.Seedlings)
 	require.Equal(t, a.GenesisPacket, b.GenesisPacket)
@@ -329,6 +336,22 @@ func addRandGroupToBatch(t *testing.T, store *AssetMintingStore,
 	return genesisAmt, seedlingGroups, group
 }
 
+// addRandSiblingToBatch generates a random hash and adds it to the given batch.
+func addRandSiblingToBatch(t *testing.T, batch *tapgarden.MintingBatch) (
+	commitment.TapscriptPreimage, chainhash.Hash) {
+
+	tapSiblingSingleLeaf := test.RandTapLeaf(nil)
+	siblingPreimage, err := commitment.NewPreimageFromLeaf(
+		tapSiblingSingleLeaf,
+	)
+	require.NoError(t, err)
+	tapSibling, err := siblingPreimage.TapHash()
+	require.NoError(t, err)
+	batch.UpdateTapSibling(tapSibling)
+
+	return *siblingPreimage, *tapSibling
+}
+
 // addMultiAssetGroupToBatch selects a random seedling pair, where neither
 // seedling is being issued into an existing group, and creates a multi-asset
 // group. Specifically, one seedling will have emission enabled, and the other
@@ -384,6 +407,7 @@ func TestCommitMintingBatchSeedlings(t *testing.T) {
 	// be a reissuance into a specific group.
 	mintingBatch := tapgarden.RandSeedlingMintingBatch(t, numSeedlings)
 	addRandGroupToBatch(t, assetStore, ctx, mintingBatch.Seedlings)
+	_, randSiblingHash := addRandSiblingToBatch(t, mintingBatch)
 	err := assetStore.CommitMintingBatch(ctx, mintingBatch)
 	require.NoError(t, err)
 
@@ -394,6 +418,7 @@ func TestCommitMintingBatchSeedlings(t *testing.T) {
 	mintingBatches := noError1(t, assetStore.FetchNonFinalBatches, ctx)
 	assertSeedlingBatchLen(t, mintingBatches, 1, numSeedlings)
 	assertBatchEqual(t, mintingBatch, mintingBatches[0])
+	assertBatchSibling(t, mintingBatch, randSiblingHash)
 
 	mintingBatchKeyed, err := assetStore.FetchMintingBatch(ctx, batchKey)
 	require.NoError(t, err)
@@ -740,13 +765,16 @@ func TestAddSproutsToBatch(t *testing.T) {
 }
 
 type randAssetCtx struct {
-	batchKey     *btcec.PublicKey
-	groupKey     *btcec.PublicKey
-	groupGenAmt  uint64
-	genesisPkt   *tapgarden.FundedPsbt
-	scriptRoot   []byte
-	assetRoot    *commitment.TapCommitment
-	mintingBatch *tapgarden.MintingBatch
+	batchKey        *btcec.PublicKey
+	groupKey        *btcec.PublicKey
+	groupGenAmt     uint64
+	genesisPkt      *tapgarden.FundedPsbt
+	assetRoot       *commitment.TapCommitment
+	merkleRoot      []byte
+	scriptRoot      []byte
+	tapSiblingBytes []byte
+	tapSiblingHash  chainhash.Hash
+	mintingBatch    *tapgarden.MintingBatch
 }
 
 func addRandAssets(t *testing.T, ctx context.Context,
@@ -756,6 +784,7 @@ func addRandAssets(t *testing.T, ctx context.Context,
 	genAmt, seedlingGroups, group := addRandGroupToBatch(
 		t, assetStore, ctx, mintingBatch.Seedlings,
 	)
+	randSibling, randSiblingHash := addRandSiblingToBatch(t, mintingBatch)
 	batchKey := mintingBatch.BatchKey.PubKey
 	require.NoError(t, assetStore.CommitMintingBatch(ctx, mintingBatch))
 
@@ -769,16 +798,24 @@ func addRandAssets(t *testing.T, ctx context.Context,
 		ctx, batchKey, genesisPacket, assetRoot,
 	))
 
+	merkleRoot := assetRoot.TapscriptRoot(&randSiblingHash)
 	scriptRoot := assetRoot.TapscriptRoot(nil)
+	siblingBytes, _, err := commitment.MaybeEncodeTapscriptPreimage(
+		&randSibling,
+	)
+	require.NoError(t, err)
 
 	return randAssetCtx{
-		batchKey:     batchKey,
-		groupKey:     &group.GroupKey.GroupPubKey,
-		groupGenAmt:  genAmt,
-		genesisPkt:   genesisPacket,
-		scriptRoot:   scriptRoot[:],
-		assetRoot:    assetRoot,
-		mintingBatch: mintingBatch,
+		batchKey:        batchKey,
+		groupKey:        &group.GroupKey.GroupPubKey,
+		groupGenAmt:     genAmt,
+		genesisPkt:      genesisPacket,
+		assetRoot:       assetRoot,
+		merkleRoot:      merkleRoot[:],
+		scriptRoot:      scriptRoot[:],
+		tapSiblingBytes: siblingBytes,
+		tapSiblingHash:  randSiblingHash,
+		mintingBatch:    mintingBatch,
 	}
 }
 
@@ -812,7 +849,8 @@ func TestCommitBatchChainActions(t *testing.T) {
 	// alongside any managed UTXOs.
 	require.NoError(t, assetStore.CommitSignedGenesisTx(
 		ctx, randAssetCtx.batchKey, randAssetCtx.genesisPkt, 2,
-		randAssetCtx.scriptRoot,
+		randAssetCtx.merkleRoot, randAssetCtx.scriptRoot,
+		randAssetCtx.tapSiblingBytes,
 	))
 
 	// The batch updated above should be found, with the batch state
@@ -825,6 +863,7 @@ func TestCommitBatchChainActions(t *testing.T) {
 	assertPsbtEqual(
 		t, randAssetCtx.genesisPkt, mintingBatches[0].GenesisPacket,
 	)
+	assertBatchSibling(t, mintingBatches[0], randAssetCtx.tapSiblingHash)
 
 	var rawTxBytes bytes.Buffer
 	rawGenTx, err := psbt.Extract(randAssetCtx.genesisPkt.Pkt)
@@ -849,7 +888,11 @@ func TestCommitBatchChainActions(t *testing.T) {
 		TxnID: sqlInt64(dbGenTx.TxnID),
 	})
 	require.NoError(t, err)
-	require.Equal(t, randAssetCtx.scriptRoot, managedUTXO.MerkleRoot)
+	require.Equal(t, randAssetCtx.merkleRoot, managedUTXO.MerkleRoot)
+	require.Equal(t, randAssetCtx.scriptRoot, managedUTXO.TaprootAssetRoot)
+	require.Equal(
+		t, randAssetCtx.tapSiblingBytes, managedUTXO.TapscriptSibling,
+	)
 
 	// Next, we'll confirm that all the assets inserted previously now are
 	// able to be queried according to the anchor UTXO primary key.