supplycommit+tapdb: extend FetchSubTrees with block height end param

Add a block height range end parameter to FetchSubTrees, enabling
filtering of supply subtree leaves by block height. This allows
reconstruction of supply subtrees as they existed at a specific supply
commitment block height.

This functionality is useful for reproducing a supply commitment at a
given block height for syncing purposes.

Author: ffranr

rpcserver.go

@@ -4407,7 +4407,7 @@ func (r *rpcServer) FetchSupplyLeaves(ctx context.Context,
 	var subtrees supplycommit.SupplyTrees
 	if needsInclusionProofs {
 		subtreeResult, err := r.cfg.SupplyCommitManager.FetchSubTrees(
-			ctx, assetSpec,
+			ctx, assetSpec, fn.None[uint32](),
 		)
 		if err != nil {
 			return nil, fmt.Errorf("failed to fetch subtrees for "+

tapdb/supply_tree.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/lightninglabs/taproot-assets/asset"
+	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/mssmt"
 	"github.com/lightninglabs/taproot-assets/proof"
 	"github.com/lightninglabs/taproot-assets/tapdb/sqlc"
@@ -196,10 +197,108 @@ func fetchSubTreeInternal(ctx context.Context, db BaseUniverseStore,
 	return memTree, nil
 }
 
-// FetchSubTrees returns copies of all sub-trees (mint, burn, ignore) for the
+// filterSubTree applies filtering to the leaves of a subtree.
+func filterSubTree(ctx context.Context,
+	treeType supplycommit.SupplySubTree, subTree mssmt.Tree,
+	blockHeightEnd fn.Option[uint32]) (mssmt.Tree, error) {
+
+	if blockHeightEnd.IsNone() {
+		// No filtering needed, return the original tree.
+		return subTree, nil
+	}
+
+	// Create a new in-memory tree to copy into.
+	filteredSubTree := mssmt.NewCompactedTree(mssmt.NewDefaultStore())
+
+	// Create a predicate function to filter leaves based on block height.
+	filterPredicate := func(key [32]byte, leaf mssmt.LeafNode) (bool,
+		error) {
+
+		blockHeightEndVal, err := blockHeightEnd.UnwrapOrErr(
+			fmt.Errorf("block height end not set"),
+		)
+		if err != nil {
+			return false, err
+		}
+
+		// Decode the leaf based on the tree type to extract block
+		// height.
+		switch treeType {
+		case supplycommit.MintTreeType:
+			// For mint trees, decode mint event to get block
+			// height.
+			var mintEvent supplycommit.NewMintEvent
+			err := mintEvent.Decode(bytes.NewReader(leaf.Value))
+			if err != nil {
+				return false, fmt.Errorf("unable to decode "+
+					"mint event: %w", err)
+			}
+
+			// Extract block height directly from the mint event.
+			mintBlockHeight := mintEvent.MintHeight
+
+			// Include the leaf if it's within range.
+			return mintBlockHeight <= blockHeightEndVal, nil
+
+		case supplycommit.BurnTreeType:
+			// For burn trees, decode burn leaf to get block height.
+			var burnLeaf universe.BurnLeaf
+			err := burnLeaf.Decode(bytes.NewReader(leaf.Value))
+			if err != nil {
+				return false, fmt.Errorf("unable to decode "+
+					"burn leaf: %w", err)
+			}
+
+			// Extract block height directly from the burn proof.
+			proofBlockHeight := burnLeaf.BurnProof.BlockHeight
+
+			// Include the leaf if it's within range.
+			return proofBlockHeight <= blockHeightEndVal, nil
+
+		case supplycommit.IgnoreTreeType:
+			// For ignore trees, decode signed ignore tuple to get
+			// block height.
+			var signedIgnoreTuple universe.SignedIgnoreTuple
+			err := signedIgnoreTuple.Decode(
+				bytes.NewReader(leaf.Value),
+			)
+			if err != nil {
+				return false, fmt.Errorf("unable to decode "+
+					"signed ignore tuple: %w", err)
+			}
+
+			// Extract block height directly from the "ignore"
+			// tuple.
+			tupleBlockHeight :=
+				signedIgnoreTuple.IgnoreTuple.Val.BlockHeight
+
+			// Include the leaf if it's within range.
+			return tupleBlockHeight <= blockHeightEndVal, nil
+
+		default:
+			return false, fmt.Errorf("unknown tree type: %v",
+				treeType)
+		}
+	}
+
+	// Copy the persistent tree to the in-memory tree with filtering.
+	err := subTree.CopyFilter(ctx, filteredSubTree, filterPredicate)
+	if err != nil {
+		return nil, fmt.Errorf("unable to copy "+
+			"sub-tree: %w", err)
+	}
+
+	return filteredSubTree, nil
+}
+
+// FetchSubTrees returns copies of all subtrees (mint, burn, ignore) for the
 // given asset spec.
+//
+// If blockHeightEnd is specified, only leaves with a block height less than
+// or equal to the given height are included in the returned subtrees.
 func (s *SupplyTreeStore) FetchSubTrees(ctx context.Context,
-	spec asset.Specifier) lfn.Result[supplycommit.SupplyTrees] {
+	spec asset.Specifier,
+	blockHeightEnd fn.Option[uint32]) lfn.Result[supplycommit.SupplyTrees] {
 
 	groupKey, err := spec.UnwrapGroupKeyOrErr()
 	if err != nil {
@@ -222,7 +321,15 @@ func (s *SupplyTreeStore) FetchSubTrees(ctx context.Context,
 					"sub-tree %v: %w", treeType, fetchErr)
 			}
 
-			trees[treeType] = subTree
+			filteredSubTree, err := filterSubTree(
+				ctx, treeType, subTree, blockHeightEnd,
+			)
+			if err != nil {
+				return fmt.Errorf("failed to filter "+
+					"sub-tree %v: %w", treeType, err)
+			}
+
+			trees[treeType] = filteredSubTree
 		}
 		return nil
 	})

universe/supplycommit/env.go

@@ -269,9 +269,10 @@ type SupplyTreeView interface {
 	FetchSubTree(ctx context.Context, assetSpec asset.Specifier,
 		treeType SupplySubTree) lfn.Result[mssmt.Tree]
 
-	// FetchSubTrees returns all the sub trees for the given asset spec.
+	// FetchSubTrees returns all the subtrees for the given asset spec.
 	FetchSubTrees(ctx context.Context,
-		assetSpec asset.Specifier) lfn.Result[SupplyTrees]
+		assetSpec asset.Specifier,
+		blockHeightEnd fn.Option[uint32]) lfn.Result[SupplyTrees]
 
 	// FetchRootSupplyTree returns the root supply tree which contains a
 	// commitment to each of the sub trees.

universe/supplycommit/manager.go

@@ -531,7 +531,9 @@ func (m *Manager) FetchCommitment(ctx context.Context,
 			"supply tree: %w", err)
 	}
 
-	subtrees, err := m.cfg.TreeView.FetchSubTrees(ctx, assetSpec).Unpack()
+	subtrees, err := m.cfg.TreeView.FetchSubTrees(
+		ctx, assetSpec, fn.None[uint32](),
+	).Unpack()
 	if err != nil {
 		return zero, fmt.Errorf("unable to fetch supply commit sub "+
 			"trees: %w", err)
@@ -565,11 +567,14 @@ func (m *Manager) FetchSupplyLeavesByHeight(
 
 // FetchSubTrees returns all the sub trees for the given asset specifier.
 func (m *Manager) FetchSubTrees(ctx context.Context,
-	assetSpec asset.Specifier) (SupplyTrees, error) {
+	assetSpec asset.Specifier,
+	blockHeightEnd fn.Option[uint32]) (SupplyTrees, error) {
 
 	var zero SupplyTrees
 
-	subtrees, err := m.cfg.TreeView.FetchSubTrees(ctx, assetSpec).Unpack()
+	subtrees, err := m.cfg.TreeView.FetchSubTrees(
+		ctx, assetSpec, blockHeightEnd,
+	).Unpack()
 	if err != nil {
 		return zero, fmt.Errorf("unable to fetch sub trees: %w", err)
 	}

universe/supplycommit/mock.go

@@ -11,6 +11,7 @@ import (
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/taproot-assets/asset"
+	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/mssmt"
 	"github.com/lightninglabs/taproot-assets/proof"
 	"github.com/lightninglabs/taproot-assets/tapsend"
@@ -36,7 +37,8 @@ func (m *mockSupplyTreeView) FetchSubTree(_ context.Context,
 }
 
 func (m *mockSupplyTreeView) FetchSubTrees(_ context.Context,
-	assetSpec asset.Specifier) lfn.Result[SupplyTrees] {
+	assetSpec asset.Specifier,
+	blockHeightEnd fn.Option[uint32]) lfn.Result[SupplyTrees] {
 
 	args := m.Called(assetSpec)
 	return args.Get(0).(lfn.Result[SupplyTrees])

universe/supplycommit/transitions.go

@@ -372,7 +372,7 @@ func (c *CommitTreeCreateState) ProcessEvent(event Event,
 		//
 		// TODO(roasbeef): sanity check on population of map?
 		oldSupplyTrees, err := env.TreeView.FetchSubTrees(
-			ctx, env.AssetSpec,
+			ctx, env.AssetSpec, fn.None[uint32](),
 		).Unpack()
 		if err != nil {
 			return nil, fmt.Errorf("unable to fetch old sub "+