WIP: debug x,[y, -y] group key serialization

I noticed that the universe ID group key returned in the new root of the sync diff event sometimes differs from the group key I use when upserting the pre-commit output (which is taken from the issuance leaf proof). The only difference is the prefix, for example:
039bd899fe00ce28741cc81473920f918356af0656a9759f6067a84f26d4951e21
029bd899fe00ce28741cc81473920f918356af0656a9759f6067a84f26d4951e21

I do not understand why the leaves and the universe ID would have different group keys (y component differs). It is flaky, not always the case. I assume I should just use schnorr.SerializePubKey, which strips the prefix with [1:], but I do not see why that should be necessary.
I guess we should only ever store 32 byte schnorr.SerializePubKey in the db? I think that's what we do for the universe and multiverse SQL tables. But then for the new supply commit tables we store the 33 byte compressed, which doesn't seem stable to me anymore.
The y component of a secp256k1 public key can be either -y or y for the same private key. An "odd" y is messing things up somewhere.

Author: ffranr

itest/supply_commit_test.go

@@ -591,10 +591,10 @@ func testSupplyCommitIgnoreAsset(t *harnessTest) {
 	t.syncUniverseState(t.universeServer.service, secondTapd, 0)
 	t.Log("Attempting to fetch supply commit from secondary node")
 
-	fetchResp = nil
+	var peerFetchResp *unirpc.FetchSupplyCommitResponse
 	require.Eventually(t.t, func() bool {
 		// nolint: lll
-		fetchResp, err = secondTapd.FetchSupplyCommit(
+		peerFetchResp, err = secondTapd.FetchSupplyCommit(
 			ctxb, &unirpc.FetchSupplyCommitRequest{
 				GroupKey: &unirpc.FetchSupplyCommitRequest_GroupKeyBytes{
 					GroupKeyBytes: groupKeyBytes,
@@ -612,15 +612,15 @@ func testSupplyCommitIgnoreAsset(t *harnessTest) {
 		// If the fetch response has no block height or hash,
 		// it means that the supply commitment transaction has not
 		// been mined yet, so we should retry.
-		if fetchResp.ChainData.BlockHeight == 0 ||
-			len(fetchResp.ChainData.BlockHash) == 0 {
+		if peerFetchResp.ChainData.BlockHeight == 0 ||
+			len(peerFetchResp.ChainData.BlockHash) == 0 {
 
 			return false
 		}
 
 		// Once the ignore tree includes the ignored asset outpoint, we
 		// know that the supply commitment has been updated.
-		if fetchResp.IgnoreSubtreeRoot == nil {
+		if peerFetchResp.IgnoreSubtreeRoot == nil {
 			return false
 		}
 

tapdb/supply_commit.go

@@ -13,6 +13,7 @@ import (
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
+	"github.com/davecgh/go-spew/spew"
 	"github.com/lightninglabs/taproot-assets/asset"
 	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/mssmt"
@@ -358,6 +359,9 @@ func (s *SupplyCommitMachine) UnspentPrecommits(ctx context.Context,
 
 		// No pre-commits found where we were the issuer. So now
 		// we'll query for pre-commits from other issuers.
+		log.Debugf("Fetching non-issuer supply pre-commit: group_key_bytes=%x", groupKeyBytes)
+		log.Debugf("Fetching non-issuer supply pre-commit: group_key=%s", spew.Sdump(groupKey))
+
 		rows, err := db.FetchUnspentSupplyPreCommits(
 			ctx, schnorr.SerializePubKey(groupKey),
 		)

tapdb/universe.go

@@ -10,6 +10,7 @@ import (
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
 	"github.com/btcsuite/btcd/wire"
+	"github.com/davecgh/go-spew/spew"
 	"github.com/lightninglabs/taproot-assets/asset"
 	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/mssmt"
@@ -703,6 +704,9 @@ func maybeUpsertSupplyPreCommit(ctx context.Context, dbTx UpsertAssetStore,
 		return err
 	}
 
+	log.Debugf("Upserting supply pre-commit: group_key_bytes=%x", groupKeyBytes)
+	log.Debugf("Upserting supply pre-commit: group_key=%s", spew.Sdump(issuanceProof.Asset.GroupKey.GroupPubKey))
+
 	_, err = dbTx.UpsertSupplyPreCommit(
 		ctx, sqlc.UpsertSupplyPreCommitParams{
 			TaprootInternalKey: taprootInternalKeyBytes,
@@ -949,6 +953,11 @@ func universeUpsertProofLeaf(ctx context.Context, dbTx BaseUniverseStore,
 	// If the asset group supports supply commitments and this is an
 	// issuance proof, then we may need to log the supply pre-commitment
 	// output.
+	if leaf.GroupKey != nil && groupKey != nil {
+		log.Debugf("leaf group key: %x", leaf.GroupKey.GroupPubKey.SerializeCompressed())
+		log.Debugf("upsert arg groupKey: %x", groupKey.SerializeCompressed())
+	}
+
 	err = maybeUpsertSupplyPreCommit(
 		ctx, dbTx, proofType, leafProof, metaReveal,
 	)

universe/supplycommit/transitions.go

@@ -454,6 +454,10 @@ func newRootCommitment(ctx context.Context,
 	logger.WhenSome(func(l btclog.Logger) {
 		l.Infof("Creating new root commitment, spending %v "+
 			"pre-commits", len(unspentPreCommits))
+
+		for _, pre := range unspentPreCommits {
+			l.Infof("pre-commit outpoint: %s", pre.OutPoint())
+		}
 	})
 
 	newCommitTx := wire.NewMsgTx(2)
@@ -494,10 +498,10 @@ func newRootCommitment(ctx context.Context,
 	// commitment that was broadcast.
 	var spentCommitOp fn.Option[wire.OutPoint]
 	oldCommitment.WhenSome(func(r RootCommitment) {
-		logger.WhenSome(func(l btclog.Logger) {
-			l.Infof("Re-using prior commitment as outpoint=%v: %v",
-				r.CommitPoint(), limitSpewer.Sdump(r))
-		})
+		//logger.WhenSome(func(l btclog.Logger) {
+		//	l.Infof("Re-using prior commitment as outpoint=%v: %v",
+		//		r.CommitPoint(), limitSpewer.Sdump(r))
+		//})
 
 		newCommitTx.AddTxIn(r.TxIn())
 
@@ -602,10 +606,10 @@ func newRootCommitment(ctx context.Context,
 		SpentCommitment: spentCommitOp,
 	}
 
-	logger.WhenSome(func(l btclog.Logger) {
-		l.Infof("Created new root commitment: %v",
-			limitSpewer.Sdump(newSupplyCommit))
-	})
+	//logger.WhenSome(func(l btclog.Logger) {
+	//	l.Infof("Created new root commitment: %v",
+	//		limitSpewer.Sdump(newSupplyCommit))
+	//})
 
 	commitPkt, err := psbt.NewFromUnsignedTx(newCommitTx)
 	if err != nil {
@@ -836,8 +840,8 @@ func (s *CommitTxSignState) ProcessEvent(event Event,
 				"commitment tx: %w", err)
 		}
 
-		prefixedLog.Infof("Signed supply "+
-			"commitment txn: %v", limitSpewer.Sdump(signedPsbt))
+		//prefixedLog.Infof("Signed supply "+
+		//	"commitment txn: %v", limitSpewer.Sdump(signedPsbt))
 
 		err = psbt.MaybeFinalizeAll(signedPsbt)
 		if err != nil {
@@ -930,10 +934,10 @@ func (c *CommitBroadcastState) ProcessEvent(event Event,
 			return nil, fmt.Errorf("commitment transaction is nil")
 		}
 
-		commitTxid := c.SupplyTransition.NewCommitment.Txn.TxHash()
-		prefixedLog.Infof("Broadcasting supply commitment "+
-			"txn (txid=%v): %v", commitTxid,
-			limitSpewer.Sdump(c.SupplyTransition.NewCommitment.Txn))
+		//commitTxid := c.SupplyTransition.NewCommitment.Txn.TxHash()
+		//prefixedLog.Infof("Broadcasting supply commitment "+
+		//	"txn (txid=%v): %v", commitTxid,
+		//	limitSpewer.Sdump(c.SupplyTransition.NewCommitment.Txn))
 
 		commitTx := c.SupplyTransition.NewCommitment.Txn
 
@@ -1022,10 +1026,10 @@ func (c *CommitBroadcastState) ProcessEvent(event Event,
 			TxIndex:     newEvent.TxIndex,
 		})
 
-		prefixedLog.Infof("Supply commitment txn confirmed "+
-			"in block %d (hash=%v): %v",
-			newEvent.BlockHeight, newEvent.Block.Header.BlockHash(),
-			limitSpewer.Sdump(c.SupplyTransition.NewCommitment.Txn))
+		//prefixedLog.Infof("Supply commitment txn confirmed "+
+		//	"in block %d (hash=%v): %v",
+		//	newEvent.BlockHeight, newEvent.Block.Header.BlockHash(),
+		//	limitSpewer.Sdump(c.SupplyTransition.NewCommitment.Txn))
 
 		// The commitment has been confirmed, so we'll transition to the
 		// finalize state, but also log on disk that we no longer need

universe/supplyverifier/manager.go

@@ -256,8 +256,7 @@ func (m *Manager) handleUniSyncEvent(event fn.Event) error {
 		return nil
 	}
 
-	// If the sync diff is not a new issuance, we
-	// disregard it.
+	// If the sync diff is not a new issuance, we disregard it.
 	universeID := syncDiffEvent.SyncDiff.NewUniverseRoot.ID
 	if universeID.ProofType != universe.ProofTypeIssuance {
 		return nil
@@ -268,7 +267,24 @@ func (m *Manager) handleUniSyncEvent(event fn.Event) error {
 	if universeID.GroupKey == nil {
 		return nil
 	}
-	assetSpec := asset.NewSpecifierFromGroupKey(*universeID.GroupKey)
+
+	// If there are no new leaf proofs, we disregard the sync event.
+	if len(syncDiffEvent.SyncDiff.NewLeafProofs) == 0 {
+		return nil
+	}
+
+	// Get genesis asset ID from the first synced leaf and formulate an
+	// asset specifier.
+	//
+	// TODO(ffranr): Revisit this. We select any asset ID to aid in metdata
+	//  retrieval, but we should be able to do this with just the group key.
+	//  However, QueryAssetGroupByGroupKey currently fails for the asset
+	//  group.
+	assetID := syncDiffEvent.SyncDiff.NewLeafProofs[0].Genesis.ID()
+
+	assetSpec := asset.NewSpecifierOptionalGroupPubKey(
+		assetID, universeID.GroupKey,
+	)
 
 	// Check that the asset group supports supply
 	// commitments.
@@ -436,6 +452,9 @@ func (m *Manager) fetchStateMachine(assetSpec asset.Specifier) (*StateMachine,
 		// the cache with a new running instance.
 	}
 
+	log.Debugf("Creating new supply verifier state machine for "+
+		"group: %x", groupKey.SerializeCompressed())
+
 	ctx, cancel := m.WithCtxQuitNoTimeout()
 	defer cancel()
 

universe/supplyverifier/transitions.go

@@ -23,40 +23,35 @@ func (s *InitState) ProcessEvent(event Event,
 	case *InitEvent:
 		ctx := context.Background()
 
-		// First, we'll query local db for the latest verified supply
-		// commitment.
+		// Retrieve the set of unspent pre-commitments for the asset
+		// group. We will need these later to watch their spends.
+		preCommits, err := env.SupplyCommitView.UnspentPrecommits(
+			ctx, env.AssetSpec, false,
+		).Unpack()
+		if err != nil {
+			return nil, fmt.Errorf("unable to fetch unspent "+
+				"pre-commitments: %w", err)
+		}
+
+		// Query local db for the latest verified supply commitment.
 		latestCommit, err := env.SupplyCommitView.FetchLatestCommitment(
 			ctx, env.AssetSpec,
 		)
 		switch {
 		case errors.Is(err, ErrCommitmentNotFound):
-			// If we don't have a supply commitment in our local db,
-			// then we will kick things off by syncing supply
-			// commitment proofs to catch up.
-			return &StateTransition{
-				NextState: &SyncVerifyState{},
-				NewEvents: lfn.Some(FsmEvent{
-					InternalEvent: []Event{
-						&SyncVerifyEvent{},
-					},
-				}),
-			}, nil
+			// Continue without the latest commitment.
 
 		case err != nil:
 			return nil, fmt.Errorf("unable to fetch latest "+
 				"verified commitment from db: %w", err)
 		}
 
-		// If a prior verified commitment exists, construct a watch
-		// event for its spend along with any other unspent
-		// pre-commitments. This code path also handles catching up on
-		// supply commitments missed while offline.
-		preCommits, err := env.SupplyCommitView.UnspentPrecommits(
-			ctx, env.AssetSpec, false,
-		).Unpack()
-		if err != nil {
-			return nil, fmt.Errorf("unable to fetch unspent "+
-				"pre-commitments: %w", err)
+		// If at this point we don't have any pre-commitments or a
+		// verified supply commitment, then we'll have to raise an
+		// error. Something went wrong before this point.
+		if latestCommit == nil && len(preCommits) == 0 {
+			return nil, fmt.Errorf("no pre-commitments or " +
+				"verified supply commitment found")
 		}
 
 		return &StateTransition{
@@ -319,26 +314,23 @@ func (s *WatchOutputsState) ProcessEvent(event Event,
 		for idx := range preCommits {
 			preCommit := preCommits[idx]
 
-			outpoint := wire.OutPoint{
-				Hash:  preCommit.MintingTxn.TxHash(),
-				Index: preCommit.OutIdx,
-			}
-			txOut := preCommit.MintingTxn.TxOut[preCommit.OutIdx]
+			log.Debugf("watching pre-commitment: %s", preCommit.OutPoint().String())
 
-			pc := preCommit
+			txOut := preCommit.MintingTxn.TxOut[preCommit.OutIdx]
 			mapper := func(spend *chainntnfs.SpendDetail) Event {
 				// nolint: lll
 				return &SpendEvent{
 					SpendDetail:         spend,
-					SpentPreCommitment:  &pc,
+					SpentPreCommitment:  &preCommit,
 					PreCommitments:      preCommits,
 					WatchStartTimestamp: watchStartTimestamp,
 				}
 			}
 
 			events = append(events, &protofsm.RegisterSpend[Event]{
-				OutPoint: outpoint,
-				PkScript: txOut.PkScript,
+				OutPoint:   preCommit.OutPoint(),
+				PkScript:   txOut.PkScript,
+				HeightHint: preCommit.BlockHeight,
 				PostSpendEvent: lfn.Some(
 					protofsm.SpendMapper[Event](mapper),
 				),