proof: make forward-compatible by parsing unknown odd types

Author: guggero

proof/meta.go

@@ -99,6 +99,14 @@ type MetaReveal struct {
 
 	// Data is the committed data being revealed.
 	Data []byte
+
+	// 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.
+	// This enables forward compatibility with future versions of the
+	// protocol as it allows new odd (optional) types to be added without
+	// breaking old clients that don't yet fully understand them.
+	UnknownOddTypes tlv.TypeMap
 }
 
 // SizableInteger is a subset of Integer that excludes int8, since we never use
@@ -337,10 +345,13 @@ func (m *MetaReveal) MetaHash() [asset.MetaHashLen]byte {
 
 // EncodeRecords returns the TLV encode records for the meta reveal.
 func (m *MetaReveal) EncodeRecords() []tlv.Record {
-	return []tlv.Record{
+	records := []tlv.Record{
 		MetaRevealTypeRecord(&m.Type),
 		MetaRevealDataRecord(&m.Data),
 	}
+
+	// Add any unknown odd types that were encountered during decoding.
+	return asset.CombineRecords(records, m.UnknownOddTypes)
 }
 
 // DecodeRecords returns the TLV decode records for the meta reveal.
@@ -370,8 +381,14 @@ func (m *MetaReveal) Decode(r io.Reader) error {
 	// Note, we can't use the DecodeP2P method here, because the meta data
 	// itself can be larger than 65k bytes. But we impose limits in the
 	// individual decoding functions.
-	//
-	// TODO(guggero): Store unknown types (next commits).
-	_, err = asset.TlvStrictDecode(stream, r, KnownMetaRevealTypes)
-	return err
+	unknownOddTypes, err := asset.TlvStrictDecode(
+		stream, r, KnownMetaRevealTypes,
+	)
+	if err != nil {
+		return err
+	}
+
+	m.UnknownOddTypes = unknownOddTypes
+
+	return nil
 }

proof/meta_test.go

@@ -8,6 +8,9 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/lightninglabs/taproot-assets/asset"
+	"github.com/lightninglabs/taproot-assets/internal/test"
+	"github.com/lightningnetwork/lnd/tlv"
 	"github.com/stretchr/testify/require"
 )
 
@@ -115,3 +118,39 @@ func TestProofInvalidJsonMetaReveal(t *testing.T) {
 	require.ErrorIs(t, err, ErrInvalidJSON)
 	require.Zero(t, decDisplay)
 }
+
+// TestMetaRevealUnknownOddType tests that an unknown odd type is allowed in a
+// meta reveal and that we can still arrive at the correct meta hash with it.
+func TestMetaRevealUnknownOddType(t *testing.T) {
+	knownMeta := &MetaReveal{
+		Type: 123,
+		Data: []byte("probably some JPEG or something"),
+	}
+	knownMetaHash := knownMeta.MetaHash()
+
+	test.RunUnknownOddTypeTest(
+		t, knownMeta, &asset.ErrUnknownType{},
+		func(buf *bytes.Buffer, meta *MetaReveal) error {
+			return meta.Encode(buf)
+		},
+		func(buf *bytes.Buffer) (*MetaReveal, error) {
+			var parsedMeta MetaReveal
+			return &parsedMeta, parsedMeta.Decode(buf)
+		},
+		func(parsedMeta *MetaReveal, unknownTypes tlv.TypeMap) {
+			require.Equal(
+				t, unknownTypes, parsedMeta.UnknownOddTypes,
+			)
+
+			// The meta should've changed, to make sure the unknown
+			// value was taken into account when creating the
+			// serialized meta.
+			parsedMetaHash := parsedMeta.MetaHash()
+
+			require.NotEqual(t, knownMetaHash, parsedMetaHash)
+
+			parsedMeta.UnknownOddTypes = nil
+			require.Equal(t, knownMeta, parsedMeta)
+		},
+	)
+}

proof/mock.go

@@ -23,6 +23,7 @@ import (
 	"github.com/lightningnetwork/lnd/keychain"
 	"github.com/lightningnetwork/lnd/lnutils"
 	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/lightningnetwork/lnd/tlv"
 	"github.com/stretchr/testify/require"
 )
 
@@ -566,13 +567,14 @@ func NewTestFromProof(t testing.TB, p *Proof) *TestProof {
 	t.Helper()
 
 	tp := &TestProof{
-		PrevOut:        p.PrevOut.String(),
-		BlockHeader:    NewTestFromBlockHeader(t, &p.BlockHeader),
-		BlockHeight:    p.BlockHeight,
-		AnchorTx:       test.HexTx(t, &p.AnchorTx),
-		TxMerkleProof:  NewTestFromTxMerkleProof(t, &p.TxMerkleProof),
-		Asset:          asset.NewTestFromAsset(t, &p.Asset),
-		InclusionProof: NewTestFromTaprootProof(t, &p.InclusionProof),
+		PrevOut:         p.PrevOut.String(),
+		BlockHeader:     NewTestFromBlockHeader(t, &p.BlockHeader),
+		BlockHeight:     p.BlockHeight,
+		AnchorTx:        test.HexTx(t, &p.AnchorTx),
+		TxMerkleProof:   NewTestFromTxMerkleProof(t, &p.TxMerkleProof),
+		Asset:           asset.NewTestFromAsset(t, &p.Asset),
+		InclusionProof:  NewTestFromTaprootProof(t, &p.InclusionProof),
+		UnknownOddTypes: p.UnknownOddTypes,
 	}
 
 	for i := range p.ExclusionProofs {
@@ -637,19 +639,21 @@ type TestProof struct {
 	ChallengeWitness []string                  `json:"challenge_witness"`
 	GenesisReveal    *asset.TestGenesisReveal  `json:"genesis_reveal"`
 	GroupKeyReveal   *asset.TestGroupKeyReveal `json:"group_key_reveal"`
+	UnknownOddTypes  tlv.TypeMap               `json:"unknown_odd_types"`
 }
 
 func (tp *TestProof) ToProof(t testing.TB) *Proof {
 	t.Helper()
 
 	p := &Proof{
-		PrevOut:        test.ParseOutPoint(t, tp.PrevOut),
-		BlockHeader:    *tp.BlockHeader.ToBlockHeader(t),
-		BlockHeight:    tp.BlockHeight,
-		AnchorTx:       *test.ParseTx(t, tp.AnchorTx),
-		TxMerkleProof:  *tp.TxMerkleProof.ToTxMerkleProof(t),
-		Asset:          *tp.Asset.ToAsset(t),
-		InclusionProof: *tp.InclusionProof.ToTaprootProof(t),
+		PrevOut:         test.ParseOutPoint(t, tp.PrevOut),
+		BlockHeader:     *tp.BlockHeader.ToBlockHeader(t),
+		BlockHeight:     tp.BlockHeight,
+		AnchorTx:        *test.ParseTx(t, tp.AnchorTx),
+		TxMerkleProof:   *tp.TxMerkleProof.ToTxMerkleProof(t),
+		Asset:           *tp.Asset.ToAsset(t),
+		InclusionProof:  *tp.InclusionProof.ToTaprootProof(t),
+		UnknownOddTypes: tp.UnknownOddTypes,
 	}
 
 	for i := range tp.ExclusionProofs {
@@ -774,8 +778,9 @@ func NewTestFromTaprootProof(t testing.TB,
 	t.Helper()
 
 	ttp := &TestTaprootProof{
-		OutputIndex: p.OutputIndex,
-		InternalKey: test.HexPubKey(p.InternalKey),
+		OutputIndex:     p.OutputIndex,
+		InternalKey:     test.HexPubKey(p.InternalKey),
+		UnknownOddTypes: p.UnknownOddTypes,
 	}
 
 	if p.CommitmentProof != nil {
@@ -798,14 +803,16 @@ type TestTaprootProof struct {
 	InternalKey     string               `json:"internal_key"`
 	CommitmentProof *TestCommitmentProof `json:"commitment_proof"`
 	TapscriptProof  *TestTapscriptProof  `json:"tapscript_proof"`
+	UnknownOddTypes tlv.TypeMap          `json:"unknown_odd_types"`
 }
 
 func (ttp *TestTaprootProof) ToTaprootProof(t testing.TB) *TaprootProof {
 	t.Helper()
 
 	p := &TaprootProof{
-		OutputIndex: ttp.OutputIndex,
-		InternalKey: test.ParsePubKey(t, ttp.InternalKey),
+		OutputIndex:     ttp.OutputIndex,
+		InternalKey:     test.ParsePubKey(t, ttp.InternalKey),
+		UnknownOddTypes: ttp.UnknownOddTypes,
 	}
 
 	if ttp.CommitmentProof != nil {
@@ -829,12 +836,14 @@ func NewTestFromCommitmentProof(t testing.TB,
 		TapscriptSibling: commitment.HexTapscriptSibling(
 			t, p.TapSiblingPreimage,
 		),
+		UnknownOddTypes: p.UnknownOddTypes,
 	}
 }
 
 type TestCommitmentProof struct {
 	Proof            *commitment.TestProof `json:"proof"`
 	TapscriptSibling string                `json:"tapscript_sibling"`
+	UnknownOddTypes  tlv.TypeMap           `json:"unknown_odd_types"`
 }
 
 func (tcp *TestCommitmentProof) ToCommitmentProof(
@@ -847,6 +856,7 @@ func (tcp *TestCommitmentProof) ToCommitmentProof(
 		TapSiblingPreimage: commitment.ParseTapscriptSibling(
 			t, tcp.TapscriptSibling,
 		),
+		UnknownOddTypes: tcp.UnknownOddTypes,
 	}
 }
 
@@ -856,16 +866,22 @@ func NewTestFromTapscriptProof(t testing.TB,
 	t.Helper()
 
 	return &TestTapscriptProof{
-		TapPreimage1: commitment.HexTapscriptSibling(t, p.TapPreimage1),
-		TapPreimage2: commitment.HexTapscriptSibling(t, p.TapPreimage2),
-		Bip86:        p.Bip86,
+		TapPreimage1: commitment.HexTapscriptSibling(
+			t, p.TapPreimage1,
+		),
+		TapPreimage2: commitment.HexTapscriptSibling(
+			t, p.TapPreimage2,
+		),
+		Bip86:           p.Bip86,
+		UnknownOddTypes: p.UnknownOddTypes,
 	}
 }
 
 type TestTapscriptProof struct {
-	TapPreimage1 string `json:"tap_preimage_1"`
-	TapPreimage2 string `json:"tap_preimage_2"`
-	Bip86        bool   `json:"bip86"`
+	TapPreimage1    string      `json:"tap_preimage_1"`
+	TapPreimage2    string      `json:"tap_preimage_2"`
+	Bip86           bool        `json:"bip86"`
+	UnknownOddTypes tlv.TypeMap `json:"unknown_odd_types"`
 }
 
 func (ttp *TestTapscriptProof) ToTapscriptProof(t testing.TB) *TapscriptProof {
@@ -878,22 +894,25 @@ func (ttp *TestTapscriptProof) ToTapscriptProof(t testing.TB) *TapscriptProof {
 		TapPreimage2: commitment.ParseTapscriptSibling(
 			t, ttp.TapPreimage2,
 		),
-		Bip86: ttp.Bip86,
+		Bip86:           ttp.Bip86,
+		UnknownOddTypes: ttp.UnknownOddTypes,
 	}
 }
 
 func NewTestFromMetaReveal(t testing.TB, m *MetaReveal) *TestMetaReveal {
 	t.Helper()
 
 	return &TestMetaReveal{
-		Type: uint8(m.Type),
-		Data: hex.EncodeToString(m.Data),
+		Type:            uint8(m.Type),
+		Data:            hex.EncodeToString(m.Data),
+		UnknownOddTypes: m.UnknownOddTypes,
 	}
 }
 
 type TestMetaReveal struct {
-	Type uint8  `json:"type"`
-	Data string `json:"data"`
+	Type            uint8       `json:"type"`
+	Data            string      `json:"data"`
+	UnknownOddTypes tlv.TypeMap `json:"unknown_odd_types"`
 }
 
 func (tmr *TestMetaReveal) ToMetaReveal(t testing.TB) *MetaReveal {
@@ -903,7 +922,8 @@ func (tmr *TestMetaReveal) ToMetaReveal(t testing.TB) *MetaReveal {
 	require.NoError(t, err)
 
 	return &MetaReveal{
-		Type: MetaType(tmr.Type),
-		Data: data,
+		Type:            MetaType(tmr.Type),
+		Data:            data,
+		UnknownOddTypes: tmr.UnknownOddTypes,
 	}
 }

proof/proof.go

@@ -277,8 +277,6 @@ type Proof struct {
 	// MetaReveal is the set of bytes that were revealed to prove the
 	// derivation of the meta data hash contained in the genesis asset.
 	//
-	// TODO(roasbeef): use even/odd framing here?
-	//
 	// NOTE: This field is optional, and can only be specified if the asset
 	// above is a genesis asset. If specified, then verifiers _should_ also
 	// verify the hashes match up.
@@ -300,14 +298,22 @@ type Proof struct {
 	// provided for minting proofs, and must be empty for non-minting
 	// proofs. This allows for derivation of the asset ID. If the asset is
 	// part of an asset group, the Genesis information is also used for
-	// rederivation of the asset group key.
+	// re-derivation of the asset group key.
 	GenesisReveal *asset.Genesis
 
 	// GroupKeyReveal is an optional set of bytes that represent the public
 	// key and Tapscript root used to derive the final tweaked group key for
 	// the asset group. This field must be provided for issuance proofs of
 	// grouped assets.
 	GroupKeyReveal *asset.GroupKeyReveal
+
+	// 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.
+	// This enables forward compatibility with future versions of the
+	// protocol as it allows new odd (optional) types to be added without
+	// breaking old clients that don't yet fully understand them.
+	UnknownOddTypes tlv.TypeMap
 }
 
 // OutPoint returns the outpoint that commits to the asset associated with this
@@ -361,7 +367,9 @@ func (p *Proof) EncodeRecords() []tlv.Record {
 			&p.GroupKeyReveal,
 		))
 	}
-	return records
+
+	// Add any unknown odd types that were encountered during decoding.
+	return asset.CombineRecords(records, p.UnknownOddTypes)
 }
 
 // DecodeRecords returns the set of known TLV records to decode a Proof.
@@ -427,9 +435,16 @@ func (p *Proof) Decode(r io.Reader) error {
 	// Note, we can't use the DecodeP2P method here, because the additional
 	// inputs records might be larger than 64k each. Instead, we add
 	// individual limits to each record.
-	// TODO(guggero): Store unknown types (next commits).
-	_, err = asset.TlvStrictDecode(stream, r, KnownProofTypes)
-	return err
+	unknownOddTypes, err := asset.TlvStrictDecode(
+		stream, r, KnownProofTypes,
+	)
+	if err != nil {
+		return err
+	}
+
+	p.UnknownOddTypes = unknownOddTypes
+
+	return nil
 }
 
 // Record returns a TLV record that can be used to encode/decode a Proof to/from