proof+tappsbt: add STXOProofs to CommitmentProof

This commit adds a new field to the CommitmentProof struct that will
house STXO proofs. We also add encoding/decoding functions for that new
sub type and update the test vectors accordingly.

Author: jharveyb

proof/encoding.go

@@ -11,6 +11,7 @@ import (
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/taproot-assets/asset"
+	"github.com/lightninglabs/taproot-assets/commitment"
 	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightningnetwork/lnd/tlv"
 )
@@ -346,6 +347,102 @@ func CommitmentProofDecoder(r io.Reader, val any, buf *[8]byte, l uint64) error
 	return tlv.NewTypeForEncodingErr(val, "*CommitmentProof")
 }
 
+func CommitmentProofsEncoder(w io.Writer, val any, buf *[8]byte) error {
+	if t, ok := val.(*map[asset.SerializedKey]commitment.Proof); ok {
+		numProofs := uint64(len(*t))
+		if err := tlv.WriteVarInt(w, numProofs, buf); err != nil {
+			return err
+		}
+
+		var proofBuf bytes.Buffer
+		for key, proof := range *t {
+			var keyBytes [33]byte
+			copy(keyBytes[:], key[:])
+
+			err := tlv.EBytes33(w, &keyBytes, buf)
+			if err != nil {
+				return err
+			}
+
+			if err := proof.Encode(&proofBuf); err != nil {
+				return err
+			}
+
+			proofBytes := proofBuf.Bytes()
+			err = asset.InlineVarBytesEncoder(w, &proofBytes, buf)
+			if err != nil {
+				return err
+			}
+
+			proofBuf.Reset()
+		}
+		return nil
+	}
+
+	return tlv.NewTypeForEncodingErr(
+		val, "map[asset.SerializedKey]CommitmentProof",
+	)
+}
+
+func CommitmentProofsDecoder(r io.Reader, val any, buf *[8]byte,
+	_ uint64) error {
+
+	if typ, ok := val.(*map[asset.SerializedKey]commitment.Proof); ok {
+		numProofs, err := tlv.ReadVarInt(r, buf)
+		if err != nil {
+			return err
+		}
+
+		// Avoid OOM by limiting the number of commitment proofs we
+		// accept.
+		if numProofs > MaxNumTaprootProofs {
+			return fmt.Errorf("%w: too many commitment proofs",
+				ErrProofInvalid)
+		}
+
+		proofs := make(
+			map[asset.SerializedKey]commitment.Proof, numProofs,
+		)
+		for i := uint64(0); i < numProofs; i++ {
+			var keyBytes [33]byte
+
+			err := tlv.DBytes33(
+				r, &keyBytes, buf,
+				btcec.PubKeyBytesLenCompressed,
+			)
+			if err != nil {
+				return err
+			}
+
+			var proofBytes []byte
+			err = asset.InlineVarBytesDecoder(
+				r, &proofBytes, buf, MaxTaprootProofSizeBytes,
+			)
+			if err != nil {
+				return err
+			}
+
+			var key asset.SerializedKey
+			copy(key[:], keyBytes[:])
+
+			var proof commitment.Proof
+			err = proof.Decode(bytes.NewReader(proofBytes))
+			if err != nil {
+				return err
+			}
+
+			proofs[key] = proof
+		}
+
+		*typ = proofs
+		return nil
+	}
+
+	return tlv.NewTypeForEncodingErr(
+		val, "map[asset.SerializedKey]CommitmentProof",
+	)
+}
+
 func TapscriptProofEncoder(w io.Writer, val any, buf *[8]byte) error {
 	if t, ok := val.(**TapscriptProof); ok {
 		return (*t).Encode(w)

proof/encoding_test.go

@@ -0,0 +1,89 @@
+package proof
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/lightninglabs/taproot-assets/asset"
+	"github.com/lightninglabs/taproot-assets/commitment"
+	"github.com/lightninglabs/taproot-assets/internal/test"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCommitmentProofsDecoderRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	testBlocks := readTestData(t)
+	oddTxBlock := testBlocks[0]
+
+	numProofs := 4
+	proofs := make(map[asset.SerializedKey]commitment.Proof, numProofs)
+	for range numProofs {
+		genesis := asset.RandGenesis(t, asset.Collectible)
+		scriptKey := test.RandPubKey(t)
+		randProof := RandProof(t, genesis, scriptKey, oddTxBlock, 0, 1)
+		randCommitmentProof := randProof.InclusionProof.CommitmentProof
+		serializedKey := asset.SerializedKey(
+			test.RandPubKey(t).SerializeCompressed(),
+		)
+		proofs[serializedKey] = randCommitmentProof.Proof
+	}
+
+	var buf [8]byte
+
+	// Helper function to encode a map of commitment proofs.
+	encodeProofs := func(
+		proofs map[asset.SerializedKey]commitment.Proof) []byte {
+
+		var b bytes.Buffer
+		err := CommitmentProofsEncoder(&b, &proofs, &buf)
+		require.NoError(t, err)
+		return b.Bytes()
+	}
+
+	// Helper function to decode a map of commitment proofs.
+	decodeProofs := func(
+		encoded []byte) map[asset.SerializedKey]commitment.Proof {
+
+		var decodedProofs map[asset.SerializedKey]commitment.Proof
+		err := CommitmentProofsDecoder(
+			bytes.NewReader(encoded), &decodedProofs, &buf,
+			uint64(len(encoded)),
+		)
+		require.NoError(t, err)
+		return decodedProofs
+	}
+
+	// Test case: round trip encoding and decoding.
+	t.Run(
+		"encode and decode map of 4 random commitment proofs",
+		func(t *testing.T) {
+			// Encode the proofs.
+			encoded := encodeProofs(proofs)
+
+			// Decode the proofs.
+			decodedProofs := decodeProofs(encoded)
+
+			// Assert the decoded proofs match the original.
+			require.Equal(t, proofs, decodedProofs)
+		},
+	)
+
+	// Test case: empty map.
+	t.Run(
+		"encode and decode empty map of commitment proofs",
+		func(t *testing.T) {
+			// Create an empty map of commitment emptyMap.
+			emptyMap := map[asset.SerializedKey]commitment.Proof{}
+
+			// Encode the proofs.
+			encoded := encodeProofs(emptyMap)
+
+			// Decode the proofs.
+			decodedMap := decodeProofs(encoded)
+
+			// Assert the decoded proofs match the original.
+			require.Equal(t, emptyMap, decodedMap)
+		},
+	)
+}

proof/mock.go

@@ -872,28 +872,58 @@ func NewTestFromCommitmentProof(t testing.TB,
 		TapscriptSibling: commitment.HexTapscriptSibling(
 			t, p.TapSiblingPreimage,
 		),
+		STXOProofs:      NewTestFromSTXOProofs(t, p),
 		UnknownOddTypes: p.UnknownOddTypes,
 	}
 }
 
+func NewTestFromSTXOProofs(t testing.TB,
+	p *CommitmentProof) *map[string]commitment.TestProof {
+
+	t.Helper()
+
+	stxoProofs := make(map[string]commitment.TestProof)
+	for key, proof := range p.STXOProofs {
+		keyHex := hex.EncodeToString(key[:])
+		stxoProofs[keyHex] = *commitment.NewTestFromProof(t, &proof)
+	}
+	return &stxoProofs
+}
+
+// nolint: lll
 type TestCommitmentProof struct {
-	Proof            *commitment.TestProof `json:"proof"`
-	TapscriptSibling string                `json:"tapscript_sibling"`
-	UnknownOddTypes  tlv.TypeMap           `json:"unknown_odd_types"`
+	Proof            *commitment.TestProof            `json:"proof"`
+	TapscriptSibling string                           `json:"tapscript_sibling"`
+	STXOProofs       *map[string]commitment.TestProof `json:"stxo_proofs"`
+	UnknownOddTypes  tlv.TypeMap                      `json:"unknown_odd_types"`
 }
 
 func (tcp *TestCommitmentProof) ToCommitmentProof(
 	t testing.TB) *CommitmentProof {
 
 	t.Helper()
 
-	return &CommitmentProof{
+	stxoProofs := make(map[asset.SerializedKey]commitment.Proof)
+	for key, proof := range *tcp.STXOProofs {
+		keyBytes, err := hex.DecodeString(key)
+		require.NoError(t, err)
+		key := asset.SerializedKey(keyBytes)
+		stxoProofs[key] = *proof.ToProof(t)
+	}
+
+	cp := &CommitmentProof{
 		Proof: *tcp.Proof.ToProof(t),
 		TapSiblingPreimage: commitment.ParseTapscriptSibling(
 			t, tcp.TapscriptSibling,
 		),
 		UnknownOddTypes: tcp.UnknownOddTypes,
 	}
+
+	if len(stxoProofs) > 0 {
+		cp.STXOProofs = stxoProofs
+	}
+
+	return cp
 }
 
 func NewTestFromTapscriptProof(t testing.TB,

proof/records.go

@@ -40,6 +40,10 @@ const (
 	// count from where commitment.ProofTaprootAssetProofType left off.
 	CommitmentProofTapSiblingPreimageType tlv.Type = 5
 
+	// CommitmentProofSTXOProofsType is the type of the TLV record for the
+	// Exclusion proof CommitmentProof's STXOProofs field.
+	CommitmentProofSTXOProofsType tlv.Type = 7
+
 	TapscriptProofTapPreimage1 tlv.Type = 1
 	TapscriptProofTapPreimage2 tlv.Type = 3
 	TapscriptProofBip86        tlv.Type = 4
@@ -74,7 +78,7 @@ var KnownTaprootProofTypes = fn.NewSet(
 // tests.
 var KnownCommitmentProofTypes = fn.NewSet(
 	commitment.ProofAssetProofType, commitment.ProofTaprootAssetProofType,
-	CommitmentProofTapSiblingPreimageType,
+	CommitmentProofTapSiblingPreimageType, CommitmentProofSTXOProofsType,
 )
 
 // KnownTapscriptProofTypes is a set of all known Tapscript proof TLV types.
@@ -288,6 +292,26 @@ func CommitmentProofTapSiblingPreimageRecord(
 	)
 }
 
+func CommitmentProofSTXOProofsRecord(
+	stxoProofs *map[asset.SerializedKey]commitment.Proof) tlv.Record {
+
+	sizeFunc := func() uint64 {
+		var buf bytes.Buffer
+		err := CommitmentProofsEncoder(
+			&buf, stxoProofs, &[8]byte{},
+		)
+		if err != nil {
+			panic(err)
+		}
+		return uint64(len(buf.Bytes()))
+	}
+	return tlv.MakeDynamicRecord(
+		CommitmentProofSTXOProofsType, stxoProofs, sizeFunc,
+		CommitmentProofsEncoder,
+		CommitmentProofsDecoder,
+	)
+}
+
 func TapscriptProofTapPreimage1Record(
 	preimage **commitment.TapscriptPreimage) tlv.Record {
 

proof/taproot.go

@@ -38,6 +38,13 @@ type CommitmentProof struct {
 	// at the tapscript root of the expected output.
 	TapSiblingPreimage *commitment.TapscriptPreimage
 
+	// STXOProofs is a list of proofs that either prove the spend of the
+	// inputs as referenced in the asset's previous witnesses' prevIDs when
+	// this is in an inclusion proof, or the non-spend of an input if this
+	// is in an exclusion proof. Only the root assets in a transfer (so no
+	// minted or split assets) will have STXO inclusion or exclusion proofs.
+	STXOProofs map[asset.SerializedKey]commitment.Proof
+
 	// UnknownOddTypes is a map of unknown odd types that were encountered
 	// during decoding. This map is used to preserve unknown types that we
 	// don't know of yet, so we can still encode them back when serializing.
@@ -57,6 +64,11 @@ func (p CommitmentProof) EncodeRecords() []tlv.Record {
 			),
 		)
 	}
+	if len(p.STXOProofs) > 0 {
+		records = append(records, CommitmentProofSTXOProofsRecord(
+			&p.STXOProofs,
+		))
+	}
 
 	// Add any unknown odd types that were encountered during decoding.
 	return asset.CombineRecords(records, p.UnknownOddTypes)
@@ -65,10 +77,14 @@ func (p CommitmentProof) EncodeRecords() []tlv.Record {
 // DecodeRecords returns the decoding records for the CommitmentProof.
 func (p *CommitmentProof) DecodeRecords() []tlv.Record {
 	records := p.Proof.DecodeRecords()
-	return append(
+	records = append(
 		records,
 		CommitmentProofTapSiblingPreimageRecord(&p.TapSiblingPreimage),
 	)
+	return append(
+		records,
+		CommitmentProofSTXOProofsRecord(&p.STXOProofs),
+	)
 }
 
 // Encode attempts to encode the CommitmentProof into the passed io.Writer.