tapdb: add meta store and metrics queries

Author: GeorgeTsagk

tapcfg/server.go

@@ -42,18 +42,25 @@ func genServerConfig(cfg *Config, cfgLogger btclog.Logger,
 	lndServices *lndclient.LndServices, enableChannelFeatures bool,
 	mainErrChan chan<- error) (*tap.Config, error) {
 
-	var err error
+	var (
+		err    error
+		db     databaseBackend
+		dbType sqlc.BackendType
+	)
 
 	// Now that we know where the database will live, we'll go ahead and
 	// open up the default implementation of it.
-	var db databaseBackend
 	switch cfg.DatabaseBackend {
 	case DatabaseBackendSqlite:
+		dbType = sqlc.BackendTypeSqlite
+
 		cfgLogger.Infof("Opening sqlite3 database at: %v",
 			cfg.Sqlite.DatabaseFileName)
 		db, err = tapdb.NewSqliteStore(cfg.Sqlite)
 
 	case DatabaseBackendPostgres:
+		dbType = sqlc.BackendTypePostgres
+
 		cfgLogger.Infof("Opening postgres database at: %v",
 			cfg.Postgres.DSN(true))
 		db, err = tapdb.NewPostgresStore(cfg.Postgres)
@@ -85,6 +92,12 @@ func genServerConfig(cfg *Config, cfgLogger btclog.Logger,
 		},
 	)
 
+	metaDB := tapdb.NewTransactionExecutor(
+		db, func(tx *sql.Tx) tapdb.MetaStore {
+			return db.WithTx(tx)
+		},
+	)
+
 	addrBookDB := tapdb.NewTransactionExecutor(
 		db, func(tx *sql.Tx) tapdb.AddrBook {
 			return db.WithTx(tx)
@@ -94,7 +107,7 @@ func genServerConfig(cfg *Config, cfgLogger btclog.Logger,
 	tapdbAddrBook := tapdb.NewTapAddressBook(
 		addrBookDB, &tapChainParams, defaultClock,
 	)
-	assetStore := tapdb.NewAssetStore(assetDB, defaultClock)
+	assetStore := tapdb.NewAssetStore(assetDB, metaDB, defaultClock, dbType)
 
 	keyRing := tap.NewLndRpcKeyRing(lndServices)
 	walletAnchor := tap.NewLndRpcWalletAnchor(lndServices)

tapdb/asset_minting_test.go

@@ -54,12 +54,18 @@ func newAssetStoreFromDB(db *BaseDB) (*AssetMintingStore, *AssetStore) {
 		return db.WithTx(tx)
 	}
 
+	metaTxCreator := func(tx *sql.Tx) MetaStore {
+		return db.WithTx(tx)
+	}
+
 	assetMintingDB := NewTransactionExecutor(db, txCreator)
 	assetsDB := NewTransactionExecutor(db, activeTxCreator)
+	metaDB := NewTransactionExecutor(db, metaTxCreator)
+
 	testClock := clock.NewTestClock(time.Now())
 
 	return NewAssetMintingStore(assetMintingDB),
-		NewAssetStore(assetsDB, testClock)
+		NewAssetStore(assetsDB, metaDB, testClock, db.Backend())
 }
 
 func assertBatchState(t *testing.T, batch *tapgarden.MintingBatch,

tapdb/assets_store.go

@@ -43,6 +43,10 @@ type (
 	// script key.
 	AssetProof = sqlc.FetchAssetProofsRow
 
+	// AssetProofSize is the asset proof size for a given asset, identified
+	// by its script key.
+	AssetProofSize = sqlc.FetchAssetProofsSizesRow
+
 	// AssetProofI is identical to AssetProof but is used for the case
 	// where the proofs for a specific asset are fetched.
 	AssetProofI = sqlc.FetchAssetProofRow
@@ -195,6 +199,10 @@ type ActiveAssetsStore interface {
 	// disk.
 	FetchAssetProofs(ctx context.Context) ([]AssetProof, error)
 
+	// FetchAssetsProofsSizes fetches all the asset proofs lengths that are
+	// stored on disk.
+	FetchAssetProofsSizes(ctx context.Context) ([]AssetProofSize, error)
+
 	// FetchAssetProof fetches the asset proof for a given asset identified
 	// by its script key.
 	FetchAssetProof(ctx context.Context,
@@ -339,6 +347,18 @@ type ActiveAssetsStore interface {
 		assetID []byte) (sqlc.FetchAssetMetaForAssetRow, error)
 }
 
+// MetaStore is a sub-set of the main sqlc.Querier interface that contains
+// methods related to metadata of the daemon.
+type MetaStore interface {
+	// AssetsDBSize returns the total size of the taproot assets sqlite
+	// database.
+	AssetsDBSizeSqlite(ctx context.Context) (int32, error)
+
+	// AssetsDBSize returns the total size of the taproot assets postgres
+	// database.
+	AssetsDBSizePostgres(ctx context.Context) (int64, error)
+}
+
 // AssetBalance holds a balance query result for a particular asset or all
 // assets tracked by this daemon.
 type AssetBalance struct {
@@ -378,29 +398,46 @@ type BatchedAssetStore interface {
 	BatchedTx[ActiveAssetsStore]
 }
 
+// BatchedMetaStore combines the MetaStore interface with the BatchedTx
+// interface, allowing for multiple queries to be executed in a single SQL
+// transaction.
+type BatchedMetaStore interface {
+	MetaStore
+
+	BatchedTx[MetaStore]
+}
+
 // AssetStore is used to query for the set of pending and confirmed assets.
 type AssetStore struct {
 	db BatchedAssetStore
 
+	metaDb BatchedMetaStore
+
 	// eventDistributor is an event distributor that will be used to notify
 	// subscribers about new proofs that are added to the archiver.
 	eventDistributor *fn.EventDistributor[proof.Blob]
 
 	clock clock.Clock
 
 	txHeights *lru.Cache[chainhash.Hash, cacheableBlockHeight]
+
+	dbType sqlc.BackendType
 }
 
 // NewAssetStore creates a new AssetStore from the specified BatchedAssetStore
 // interface.
-func NewAssetStore(db BatchedAssetStore, clock clock.Clock) *AssetStore {
+func NewAssetStore(db BatchedAssetStore, metaDB BatchedMetaStore,
+	clock clock.Clock, dbType sqlc.BackendType) *AssetStore {
+
 	return &AssetStore{
 		db:               db,
+		metaDb:           metaDB,
 		eventDistributor: fn.NewEventDistributor[proof.Blob](),
 		clock:            clock,
 		txHeights: lru.NewCache[chainhash.Hash, cacheableBlockHeight](
 			10_000,
 		),
+		dbType: dbType,
 	}
 }
 
@@ -1171,6 +1208,38 @@ func (a *AssetStore) FetchManagedUTXOs(ctx context.Context) (
 	return managedUtxos, nil
 }
 
+// FetchAssetProofsSizes fetches the sizes of the proofs in the db.
+func (a *AssetStore) FetchAssetProofsSizes(
+	ctx context.Context) ([]AssetProofSize, error) {
+
+	var pSizes []AssetProofSize
+
+	readOpts := NewAssetStoreReadTx()
+	dbErr := a.db.ExecTx(ctx, &readOpts, func(q ActiveAssetsStore) error {
+		proofSizes, err := q.FetchAssetProofsSizes(ctx)
+		if err != nil {
+			return err
+		}
+
+		for _, v := range proofSizes {
+			pSizes = append(
+				pSizes, AssetProofSize{
+					ScriptKey:       v.ScriptKey,
+					ProofFileLength: v.ProofFileLength,
+				},
+			)
+		}
+
+		return nil
+	})
+
+	if dbErr != nil {
+		return nil, dbErr
+	}
+
+	return pSizes, nil
+}
+
 // FetchAssetProofs returns the latest proof file for either the set of target
 // assets, or all assets if no script keys for an asset are passed in.
 //
@@ -3267,6 +3336,45 @@ func (a *AssetStore) FetchAssetMetaForAsset(ctx context.Context,
 	return assetMeta, nil
 }
 
+// AssetsDBSize returns the total size of the taproot assets database.
+func (a *AssetStore) AssetsDBSize(ctx context.Context) (int64, error) {
+	var totalSize int64
+
+	readOpts := NewAssetStoreReadTx()
+	dbErr := a.metaDb.ExecTx(ctx, &readOpts, func(q MetaStore) error {
+		var (
+			size int64
+			err  error
+		)
+		switch a.dbType {
+		case sqlc.BackendTypePostgres:
+			size, err = q.AssetsDBSizePostgres(ctx)
+
+		case sqlc.BackendTypeSqlite:
+			var res int32
+			res, err = q.AssetsDBSizeSqlite(ctx)
+			size = int64(res)
+
+		default:
+			return fmt.Errorf("unsupported db backend type")
+		}
+
+		if err != nil {
+			return err
+		}
+
+		totalSize = size
+
+		return nil
+	})
+
+	if dbErr != nil {
+		return 0, dbErr
+	}
+
+	return totalSize, nil
+}
+
 // FetchAssetMetaByHash attempts to fetch an asset meta based on an asset hash.
 func (a *AssetStore) FetchAssetMetaByHash(ctx context.Context,
 	metaHash [asset.MetaHashLen]byte) (*proof.MetaReveal, error) {

tapdb/sqlc/assets.sql.go

@@ -709,6 +709,15 @@ FROM asset_proofs
 JOIN asset_info
     ON asset_info.asset_id = asset_proofs.asset_id;
 
+-- name: FetchAssetProofsSizes :many
+SELECT script_keys.tweaked_script_key AS script_key, 
+       LENGTH(asset_proofs.proof_file) AS proof_file_length
+FROM asset_proofs
+JOIN assets
+    ON asset_proofs.asset_id = assets.asset_id
+JOIN script_keys
+    ON assets.script_key_id = script_keys.script_key_id;
+
 -- name: FetchAssetProofsByAssetID :many
 WITH asset_info AS (
     SELECT assets.asset_id, script_keys.tweaked_script_key

tapdb/sqlc/metadata.sql.go

@@ -0,0 +1,6 @@
+-- name: AssetsDBSizePostgres :one
+SELECT pg_catalog.pg_database_size(current_database()) AS size;
+
+-- name: AssetsDBSizeSqlite :one
+SELECT page_count * page_size AS size_in_bytes 
+FROM pragma_page_count(), pragma_page_size();

tapdb/sqlc/querier.go

@@ -274,7 +274,17 @@ func newDbHandleFromDb(db *BaseDB) *DbHandler {
 			return db.WithTx(tx)
 		},
 	)
-	activeAssetsStore := NewAssetStore(assetsDB, testClock)
+
+	// Gain a handle to the meta store.
+	metaDB := NewTransactionExecutor(
+		db, func(tx *sql.Tx) MetaStore {
+			return db.WithTx(tx)
+		},
+	)
+
+	activeAssetsStore := NewAssetStore(
+		assetsDB, metaDB, testClock, db.Backend(),
+	)
 
 	return &DbHandler{
 		UniverseFederationStore: fedStore,