Merge pull request #1820 from lightninglabs/wip/supplyverify/late-mint-precommit-sync

Extract supply pre-commits from mint leaves during supply verifier sync

Author: Roasbeef

docs/release-notes/release-notes-0.7.0.md

@@ -78,6 +78,7 @@
    - https://github.com/lightninglabs/taproot-assets/pull/1797
    - https://github.com/lightninglabs/taproot-assets/pull/1823
    - https://github.com/lightninglabs/taproot-assets/pull/1822
+   - https://github.com/lightninglabs/taproot-assets/pull/1820
 
 - A new [address version 2 was introduced that supports grouped assets and
   custom (sender-defined)

itest/supply_commit_test.go

@@ -1042,18 +1042,21 @@ func testSupplyCommitMintBurn(t *harnessTest) {
 //  5. Ignores the asset outpoint sent to the secondary node.
 //  6. Publishes the second supply commitment and mines it.
 //  7. Verifies the secondary node can fetch the updated supply commitment.
+//  8. Primary node mints another asset into the group and publishes the
+//     third supply commitment.
+//  9. Verifies the secondary node can fetch the third supply commitment.
 func testSupplyVerifyPeerNode(t *harnessTest) {
 	ctxb := context.Background()
 
 	t.Log("Minting initial asset group with universe/supply " +
 		"commitments enabled")
 
 	// Create a mint request for a grouped asset with supply commitments.
-	mintReq := CopyRequest(issuableAssets[0])
-	mintReq.Asset.Amount = 5000
+	firstMintReq := CopyRequest(issuableAssets[0])
+	firstMintReq.Asset.Amount = 5000
 
 	rpcFirstAsset, _ := MintAssetWithSupplyCommit(
-		t, mintReq, fn.None[btcec.PublicKey](),
+		t, firstMintReq, fn.None[btcec.PublicKey](),
 	)
 
 	// Parse out the group key from the minted asset.
@@ -1077,7 +1080,7 @@ func testSupplyVerifyPeerNode(t *harnessTest) {
 	// Verify the issuance subtree root exists and has the correct amount.
 	require.NotNil(t.t, fetchResp.IssuanceSubtreeRoot)
 	require.Equal(
-		t.t, int64(mintReq.Asset.Amount),
+		t.t, int64(firstMintReq.Asset.Amount),
 		fetchResp.IssuanceSubtreeRoot.RootNode.RootSum,
 	)
 
@@ -1125,7 +1128,7 @@ func testSupplyVerifyPeerNode(t *harnessTest) {
 	)
 
 	require.Equal(
-		t.t, int64(mintReq.Asset.Amount),
+		t.t, int64(firstMintReq.Asset.Amount),
 		peerFetchResp.IssuanceSubtreeRoot.RootNode.RootSum,
 	)
 
@@ -1160,7 +1163,7 @@ func testSupplyVerifyPeerNode(t *harnessTest) {
 
 	t.Log("Verifying retrieval of second supply commitment from primary " +
 		"node")
-	fetchResp, _ = WaitForSupplyCommit(
+	fetchResp, supplyOutpoint = WaitForSupplyCommit(
 		t.t, ctxb, t.tapd, groupKeyBytes, fn.Some(supplyOutpoint),
 		func(resp *unirpc.FetchSupplyCommitResponse) bool {
 			ignoreRoot := resp.IgnoreSubtreeRoot
@@ -1265,4 +1268,92 @@ func testSupplyVerifyPeerNode(t *harnessTest) {
 	// Verify that the secondary node's supply commitment matches the
 	// primary's.
 	assertFetchCommitResponse(t, fetchResp, peerFetchResp2)
+
+	// Step 8: Primary node mints another asset into the group and publishes
+	// the third supply commitment.
+	t.Log("Minting second asset into the same asset group")
+
+	secondMintReq := &mintrpc.MintAssetRequest{
+		Asset: &mintrpc.MintAsset{
+			AssetType: taprpc.AssetType_NORMAL,
+			Name:      "itestbuxx-supply-commit-tranche-2",
+			AssetMeta: &taprpc.AssetMeta{
+				Data: []byte("second tranche metadata"),
+			},
+			Amount:          2000,
+			AssetVersion:    taprpc.AssetVersion_ASSET_VERSION_V1,
+			NewGroupedAsset: false,
+			GroupedAsset:    true,
+			GroupKey:        groupKeyBytes,
+
+			EnableSupplyCommitments: true,
+		},
+	}
+
+	MintAssetWithSupplyCommit(
+		t, secondMintReq, fn.None[btcec.PublicKey](),
+	)
+
+	t.Log("Updating supply commitment after second mint (creating third " +
+		"supply commitment)")
+	UpdateAndMineSupplyCommit(
+		t.t, ctxb, t.tapd, t.lndHarness.Miner().Client,
+		groupKeyBytes, 1,
+	)
+
+	// Wait for the third supply commitment to be available.
+	expectedTotalAfterSecondMint := int64(
+		firstMintReq.Asset.Amount + secondMintReq.Asset.Amount,
+	)
+	var thirdSupplyCommitResp *unirpc.FetchSupplyCommitResponse
+	thirdSupplyCommitResp, _ = WaitForSupplyCommit(
+		t.t, ctxb, t.tapd, groupKeyBytes, fn.Some(supplyOutpoint),
+		func(resp *unirpc.FetchSupplyCommitResponse) bool {
+			actualRootSum :=
+				resp.IssuanceSubtreeRoot.RootNode.RootSum
+
+			return resp.IssuanceSubtreeRoot != nil &&
+				actualRootSum == expectedTotalAfterSecondMint
+		},
+	)
+
+	// Step 9: Verify the secondary node can fetch the third supply
+	// commitment.
+	t.Log("Verifying secondary node can fetch third supply commitment")
+
+	// Verify the secondary node can fetch the third supply commitment.
+	peerFetchPred3 := func(resp *unirpc.FetchSupplyCommitResponse) error {
+		if resp.IssuanceSubtreeRoot == nil {
+			return fmt.Errorf("expected issuance subtree root")
+		}
+
+		// Check if the supply commitment includes the second mint.
+		if resp.IssuanceSubtreeRoot.RootNode.RootSum !=
+			expectedTotalAfterSecondMint {
+
+			return fmt.Errorf("expected RootSum %d, got %d",
+				expectedTotalAfterSecondMint,
+				resp.IssuanceSubtreeRoot.RootNode.RootSum)
+		}
+
+		return nil
+	}
+
+	// nolint: lll
+	req = unirpc.FetchSupplyCommitRequest{
+		GroupKey: &unirpc.FetchSupplyCommitRequest_GroupKeyBytes{
+			GroupKeyBytes: groupKeyBytes,
+		},
+		Locator: &unirpc.FetchSupplyCommitRequest_SpentCommitOutpoint{
+			SpentCommitOutpoint: thirdSupplyCommitResp.SpentCommitmentOutpoint,
+		},
+	}
+
+	peerFetchResp3 := rpcassert.FetchSupplyCommitRPC(
+		t.t, ctxb, secondTapd, peerFetchPred3, &req,
+	)
+
+	// Verify that the secondary node's third supply commitment matches the
+	// primary's.
+	assertFetchCommitResponse(t, thirdSupplyCommitResp, peerFetchResp3)
 }

tapdb/supply_commit.go

@@ -1151,6 +1151,12 @@ func (s *SupplyCommitMachine) InsertSupplyCommit(ctx context.Context,
 					"pre-commit outpoint: %w", err)
 			}
 
+			err = upsertSupplyPreCommit(ctx, db, preCommit)
+			if err != nil {
+				return fmt.Errorf("failed to upsert "+
+					"pre-commit: %w", err)
+			}
+
 			markParams := sqlc.MarkPreCommitSpentByOutpointParams{
 				SpentByCommitID: sqlInt64(newCommitmentID),
 				Outpoint:        outpointBytes,

tapdb/universe.go

@@ -16,7 +16,7 @@ import (
 	"github.com/lightninglabs/taproot-assets/proof"
 	"github.com/lightninglabs/taproot-assets/tapdb/sqlc"
 	"github.com/lightninglabs/taproot-assets/universe"
-	"github.com/lightninglabs/taproot-assets/universe/supplyverifier"
+	"github.com/lightninglabs/taproot-assets/universe/supplycommit"
 	lfn "github.com/lightningnetwork/lnd/fn/v2"
 	"github.com/lightningnetwork/lnd/keychain"
 )
@@ -611,52 +611,27 @@ func shouldInsertPreCommit(proofType universe.ProofType,
 	return true
 }
 
-// maybeUpsertSupplyPreCommit inserts a supply pre-commitment output if the
-// asset group supports supply commitments and this is an issuance proof.
-func maybeUpsertSupplyPreCommit(ctx context.Context, dbTx UpsertAssetStore,
-	proofType universe.ProofType, issuanceProof proof.Proof,
-	metaReveal *proof.MetaReveal) error {
+// upsertSupplyPreCommit upserts a supply pre-commitment into the database.
+func upsertSupplyPreCommit(ctx context.Context, dbTx UpsertAssetStore,
+	preCommit supplycommit.PreCommitment) error {
 
-	if !shouldInsertPreCommit(proofType, issuanceProof, metaReveal) {
-		return nil
-	}
-
-	delegationKey, err := metaReveal.DelegationKey.UnwrapOrErr(
-		errors.New("missing delegation key"),
-	)
-	if err != nil {
-		return err
-	}
-
-	preCommitOutput, err := supplyverifier.ExtractPreCommitOutput(
-		issuanceProof, delegationKey,
-	)
-	if err != nil {
-		return fmt.Errorf("unable to extract pre-commit "+
-			"output: %w", err)
-	}
+	// Encode the group key, taproot internal key, and pre-commit outpoint.
+	groupKeyBytes := schnorr.SerializePubKey(&preCommit.GroupPubKey)
+	taprootInternalKeyBytes :=
+		preCommit.InternalKey.PubKey.SerializeCompressed()
 
-	outPointBytes, err := encodeOutpoint(preCommitOutput.OutPoint())
+	outPointBytes, err := encodeOutpoint(preCommit.OutPoint())
 	if err != nil {
 		return fmt.Errorf("unable to encode supply pre-commit "+
 			"outpoint: %w", err)
 	}
 
-	// Upsert the supply pre-commitment output.
-	//
-	// Encode the group key and taproot internal key.
-	groupKeyBytes := schnorr.SerializePubKey(
-		&issuanceProof.Asset.GroupKey.GroupPubKey,
-	)
-	taprootInternalKeyBytes :=
-		preCommitOutput.InternalKey.PubKey.SerializeCompressed()
-
 	// Try to fetch an existing chain tx row from the database. We fetch
 	// first instead of blindly upserting to avoid overwriting existing data
 	// with null values.
 	var chainTxDbID fn.Option[int64]
 
-	txIDBytes := fn.ByteSlice(issuanceProof.AnchorTx.TxHash())
+	txIDBytes := fn.ByteSlice(preCommit.MintingTxn.TxHash())
 	chainTxn, err := dbTx.FetchChainTx(ctx, txIDBytes)
 	switch {
 	case errors.Is(err, sql.ErrNoRows):
@@ -677,17 +652,15 @@ func maybeUpsertSupplyPreCommit(ctx context.Context, dbTx UpsertAssetStore,
 	// If we didn't find an existing chain tx, then we'll insert a new
 	// one now.
 	if chainTxDbID.IsNone() {
-		blockHash := issuanceProof.BlockHeader.BlockHash()
-		txBytes, err := fn.Serialize(&issuanceProof.AnchorTx)
+		txBytes, err := fn.Serialize(preCommit.MintingTxn)
 		if err != nil {
 			return fmt.Errorf("failed to serialize tx: %w", err)
 		}
 
 		txDbID, err := dbTx.UpsertChainTx(ctx, ChainTxParams{
 			Txid:        txIDBytes,
 			RawTx:       txBytes,
-			BlockHeight: sqlInt32(issuanceProof.BlockHeight),
-			BlockHash:   blockHash.CloneBytes(),
+			BlockHeight: sqlInt32(preCommit.BlockHeight),
 		})
 		if err != nil {
 			return fmt.Errorf("unable to upsert chain tx: %w", err)
@@ -718,6 +691,39 @@ func maybeUpsertSupplyPreCommit(ctx context.Context, dbTx UpsertAssetStore,
 	return nil
 }
 
+// maybeUpsertSupplyPreCommit inserts a supply pre-commitment output if the
+// asset group supports supply commitments and this is an issuance proof.
+func maybeUpsertSupplyPreCommit(ctx context.Context, dbTx UpsertAssetStore,
+	proofType universe.ProofType, issuanceProof proof.Proof,
+	metaReveal *proof.MetaReveal) error {
+
+	if !shouldInsertPreCommit(proofType, issuanceProof, metaReveal) {
+		return nil
+	}
+
+	delegationKey, err := metaReveal.DelegationKey.UnwrapOrErr(
+		errors.New("missing delegation key"),
+	)
+	if err != nil {
+		return err
+	}
+
+	preCommit, err := supplycommit.NewPreCommitFromProof(
+		issuanceProof, delegationKey,
+	)
+	if err != nil {
+		return fmt.Errorf("unable to extract pre-commit "+
+			"output: %w", err)
+	}
+
+	err = upsertSupplyPreCommit(ctx, dbTx, preCommit)
+	if err != nil {
+		return fmt.Errorf("unable to upsert supply pre-commit: %w", err)
+	}
+
+	return nil
+}
+
 // UpsertProofLeaf inserts or updates a proof leaf within the universe tree,
 // stored at the base key. The metaReveal type is purely optional, and should be
 // specified if the genesis proof committed to a non-zero meta hash.