multi: add universe commitment fields to meta

Author: guggero

proof/encoding.go

@@ -5,8 +5,10 @@ import (
 	"fmt"
 	"io"
 	"math"
+	"net/url"
 
 	"github.com/btcsuite/btcd/blockchain"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/taproot-assets/asset"
 	"github.com/lightninglabs/taproot-assets/fn"
@@ -500,3 +502,143 @@ func DUint32Option(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {
 	}
 	return tlv.NewTypeForDecodingErr(val, "*fn.Option[uint32]", l, l)
 }
+
+// UrlSliceOptionEncoder encodes a URL option. If the value is not set, or the
+// slice is empty, we'll encode it as a zero-length record. But that means that
+// the type and length fields will still be encoded, which is different from the
+// record not being present at all. If the distinction should be made (e.g. to
+// not re-encode old records that didn't have that field at all with the new
+// zero-length record), the caller needs to handle that by conditionally
+// including or not including the record.
+func UrlSliceOptionEncoder(w io.Writer, val any, buf *[8]byte) error {
+	if t, ok := val.(*fn.Option[[]url.URL]); ok {
+		return fn.MapOptionZ(*t, func(value []url.URL) error {
+			numValues := uint64(len(value))
+			if numValues == 0 {
+				return nil
+			}
+
+			err := tlv.WriteVarInt(w, numValues, buf)
+			if err != nil {
+				return err
+			}
+
+			for _, addr := range value {
+				addrBytes := []byte(addr.String())
+				err := asset.InlineVarBytesEncoder(
+					w, &addrBytes, buf,
+				)
+				if err != nil {
+					return err
+				}
+			}
+
+			return nil
+		})
+	}
+	return tlv.NewTypeForEncodingErr(val, "*fn.Option[[]url.URL]")
+}
+
+// UrlSliceOptionDecoder decodes a URL option.
+func UrlSliceOptionDecoder(r io.Reader, val any, buf *[8]byte, l uint64) error {
+	if l > MaxNumCanonicalUniverseURLs*MaxCanonicalUniverseURLLength {
+		return tlv.ErrRecordTooLarge
+	}
+
+	if t, ok := val.(*fn.Option[[]url.URL]); ok {
+		if l == 0 {
+			*t = fn.None[[]url.URL]()
+
+			return nil
+		}
+
+		numValues, err := tlv.ReadVarInt(r, buf)
+		if err != nil {
+			return err
+		}
+
+		if numValues > MaxNumCanonicalUniverseURLs {
+			return tlv.ErrRecordTooLarge
+		}
+
+		urls := make([]url.URL, 0, numValues)
+		for i := uint64(0); i < numValues; i++ {
+			var urlBytes []byte
+			err := asset.InlineVarBytesDecoder(
+				r, &urlBytes, buf,
+				MaxCanonicalUniverseURLLength,
+			)
+			if err != nil {
+				return err
+			}
+
+			addr, err := url.ParseRequestURI(string(urlBytes))
+			if err != nil {
+				return err
+			}
+			urls = append(urls, *addr)
+		}
+
+		*t = fn.Some(urls)
+
+		return nil
+	}
+	return tlv.NewTypeForDecodingErr(val, "*fn.Option[[]url.URL]", l, l)
+}
+
+// PublicKeyOptionEncoder encodes a public key option. If the value is not set,
+// we'll encode it as a zero-length record. But that means that the type and
+// length fields will still be encoded, which is different from the record not
+// being present at all. If the distinction should be made (e.g. to not
+// re-encode old records that didn't have that field at all with the new
+// zero-length record), the caller needs to handle that by conditionally
+// including or not including the record.
+func PublicKeyOptionEncoder(w io.Writer, val any, buf *[8]byte) error {
+	if t, ok := val.(*fn.Option[btcec.PublicKey]); ok {
+		return fn.MapOptionZ(*t, func(value btcec.PublicKey) error {
+			if value == emptyKey {
+				return nil
+			}
+
+			ptr := &value
+			return asset.CompressedPubKeyEncoder(w, &ptr, buf)
+		})
+	}
+	return tlv.NewTypeForEncodingErr(val, "*fn.Option[btcec.PublicKey]")
+}
+
+// PublicKeyOptionDecoder decodes a public key option.
+func PublicKeyOptionDecoder(r io.Reader, val any, buf *[8]byte,
+	l uint64) error {
+
+	if l > btcec.PubKeyBytesLenCompressed {
+		return tlv.ErrRecordTooLarge
+	}
+
+	if t, ok := val.(*fn.Option[btcec.PublicKey]); ok {
+		if l == 0 {
+			*t = fn.None[btcec.PublicKey]()
+
+			return nil
+		}
+
+		var result *btcec.PublicKey
+		err := asset.CompressedPubKeyDecoder(r, &result, buf, l)
+		if err != nil {
+			return err
+		}
+
+		if result == nil || *result == emptyKey {
+			*t = fn.None[btcec.PublicKey]()
+
+			return nil
+		}
+
+		*t = fn.Some(*result)
+
+		return nil
+	}
+	return tlv.NewTypeForDecodingErr(
+		val, "*fn.Option[btcec.PublicKey]", l, l,
+	)
+}

proof/meta.go

@@ -8,7 +8,9 @@ import (
 	"fmt"
 	"io"
 	"math"
+	"net/url"
 
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/lightninglabs/taproot-assets/asset"
 	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightningnetwork/lnd/tlv"
@@ -46,6 +48,14 @@ const (
 	// define when minting assets. Since the uint64 max value has 19 decimal
 	// places we will allow for a max of 12 decimal places.
 	MaxDecDisplay = uint32(12)
+
+	// MaxNumCanonicalUniverseURLs is the maximum number of canonical
+	// universe URLs that can be set.
+	MaxNumCanonicalUniverseURLs = 16
+
+	// MaxCanonicalUniverseURLLength is the maximum length of the canonical
+	// universe URL.
+	MaxCanonicalUniverseURLLength = 255
 )
 
 var (
@@ -86,6 +96,35 @@ var (
 	// ErrDecDisplayMissing is returned if the decimal display key is
 	// not present in a JSON object.
 	ErrDecDisplayMissing = errors.New("decimal display field missing")
+
+	// ErrCanonicalUniverseInvalid is returned if the canonical universe
+	// URL is invalid.
+	ErrCanonicalUniverseInvalid = errors.New(
+		"canonical universe URL invalid",
+	)
+
+	// ErrTooManyCanonicalUniverseURLs is returned if the number of
+	// canonical universe URLs exceeds the maximum.
+	ErrTooManyCanonicalUniverseURLs = fmt.Errorf(
+		"too many canonical universe URLs, max %d",
+		MaxNumCanonicalUniverseURLs,
+	)
+
+	// ErrCanonicalUniverseURLTooLong is returned if the canonical universe
+	// URL is too long.
+	ErrCanonicalUniverseURLTooLong = fmt.Errorf(
+		"canonical universe URL too long, max %d characters",
+		MaxCanonicalUniverseURLLength,
+	)
+
+	// ErrDelegationKeyEmpty is returned if the delegation key is empty.
+	ErrDelegationKeyEmpty = errors.New("delegation key is empty")
+
+	// ErrDelegationKeyNotOnCurve is returned if the delegation key is not
+	// on the curve.
+	ErrDelegationKeyNotOnCurve = errors.New(
+		"delegation key is not on curve",
+	)
 )
 
 // MetaReveal is an optional TLV type that can be added to the proof of a
@@ -110,6 +149,22 @@ type MetaReveal struct {
 	// field to the JSON object for backward compatibility.
 	DecimalDisplay fn.Option[uint32]
 
+	// UniverseCommitments indicates that the asset group this asset belongs
+	// to will create and push universe commitments to the canonical
+	// universe. A universe commitment is a "proof of inventory" that
+	// commits the issuer's current total asset balance (sum of all mints
+	// minus burns or ignored assets) on-chain.
+	UniverseCommitments bool
+
+	// CanonicalUniverses is a list of URLs of the canonical (approved,
+	// authoritative) universe where the asset minting and universe
+	// commitment proofs will be pushed to.
+	CanonicalUniverses fn.Option[[]url.URL]
+
+	// DelegationKey is the public key that is used to verify universe
+	// commitment related on-chain outputs and proofs.
+	DelegationKey fn.Option[btcec.PublicKey]
+
 	// 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.
@@ -152,7 +207,44 @@ func (m *MetaReveal) Validate() error {
 	}
 
 	// If the decimal display is set, it must be valid.
-	return fn.MapOptionZ(m.DecimalDisplay, IsValidDecDisplay)
+	err = fn.MapOptionZ(m.DecimalDisplay, IsValidDecDisplay)
+	if err != nil {
+		return err
+	}
+
+	err = fn.MapOptionZ(m.CanonicalUniverses, func(urls []url.URL) error {
+		// If the option is set, the slice must not be empty.
+		if len(urls) == 0 {
+			return ErrCanonicalUniverseInvalid
+		}
+
+		if len(urls) > MaxNumCanonicalUniverseURLs {
+			return ErrTooManyCanonicalUniverseURLs
+		}
+
+		for _, u := range urls {
+			if len(u.String()) > MaxCanonicalUniverseURLLength {
+				return ErrCanonicalUniverseURLTooLong
+			}
+		}
+
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	return fn.MapOptionZ(m.DelegationKey, func(key btcec.PublicKey) error {
+		if key == emptyKey {
+			return ErrDelegationKeyEmpty
+		}
+
+		if !key.IsOnCurve() {
+			return ErrDelegationKeyNotOnCurve
+		}
+
+		return nil
+	})
 }
 
 // IsValidMetaType checks if the passed value is a valid meta type.
@@ -385,6 +477,15 @@ func (m *MetaReveal) EncodeRecords() []tlv.Record {
 		MetaRevealDataRecord(&m.Data),
 	}
 
+	// In order not to change the encoding of existing records if
+	// we de-serialize and re-serialize them, we only encode this boolean
+	// value if it's actually true.
+	if m.UniverseCommitments {
+		records = append(records, MetaRevealUniverseCommitmentsRecord(
+			&m.UniverseCommitments,
+		))
+	}
+
 	// To make sure we don't re-encode old assets that don't have a decimal
 	// display value as a TLV field with a different value, we only encode
 	// the decimal display value if it is explicitly set.
@@ -394,6 +495,18 @@ func (m *MetaReveal) EncodeRecords() []tlv.Record {
 		))
 	}
 
+	if m.CanonicalUniverses.IsSome() {
+		records = append(records, MetaRevealCanonicalUniversesRecord(
+			&m.CanonicalUniverses,
+		))
+	}
+
+	if m.DelegationKey.IsSome() {
+		records = append(records, MetaRevealDelegationKeyRecord(
+			&m.DelegationKey,
+		))
+	}
+
 	// Add any unknown odd types that were encountered during decoding.
 	return asset.CombineRecords(records, m.UnknownOddTypes)
 }
@@ -404,6 +517,9 @@ func (m *MetaReveal) DecodeRecords() []tlv.Record {
 		MetaRevealTypeRecord(&m.Type),
 		MetaRevealDataRecord(&m.Data),
 		MetaRevealDecimalDisplayRecord(&m.DecimalDisplay),
+		MetaRevealUniverseCommitmentsRecord(&m.UniverseCommitments),
+		MetaRevealCanonicalUniversesRecord(&m.CanonicalUniverses),
+		MetaRevealDelegationKeyRecord(&m.DelegationKey),
 	}
 }