tappsbt+asset: move AltLeafAsset type alias

Author: jharveyb

asset/asset.go

@@ -2336,18 +2336,27 @@ func NewAltLeaf(key ScriptKey, keyVersion ScriptVersion,
 	}, nil
 }
 
+// InnerAltLeaf returns the inner value of an AltLeaf, as its concrete type.
+func InnerAltLeaf[T AltLeaf[T]](a AltLeaf[T]) T {
+	return a.(T)
+}
+
 // CopyAltLeaf performs a deep copy of an AltLeaf.
 func CopyAltLeaf[T AltLeaf[T]](a AltLeaf[T]) AltLeaf[T] {
 	return a.Copy()
 }
 
 // CopyAltLeaves performs a deep copy of an AltLeaf slice.
 func CopyAltLeaves[T AltLeaf[T]](a []AltLeaf[T]) []AltLeaf[T] {
+	if len(a) == 0 {
+		return nil
+	}
+
 	return fn.Map(a, CopyAltLeaf[T])
 }
 
-// Validate checks that an Asset is a valid AltLeaf. An Asset used as an AltLeaf
-// must meet these constraints:
+// ValidateAltLeaf checks that an Asset is a valid AltLeaf. An Asset used as an
+// AltLeaf must meet these constraints:
 // - Version must be V0.
 // - Genesis must be the empty Genesis.
 // - Amount, LockTime, and RelativeLockTime must be 0.
@@ -2375,9 +2384,8 @@ func (a *Asset) ValidateAltLeaf() error {
 	}
 
 	if a.SplitCommitmentRoot != nil {
-		return fmt.Errorf(
-			"alt leaf split commitment root must be empty",
-		)
+		return fmt.Errorf("alt leaf split commitment root must be " +
+			"empty")
 	}
 
 	if a.GroupKey != nil {
@@ -2427,5 +2435,8 @@ func (a *Asset) DecodeAltLeaf(r io.Reader) error {
 	return a.Decode(r)
 }
 
+// AltLeafAsset is an AltLeaf backed by an Asset object.
+type AltLeafAsset = AltLeaf[*Asset]
+
 // Ensure Asset implements the AltLeaf interface.
 var _ AltLeaf[*Asset] = (*Asset)(nil)

asset/encoding.go

@@ -810,6 +810,9 @@ func DecodeTapLeaf(leafData []byte) (*txscript.TapLeaf, error) {
 
 func AltLeavesEncoder(w io.Writer, val any, buf *[8]byte) error {
 	if t, ok := val.(*[]AltLeaf[*Asset]); ok {
+		// If the AltLeaves slice is empty, we will still encode its
+		// length here (as 0). Callers should avoid encoding empty
+		// AltLeaves slices.
 		if err := tlv.WriteVarInt(w, uint64(len(*t)), buf); err != nil {
 			return err
 		}

asset/mock.go

@@ -6,13 +6,15 @@ import (
 	"crypto/sha256"
 	"encoding/hex"
 	"fmt"
+	"slices"
 	"testing"
 
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/lndclient"
+	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/internal/test"
 	"github.com/lightninglabs/taproot-assets/mssmt"
 	"github.com/lightningnetwork/lnd/input"
@@ -151,6 +153,14 @@ func CheckAssetAsserts(a *Asset, checks ...AssetAssert) error {
 	return nil
 }
 
+// SortFunc is used to sort assets lexicographically by their script keys.
+func SortFunc(a, b *Asset) int {
+	return bytes.Compare(
+		a.ScriptKey.PubKey.SerializeCompressed(),
+		b.ScriptKey.PubKey.SerializeCompressed(),
+	)
+}
+
 // RandGenesis creates a random genesis for testing.
 func RandGenesis(t testing.TB, assetType Type) Genesis {
 	t.Helper()
@@ -660,6 +670,68 @@ func RandAssetWithValues(t testing.TB, genesis Genesis, groupKey *GroupKey,
 	)
 }
 
+// RandAltLeaf generates a random Asset that is a valid AltLeaf.
+func RandAltLeaf(t testing.TB) *Asset {
+	randWitness := []Witness{
+		{TxWitness: test.RandTxWitnesses(t)},
+	}
+	randKey := RandScriptKey(t)
+	randVersion := ScriptVersion(test.RandInt[uint16]())
+	randLeaf, err := NewAltLeaf(randKey, randVersion, randWitness)
+	require.NoError(t, err)
+	require.NoError(t, randLeaf.ValidateAltLeaf())
+
+	return randLeaf
+}
+
+// RandAltLeaves generates a random number of random alt leaves.
+func RandAltLeaves(t testing.TB, nonZero bool) []*Asset {
+	// Limit the number of leaves to keep test vectors small.
+	maxLeaves := 4
+	numLeaves := test.RandIntn(maxLeaves)
+	if nonZero {
+		numLeaves += 1
+	}
+
+	if numLeaves == 0 {
+		return nil
+	}
+
+	altLeaves := make([]*Asset, numLeaves)
+	for idx := range numLeaves {
+		altLeaves[idx] = RandAltLeaf(t)
+	}
+
+	return altLeaves
+}
+
+// ToAltLeaves casts []Asset to []AltLeafAsset, without checking that the assets
+// are valid AltLeaves.
+func ToAltLeaves(leaves []*Asset) []AltLeafAsset {
+	return fn.Map(leaves, func(l *Asset) AltLeafAsset {
+		return AltLeafAsset(l)
+	})
+}
+
+// FromAltLeaves casts []AltLeafAsset to []Asset, which is always safe.
+func FromAltLeaves(leaves []AltLeafAsset) []*Asset {
+	return fn.Map(leaves, InnerAltLeaf[*Asset])
+}
+
+// CompareAltLeaves compares two slices of AltLeafAssets for equality.
+func CompareAltLeaves(t *testing.T, a, b []AltLeafAsset) {
+	require.Equal(t, len(a), len(b))
+
+	aInner := fn.Map(a, InnerAltLeaf[*Asset])
+	bInner := fn.Map(b, InnerAltLeaf[*Asset])
+
+	slices.SortStableFunc(aInner, SortFunc)
+	slices.SortStableFunc(bInner, SortFunc)
+	for idx := range aInner {
+		require.True(t, aInner[idx].DeepEqual(bInner[idx]))
+	}
+}
+
 type ValidTestCase struct {
 	Asset    *TestAsset `json:"asset"`
 	Expected string     `json:"expected"`

tappsbt/decode.go

@@ -366,7 +366,7 @@ func proofDecoder(p **proof.Proof) decoderFunc {
 }
 
 // altLeavesDecoder returns a decoder function that can handle nil alt leaves.
-func altLeavesDecoder(a *[]AltLeafAsset) decoderFunc {
+func altLeavesDecoder(a *[]asset.AltLeafAsset) decoderFunc {
 	return func(key, byteVal []byte) error {
 		if len(byteVal) == 0 {
 			return nil

tappsbt/decode_test.go

@@ -241,8 +241,8 @@ func TestEncodingDecoding(t *testing.T) {
 		name: "random packet with colliding alt leaves",
 		pkg: func(t *testing.T) *VPacket {
 			pkt := RandPacket(t, true, true)
-			firstLeaf := RandAltLeaf(t)
-			secondLeaf := RandAltLeaf(t)
+			firstLeaf := asset.RandAltLeaf(t)
+			secondLeaf := asset.RandAltLeaf(t)
 
 			firstLeafKey := asset.ToSerialized(
 				firstLeaf.ScriptKey.PubKey,
@@ -251,7 +251,7 @@ func TestEncodingDecoding(t *testing.T) {
 			require.NoError(t, err)
 
 			secondLeaf.ScriptKey = asset.NewScriptKey(leafKeyCopy)
-			altLeaves := []AltLeafAsset{firstLeaf, secondLeaf}
+			altLeaves := []asset.AltLeafAsset{firstLeaf, secondLeaf}
 
 			pkt.Inputs[0].AltLeaves = asset.CopyAltLeaves(altLeaves)
 			pkt.Outputs[0].AltLeaves = asset.CopyAltLeaves(
@@ -270,9 +270,9 @@ func TestEncodingDecoding(t *testing.T) {
 			pkt := RandPacket(t, true, true)
 
 			numLeaves := 2000
-			altLeaves := make([]AltLeafAsset, 0, numLeaves)
-			for range numLeaves {
-				altLeaves = append(altLeaves, RandAltLeaf(t))
+			altLeaves := make([]asset.AltLeafAsset, numLeaves)
+			for idx := range numLeaves {
+				altLeaves[idx] = asset.RandAltLeaf(t)
 			}
 
 			pkt.Inputs[0].AltLeaves = altLeaves

tappsbt/encode.go

@@ -384,9 +384,9 @@ func proofEncoder(p *proof.Proof) encoderFunc {
 }
 
 // altLeavesEncoder is an encoder that does nothing if the given alt leaf slice
-// is nil.
-func altLeavesEncoder(a []AltLeafAsset) encoderFunc {
-	if a == nil {
+// is nil or empty.
+func altLeavesEncoder(a []asset.AltLeafAsset) encoderFunc {
+	if len(a) == 0 {
 		return func([]byte) ([]*customPsbtField, error) {
 			return nil, nil
 		}

tappsbt/interface.go

@@ -106,9 +106,6 @@ type bip32DerivationPredicate func(*psbt.Bip32Derivation) bool
 // BIP-0032 derivation paths.
 type taprootBip32DerivationPredicate func(*psbt.TaprootBip32Derivation) bool
 
-// AltLeafAsset is an AltLeaf backed by an Asset object.
-type AltLeafAsset = asset.AltLeaf[*asset.Asset]
-
 var (
 	// VOutIsSplitRoot is a predicate that returns true if the virtual
 	// output is a split root output.
@@ -399,7 +396,7 @@ type VInput struct {
 	// will be inserted in the input anchor Tap commitment. These
 	// data-carrying leaves are used for a purpose distinct from
 	// representing individual Taproot Assets.
-	AltLeaves []AltLeafAsset
+	AltLeaves []asset.AltLeafAsset
 }
 
 // Copy creates a deep copy of the VInput.
@@ -599,7 +596,7 @@ type VOutput struct {
 	// will be inserted in the output anchor Tap commitment. These
 	// data-carrying leaves are used for a purpose distinct from
 	// representing individual Taproot Assets.
-	AltLeaves []AltLeafAsset
+	AltLeaves []asset.AltLeafAsset
 }
 
 // Copy creates a deep copy of the VOutput.

tappsbt/mock.go

@@ -37,38 +37,6 @@ var (
 	)
 )
 
-// RandAltLeaf generates a random Asset that is a valid AltLeaf.
-func RandAltLeaf(t testing.TB) *asset.Asset {
-	randWitness := []asset.Witness{
-		{TxWitness: test.RandTxWitnesses(t)},
-	}
-	randKey := asset.RandScriptKey(t)
-	randVersion := asset.ScriptVersion(test.RandInt[uint16]())
-	randLeaf, err := asset.NewAltLeaf(randKey, randVersion, randWitness)
-	require.NoError(t, err)
-
-	require.NoError(t, randLeaf.ValidateAltLeaf())
-
-	return randLeaf
-}
-
-// RandAltLeaves generates a set of random number of random alt leaves.
-func RandAltLeaves(t testing.TB) []AltLeafAsset {
-	// Limit the number of leaves to keep the test vectors small.
-	maxLeaves := int32(4)
-	numLeaves := test.RandInt31n(maxLeaves)
-	if numLeaves == 0 {
-		return nil
-	}
-
-	altLeaves := make([]AltLeafAsset, 0, numLeaves)
-	for range numLeaves {
-		altLeaves = append(altLeaves, AltLeafAsset(RandAltLeaf(t)))
-	}
-
-	return altLeaves
-}
-
 func RandAssetForPacket(t testing.TB, assetType asset.Type,
 	desc keychain.KeyDescriptor) *asset.Asset {
 
@@ -205,9 +173,12 @@ func RandPacket(t testing.TB, setVersion, altLeaves bool) *VPacket {
 	}
 
 	if altLeaves {
-		randVInput.AltLeaves = RandAltLeaves(t)
-		randVOutput1.AltLeaves = RandAltLeaves(t)
-		randVOutput2.AltLeaves = RandAltLeaves(t)
+		inputLeaves := asset.RandAltLeaves(t, true)
+		output1Leaves := asset.RandAltLeaves(t, true)
+		output2Leaves := asset.RandAltLeaves(t, true)
+		randVInput.AltLeaves = asset.ToAltLeaves(inputLeaves)
+		randVOutput1.AltLeaves = asset.ToAltLeaves(output1Leaves)
+		randVOutput2.AltLeaves = asset.ToAltLeaves(output2Leaves)
 	}
 
 	vPacket := &VPacket{
@@ -346,15 +317,9 @@ func NewTestFromVInput(t testing.TB, i *VInput) *TestVInput {
 
 		ti.AltLeaves = make([]*asset.TestAsset, 0, len(i.AltLeaves))
 		for idx := range i.AltLeaves {
-			// We also need a type assertion on each leaf.
-			leaf, ok := i.AltLeaves[idx].(*asset.Asset)
-			if !ok {
-				t.Errorf("AltLeaf must be of type *asset.Asset")
-			}
-
+			leaf := asset.InnerAltLeaf(i.AltLeaves[idx])
 			ti.AltLeaves = append(
-				ti.AltLeaves,
-				asset.NewTestFromAsset(t, leaf),
+				ti.AltLeaves, asset.NewTestFromAsset(t, leaf),
 			)
 		}
 	}
@@ -415,7 +380,7 @@ func (ti *TestVInput) ToVInput(t testing.TB) *VInput {
 	}
 
 	if len(ti.AltLeaves) > 0 {
-		vi.AltLeaves = make([]AltLeafAsset, len(ti.AltLeaves))
+		vi.AltLeaves = make([]asset.AltLeafAsset, len(ti.AltLeaves))
 		for idx, leaf := range ti.AltLeaves {
 			vi.AltLeaves[idx] = leaf.ToAsset(t)
 		}
@@ -669,15 +634,9 @@ func NewTestFromVOutput(t testing.TB, v *VOutput,
 
 		vo.AltLeaves = make([]*asset.TestAsset, 0, len(vo.AltLeaves))
 		for idx := range v.AltLeaves {
-			// We also need a type assertion on each leaf.
-			leaf, ok := v.AltLeaves[idx].(*asset.Asset)
-			if !ok {
-				t.Errorf("AltLeaf must be of type *asset.Asset")
-			}
-
+			leaf := asset.InnerAltLeaf(v.AltLeaves[idx])
 			vo.AltLeaves = append(
-				vo.AltLeaves,
-				asset.NewTestFromAsset(t, leaf),
+				vo.AltLeaves, asset.NewTestFromAsset(t, leaf),
 			)
 		}
 	}
@@ -800,7 +759,7 @@ func (to *TestVOutput) ToVOutput(t testing.TB) *VOutput {
 	}
 
 	if len(to.AltLeaves) > 0 {
-		v.AltLeaves = make([]AltLeafAsset, len(to.AltLeaves))
+		v.AltLeaves = make([]asset.AltLeafAsset, len(to.AltLeaves))
 		for idx, leaf := range to.AltLeaves {
 			v.AltLeaves[idx] = leaf.ToAsset(t)
 		}