asset+test+vm: extract common tapscript test code

Author: jharveyb

asset/mock.go

@@ -309,6 +309,109 @@ func SignVirtualTx(priv *btcec.PrivateKey, signDesc *lndclient.SignDescriptor,
 	return sig, nil
 }
 
+// AssetCustomGroupKey constructs a new asset group key and anchor asset from a
+// given asset genesis. The asset group key may also commit to a Tapscript tree
+// root. The tree used in that case includes a hash lock and signature lock.
+// The validity of that Tapscript tree is set by the caller.
+//
+// The following group key derivation methods are supported:
+//
+// BIP86: The group key commits to an empty tapscript tree. Assets can only be
+// added to the group with a valid signature from the tweaked group key.
+//
+// Key-spend: The group key commits to a tapscript tree root, but the witness
+// for the group anchor will be a signature using the tweaked group key. Assets
+// could later be added to the group with either a signature from the tweaked
+// group key or a valid witness for a script in the committed tapscript tree.
+//
+// Script-spend: The group key commits to a tapscript tree root, and the witness
+// for the group anchor is a valid script witness for a script in the tapscript
+// tree. Assets could later be added to the group with either a signature from
+// the tweaked group key or a valid witness for a script in the committed
+// tapscript tree.
+func AssetCustomGroupKey(t *testing.T, useHashLock, BIP86, keySpend,
+	validScriptWitness bool, gen Genesis) *Asset {
+
+	t.Helper()
+
+	// Sanity check the custom group key request. If both flags are false,
+	// the script-spend path will be used.
+	if BIP86 && keySpend {
+		require.Fail(t, "Cannot have both BIP 86 and key spend group "+
+			"key types")
+	}
+
+	var (
+		groupKey *GroupKey
+		err      error
+	)
+
+	genID := gen.ID()
+	scriptKey := RandScriptKey(t)
+	protoAsset := RandAssetWithValues(t, gen, nil, scriptKey)
+
+	groupPrivKey := test.RandPrivKey(t)
+	groupInternalKey := groupPrivKey.PubKey()
+	genSigner := NewMockGenesisSigner(groupPrivKey)
+	genBuilder := MockGroupTxBuilder{}
+
+	// Manually create and use the singly tweaked key here, to match the
+	// signing behavior later when using the signing descriptor.
+	groupSinglyTweakedKey := input.TweakPubKeyWithTweak(
+		groupInternalKey, genID[:],
+	)
+
+	// Populate the initial parameters for the group key request.
+	groupReq := GroupKeyRequest{
+		RawKey:    test.PubToKeyDesc(groupInternalKey),
+		AnchorGen: gen,
+		NewAsset:  protoAsset,
+	}
+
+	// Update the group key request and group key derivation arguments
+	// to match the requested group key type.
+	switch {
+	// Use an empty tapscript and script witness.
+	case BIP86:
+		groupKey, err = DeriveCustomGroupKey(
+			genSigner, &genBuilder, groupReq, nil, nil,
+		)
+
+	// Derive a tapscipt root using the default tapscript tree used for
+	// testing, but use a signature as a witness.
+	case keySpend:
+		tapRootHash := test.BuildTapscriptTreeNoReveal(
+			t, groupSinglyTweakedKey,
+		)
+
+		groupReq.TapscriptRoot = tapRootHash
+		groupKey, err = DeriveCustomGroupKey(
+			genSigner, &genBuilder, groupReq, nil, nil,
+		)
+
+	// For a script spend, we derive a tapscript root, and create the needed
+	// tapscript and script witness.
+	default:
+		_, _, tapLeaf, tapRootHash, witness := test.BuildTapscriptTree(
+			t, useHashLock, validScriptWitness,
+			groupSinglyTweakedKey,
+		)
+
+		groupReq.TapscriptRoot = tapRootHash
+		groupKey, err = DeriveCustomGroupKey(
+			genSigner, &genBuilder, groupReq, tapLeaf, witness,
+		)
+	}
+
+	require.NoError(t, err)
+
+	return NewAssetNoErr(
+		t, gen, protoAsset.Amount, protoAsset.LockTime,
+		protoAsset.RelativeLockTime, scriptKey, groupKey,
+		WithAssetVersion(protoAsset.Version),
+	)
+}
+
 // RandScriptKey creates a random script key for testing.
 func RandScriptKey(t testing.TB) ScriptKey {
 	return NewScriptKey(test.RandPrivKey(t).PubKey())

internal/test/helpers.go

@@ -13,9 +13,11 @@ import (
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
 	"github.com/btcsuite/btcd/btcutil"
+	"github.com/btcsuite/btcd/btcutil/psbt"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcwallet/waddrmgr"
 	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/keychain"
 	"github.com/lightningnetwork/lnd/lnrpc/signrpc"
@@ -389,3 +391,86 @@ func ReadTestDataFile(t *testing.T, fileName string) string {
 
 	return string(fileBytes)
 }
+
+// BuildTapscriptTree builds a Tapscript tree with two leaves, a hash lock
+// script and a signature verification script. It returns only the tapscript
+// tree root.
+func BuildTapscriptTreeNoReveal(t *testing.T,
+	internalKey *btcec.PublicKey) []byte {
+
+	hashLockWitness := []byte("foobar")
+	hashLockLeaf := ScriptHashLock(t, hashLockWitness)
+	sigLeaf := ScriptSchnorrSig(t, internalKey)
+
+	tree := txscript.AssembleTaprootScriptTree(hashLockLeaf, sigLeaf)
+	rootHash := tree.RootNode.TapHash()
+
+	return rootHash[:]
+}
+
+// BuildTapscriptTree builds a Tapscript tree with two leaves, a hash lock
+// script and a signature verification script. It also returns the data needed
+// to satisfy one of the two leaves.
+func BuildTapscriptTree(t *testing.T, useHashLock, valid bool,
+	internalKey *btcec.PublicKey) (*txscript.TapLeaf, *waddrmgr.Tapscript,
+	*psbt.TaprootTapLeafScript, []byte, []byte) {
+
+	// Let's create a taproot asset script now. This is a hash lock with a
+	// simple preimage of "foobar".
+	hashLockWitness := []byte("foobar")
+	invalidHashLockWitness := []byte("not-foobar")
+	hashLockLeaf := ScriptHashLock(t, hashLockWitness)
+
+	// Let's add a second script output as well to test the partial reveal.
+	sigLeaf := ScriptSchnorrSig(t, internalKey)
+	invalidSigWitness := make([]byte, 64)
+
+	var (
+		usedLeaf      *txscript.TapLeaf
+		testTapScript *waddrmgr.Tapscript
+		scriptWitness []byte
+	)
+
+	if useHashLock {
+		usedLeaf = &hashLockLeaf
+		inclusionProof := sigLeaf.TapHash()
+		testTapScript = input.TapscriptPartialReveal(
+			internalKey, hashLockLeaf, inclusionProof[:],
+		)
+		scriptWitness = hashLockWitness
+
+		if !valid {
+			scriptWitness = invalidHashLockWitness
+		}
+	} else {
+		usedLeaf = &sigLeaf
+		inclusionProof := hashLockLeaf.TapHash()
+		testTapScript = input.TapscriptPartialReveal(
+			internalKey, sigLeaf, inclusionProof[:],
+		)
+
+		// If we leave the scriptWitness nil, the genTaprootScriptSpend
+		// function will automatically create a signature for us.
+		// We only need to create a witness if we want an invalid
+		// signature.
+		if !valid {
+			scriptWitness = invalidSigWitness
+		}
+	}
+
+	// Compute the final tapscript root and leaf script needed to create a
+	// key that includes the above tapscript tree.
+	tapTweak := testTapScript.ControlBlock.RootHash(
+		testTapScript.RevealedScript,
+	)
+	controlBlockBytes, err := testTapScript.ControlBlock.ToBytes()
+	require.NoError(t, err)
+
+	tapLeaf := &psbt.TaprootTapLeafScript{
+		ControlBlock: controlBlockBytes,
+		Script:       usedLeaf.Script,
+		LeafVersion:  usedLeaf.LeafVersion,
+	}
+
+	return usedLeaf, testTapScript, tapLeaf, tapTweak, scriptWitness
+}

vm/vm_test.go

@@ -10,12 +10,10 @@ import (
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
-	"github.com/btcsuite/btcwallet/waddrmgr"
 	"github.com/lightninglabs/taproot-assets/asset"
 	"github.com/lightninglabs/taproot-assets/commitment"
 	"github.com/lightninglabs/taproot-assets/internal/test"
 	"github.com/lightninglabs/taproot-assets/tapscript"
-	"github.com/lightningnetwork/lnd/input"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/exp/maps"
 )
@@ -450,47 +448,9 @@ func scriptTreeSpendStateTransition(t *testing.T, useHashLock,
 	valid bool, sigHashType txscript.SigHashType) stateTransitionFunc {
 
 	scriptPrivKey := test.RandPrivKey(t)
-	scriptInternalKey := scriptPrivKey.PubKey()
-
-	// Let's create a taproot asset script now. This is a hash lock with a
-	// simple preimage of "foobar".
-	leaf1 := test.ScriptHashLock(t, []byte("foobar"))
-
-	// Let's add a second script output as well to test the partial reveal.
-	leaf2 := test.ScriptSchnorrSig(t, scriptInternalKey)
-
-	var (
-		usedLeaf      *txscript.TapLeaf
-		testTapScript *waddrmgr.Tapscript
-		scriptWitness []byte
+	usedLeaf, testTapScript, _, _, scriptWitness := test.BuildTapscriptTree(
+		t, useHashLock, valid, scriptPrivKey.PubKey(),
 	)
-	if useHashLock {
-		usedLeaf = &leaf1
-		inclusionProof := leaf2.TapHash()
-		testTapScript = input.TapscriptPartialReveal(
-			scriptInternalKey, leaf1, inclusionProof[:],
-		)
-		scriptWitness = []byte("foobar")
-
-		if !valid {
-			scriptWitness = []byte("not-foobar")
-		}
-	} else {
-		usedLeaf = &leaf2
-		inclusionProof := leaf1.TapHash()
-		testTapScript = input.TapscriptPartialReveal(
-			scriptInternalKey, leaf2, inclusionProof[:],
-		)
-
-		// If we leave the scriptWitness nil, the genTaprootScriptSpend
-		// function will automatically create a signature for us.
-		// We only need to create a witness if we want an invalid
-		// signature.
-		if !valid {
-			scriptWitness = make([]byte, 64)
-		}
-	}
-
 	scriptKey, err := testTapScript.TaprootKey()
 	require.NoError(t, err)