asset+tappsbt: fix generic type weirdness

By changing the generic signature of the AltLeaf type we can get rid of
some of the weirdness and helper methods surrounding the type.

Author: guggero

asset/asset.go

@@ -2302,7 +2302,7 @@ type ChainAsset struct {
 type AltLeaf[T any] interface {
 	// Copyable asserts that the target type of this interface satisfies
 	// the Copyable interface.
-	fn.Copyable[T]
+	fn.Copyable[*T]
 
 	// ValidateAltLeaf ensures that an AltLeaf is valid.
 	ValidateAltLeaf() error
@@ -2336,23 +2336,13 @@ 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] {
+func CopyAltLeaves(a []AltLeaf[Asset]) []AltLeaf[Asset] {
 	if len(a) == 0 {
 		return nil
 	}
 
-	return fn.Map(a, CopyAltLeaf[T])
+	return ToAltLeaves(fn.CopyAll(FromAltLeaves(a)))
 }
 
 // ValidateAltLeaf checks that an Asset is a valid AltLeaf. An Asset used as an
@@ -2435,8 +2425,20 @@ 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)
+var _ AltLeaf[Asset] = (*Asset)(nil)
+
+// ToAltLeaves casts []Asset to []AltLeafAsset, without checking that the assets
+// are valid AltLeaves.
+func ToAltLeaves(leaves []*Asset) []AltLeaf[Asset] {
+	return fn.Map(leaves, func(l *Asset) AltLeaf[Asset] {
+		return l
+	})
+}
+
+// FromAltLeaves casts []AltLeafAsset to []Asset, which is always safe.
+func FromAltLeaves(leaves []AltLeaf[Asset]) []*Asset {
+	return fn.Map(leaves, func(l AltLeaf[Asset]) *Asset {
+		return l.(*Asset)
+	})
+}

asset/encoding.go

@@ -809,7 +809,7 @@ 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 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.
@@ -855,7 +855,7 @@ func AltLeavesDecoder(r io.Reader, val any, buf *[8]byte, l uint64) error {
 		return tlv.ErrRecordTooLarge
 	}
 
-	if typ, ok := val.(*[]AltLeaf[*Asset]); ok {
+	if typ, ok := val.(*[]AltLeaf[Asset]); ok {
 		// Each alt leaf is at least 42 bytes, which limits the total
 		// number of aux leaves. So we don't need to enforce a strict
 		// limit here.
@@ -864,7 +864,7 @@ func AltLeavesDecoder(r io.Reader, val any, buf *[8]byte, l uint64) error {
 			return err
 		}
 
-		leaves := make([]AltLeaf[*Asset], 0, numItems)
+		leaves := make([]AltLeaf[Asset], 0, numItems)
 		leafKeys := make(map[SerializedKey]struct{})
 		for i := uint64(0); i < numItems; i++ {
 			var streamBytes []byte
@@ -890,7 +890,7 @@ func AltLeavesDecoder(r io.Reader, val any, buf *[8]byte, l uint64) error {
 			}
 
 			leafKeys[leafKey] = struct{}{}
-			leaves = append(leaves, AltLeaf[*Asset](&leaf))
+			leaves = append(leaves, AltLeaf[Asset](&leaf))
 		}
 
 		*typ = leaves

asset/mock.go

@@ -14,7 +14,6 @@ import (
 	"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"
@@ -705,25 +704,12 @@ func RandAltLeaves(t testing.TB, nonZero bool) []*Asset {
 	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) {
+func CompareAltLeaves(t *testing.T, a, b []AltLeaf[Asset]) {
 	require.Equal(t, len(a), len(b))
 
-	aInner := fn.Map(a, InnerAltLeaf[*Asset])
-	bInner := fn.Map(b, InnerAltLeaf[*Asset])
+	aInner := FromAltLeaves(a)
+	bInner := FromAltLeaves(b)
 
 	slices.SortStableFunc(aInner, SortFunc)
 	slices.SortStableFunc(bInner, SortFunc)

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 *[]asset.AltLeafAsset) decoderFunc {
+func altLeavesDecoder(a *[]asset.AltLeaf[asset.Asset]) decoderFunc {
 	return func(key, byteVal []byte) error {
 		if len(byteVal) == 0 {
 			return nil

tappsbt/decode_test.go

@@ -251,7 +251,9 @@ func TestEncodingDecoding(t *testing.T) {
 			require.NoError(t, err)
 
 			secondLeaf.ScriptKey = asset.NewScriptKey(leafKeyCopy)
-			altLeaves := []asset.AltLeafAsset{firstLeaf, secondLeaf}
+			altLeaves := []asset.AltLeaf[asset.Asset]{
+				firstLeaf, secondLeaf,
+			}
 
 			pkt.Inputs[0].AltLeaves = asset.CopyAltLeaves(altLeaves)
 			pkt.Outputs[0].AltLeaves = asset.CopyAltLeaves(
@@ -270,7 +272,9 @@ func TestEncodingDecoding(t *testing.T) {
 			pkt := RandPacket(t, true, true)
 
 			numLeaves := 2000
-			altLeaves := make([]asset.AltLeafAsset, numLeaves)
+			altLeaves := make(
+				[]asset.AltLeaf[asset.Asset], numLeaves,
+			)
 			for idx := range numLeaves {
 				altLeaves[idx] = asset.RandAltLeaf(t)
 			}

tappsbt/encode.go

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

tappsbt/interface.go

@@ -396,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 []asset.AltLeafAsset
+	AltLeaves []asset.AltLeaf[asset.Asset]
 }
 
 // Copy creates a deep copy of the VInput.
@@ -596,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 []asset.AltLeafAsset
+	AltLeaves []asset.AltLeaf[asset.Asset]
 }
 
 // Copy creates a deep copy of the VOutput.

tappsbt/mock.go

@@ -317,7 +317,7 @@ func NewTestFromVInput(t testing.TB, i *VInput) *TestVInput {
 
 		ti.AltLeaves = make([]*asset.TestAsset, 0, len(i.AltLeaves))
 		for idx := range i.AltLeaves {
-			leaf := asset.InnerAltLeaf(i.AltLeaves[idx])
+			leaf := i.AltLeaves[idx].(*asset.Asset)
 			ti.AltLeaves = append(
 				ti.AltLeaves, asset.NewTestFromAsset(t, leaf),
 			)
@@ -380,7 +380,9 @@ func (ti *TestVInput) ToVInput(t testing.TB) *VInput {
 	}
 
 	if len(ti.AltLeaves) > 0 {
-		vi.AltLeaves = make([]asset.AltLeafAsset, len(ti.AltLeaves))
+		vi.AltLeaves = make(
+			[]asset.AltLeaf[asset.Asset], len(ti.AltLeaves),
+		)
 		for idx, leaf := range ti.AltLeaves {
 			vi.AltLeaves[idx] = leaf.ToAsset(t)
 		}
@@ -634,7 +636,7 @@ func NewTestFromVOutput(t testing.TB, v *VOutput,
 
 		vo.AltLeaves = make([]*asset.TestAsset, 0, len(vo.AltLeaves))
 		for idx := range v.AltLeaves {
-			leaf := asset.InnerAltLeaf(v.AltLeaves[idx])
+			leaf := v.AltLeaves[idx].(*asset.Asset)
 			vo.AltLeaves = append(
 				vo.AltLeaves, asset.NewTestFromAsset(t, leaf),
 			)
@@ -759,7 +761,9 @@ func (to *TestVOutput) ToVOutput(t testing.TB) *VOutput {
 	}
 
 	if len(to.AltLeaves) > 0 {
-		v.AltLeaves = make([]asset.AltLeafAsset, len(to.AltLeaves))
+		v.AltLeaves = make(
+			[]asset.AltLeaf[asset.Asset], len(to.AltLeaves),
+		)
 		for idx, leaf := range to.AltLeaves {
 			v.AltLeaves[idx] = leaf.ToAsset(t)
 		}