tappsbt: add AltLeaf support to vPacket

address/mock.go

@@ -33,7 +33,7 @@ func RandAddr(t testing.TB, params *ChainParams,
 	proofCourierAddr url.URL) (*AddrWithKeyInfo,
 	*asset.Genesis, *asset.GroupKey) {
 
-	scriptKeyPriv := test.RandPrivKey(t)
+	scriptKeyPriv := test.RandPrivKey()
 	scriptKey := asset.NewScriptKeyBip86(keychain.KeyDescriptor{
 		PubKey: scriptKeyPriv.PubKey(),
 		KeyLocator: keychain.KeyLocator{
@@ -42,7 +42,7 @@ func RandAddr(t testing.TB, params *ChainParams,
 		},
 	})
 
-	internalKey := test.RandPrivKey(t)
+	internalKey := test.RandPrivKey()
 
 	genesis := asset.RandGenesis(t, asset.Type(test.RandInt31n(2)))
 	amount := test.RandInt[uint64]()

asset/asset_test.go

@@ -857,7 +857,7 @@ func TestAssetGroupKey(t *testing.T) {
 func TestDeriveGroupKey(t *testing.T) {
 	t.Parallel()
 
-	groupPriv := test.RandPrivKey(t)
+	groupPriv := test.RandPrivKey()
 	groupPub := groupPriv.PubKey()
 	groupKeyDesc := test.PubToKeyDesc(groupPub)
 	genSigner := NewMockGenesisSigner(groupPriv)

asset/mock.go

@@ -19,6 +19,7 @@ import (
 	"github.com/lightningnetwork/lnd/keychain"
 	"github.com/lightningnetwork/lnd/tlv"
 	"github.com/stretchr/testify/require"
+	"pgregory.net/rapid"
 )
 
 // RandGenesis creates a random genesis for testing.
@@ -38,17 +39,24 @@ func RandGenesis(t testing.TB, assetType Type) Genesis {
 }
 
 // RandGroupKey creates a random group key for testing.
-func RandGroupKey(t testing.TB, genesis Genesis, newAsset *Asset) *GroupKey {
-	groupKey, _ := RandGroupKeyWithSigner(t, genesis, newAsset)
+func RandGroupKey(t rapid.TB, genesis Genesis, newAsset *Asset) *GroupKey {
+	groupKey, _ := RandGroupKeyWithSigner(t, nil, genesis, newAsset)
 	return groupKey
 }
 
 // RandGroupKeyWithSigner creates a random group key for testing, and provides
 // the signer for reissuing assets into the same group.
-func RandGroupKeyWithSigner(t testing.TB, genesis Genesis,
-	newAsset *Asset) (*GroupKey, []byte) {
+func RandGroupKeyWithSigner(t rapid.TB, privKey *btcec.PrivateKey,
+	genesis Genesis, newAsset *Asset) (*GroupKey, []byte) {
 
-	privateKey := test.RandPrivKey(t)
+	var privateKey *btcec.PrivateKey
+	switch {
+	case privKey != nil:
+		privateKey = privKey
+
+	default:
+		privateKey = test.RandPrivKey()
+	}
 
 	genSigner := NewMockGenesisSigner(privateKey)
 	genBuilder := MockGroupTxBuilder{}
@@ -352,7 +360,7 @@ func AssetCustomGroupKey(t *testing.T, useHashLock, BIP86, keySpend,
 	scriptKey := RandScriptKey(t)
 	protoAsset := RandAssetWithValues(t, gen, nil, scriptKey)
 
-	groupPrivKey := test.RandPrivKey(t)
+	groupPrivKey := test.RandPrivKey()
 	groupInternalKey := groupPrivKey.PubKey()
 	genSigner := NewMockGenesisSigner(groupPrivKey)
 	genBuilder := MockGroupTxBuilder{}
@@ -430,12 +438,12 @@ func AssetCustomGroupKey(t *testing.T, useHashLock, BIP86, keySpend,
 
 // RandScriptKey creates a random script key for testing.
 func RandScriptKey(t testing.TB) ScriptKey {
-	return NewScriptKey(test.RandPrivKey(t).PubKey())
+	return NewScriptKey(test.RandPrivKey().PubKey())
 }
 
 // RandSerializedKey creates a random serialized key for testing.
 func RandSerializedKey(t testing.TB) SerializedKey {
-	return ToSerialized(test.RandPrivKey(t).PubKey())
+	return ToSerialized(test.RandPrivKey().PubKey())
 }
 
 // RandID creates a random asset ID.

commitment/commitment_test.go

@@ -53,7 +53,7 @@ func randAssetDetails(t *testing.T, assetType asset.Type) *AssetDetails {
 		Version: assetVersion,
 		Type:    assetType,
 		ScriptKey: keychain.KeyDescriptor{
-			PubKey: test.RandPrivKey(t).PubKey(),
+			PubKey: test.RandPrivKey().PubKey(),
 		},
 		Amount:           &amount,
 		LockTime:         rand.Uint64(),
@@ -127,7 +127,7 @@ func TestNewAssetCommitment(t *testing.T) {
 	)
 	group1Anchor := randAsset(t, genesis1, nil)
 	groupKey1, group1PrivBytes := asset.RandGroupKeyWithSigner(
-		t, genesis1, group1Anchor,
+		t, nil, genesis1, group1Anchor,
 	)
 	group1Anchor = asset.NewAssetNoErr(
 		t, genesis1, group1Anchor.Amount, group1Anchor.LockTime,
@@ -289,7 +289,7 @@ func TestMintTapCommitment(t *testing.T) {
 	genesisNormal := asset.RandGenesis(t, asset.Normal)
 	genesisCollectible := asset.RandGenesis(t, asset.Collectible)
 	pubKey := keychain.KeyDescriptor{
-		PubKey: test.RandPrivKey(t).PubKey(),
+		PubKey: test.RandPrivKey().PubKey(),
 	}
 
 	testCases := []struct {
@@ -1008,7 +1008,7 @@ func TestUpdateAssetCommitment(t *testing.T) {
 	genesis1collect.Type = asset.Collectible
 	group1Anchor := randAsset(t, genesis1, nil)
 	groupKey1, group1PrivBytes := asset.RandGroupKeyWithSigner(
-		t, genesis1, group1Anchor,
+		t, nil, genesis1, group1Anchor,
 	)
 	group1Anchor = asset.NewAssetNoErr(
 		t, genesis1, group1Anchor.Amount, group1Anchor.LockTime,

commitment/taproot_test.go

@@ -27,7 +27,7 @@ func TestTapscriptPreimage(t *testing.T) {
 
 	// Create a script tree that we'll use for our tapscript sibling test
 	// cases.
-	scriptInternalKey := test.RandPrivKey(t).PubKey()
+	scriptInternalKey := test.RandPrivKey().PubKey()
 	leaf1 := test.ScriptHashLock(t, []byte("foobar"))
 	leaf1Hash := leaf1.TapHash()
 	leaf2 := test.ScriptSchnorrSig(t, scriptInternalKey)

internal/test/helpers.go

@@ -98,7 +98,7 @@ func RandOp(t testing.TB) wire.OutPoint {
 	return op
 }
 
-func RandPrivKey(_ testing.TB) *btcec.PrivateKey {
+func RandPrivKey() *btcec.PrivateKey {
 	priv, _ := btcec.PrivKeyFromBytes(RandBytes(32))
 	return priv
 }
@@ -139,7 +139,7 @@ func SchnorrKeysEqual(t testing.TB, a, b *btcec.PublicKey) bool {
 }
 
 func RandPubKey(t testing.TB) *btcec.PublicKey {
-	return SchnorrPubKey(t, RandPrivKey(t))
+	return SchnorrPubKey(t, RandPrivKey())
 }
 
 func RandCommitmentKeyRing(t *testing.T) lnwallet.CommitmentKeyRing {

itest/assets_test.go

@@ -417,7 +417,7 @@ func testMintAssetsWithTapscriptSibling(t *harnessTest) {
 	defer cancel()
 
 	// Build the tapscript tree.
-	sigLockPrivKey := test.RandPrivKey(t.t)
+	sigLockPrivKey := test.RandPrivKey()
 	hashLockPreimage := []byte("foobar")
 	hashLockLeaf := test.ScriptHashLock(t.t, hashLockPreimage)
 	sigLeaf := test.ScriptSchnorrSig(t.t, sigLockPrivKey.PubKey())

proof/append_test.go

@@ -118,7 +118,7 @@ func runAppendTransitionTest(t *testing.T, assetType asset.Type, amt uint64,
 	require.NoError(t, err)
 
 	// Transfer the asset to a new owner.
-	recipientPrivKey := test.RandPrivKey(t)
+	recipientPrivKey := test.RandPrivKey()
 	newAsset := *genesisProof.Asset.Copy()
 	newAsset.ScriptKey = asset.NewScriptKeyBip86(
 		test.PubToKeyDesc(recipientPrivKey.PubKey()),
@@ -156,7 +156,7 @@ func runAppendTransitionTest(t *testing.T, assetType asset.Type, amt uint64,
 	// Add a P2TR change output to test the exclusion proof.
 	var changeInternalKey *btcec.PublicKey
 	if withBip86Change {
-		changeInternalKey = test.RandPrivKey(t).PubKey()
+		changeInternalKey = test.RandPrivKey().PubKey()
 		changeTaprootKey := txscript.ComputeTaprootKeyNoScript(
 			changeInternalKey,
 		)
@@ -221,9 +221,9 @@ func runAppendTransitionTest(t *testing.T, assetType asset.Type, amt uint64,
 	}
 
 	// If we want to test splitting, we do that now, as a second transfer.
-	split1PrivKey := test.RandPrivKey(t)
-	split2PrivKey := test.RandPrivKey(t)
-	split3PrivKey := test.RandPrivKey(t)
+	split1PrivKey := test.RandPrivKey()
+	split2PrivKey := test.RandPrivKey()
+	split3PrivKey := test.RandPrivKey()
 	transitionOutpoint := wire.OutPoint{
 		Hash:  transitionProof.AnchorTx.TxHash(),
 		Index: transitionProof.InclusionProof.OutputIndex,

proof/mint_test.go

@@ -22,7 +22,7 @@ func TestNewMintingBlobs(t *testing.T) {
 
 	// First, we'll create a fake, but legit looking set of minting params
 	// to generate a proof with.
-	genesisPrivKey := test.RandPrivKey(t)
+	genesisPrivKey := test.RandPrivKey()
 	genesisScriptKey := test.PubToKeyDesc(genesisPrivKey.PubKey())
 
 	// We'll modify the returned genesis to instead commit to some actual
@@ -71,7 +71,7 @@ func TestNewMintingBlobs(t *testing.T) {
 	)
 	taprootScript := test.ComputeTaprootScript(t, taprootKey)
 
-	changeInternalKey := test.RandPrivKey(t).PubKey()
+	changeInternalKey := test.RandPrivKey().PubKey()
 	changeTaprootKey := txscript.ComputeTaprootKeyNoScript(
 		changeInternalKey,
 	)

proof/proof_test.go

@@ -234,7 +234,7 @@ func genRandomGenesisWithProof(t testing.TB, assetType asset.Type,
 
 	t.Helper()
 
-	genesisPrivKey := test.RandPrivKey(t)
+	genesisPrivKey := test.RandPrivKey()
 	genesisPubKey := test.PubToKeyDesc(genesisPrivKey.PubKey())
 
 	// If we have a specified meta reveal, then we'll replace the meta hash
@@ -371,7 +371,7 @@ func TestGenesisProofVerification(t *testing.T) {
 
 	// Create a script tree that we'll use for our tapscript sibling test
 	// cases.
-	scriptInternalKey := test.RandPrivKey(t).PubKey()
+	scriptInternalKey := test.RandPrivKey().PubKey()
 	leaf1 := test.ScriptHashLock(t, []byte("foobar"))
 	leaf2 := test.ScriptSchnorrSig(t, scriptInternalKey)
 	testLeafPreimage, err := commitment.NewPreimageFromLeaf(leaf1)

rfqmsg/request_test.go

@@ -139,7 +139,7 @@ func TestRequestMsgDataEncodeDecode(t *testing.T) {
 	assetId := asset.ID(randomAssetIdBytes)
 
 	// Create a random asset group key.
-	assetGroupKey := test.RandPrivKey(t).PubKey()
+	assetGroupKey := test.RandPrivKey().PubKey()
 
 	// Create a zero asset ID. An asset ID of all zeros indicates BTC in the
 	// context of the request message.

tapdb/assets_store_test.go

@@ -57,7 +57,7 @@ func defaultAssetGenOpts(t *testing.T) *assetGenOptions {
 	return &assetGenOptions{
 		version:      asset.Version(rand.Int31n(2)),
 		assetGen:     gen,
-		groupKeyPriv: test.RandPrivKey(t),
+		groupKeyPriv: test.RandPrivKey(),
 		amt:          uint64(test.RandInt[uint32]()),
 		genesisPoint: test.RandOp(t),
 		scriptKey: asset.NewScriptKeyBip86(keychain.KeyDescriptor{
@@ -520,7 +520,7 @@ func newAssetGenerator(t *testing.T,
 
 	groupKeys := make([]*btcec.PrivateKey, numGroupKeys)
 	for i := 0; i < numGroupKeys; i++ {
-		groupKeys[i] = test.RandPrivKey(t)
+		groupKeys[i] = test.RandPrivKey()
 	}
 
 	return &assetGenerator{

tapsend/send_test.go

@@ -2020,11 +2020,11 @@ func TestPayToAddrScript(t *testing.T) {
 		sendAmt    = 2
 	)
 	gen := asset.RandGenesis(t, asset.Normal)
-	ownerDescriptor := test.PubToKeyDesc(test.RandPrivKey(t).PubKey())
+	ownerDescriptor := test.PubToKeyDesc(test.RandPrivKey().PubKey())
 
-	internalKey := test.RandPrivKey(t).PubKey()
+	internalKey := test.RandPrivKey().PubKey()
 	recipientScriptKey := asset.NewScriptKeyBip86(test.PubToKeyDesc(
-		test.RandPrivKey(t).PubKey(),
+		test.RandPrivKey().PubKey(),
 	))
 
 	// Create an asset and derive a commitment for sending 2 of the 5 asset

vm/vm_test.go

@@ -194,7 +194,7 @@ func invalidGenesisStateTransitionWitness(assetType asset.Type,
 func collectibleStateTransition(t *testing.T) (*asset.Asset,
 	commitment.SplitSet, commitment.InputSet, uint32) {
 
-	privKey := test.RandPrivKey(t)
+	privKey := test.RandPrivKey()
 	scriptKey := txscript.ComputeTaprootKeyNoScript(privKey.PubKey())
 
 	genesisOutPoint := wire.OutPoint{}
@@ -206,7 +206,7 @@ func collectibleStateTransition(t *testing.T) (*asset.Asset,
 		ScriptKey: asset.ToSerialized(genesisAsset.ScriptKey.PubKey),
 	}
 	newAsset := genesisAsset.Copy()
-	newAsset.ScriptKey = asset.NewScriptKey(test.RandPrivKey(t).PubKey())
+	newAsset.ScriptKey = asset.NewScriptKey(test.RandPrivKey().PubKey())
 	newAsset.PrevWitnesses = []asset.Witness{{
 		PrevID:          prevID,
 		TxWitness:       nil,
@@ -245,12 +245,12 @@ func normalStateTransition(t *testing.T, currentHeight uint32, sequence,
 	lockTime uint64, addCsvScript, addCltvScript bool) (*asset.Asset,
 	commitment.SplitSet, commitment.InputSet, uint32) {
 
-	privKey1 := test.RandPrivKey(t)
+	privKey1 := test.RandPrivKey()
 	scriptKey1 := txscript.ComputeTaprootKeyNoScript(
 		privKey1.PubKey(),
 	)
 
-	privKey2 := test.RandPrivKey(t)
+	privKey2 := test.RandPrivKey()
 	builder := txscript.NewScriptBuilder().
 		AddData(schnorr.SerializePubKey(privKey2.PubKey())).
 		AddOp(txscript.OP_CHECKSIG)
@@ -357,7 +357,7 @@ func customScriptStateTransition(t *testing.T, currentHeight uint32, sequence,
 	lockTime uint64, tapLeaf txscript.TapLeaf) (*asset.Asset,
 	commitment.SplitSet, commitment.InputSet, uint32) {
 
-	privKey := test.RandPrivKey(t)
+	privKey := test.RandPrivKey()
 	tapTree := txscript.AssembleTaprootScriptTree(tapLeaf)
 	tapTreeRoot := tapTree.RootNode.TapHash()
 	scriptKey := txscript.ComputeTaprootOutputKey(
@@ -414,7 +414,7 @@ func customScriptStateTransition(t *testing.T, currentHeight uint32, sequence,
 func splitStateTransition(t *testing.T) (*asset.Asset, commitment.SplitSet,
 	commitment.InputSet, uint32) {
 
-	privKey := test.RandPrivKey(t)
+	privKey := test.RandPrivKey()
 	scriptKey := txscript.ComputeTaprootKeyNoScript(privKey.PubKey())
 
 	genesisOutPoint := wire.OutPoint{}
@@ -470,7 +470,7 @@ func splitFullValueStateTransition(validRootLocator,
 	return func(t *testing.T) (*asset.Asset, commitment.SplitSet,
 		commitment.InputSet, uint32) {
 
-		privKey := test.RandPrivKey(t)
+		privKey := test.RandPrivKey()
 		scriptKey := txscript.ComputeTaprootKeyNoScript(privKey.PubKey())
 
 		genesisOutPoint := wire.OutPoint{}
@@ -530,7 +530,7 @@ func splitCollectibleStateTransition(validRoot bool) stateTransitionFunc {
 	return func(t *testing.T) (*asset.Asset, commitment.SplitSet,
 		commitment.InputSet, uint32) {
 
-		privKey := test.RandPrivKey(t)
+		privKey := test.RandPrivKey()
 		scriptKey := txscript.ComputeTaprootKeyNoScript(privKey.PubKey())
 
 		genesisOutPoint := wire.OutPoint{}
@@ -595,7 +595,7 @@ func groupAnchorStateTransition(useHashLock, BIP86, keySpend, valid bool,
 func scriptTreeSpendStateTransition(t *testing.T, useHashLock,
 	valid bool, sigHashType txscript.SigHashType) stateTransitionFunc {
 
-	scriptPrivKey := test.RandPrivKey(t)
+	scriptPrivKey := test.RandPrivKey()
 	usedLeaf, testTapScript, _, _, scriptWitness := test.BuildTapscriptTree(
 		t, useHashLock, valid, scriptPrivKey.PubKey(),
 	)