tapdb: add new TLV fields to assets meta table

Author: guggero

tapdb/addrs.go

@@ -1131,11 +1131,14 @@ func (t *TapAddressBook) FetchAssetMetaByHash(ctx context.Context,
 
 		// If no record is present, we should get a sql.ErrNoRows error
 		// above.
-		parseAssetMetaReveal(dbMeta.AssetsMetum).WhenSome(
-			func(meta proof.MetaReveal) {
-				assetMeta = &meta
-			},
-		)
+		metaOpt, err := parseAssetMetaReveal(dbMeta.AssetsMetum)
+		if err != nil {
+			return fmt.Errorf("unable to parse asset meta: %w", err)
+		}
+
+		metaOpt.WhenSome(func(meta proof.MetaReveal) {
+			assetMeta = &meta
+		})
 
 		return nil
 	})
@@ -1164,11 +1167,14 @@ func (t *TapAddressBook) FetchAssetMetaForAsset(ctx context.Context,
 
 		// If no record is present, we should get a sql.ErrNoRows error
 		// above.
-		parseAssetMetaReveal(dbMeta.AssetsMetum).WhenSome(
-			func(meta proof.MetaReveal) {
-				assetMeta = &meta
-			},
-		)
+		metaOpt, err := parseAssetMetaReveal(dbMeta.AssetsMetum)
+		if err != nil {
+			return fmt.Errorf("unable to parse asset meta: %w", err)
+		}
+
+		metaOpt.WhenSome(func(meta proof.MetaReveal) {
+			assetMeta = &meta
+		})
 
 		return nil
 	})

tapdb/asset_meta.go

@@ -1,6 +1,10 @@
 package tapdb
 
 import (
+	"net/url"
+	"strings"
+
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/proof"
 	"github.com/lightninglabs/taproot-assets/tapdb/sqlc"
@@ -11,13 +15,48 @@ import (
 // the case if there is no database entry for the asset meta and there was a
 // LEFT JOIN in a query. Non-existence of a standalone asset metadata record
 // should be decided by the sql.ErrNoRows instead.
-func parseAssetMetaReveal(meta sqlc.AssetsMetum) fn.Option[proof.MetaReveal] {
+func parseAssetMetaReveal(
+	meta sqlc.AssetsMetum) (fn.Option[proof.MetaReveal], error) {
+
 	if len(meta.MetaDataHash) == 0 {
-		return fn.None[proof.MetaReveal]()
+		return fn.None[proof.MetaReveal](), nil
+	}
+
+	var canonicalUniverse fn.Option[[]url.URL]
+	if len(meta.MetaCanonicalUniverses) > 0 {
+		urls := strings.Split(
+			string(meta.MetaCanonicalUniverses), "\x00",
+		)
+		canonicalUniverseURLs := make([]url.URL, len(urls))
+		for i, u := range urls {
+			canonicalUniverseURL, err := url.ParseRequestURI(u)
+			if err != nil {
+				return fn.None[proof.MetaReveal](), err
+			}
+			canonicalUniverseURLs[i] = *canonicalUniverseURL
+		}
+
+		canonicalUniverse = fn.Some(canonicalUniverseURLs)
+	}
+
+	var delegationKey fn.Option[btcec.PublicKey]
+	if len(meta.MetaDelegationKey) > 0 {
+		key, err := btcec.ParsePubKey(meta.MetaDelegationKey)
+		if err != nil {
+			return fn.None[proof.MetaReveal](), err
+		}
+
+		delegationKey = fn.Some(*key)
 	}
 
 	return fn.Some(proof.MetaReveal{
 		Data: meta.MetaDataBlob,
 		Type: proof.MetaType(meta.MetaDataType.Int16),
-	})
+		DecimalDisplay: extractOptSqlInt32[uint32](
+			meta.MetaDecimalDisplay,
+		),
+		UniverseCommitments: extractBool(meta.MetaUniverseCommitments),
+		CanonicalUniverses:  canonicalUniverse,
+		DelegationKey:       delegationKey,
+	}), nil
 }

tapdb/asset_meta_test.go

@@ -3,8 +3,11 @@ package tapdb
 import (
 	"context"
 	"math/rand"
+	"net/url"
 	"testing"
 
+	"github.com/lightninglabs/taproot-assets/asset"
+	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/proof"
 	"github.com/stretchr/testify/require"
 )
@@ -46,15 +49,54 @@ func TestAssetMetaUpsert(t *testing.T) {
 	// Now we'll insert the meta hash again, but this time we'll add the
 	// blob.
 	metaID, err = db.UpsertAssetMeta(ctx, NewAssetMeta{
-		MetaDataHash: metaHash[:],
-		MetaDataBlob: assetMeta.Data,
+		MetaDataHash:            metaHash[:],
+		MetaDataBlob:            assetMeta.Data,
+		MetaDecimalDisplay:      sqlInt32(11),
+		MetaUniverseCommitments: sqlBool(true),
+		MetaCanonicalUniverses:  []byte("http://test1\x00http://test2"),
+		MetaDelegationKey:       asset.NUMSBytes,
 	})
 	require.NoError(t, err)
 
 	// If we fetch the meta, then we should get the blob back this time.
 	fetchedMeta, err := db.FetchAssetMeta(ctx, metaID)
 	require.NoError(t, err)
 	require.Equal(t, metaBlob[:], fetchedMeta.AssetsMetum.MetaDataBlob)
+	require.Equal(
+		t, sqlInt32(11), fetchedMeta.AssetsMetum.MetaDecimalDisplay,
+	)
+	require.Equal(
+		t, sqlBool(true),
+		fetchedMeta.AssetsMetum.MetaUniverseCommitments,
+	)
+	require.Equal(
+		t, []byte("http://test1\x00http://test2"),
+		fetchedMeta.AssetsMetum.MetaCanonicalUniverses,
+	)
+	require.Equal(
+		t, asset.NUMSBytes,
+		fetchedMeta.AssetsMetum.MetaDelegationKey,
+	)
+
+	parsed, err := parseAssetMetaReveal(fetchedMeta.AssetsMetum)
+	require.NoError(t, err)
+	require.True(t, parsed.IsSome())
+
+	url1, err := url.ParseRequestURI("http://test1")
+	require.NoError(t, err)
+	url2, err := url.ParseRequestURI("http://test2")
+	require.NoError(t, err)
+	parsed.WhenSome(func(reveal proof.MetaReveal) {
+		require.Equal(t, fn.Some(uint32(11)), reveal.DecimalDisplay)
+		require.Equal(t, true, reveal.UniverseCommitments)
+		require.Equal(
+			t, fn.Some([]url.URL{*url1, *url2}),
+			reveal.CanonicalUniverses,
+		)
+		require.Equal(
+			t, fn.MaybeSome(asset.NUMSPubKey), reveal.DelegationKey,
+		)
+	})
 
 	// If we insert a meta of all zeroes twice, then we should get the same
 	// value back.

tapdb/asset_minting.go

@@ -738,11 +738,15 @@ func fetchAssetSeedlings(ctx context.Context, q PendingAssetStore,
 			seedling.GroupAnchor = &seedlingAnchor.AssetName
 		}
 
-		parseAssetMetaReveal(dbSeedling.AssetsMetum).WhenSome(
-			func(meta proof.MetaReveal) {
-				seedling.Meta = &meta
-			},
-		)
+		metaOpt, err := parseAssetMetaReveal(dbSeedling.AssetsMetum)
+		if err != nil {
+			return nil, fmt.Errorf("unable to parse asset meta: %w",
+				err)
+		}
+
+		metaOpt.WhenSome(func(meta proof.MetaReveal) {
+			seedling.Meta = &meta
+		})
 
 		seedlings[seedling.AssetName] = seedling
 	}
@@ -968,9 +972,12 @@ func fetchMetaByAssetID(ctx context.Context, db PendingAssetStore,
 
 	// Parse the meta reveal from the database. We expect it to exist at
 	// this point, as we didn't get an sql.ErrNoRows error above.
-	meta, err := parseAssetMetaReveal(assetMeta.AssetsMetum).UnwrapOrErr(
-		ErrNoAssetMeta,
-	)
+	metaOpt, err := parseAssetMetaReveal(assetMeta.AssetsMetum)
+	if err != nil {
+		return nil, fmt.Errorf("unable to parse asset meta: %w", err)
+	}
+
+	meta, err := metaOpt.UnwrapOrErr(ErrNoAssetMeta)
 	if err != nil {
 		return nil, err
 	}

tapdb/assets_common.go

@@ -7,6 +7,8 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
+	"net/url"
+	"strings"
 
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
@@ -688,9 +690,13 @@ func maybeUpsertAssetMeta(ctx context.Context, db UpsertAssetStore,
 	assetGen *asset.Genesis, metaReveal *proof.MetaReveal) (int64, error) {
 
 	var (
-		metaHash [32]byte
-		metaBlob []byte
-		metaType sql.NullInt16
+		metaHash                [32]byte
+		metaBlob                []byte
+		metaType                sql.NullInt16
+		metaDecimalDisplay      sql.NullInt32
+		metaUniverseCommitments sql.NullBool
+		metaCanonicalUniverses  []byte
+		metaDelegationKey       []byte
 
 		err error
 	)
@@ -701,10 +707,22 @@ func maybeUpsertAssetMeta(ctx context.Context, db UpsertAssetStore,
 	case metaReveal != nil:
 		metaHash = metaReveal.MetaHash()
 		metaBlob = metaReveal.Data
-		metaType = sql.NullInt16{
-			Int16: int16(metaReveal.Type),
-			Valid: true,
-		}
+		metaType = sqlInt16(metaReveal.Type)
+		metaDecimalDisplay = sqlOptInt32(metaReveal.DecimalDisplay)
+		metaUniverseCommitments = sqlBool(
+			metaReveal.UniverseCommitments,
+		)
+		metaReveal.CanonicalUniverses.WhenSome(func(u []url.URL) {
+			urlStrings := fn.Map(u, func(u url.URL) string {
+				return u.String()
+			})
+			metaCanonicalUniverses = []byte(
+				strings.Join(urlStrings, "\x00"),
+			)
+		})
+		metaReveal.DelegationKey.WhenSome(func(key btcec.PublicKey) {
+			metaDelegationKey = key.SerializeCompressed()
+		})
 
 	// Otherwise, we'll just be inserting only the meta hash. At a later
 	// time, the reveal/blob can also be inserted.
@@ -717,9 +735,13 @@ func maybeUpsertAssetMeta(ctx context.Context, db UpsertAssetStore,
 	}
 
 	assetMetaID, err := db.UpsertAssetMeta(ctx, NewAssetMeta{
-		MetaDataHash: metaHash[:],
-		MetaDataBlob: metaBlob,
-		MetaDataType: metaType,
+		MetaDataHash:            metaHash[:],
+		MetaDataBlob:            metaBlob,
+		MetaDataType:            metaType,
+		MetaDecimalDisplay:      metaDecimalDisplay,
+		MetaUniverseCommitments: metaUniverseCommitments,
+		MetaCanonicalUniverses:  metaCanonicalUniverses,
+		MetaDelegationKey:       metaDelegationKey,
 	})
 	if err != nil {
 		return assetMetaID, err

tapdb/migrations.go

@@ -22,7 +22,7 @@ const (
 	// daemon.
 	//
 	// NOTE: This MUST be updated when a new migration is added.
-	LatestMigrationVersion = 27
+	LatestMigrationVersion = 28
 )
 
 // MigrationTarget is a functional option that can be passed to applyMigrations