Merge pull request #1716 from lightninglabs/ignore-checker

proof: implement and hook up ignore checker

Author: ffranr

asset/asset.go

@@ -772,6 +772,12 @@ func (id PrevID) Hash() [sha256.Size]byte {
 	return *(*[sha256.Size]byte)(h.Sum(nil))
 }
 
+// String returns a human-readable description of the PrevID.
+func (id PrevID) String() string {
+	return fmt.Sprintf("PrevID(outpoint=%s, id=%s, script_key=%x)",
+		id.OutPoint.String(), id.ID.String(), id.ScriptKey[:])
+}
+
 // AnchorPoint is a type alias for an asset anchor outpoint. It relates the
 // on-chain anchor outpoint (txid:vout) to the corresponding committed asset.
 type AnchorPoint = PrevID

config.go

@@ -197,6 +197,8 @@ type Config struct {
 	// attestations of the total supply of an asset.
 	SupplyCommitManager *supplycommit.MultiStateMachineManager
 
+	IgnoreChecker *tapdb.CachingIgnoreChecker
+
 	UniverseArchive *universe.Archive
 
 	UniverseSyncer universe.Syncer

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

@@ -52,6 +52,7 @@
    - https://github.com/lightninglabs/taproot-assets/pull/1655
    - https://github.com/lightninglabs/taproot-assets/pull/1554
    - https://github.com/lightninglabs/taproot-assets/pull/1587
+   - https://github.com/lightninglabs/taproot-assets/pull/1716
 
 - A new [address version 2 was introduced that supports grouped assets and
   custom (sender-defined)

itest/supply_commit_test.go

@@ -196,8 +196,10 @@ func testSupplyCommitIgnoreAsset(t *harnessTest) {
 	// Determine the transfer output owned by the secondary node.
 	// This is the output that we will ignore.
 	transferOutput := sendResp.RpcResp.Transfer.Outputs[0]
+	changeOutput := sendResp.RpcResp.Transfer.Outputs[1]
 	if sendResp.RpcResp.Transfer.Outputs[1].Amount == sendAssetAmount {
 		transferOutput = sendResp.RpcResp.Transfer.Outputs[1]
+		changeOutput = sendResp.RpcResp.Transfer.Outputs[0]
 	}
 
 	// Get block height at the time of the ignore request.
@@ -217,6 +219,21 @@ func testSupplyCommitIgnoreAsset(t *harnessTest) {
 	require.NotNil(t.t, respIgnore)
 	require.EqualValues(t.t, sendAssetAmount, respIgnore.Leaf.RootSum)
 
+	// We also ignore our change output, so we can later verify that the
+	// proof verifier correctly denies spending the change output.
+	ignoreReq2 := &unirpc.IgnoreAssetOutPointRequest{
+		AssetOutPoint: &taprpc.AssetOutPoint{
+			AnchorOutPoint: changeOutput.Anchor.Outpoint,
+			AssetId:        rpcAsset.AssetGenesis.AssetId,
+			ScriptKey:      changeOutput.ScriptKey,
+		},
+		Amount: sendChangeAmount,
+	}
+	respIgnore2, err := t.tapd.IgnoreAssetOutPoint(ctxb, ignoreReq2)
+	require.NoError(t.t, err)
+	require.NotNil(t.t, respIgnore2)
+	require.EqualValues(t.t, sendChangeAmount, respIgnore2.Leaf.RootSum)
+
 	// Assert that the mempool is empty.
 	mempool := t.lndHarness.Miner().GetRawMempool()
 	require.Empty(t.t, mempool)
@@ -232,6 +249,7 @@ func testSupplyCommitIgnoreAsset(t *harnessTest) {
 			},
 			IgnoreLeafKeys: [][]byte{
 				respIgnore.LeafKey,
+				respIgnore2.LeafKey,
 			},
 		},
 	)
@@ -256,6 +274,7 @@ func testSupplyCommitIgnoreAsset(t *harnessTest) {
 	minedBlocks := MineBlocks(t.t, t.lndHarness.Miner().Client, 1, 1)
 
 	t.Log("Fetch updated supply commitment")
+
 	// Ensure that the supply commitment reflects the ignored asset
 	// outpoint owned by the secondary node.
 	var fetchResp *unirpc.FetchSupplyCommitResponse
@@ -268,6 +287,7 @@ func testSupplyCommitIgnoreAsset(t *harnessTest) {
 				},
 				IgnoreLeafKeys: [][]byte{
 					respIgnore.LeafKey,
+					respIgnore2.LeafKey,
 				},
 			},
 		)
@@ -283,7 +303,7 @@ func testSupplyCommitIgnoreAsset(t *harnessTest) {
 		// Once the ignore tree includes the ignored asset outpoint, we
 		// know that the supply commitment has been updated.
 		return fetchResp.IgnoreSubtreeRoot.RootNode.RootSum ==
-			int64(sendAssetAmount)
+			int64(sendAssetAmount+sendChangeAmount)
 	}, defaultWaitTimeout, time.Second)
 
 	// Verify that the supply commitment tree commits to the ignore subtree.
@@ -310,7 +330,7 @@ func testSupplyCommitIgnoreAsset(t *harnessTest) {
 
 	// Unmarshal ignore tree leaf inclusion proof to verify that the
 	// ignored asset outpoint is included in the ignore tree.
-	require.Len(t.t, fetchResp.IgnoreLeafInclusionProofs, 1)
+	require.Len(t.t, fetchResp.IgnoreLeafInclusionProofs, 2)
 	inclusionProofBytes := fetchResp.IgnoreLeafInclusionProofs[0]
 
 	// Verify that the ignore tree root can be computed from the ignore leaf
@@ -408,11 +428,11 @@ func testSupplyCommitIgnoreAsset(t *harnessTest) {
 	require.NoError(t.t, err)
 	require.NotNil(t.t, respLeaves)
 
-	require.Len(t.t, respLeaves.IgnoreLeaves, 1)
+	require.Len(t.t, respLeaves.IgnoreLeaves, 2)
 
 	ignoreLeafEntry := respLeaves.IgnoreLeaves[0]
 	require.EqualValues(
-		t.t, 10, ignoreLeafEntry.LeafNode.RootSum,
+		t.t, sendAssetAmount, ignoreLeafEntry.LeafNode.RootSum,
 	)
 	require.EqualValues(
 		t.t, newIgnoreBlockHeight, ignoreLeafEntry.BlockHeight,
@@ -432,6 +452,11 @@ func testSupplyCommitIgnoreAsset(t *harnessTest) {
 		"asset script key mismatch in ignore leaf",
 	)
 
+	ignoreLeafEntry2 := respLeaves.IgnoreLeaves[1]
+	require.EqualValues(
+		t.t, sendChangeAmount, ignoreLeafEntry2.LeafNode.RootSum,
+	)
+
 	transferOutPoint, err := wire.NewOutPointFromString(
 		transferOutput.Anchor.Outpoint,
 	)
@@ -443,6 +468,27 @@ func testSupplyCommitIgnoreAsset(t *harnessTest) {
 		t.t, transferOutPoint.Index,
 		ignoreLeafEntry.LeafKey.Outpoint.Index,
 	)
+
+	// We now add our change output to the ignore list as well, then try to
+	// spend it.
+	bobAddr, err := secondTapd.NewAddr(ctxb, &taprpc.NewAddrRequest{
+		AssetId: rpcAsset.AssetGenesis.AssetId,
+		Amt:     sendChangeAmount / 2,
+	})
+	require.NoError(t.t, err)
+	sendAsset(
+		t, t.tapd, withReceiverAddresses(bobAddr),
+		withError("is ignored"),
+	)
+
+	// TODO(ffranr): The above only tests that the node that issued the
+	// ignore request has it in its ignore tree and can then deny spending
+	// it. What we should also test is that the secondary node can sync the
+	// ignore tree and then also deny spending the ignored asset outpoint
+	// they received from the primary node.
+	// Another test case we should add is that a node that _does not_ sync
+	// the ignore tree can _send_ an ignored asset, but a synced node will
+	// deny accepting it (transfer will never complete).
 }
 
 // AssertInclusionProof checks that the inclusion proof for a given leaf key

monitoring/config.go

@@ -43,6 +43,11 @@ type PrometheusConfig struct {
 	// asset minter.
 	AssetMinter tapgarden.Planter
 
+	// CacheStats is a function that can be used to collect cache stats
+	// from the daemon. This is used to export cache hits and misses for
+	// various caches used in the daemon.
+	CacheStats func(hits, misses map[string]int64)
+
 	// PerfHistograms indicates if the additional histogram information for
 	// latency, and handling time of gRPC calls should be enabled. This
 	// generates additional data, and consume more memory for the

monitoring/db_collector.go

@@ -9,7 +9,9 @@ import (
 )
 
 const (
-	dbSizeMetric = "total_db_size"
+	dbSizeMetric        = "total_db_size"
+	dbCacheHitsMetric   = "db_cache_hits_total"
+	dbCacheMissesMetric = "db_cache_misses_total"
 
 	assetProofSizesHistogram = "asset_proofs_sizes"
 )
@@ -24,6 +26,8 @@ type dbCollector struct {
 
 	dbSize              prometheus.Gauge
 	proofSizesHistogram prometheus.Histogram
+	dbCacheHits         *prometheus.CounterVec
+	dbCacheMisses       *prometheus.CounterVec
 }
 
 func newDbCollector(cfg *PrometheusConfig,
@@ -47,6 +51,21 @@ func newDbCollector(cfg *PrometheusConfig,
 			},
 		),
 		proofSizesHistogram: newProofSizesHistogram(),
+		dbCacheHits: prometheus.NewCounterVec(
+			prometheus.CounterOpts{
+				Name: dbCacheHitsMetric,
+				Help: "Total number of cache hits",
+			},
+			[]string{"cache_name"},
+		),
+
+		dbCacheMisses: prometheus.NewCounterVec(
+			prometheus.CounterOpts{
+				Name: dbCacheMissesMetric,
+				Help: "Total number of cache misses",
+			},
+			[]string{"cache_name"},
+		),
 	}, nil
 }
 
@@ -75,6 +94,8 @@ func (a *dbCollector) Describe(ch chan<- *prometheus.Desc) {
 
 	a.dbSize.Describe(ch)
 	a.proofSizesHistogram.Describe(ch)
+	a.dbCacheHits.Describe(ch)
+	a.dbCacheMisses.Describe(ch)
 }
 
 // Collect is called by the Prometheus registry when collecting metrics.
@@ -117,4 +138,23 @@ func (a *dbCollector) Collect(ch chan<- prometheus.Metric) {
 
 	a.proofSizesHistogram.Collect(ch)
 	a.dbSize.Collect(ch)
+
+	// If we don't have a cache stats function, then we skip the cache
+	// stats collection.
+	if a.cfg.CacheStats == nil {
+		return
+	}
+
+	// Fetch all db cache hits and misses.
+	var (
+		cacheHits   = make(map[string]int64)
+		cacheMisses = make(map[string]int64)
+	)
+	a.cfg.CacheStats(cacheHits, cacheMisses)
+	for cacheName, hits := range cacheHits {
+		a.dbCacheHits.WithLabelValues(cacheName).Add(float64(hits))
+	}
+	for cacheName, misses := range cacheMisses {
+		a.dbCacheMisses.WithLabelValues(cacheName).Add(float64(misses))
+	}
 }

proof/mock.go

@@ -24,6 +24,7 @@ import (
 	"github.com/lightninglabs/taproot-assets/internal/test"
 	mboxrpc "github.com/lightninglabs/taproot-assets/taprpc/authmailboxrpc"
 	"github.com/lightninglabs/taproot-assets/taprpc/universerpc"
+	lfn "github.com/lightningnetwork/lnd/fn/v2"
 	"github.com/lightningnetwork/lnd/keychain"
 	"github.com/lightningnetwork/lnd/lnutils"
 	"github.com/lightningnetwork/lnd/lnwire"
@@ -1080,8 +1081,10 @@ func newMockIgnoreChecker(ignoreAll bool,
 	}
 }
 
-func (m *mockIgnoreChecker) IsIgnored(assetPoint AssetPoint) bool {
-	return m.ignoreAll || m.ignoredAssetPoints.Contains(assetPoint)
+func (m *mockIgnoreChecker) IsIgnored(_ context.Context,
+	assetPoint AssetPoint) lfn.Result[bool] {
+
+	return lfn.Ok(m.ignoreAll || m.ignoredAssetPoints.Contains(assetPoint))
 }
 
 // MockUniverseServer is a mock implementation of the UniverseServer

proof/proof_test.go

@@ -996,7 +996,8 @@ func TestProofVerification(t *testing.T) {
 
 	// Verifying the inclusion and exclusion proofs can also be done without
 	// the previous proof.
-	_, err = p.VerifyProofs()
+	vCtx := MockVerifierCtx
+	_, err = p.VerifyProofIntegrity(context.Background(), vCtx)
 	require.NoError(t, err)
 
 	// Ensure that verification of a proof of unknown version fails.