itest: extend supply commit peer verification with mint event

Extend itest `testSupplyVerifyPeerNode` to include minting on the
primary node, publishing a new supply commit, and verifying that the
secondary node can fetch the updated supply commit.

Author: ffranr

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)
 }