tapdb: update all trees to specify a block height for a universe leaf

Author: Roasbeef

tapdb/burn_tree.go

@@ -117,11 +117,17 @@ func insertBurnsInternal(ctx context.Context, db BaseUniverseStore,
 			IsBurn:   true,
 		}
 
+		var blockHeight lfn.Option[uint32]
+		height := burnLeaf.BurnProof.BlockHeight
+		if height > 0 {
+			blockHeight = lfn.Some(height)
+		}
+
 		// Call the generic upsert function for the burn sub-tree to
 		// update DB records. MetaReveal is nil for burns.
 		_, err = universeUpsertProofLeaf(
 			ctx, db, subNs, supplycommit.BurnTreeType.String(),
-			groupKey, leafKey, leaf, nil,
+			groupKey, leafKey, leaf, nil, blockHeight,
 		)
 		if err != nil {
 			return nil, fmt.Errorf("unable to upsert burn "+

tapdb/ignore_tree.go

@@ -113,6 +113,21 @@ func addTuplesInternal(ctx context.Context, db BaseUniverseStore,
 				"universe root: %w", err)
 		}
 
+		var blockHeight lfn.Option[uint32]
+		height := tup.IgnoreTuple.Val.BlockHeight
+		if height > 0 {
+			blockHeight = lfn.Some(height)
+		}
+
+		sqlBlockHeight := lfn.MapOptionZ(
+			blockHeight, func(num uint32) sql.NullInt32 {
+				return sql.NullInt32{
+					Int32: int32(num),
+					Valid: true,
+				}
+			},
+		)
+
 		scriptKey := ignoreTup.ScriptKey
 		err = db.UpsertUniverseLeaf(ctx, UpsertUniverseLeaf{
 			AssetGenesisID:    assetGenID,
@@ -121,6 +136,7 @@ func addTuplesInternal(ctx context.Context, db BaseUniverseStore,
 			LeafNodeKey:       smtKey[:],
 			LeafNodeNamespace: namespace,
 			MintingPoint:      ignorePointBytes,
+			BlockHeight:       sqlBlockHeight,
 		})
 		if err != nil {
 			return nil, fmt.Errorf("failed to upsert ignore "+

tapdb/multiverse.go

@@ -776,11 +776,16 @@ func (b *MultiverseStore) UpsertProofLeaf(ctx context.Context,
 
 	execTxFunc := func(dbTx BaseMultiverseStore) error {
 		// Register issuance in the asset (group) specific universe
-		// tree.
-		var err error
+		// tree. We don't need to decode the whole proof, we just
+		// need the block height.
+		blockHeight, err := SparseDecodeBlockHeight(leaf.RawProof)
+		if err != nil {
+			return err
+		}
+
 		uniProof, err = universeUpsertProofLeaf(
 			ctx, dbTx, id.String(), id.ProofType.String(),
-			id.GroupKey, key, leaf, metaReveal,
+			id.GroupKey, key, leaf, metaReveal, blockHeight,
 		)
 		if err != nil {
 			return fmt.Errorf("failed universe upsert: %w", err)
@@ -847,13 +852,22 @@ func (b *MultiverseStore) UpsertProofLeafBatch(ctx context.Context,
 			for idx := range items {
 				item := items[idx]
 
+				// We don't need to decode the whole proof, we
+				// just need the block height.
+				blockHeight, err := SparseDecodeBlockHeight(
+					item.Leaf.RawProof,
+				)
+				if err != nil {
+					return err
+				}
+
 				// Upsert into the specific universe tree to
 				// start with.
 				uniProof, err := universeUpsertProofLeaf(
 					ctx, store, item.ID.String(),
 					item.ID.ProofType.String(),
 					item.ID.GroupKey, item.Key, item.Leaf,
-					item.MetaReveal,
+					item.MetaReveal, blockHeight,
 				)
 				if err != nil {
 					return fmt.Errorf("failed universe "+

tapdb/sqlc/queries/universe.sql

@@ -38,17 +38,18 @@ WHERE namespace_root = @namespace_root;
 
 -- name: UpsertUniverseLeaf :exec
 INSERT INTO universe_leaves (
-    asset_genesis_id, script_key_bytes, universe_root_id, leaf_node_key, 
-    leaf_node_namespace, minting_point
+    asset_genesis_id, script_key_bytes, universe_root_id, leaf_node_key,
+    leaf_node_namespace, minting_point, block_height
 ) VALUES (
     @asset_genesis_id, @script_key_bytes, @universe_root_id, @leaf_node_key,
-    @leaf_node_namespace, @minting_point
+    @leaf_node_namespace, @minting_point, @block_height
 ) ON CONFLICT (minting_point, script_key_bytes, leaf_node_namespace)
-    -- This is a NOP, minting_point and script_key_bytes are the unique fields
-    -- that caused the conflict.
+    -- Update the block_height on conflict. The minting_point, script_key_bytes,
+    -- and leaf_node_namespace remain unchanged as they form the unique constraint.
     DO UPDATE SET minting_point = EXCLUDED.minting_point,
                   script_key_bytes = EXCLUDED.script_key_bytes,
-                  leaf_node_namespace = EXCLUDED.leaf_node_namespace;
+                  leaf_node_namespace = EXCLUDED.leaf_node_namespace,
+                  block_height = EXCLUDED.block_height;
 
 -- name: DeleteUniverseLeaves :exec
 DELETE FROM universe_leaves

tapdb/sqlc/universe.sql.go

@@ -274,7 +274,8 @@ func (s *SupplyTreeStore) FetchRootSupplyTree(ctx context.Context,
 // NOTE: This function must be called within a database transaction.
 func registerMintSupplyInternal(ctx context.Context, dbTx BaseUniverseStore,
 	assetSpec asset.Specifier, key universe.LeafKey, leaf *universe.Leaf,
-	metaReveal *proof.MetaReveal) (*universe.Proof, error) {
+	metaReveal *proof.MetaReveal,
+	blockHeight lfn.Option[uint32]) (*universe.Proof, error) {
 
 	groupKey, err := assetSpec.UnwrapGroupKeyOrErr()
 	if err != nil {
@@ -286,7 +287,7 @@ func registerMintSupplyInternal(ctx context.Context, dbTx BaseUniverseStore,
 	// Upsert the leaf into the mint supply sub-tree SMT and DB.
 	mintSupplyProof, err := universeUpsertProofLeaf(
 		ctx, dbTx, subNs, supplycommit.MintTreeType.String(), groupKey,
-		key, leaf, metaReveal,
+		key, leaf, metaReveal, blockHeight,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("failed mint supply universe "+
@@ -312,15 +313,21 @@ func (s *SupplyTreeStore) RegisterMintSupply(ctx context.Context,
 
 	var (
 		writeTx           BaseUniverseStoreOptions
-		err               error
 		mintSupplyProof   *universe.Proof
 		newRootSupplyRoot mssmt.Node
 	)
 	dbErr := s.db.ExecTx(ctx, &writeTx, func(dbTx BaseUniverseStore) error {
+		// We don't need to decode the whole proof, we just need the
+		// block height.
+		blockHeight, err := SparseDecodeBlockHeight(leaf.RawProof)
+		if err != nil {
+			return err
+		}
+
 		// Upsert the leaf into the mint supply sub-tree SMT and DB
 		// first.
 		mintSupplyProof, err = registerMintSupplyInternal(
-			ctx, dbTx, spec, key, leaf, nil,
+			ctx, dbTx, spec, key, leaf, nil, blockHeight,
 		)
 		if err != nil {
 			return fmt.Errorf("failed mint supply universe "+
@@ -395,9 +402,15 @@ func applySupplyUpdatesInternal(ctx context.Context, dbTx BaseUniverseStore,
 					"type: %T", update)
 			}
 
+			var blockHeight lfn.Option[uint32]
+			height := mintEvent.BlockHeight()
+			if height > 0 {
+				blockHeight = lfn.Some(height)
+			}
+
 			mintProof, err := registerMintSupplyInternal(
 				ctx, dbTx, spec, mintEvent.LeafKey,
-				&mintEvent.IssuanceProof, nil,
+				&mintEvent.IssuanceProof, nil, blockHeight,
 			)
 			if err != nil {
 				return nil, fmt.Errorf("failed to register "+

tapdb/supply_tree.go

@@ -58,6 +58,10 @@ type (
 
 	// UpsertUniverseSupplyLeaf is used to upsert a universe supply leaf.
 	UpsertUniverseSupplyLeaf = sqlc.UpsertUniverseSupplyLeafParams
+
+	// QuerySupplyLeavesByHeightParams is used to query for supply leaves
+	// by height.
+	QuerySupplyLeavesByHeightParams = sqlc.QuerySupplyLeavesByHeightParams
 )
 
 // BaseUniverseStore is the main interface for the Taproot Asset universe store.
@@ -128,6 +132,12 @@ type BaseUniverseStore interface {
 	// supply tree for a given asset.
 	UpsertUniverseSupplyRoot(ctx context.Context,
 		arg UpsertUniverseSupplyRoot) (int64, error)
+
+	// QuerySupplyLeavesByHeight is used to query for supply leaves by
+	// height.
+	QuerySupplyLeavesByHeight(ctx context.Context,
+		arg QuerySupplyLeavesByHeightParams) (
+		[]sqlc.QuerySupplyLeavesByHeightRow, error)
 }
 
 // getUniverseTreeSum retrieves the sum of a universe tree specified by its
@@ -570,9 +580,17 @@ func (b *BaseUniverseTree) UpsertProofLeaf(ctx context.Context,
 	)
 	dbErr := b.db.ExecTx(ctx, &writeTx, func(dbTx BaseUniverseStore) error {
 		namespace := b.id.String()
+
+		// We don't need to decode the whole proof, we just need the
+		// block height.
+		blockHeight, err := SparseDecodeBlockHeight(leaf.RawProof)
+		if err != nil {
+			return err
+		}
+
 		issuanceProof, err := universeUpsertProofLeaf(
 			ctx, dbTx, namespace, b.id.ProofType.String(),
-			b.id.GroupKey, key, leaf, metaReveal,
+			b.id.GroupKey, key, leaf, metaReveal, blockHeight,
 		)
 		if err != nil {
 			return fmt.Errorf("failed universe upsert: %w", err)
@@ -701,8 +719,8 @@ func upsertMultiverseLeafEntry(ctx context.Context, dbTx BaseUniverseStore,
 // broader DB updates.
 func universeUpsertProofLeaf(ctx context.Context, dbTx BaseUniverseStore,
 	namespace string, proofTypeStr string, groupKey *btcec.PublicKey,
-	key universe.LeafKey, leaf *universe.Leaf,
-	metaReveal *proof.MetaReveal) (*universe.Proof, error) {
+	key universe.LeafKey, leaf *universe.Leaf, metaReveal *proof.MetaReveal,
+	blockHeight lfn.Option[uint32]) (*universe.Proof, error) {
 
 	// With the tree store created, we'll now obtain byte representation of
 	// the minting key, as that'll be the key in the SMT itself.
@@ -773,6 +791,21 @@ func universeUpsertProofLeaf(ctx context.Context, dbTx BaseUniverseStore,
 		return nil, err
 	}
 
+	// If the block height isn't specified, then we'll attempt to extract it
+	// from the proof itself.
+	if blockHeight.IsNone() && leafProof.BlockHeight > 0 {
+		blockHeight = lfn.Some(leafProof.BlockHeight)
+	}
+
+	sqlBlockHeight := lfn.MapOptionZ(
+		blockHeight, func(num uint32) sql.NullInt32 {
+			return sql.NullInt32{
+				Int32: int32(num),
+				Valid: true,
+			}
+		},
+	)
+
 	scriptKey := key.LeafScriptKey()
 	scriptKeyBytes := schnorr.SerializePubKey(scriptKey.PubKey)
 	err = dbTx.UpsertUniverseLeaf(ctx, UpsertUniverseLeaf{
@@ -782,6 +815,7 @@ func universeUpsertProofLeaf(ctx context.Context, dbTx BaseUniverseStore,
 		LeafNodeKey:       smtKey[:],
 		LeafNodeNamespace: namespace,
 		MintingPoint:      mintingPointBytes,
+		BlockHeight:       sqlBlockHeight,
 	})
 	if err != nil {
 		return nil, err