supplyverifier: extract pre-commits from issuance leaves

Ensure issuance leaves fetched with the supply commitment during
sync pull are also processed for pre-commits. Previously, only
separately retrieved leaves were handled, which could cause
missing pre-commit data and reduce verification completeness.

Author: ffranr

universe/supplycommit/env.go

@@ -416,6 +416,25 @@ func NewPreCommitFromProof(issuanceProof proof.Proof,
 	}, nil
 }
 
+// NewPreCommitFromMintEvent extracts and returns the supply pre-commitment
+// from the given mint event.
+func NewPreCommitFromMintEvent(issuanceEntry NewMintEvent,
+	delegationKey btcec.PublicKey) (PreCommitment, error) {
+
+	var zero PreCommitment
+
+	issuanceLeaf := issuanceEntry.IssuanceProof
+
+	var issuanceProof proof.Proof
+	err := issuanceProof.Decode(bytes.NewReader(issuanceLeaf.RawProof))
+	if err != nil {
+		return zero, fmt.Errorf("unable to decode issuance proof: %w",
+			err)
+	}
+
+	return NewPreCommitFromProof(issuanceProof, delegationKey)
+}
+
 // TxIn returns the transaction input that corresponds to the pre-commitment.
 func (p *PreCommitment) TxIn() *wire.TxIn {
 	return &wire.TxIn{

universe/supplyverifier/manager.go

@@ -551,13 +551,12 @@ func (m *Manager) InsertSupplyCommit(ctx context.Context,
 		commitment.CommitPoint().String())
 
 	// Fetch all known unspent pre-commitment outputs for the asset group.
-	unspentPreCommits, err :=
-		m.cfg.SupplyCommitView.UnspentPrecommits(
-			ctx, assetSpec, false,
-		).Unpack()
+	preCommits, err := FetchPreCommits(ctx,
+		m.cfg.AssetLookup, m.cfg.SupplyCommitView, assetSpec,
+		commitment, leaves.IssuanceLeafEntries,
+	)
 	if err != nil {
-		return fmt.Errorf("unable to fetch unspent pre-commitments: %w",
-			err)
+		return fmt.Errorf("unable to fetch pre-commitments: %w", err)
 	}
 
 	// First, we verify the supply commitment to ensure it is valid and
@@ -578,15 +577,15 @@ func (m *Manager) InsertSupplyCommit(ctx context.Context,
 	}
 
 	err = verifier.VerifyCommit(
-		ctx, assetSpec, commitment, leaves, unspentPreCommits,
+		ctx, assetSpec, commitment, leaves, preCommits,
 	)
 	if err != nil {
 		return fmt.Errorf("supply commitment verification failed: %w",
 			err)
 	}
 
 	return m.cfg.SupplyCommitView.InsertSupplyCommit(
-		ctx, assetSpec, commitment, leaves, unspentPreCommits,
+		ctx, assetSpec, commitment, leaves, preCommits,
 	)
 }
 

universe/supplyverifier/transitions.go

@@ -204,10 +204,11 @@ func (s *SyncVerifyState) ProcessEvent(event Event,
 
 		// Fetch all known unspent pre-commitment outputs for the asset
 		// group.
-		unspentPreCommits, err :=
-			env.SupplyCommitView.UnspentPrecommits(
-				ctx, env.AssetSpec, false,
-			).Unpack()
+		mintEvents := supplyCommit.SupplyLeaves.IssuanceLeafEntries
+		preCommits, err := FetchPreCommits(
+			ctx, env.AssetLookup, env.SupplyCommitView,
+			env.AssetSpec, supplyCommit.RootCommitment, mintEvents,
+		)
 		if err != nil {
 			return nil, fmt.Errorf("unable to fetch unspent "+
 				"pre-commitments: %w", err)
@@ -231,7 +232,7 @@ func (s *SyncVerifyState) ProcessEvent(event Event,
 
 		err = verifier.VerifyCommit(
 			ctx, env.AssetSpec, supplyCommit.RootCommitment,
-			supplyCommit.SupplyLeaves, unspentPreCommits,
+			supplyCommit.SupplyLeaves, preCommits,
 		)
 		if err != nil {
 			return nil, fmt.Errorf("unable to verify supply "+
@@ -243,7 +244,7 @@ func (s *SyncVerifyState) ProcessEvent(event Event,
 		// Store the verified commitment.
 		err = env.SupplyCommitView.InsertSupplyCommit(
 			ctx, env.AssetSpec, supplyCommit.RootCommitment,
-			supplyCommit.SupplyLeaves, unspentPreCommits,
+			supplyCommit.SupplyLeaves, preCommits,
 		)
 		if err != nil {
 			return nil, fmt.Errorf("unable to store supply "+

universe/supplyverifier/util.go

@@ -6,6 +6,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/universe/supplycommit"
 )
 
@@ -33,3 +34,94 @@ func FetchDelegationKey(ctx context.Context,
 
 	return delegationKey, nil
 }
+
+// FetchPreCommits returns all pre-commitment outputs expected to be spent by
+// the anchoring transaction of the specified supply commitment.
+func FetchPreCommits(ctx context.Context,
+	assetLookup supplycommit.AssetLookup, supplyCommitView SupplyCommitView,
+	assetSpec asset.Specifier, supplyCommit supplycommit.RootCommitment,
+	mintEvents []supplycommit.NewMintEvent) ([]supplycommit.PreCommitment,
+	error) {
+
+	// Get supply commit block height. This will be used to filter out any
+	// pre-commitments that are above the supply commitment height.
+	chainCommit, err := supplyCommit.CommitmentBlock.UnwrapOrErr(
+		fmt.Errorf("commitment block missing"),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("unable to extract supply commitment "+
+			"chain block: %w", err)
+	}
+	supplyCommitBlockHeight := chainCommit.Height
+
+	// Fetch all known unspent pre-commitment outputs for the asset
+	// group.
+	preCommits, err := supplyCommitView.UnspentPrecommits(
+		ctx, assetSpec, false,
+	).Unpack()
+	if err != nil {
+		return nil, fmt.Errorf("unable to fetch unspent "+
+			"pre-commitments: %w", err)
+	}
+
+	// Filter out any pre-commitments that are above the supply commitment
+	// height. These can't be spent by the current supply commitment.
+	filteredPreCommits := make(
+		[]supplycommit.PreCommitment, 0, len(preCommits),
+	)
+	for _, pc := range preCommits {
+		if pc.BlockHeight <= supplyCommitBlockHeight {
+			filteredPreCommits = append(filteredPreCommits, pc)
+		}
+	}
+	preCommits = filteredPreCommits
+
+	// If there are no mint events, then we can return early here because
+	// there won't be any new pre-commitments to consider.
+	if len(mintEvents) == 0 {
+		return preCommits, nil
+	}
+
+	// We'll need the delegation key to extract any new pre-commitments from
+	// the mint events.
+	delegationKey, err := FetchDelegationKey(
+		ctx, assetLookup, assetSpec,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("unable to fetch delegation key: %w",
+			err)
+	}
+
+	// Create a set of outpoints from all known pre-commits. This will be
+	// used to prevent duplicates when adding new pre-commits from the mint
+	// events.
+	preCommitOutPoints := fn.NewSet(fn.Map(
+		preCommits, func(preCommit supplycommit.PreCommitment) string {
+			return preCommit.OutPoint().String()
+		},
+	)...)
+
+	// Collect pre-commitments from the mint events that we haven't already
+	// seen.
+	for idx := range mintEvents {
+		mintEvent := mintEvents[idx]
+
+		preCommit, err := supplycommit.NewPreCommitFromMintEvent(
+			mintEvent, delegationKey,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("unable to extract "+
+				"pre-commitment from mint event: %w", err)
+		}
+
+		// If we already have this pre-commitment, then skip it.
+		op := preCommit.OutPoint()
+		if preCommitOutPoints.Contains(op.String()) {
+			continue
+		}
+
+		preCommits = append(preCommits, preCommit)
+	}
+
+	return preCommits, nil
+}