multi: introduce in proof.VerifierCtx struct

In this commit, we introduce a new proof.VerifierCtx struct to cut down
on line noise when verifying single proofs and proof files. This also
lets us centralize the creation of the various interfaces we need to
verify a proof. Finally, this is a prep for an upcoming change where
we'll add a new interface to the validation context.

Author: Roasbeef

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)

proof/proof_stitching_test.go

@@ -51,12 +51,16 @@ func TestProofStitching(t *testing.T) {
 	err = f.Decode(bytes.NewReader(tplBytes))
 	require.NoError(t, err)
 
+	vCtx := VerifierCtx{
+		HeaderVerifier: verifier.VerifyHeader,
+		MerkleVerifier: MockMerkleVerifier,
+		GroupVerifier:  MockGroupVerifier,
+		ChainLookupGen: MockChainLookup,
+	}
+
 	// We want the template to valid, otherwise all other steps are
 	// meaningless.
-	_, err = f.Verify(
-		context.Background(), verifier.VerifyHeader, MockMerkleVerifier,
-		MockGroupVerifier, MockChainLookup,
-	)
+	_, err = f.Verify(context.Background(), vCtx)
 	require.NoError(t, err)
 
 	// The template proof is the last proof in the file, that was the only
@@ -110,6 +114,7 @@ func TestProofStitching(t *testing.T) {
 		brokenProof.TxMerkleProof = *merkleProof
 		brokenProof.BlockHeight = mindedBlock
 		brokenProof.BlockHeader = block.Header
+		vCtx.MerkleVerifier = DefaultMerkleVerifier
 
 		// We now should have a fully valid proof that we can write out
 		// to a file, by replacing the last one in the template.
@@ -120,11 +125,7 @@ func TestProofStitching(t *testing.T) {
 		// can't be fixed because of the script key usage. So if we
 		// get an "invalid exclusion proof" error when validating, we
 		// need to skip this proof.
-		_, err = f.Verify(
-			context.Background(), verifier.VerifyHeader,
-			DefaultMerkleVerifier, MockGroupVerifier,
-			MockChainLookup,
-		)
+		_, err = f.Verify(context.Background(), vCtx)
 		switch {
 		case errors.Is(err, commitment.ErrInvalidTaprootProof):
 			t.Logf("Proof %d is invalid and can't be rescued: %v",