Merge pull request #1400 from Roasbeef/ignore-proof-checker

proof: add new IgnoreChecker proof rejection cache

Author: guggero

itest/assertions.go

@@ -746,10 +746,14 @@ func VerifyProofBlob(t *testing.T, tapClient taprpc.TaprootAssetsClient,
 		return nil
 	}
 
-	snapshot, err := f.Verify(
-		ctxt, headerVerifier, proof.DefaultMerkleVerifier,
-		groupVerifier, proof.MockChainLookup,
-	)
+	vCtx := proof.VerifierCtx{
+		HeaderVerifier: headerVerifier,
+		MerkleVerifier: proof.DefaultMerkleVerifier,
+		GroupVerifier:  groupVerifier,
+		ChainLookupGen: proof.MockChainLookup,
+	}
+
+	snapshot, err := f.Verify(ctxt, vCtx)
 	require.NoError(t, err)
 
 	return f, snapshot

itest/utils.go

@@ -712,11 +712,9 @@ func ManualMintSimpleAsset(t *harnessTest, lndNode *node.HarnessNode,
 	)
 	require.NoError(t.t, err)
 
-	chainBridge := tapgarden.NewMockChainBridge()
 	mintingProofs, err := proof.NewMintingBlobs(
-		&baseProof, proof.MockHeaderVerifier, proof.MockMerkleVerifier,
-		proof.MockGroupVerifier, proof.MockGroupAnchorVerifier,
-		chainBridge, proof.WithAssetMetaReveals(metaReveals),
+		&baseProof, proof.MockVerifierCtx,
+		proof.WithAssetMetaReveals(metaReveals),
 	)
 	require.NoError(t.t, err)
 

proof/append.go

@@ -43,9 +43,7 @@ type TransitionParams struct {
 // the proof for. This method returns both the encoded full provenance (proof
 // chain) and the added latest proof.
 func AppendTransition(blob Blob, params *TransitionParams,
-	headerVerifier HeaderVerifier, merkleVerifier MerkleVerifier,
-	groupVerifier GroupVerifier, chainLookup asset.ChainLookup) (Blob,
-	*Proof, error) {
+	vCtx VerifierCtx) (Blob, *Proof, error) {
 
 	// Decode the proof blob into a proper file structure first.
 	f := NewEmptyFile(V0)
@@ -83,9 +81,8 @@ func AppendTransition(blob Blob, params *TransitionParams,
 	if err := f.AppendProof(*newProof); err != nil {
 		return nil, nil, fmt.Errorf("error appending proof: %w", err)
 	}
-	_, err = f.Verify(
-		ctx, headerVerifier, merkleVerifier, groupVerifier, chainLookup,
-	)
+
+	_, err = f.Verify(ctx, vCtx)
 	if err != nil {
 		return nil, nil, fmt.Errorf("error verifying proof: %w", err)
 	}

proof/append_test.go

@@ -212,8 +212,7 @@ func runAppendTransitionTest(t *testing.T, assetType asset.Type, amt uint64,
 
 	// Append the new transition to the genesis blob.
 	transitionBlob, transitionProof, err := AppendTransition(
-		genesisBlob, transitionParams, MockHeaderVerifier,
-		MockMerkleVerifier, MockGroupVerifier, MockChainLookup,
+		genesisBlob, transitionParams, MockVerifierCtx,
 	)
 	require.NoError(t, err)
 	require.Greater(t, len(transitionBlob), len(genesisBlob))
@@ -421,8 +420,7 @@ func runAppendTransitionTest(t *testing.T, assetType asset.Type, amt uint64,
 	}
 
 	split1Blob, split1Proof, err := AppendTransition(
-		transitionBlob, split1Params, MockHeaderVerifier,
-		MockMerkleVerifier, MockGroupVerifier, MockChainLookup,
+		transitionBlob, split1Params, MockVerifierCtx,
 	)
 	require.NoError(t, err)
 	require.Greater(t, len(split1Blob), len(transitionBlob))
@@ -464,8 +462,7 @@ func runAppendTransitionTest(t *testing.T, assetType asset.Type, amt uint64,
 	}
 
 	split2Blob, split2Proof, err := AppendTransition(
-		transitionBlob, split2Params, MockHeaderVerifier,
-		MockMerkleVerifier, MockGroupVerifier, MockChainLookup,
+		transitionBlob, split2Params, MockVerifierCtx,
 	)
 	require.NoError(t, err)
 	require.Greater(t, len(split2Blob), len(transitionBlob))
@@ -508,8 +505,7 @@ func runAppendTransitionTest(t *testing.T, assetType asset.Type, amt uint64,
 	}
 
 	split3Blob, split3Proof, err := AppendTransition(
-		transitionBlob, split3Params, MockHeaderVerifier,
-		MockMerkleVerifier, MockGroupVerifier, MockChainLookup,
+		transitionBlob, split3Params, MockVerifierCtx,
 	)
 	require.NoError(t, err)
 	require.Greater(t, len(split3Blob), len(transitionBlob))
@@ -569,10 +565,7 @@ func verifyBlob(t testing.TB, blob Blob) *AssetSnapshot {
 	f := NewEmptyFile(V0)
 	require.NoError(t, f.Decode(bytes.NewReader(blob)))
 
-	finalSnapshot, err := f.Verify(
-		context.Background(), MockHeaderVerifier, MockMerkleVerifier,
-		MockGroupVerifier, MockChainLookup,
-	)
+	finalSnapshot, err := f.Verify(context.Background(), MockVerifierCtx)
 	require.NoError(t, err)
 
 	return finalSnapshot

proof/archive.go

@@ -167,10 +167,8 @@ type Archiver interface {
 	// the script key itself. If replace is specified, we expect a proof to
 	// already be present, and we just update (replace) it with the new
 	// proof.
-	ImportProofs(ctx context.Context, headerVerifier HeaderVerifier,
-		merkleVerifier MerkleVerifier, groupVerifier GroupVerifier,
-		chainLookupGen ChainLookupGenerator, replace bool,
-		proofs ...*AnnotatedProof) error
+	ImportProofs(ctx context.Context, vCtx VerifierCtx,
+		replace bool, proofs ...*AnnotatedProof) error
 }
 
 // NotifyArchiver is an Archiver that also allows callers to subscribe to
@@ -709,9 +707,8 @@ func (f *FileArchiver) FetchProofs(_ context.Context,
 // update (replace) it with the new proof.
 //
 // NOTE: This implements the Archiver interface.
-func (f *FileArchiver) ImportProofs(_ context.Context,
-	_ HeaderVerifier, _ MerkleVerifier, _ GroupVerifier,
-	_ ChainLookupGenerator, replace bool, proofs ...*AnnotatedProof) error {
+func (f *FileArchiver) ImportProofs(_ context.Context, _ VerifierCtx,
+	replace bool, proofs ...*AnnotatedProof) error {
 
 	for _, proof := range proofs {
 		proofPath, err := genProofFileStoragePath(
@@ -906,9 +903,7 @@ func (m *MultiArchiver) FetchProofs(ctx context.Context,
 // ImportProofs attempts to store fully populated proofs on disk. The previous
 // outpoint of the first state transition will be used as the Genesis point.
 // The final resting place of the asset will be used as the script key itself.
-func (m *MultiArchiver) ImportProofs(ctx context.Context,
-	headerVerifier HeaderVerifier, merkleVerifier MerkleVerifier,
-	groupVerifier GroupVerifier, chainLookupGen ChainLookupGenerator,
+func (m *MultiArchiver) ImportProofs(ctx context.Context, vCtx VerifierCtx,
 	replace bool, proofs ...*AnnotatedProof) error {
 
 	// Before we import the proofs into the archive, we want to make sure
@@ -917,8 +912,7 @@ func (m *MultiArchiver) ImportProofs(ctx context.Context,
 	f := func(c context.Context, proof *AnnotatedProof) error {
 		// First, we'll decode and then also verify the proof.
 		finalStateTransition, err := m.proofVerifier.Verify(
-			c, bytes.NewReader(proof.Blob), headerVerifier,
-			merkleVerifier, groupVerifier, chainLookupGen,
+			c, bytes.NewReader(proof.Blob), vCtx,
 		)
 		if err != nil {
 			return fmt.Errorf("unable to verify proof: %w", err)
@@ -957,10 +951,7 @@ func (m *MultiArchiver) ImportProofs(ctx context.Context,
 	// additional supplementary information into the locator, we'll attempt
 	// to import each proof our archive backends.
 	for _, archive := range m.backends {
-		err := archive.ImportProofs(
-			ctx, headerVerifier, merkleVerifier, groupVerifier,
-			chainLookupGen, replace, proofs...,
-		)
+		err := archive.ImportProofs(ctx, vCtx, replace, proofs...)
 		if err != nil {
 			return err
 		}
@@ -1026,9 +1017,7 @@ var _ NotifyArchiver = (*MultiArchiver)(nil)
 // assets of the same ID. This is useful when we want to update the proof with a
 // new one after a re-org.
 func ReplaceProofInBlob(ctx context.Context, p *Proof, archive Archiver,
-	headerVerifier HeaderVerifier, merkleVerifier MerkleVerifier,
-	groupVerifier GroupVerifier,
-	chainLookupGen ChainLookupGenerator) error {
+	vCtx VerifierCtx) error {
 
 	// This is a bit of a hacky part. If we have a chain of transactions
 	// that were re-organized, we can't verify the whole chain until all of
@@ -1037,7 +1026,7 @@ func ReplaceProofInBlob(ctx context.Context, p *Proof, archive Archiver,
 	// since we don't know if the whole chain has been updated yet (the
 	// confirmations might come in out of order).
 	// TODO(guggero): Find a better way to do this.
-	headerVerifier = func(wire.BlockHeader, uint32) error {
+	vCtx.HeaderVerifier = func(wire.BlockHeader, uint32) error {
 		return nil
 	}
 
@@ -1105,10 +1094,7 @@ func ReplaceProofInBlob(ctx context.Context, p *Proof, archive Archiver,
 			Locator: existingProof.Locator,
 			Blob:    buf.Bytes(),
 		}
-		err = archive.ImportProofs(
-			ctx, headerVerifier, merkleVerifier, groupVerifier,
-			chainLookupGen, true, directProof,
-		)
+		err = archive.ImportProofs(ctx, vCtx, true, directProof)
 		if err != nil {
 			return fmt.Errorf("unable to import updated proof: %w",
 				err)

proof/archive_test.go

@@ -62,16 +62,14 @@ func TestFileArchiverProofCollision(t *testing.T) {
 		blob2 = []byte("this is the second blob")
 	)
 	err = fileArchive.ImportProofs(
-		ctx, MockHeaderVerifier, MockMerkleVerifier, MockGroupVerifier,
-		MockChainLookup, false, &AnnotatedProof{
+		ctx, MockVerifierCtx, false, &AnnotatedProof{
 			Locator: locator1,
 			Blob:    blob1,
 		},
 	)
 	require.NoError(t, err)
 	err = fileArchive.ImportProofs(
-		ctx, MockHeaderVerifier, MockMerkleVerifier, MockGroupVerifier,
-		MockChainLookup, false, &AnnotatedProof{
+		ctx, MockVerifierCtx, false, &AnnotatedProof{
 			Locator: locator2,
 			Blob:    blob2,
 		},
@@ -189,10 +187,7 @@ func TestFileArchiver(t *testing.T) {
 				}
 
 				err = archive.ImportProofs(
-					ctx, MockHeaderVerifier,
-					MockMerkleVerifier, MockGroupVerifier,
-					MockChainLookup, false,
-					proof,
+					ctx, MockVerifierCtx, false, proof,
 				)
 
 				if testCase.expectedStoreError != nil {
@@ -326,7 +321,7 @@ func TestMigrateOldFileNames(t *testing.T) {
 	// under the new naming scheme.
 	proof6 := RandProof(t, genesis2, scriptKey2, oddTxBlock, 2, 1)
 	err = fileArchive.ImportProofs(
-		nil, nil, nil, nil, MockChainLookup, false, &AnnotatedProof{
+		nil, MockVerifierCtx, false, &AnnotatedProof{
 			Locator: Locator{
 				AssetID:   fn.Ptr(proof6.Asset.ID()),
 				ScriptKey: *proof6.Asset.ScriptKey.PubKey,

proof/backward_compat_test.go

@@ -68,11 +68,15 @@ func runBIPTestVectorBackwardCompatible(t *testing.T,
 			// full proof chain, as it's the first proof in the
 			// chain.
 			if decoded.GenesisReveal != nil {
+				vCtx := VerifierCtx{
+					HeaderVerifier: MockHeaderVerifier,
+					MerkleVerifier: DefaultMerkleVerifier,
+					GroupVerifier:  MockGroupVerifier,
+					ChainLookupGen: MockChainLookup,
+				}
 				_, err = decoded.Verify(
 					context.Background(), nil,
-					MockHeaderVerifier,
-					DefaultMerkleVerifier,
-					MockGroupVerifier, MockChainLookup,
+					MockChainLookup, vCtx,
 				)
 				require.NoError(tt, err)
 			}

proof/mint.go

@@ -229,9 +229,7 @@ func WithSiblingPreimage(
 // NewMintingBlobs takes a set of minting parameters, and produces a series of
 // serialized proof files, which proves the creation/existence of each of the
 // assets within the batch.
-func NewMintingBlobs(params *MintParams, headerVerifier HeaderVerifier,
-	merkleVerifier MerkleVerifier, groupVerifier GroupVerifier,
-	anchorVerifier GroupAnchorVerifier, chainLookupGen ChainLookupGenerator,
+func NewMintingBlobs(params *MintParams, vCtx VerifierCtx,
 	blobOpts ...MintingBlobOption) (AssetProofs, error) {
 
 	opts := defaultMintingBlobOpts()
@@ -245,7 +243,7 @@ func NewMintingBlobs(params *MintParams, headerVerifier HeaderVerifier,
 	}
 
 	proofs, err := committedProofs(
-		base, params.TaprootAssetRoot, anchorVerifier, opts,
+		base, params.TaprootAssetRoot, vCtx.GroupAnchorVerifier, opts,
 	)
 	if err != nil {
 		return nil, err
@@ -257,15 +255,12 @@ func NewMintingBlobs(params *MintParams, headerVerifier HeaderVerifier,
 	for key := range proofs {
 		proof := proofs[key]
 
-		lookup, err := chainLookupGen.GenProofChainLookup(proof)
+		lookup, err := vCtx.ChainLookupGen.GenProofChainLookup(proof)
 		if err != nil {
 			return nil, err
 		}
 
-		_, err = proof.Verify(
-			ctx, nil, headerVerifier, merkleVerifier, groupVerifier,
-			lookup,
-		)
+		_, err = proof.Verify(ctx, nil, lookup, vCtx)
 		if err != nil {
 			return nil, fmt.Errorf("invalid proof file generated: "+
 				"%w", err)

proof/mint_test.go

@@ -128,9 +128,6 @@ func TestNewMintingBlobs(t *testing.T) {
 			}},
 		},
 		GenesisPoint: genesisTx.TxIn[0].PreviousOutPoint,
-	}, MockHeaderVerifier, MockMerkleVerifier, MockGroupVerifier,
-		MockGroupAnchorVerifier, MockChainLookup,
-		WithAssetMetaReveals(metaReveals),
-	)
+	}, MockVerifierCtx, WithAssetMetaReveals(metaReveals))
 	require.NoError(t, err)
 }

proof/mock.go

@@ -27,6 +27,18 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+var (
+	// MockVerifierCtx is a verifier context that uses mock implementations
+	// for all the verifier interfaces.
+	MockVerifierCtx = VerifierCtx{
+		HeaderVerifier:      MockHeaderVerifier,
+		MerkleVerifier:      MockMerkleVerifier,
+		GroupVerifier:       MockGroupVerifier,
+		GroupAnchorVerifier: MockGroupAnchorVerifier,
+		ChainLookupGen:      MockChainLookup,
+	}
+)
+
 func RandProof(t testing.TB, genesis asset.Genesis,
 	scriptKey *btcec.PublicKey, block wire.MsgBlock, txIndex int,
 	outputIndex uint32) Proof {
@@ -161,8 +173,7 @@ func NewMockVerifier(t *testing.T) *MockVerifier {
 }
 
 func (m *MockVerifier) Verify(context.Context, io.Reader,
-	HeaderVerifier, MerkleVerifier, GroupVerifier,
-	ChainLookupGenerator) (*AssetSnapshot, error) {
+	VerifierCtx) (*AssetSnapshot, error) {
 
 	return &AssetSnapshot{
 		Asset: &asset.Asset{
@@ -413,9 +424,8 @@ func (m *MockProofArchive) FetchProofs(_ context.Context,
 }
 
 // ImportProofs will store the given proofs, without performing any validation.
-func (m *MockProofArchive) ImportProofs(_ context.Context, _ HeaderVerifier,
-	_ MerkleVerifier, _ GroupVerifier, _ ChainLookupGenerator, _ bool,
-	proofs ...*AnnotatedProof) error {
+func (m *MockProofArchive) ImportProofs(_ context.Context, _ VerifierCtx,
+	_ bool, proofs ...*AnnotatedProof) error {
 
 	for _, proof := range proofs {
 		err := m.storeLocator(proof.Locator)
@@ -1018,3 +1028,21 @@ func (tmr *TestMetaReveal) ToMetaReveal(t testing.TB) *MetaReveal {
 		UnknownOddTypes:     tmr.UnknownOddTypes,
 	}
 }
+
+type mockIgnoreChecker struct {
+	ignoredAssetPoints fn.Set[AssetPoint]
+	ignoreAll          bool
+}
+
+func newMockIgnoreChecker(ignoreAll bool,
+	ignorePoints ...AssetPoint) *mockIgnoreChecker {
+
+	return &mockIgnoreChecker{
+		ignoredAssetPoints: fn.NewSet(ignorePoints...),
+		ignoreAll:          ignoreAll,
+	}
+}
+
+func (m *mockIgnoreChecker) IsIgnored(assetPoint AssetPoint) bool {
+	return m.ignoreAll || m.ignoredAssetPoints.Contains(assetPoint)
+}