@blinklabs/dingo 0.7.0 → 0.8.0

package/database/plugin/metadata/sqlite/account.go

@@ -1,313 +0,0 @@
-// Copyright 2025 Blink Labs Software
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package sqlite
-
-import (
-	"github.com/blinklabs-io/dingo/database/plugin/metadata/sqlite/models"
-	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-)
-
-// GetAccount gets an account
-func (d *MetadataStoreSqlite) GetAccount(
-	stakeKey []byte,
-	txn *gorm.DB,
-) (models.Account, error) {
-	ret := models.Account{}
-	tmpAccount := models.Account{}
-	if txn != nil {
-		if result := txn.First(&tmpAccount, "staking_key = ?", stakeKey); result.Error != nil {
-			return ret, result.Error
-		}
-	} else {
-		if result := d.DB().First(&tmpAccount, "staking_key = ?", stakeKey); result.Error != nil {
-			return ret, result.Error
-		}
-	}
-	ret = tmpAccount
-	return ret, nil
-}
-
-// SetAccount saves an account
-func (d *MetadataStoreSqlite) SetAccount(
-	stakeKey, pkh, drep []byte,
-	slot uint64,
-	active bool,
-	txn *gorm.DB,
-) error {
-	tmpItem := models.Account{
-		StakingKey: stakeKey,
-		AddedSlot:  slot,
-		Pool:       pkh,
-		Drep:       drep,
-	}
-	if txn != nil {
-		if result := txn.Clauses(clause.OnConflict{UpdateAll: true}).Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	} else {
-		if result := d.DB().Clauses(clause.OnConflict{UpdateAll: true}).Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	}
-	return nil
-}
-
-// SetDeregistration saves a deregistration certificate
-func (d *MetadataStoreSqlite) SetDeregistration(
-	cert *lcommon.DeregistrationCertificate,
-	slot uint64,
-	txn *gorm.DB,
-) error {
-	stakeKey := cert.StakeCredential.Credential.Bytes()
-	tmpAccount, err := d.GetAccount(stakeKey, txn)
-	if err != nil {
-		return err
-	}
-	tmpItem := models.Deregistration{
-		StakingKey: stakeKey,
-		AddedSlot:  slot,
-	}
-	tmpAccount.Active = false
-	if txn != nil {
-		if accountErr := txn.Save(&tmpAccount); accountErr.Error != nil {
-			return accountErr.Error
-		}
-		if result := txn.Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	} else {
-		if accountErr := d.DB().Save(&tmpAccount); accountErr.Error != nil {
-			return accountErr.Error
-		}
-		if result := d.DB().Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	}
-	return nil
-}
-
-// SetRegistration saves a registration certificate and account
-func (d *MetadataStoreSqlite) SetRegistration(
-	cert *lcommon.RegistrationCertificate,
-	slot, deposit uint64,
-	txn *gorm.DB,
-) error {
-	stakeKey := cert.StakeCredential.Credential.Bytes()
-	tmpItem := models.Registration{
-		StakingKey:    stakeKey,
-		AddedSlot:     slot,
-		DepositAmount: deposit,
-	}
-	if err := d.SetAccount(stakeKey, nil, nil, slot, true, txn); err != nil {
-		return err
-	}
-	if txn != nil {
-		if result := txn.Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	} else {
-		if result := d.DB().Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	}
-	return nil
-}
-
-// SetStakeDelegation saves a stake delegation certificate
-func (d *MetadataStoreSqlite) SetStakeDelegation(
-	cert *lcommon.StakeDelegationCertificate,
-	slot uint64,
-	txn *gorm.DB,
-) error {
-	stakeKey := cert.StakeCredential.Credential.Bytes()
-	tmpAccount, err := d.GetAccount(stakeKey, txn)
-	if err != nil {
-		return err
-	}
-	tmpItem := models.StakeDelegation{
-		StakingKey:  stakeKey,
-		PoolKeyHash: cert.PoolKeyHash[:],
-		AddedSlot:   slot,
-	}
-	tmpAccount.Pool = tmpItem.PoolKeyHash
-	if txn != nil {
-		if accountErr := txn.Save(&tmpAccount); accountErr.Error != nil {
-			return accountErr.Error
-		}
-		if result := txn.Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	} else {
-		if accountErr := d.DB().Save(&tmpAccount); accountErr.Error != nil {
-			return accountErr.Error
-		}
-		if result := d.DB().Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	}
-	return nil
-}
-
-// SetStakeDeregistration saves a stake deregistration certificate
-func (d *MetadataStoreSqlite) SetStakeDeregistration(
-	cert *lcommon.StakeDeregistrationCertificate,
-	slot uint64,
-	txn *gorm.DB,
-) error {
-	stakeKey := cert.StakeDeregistration.Credential.Bytes()
-	tmpAccount, err := d.GetAccount(stakeKey, txn)
-	if err != nil {
-		return err
-	}
-	tmpItem := models.StakeDeregistration{
-		StakingKey: stakeKey,
-		AddedSlot:  slot,
-	}
-	tmpAccount.Active = false
-	if txn != nil {
-		if accountErr := txn.Save(&tmpAccount); accountErr.Error != nil {
-			return accountErr.Error
-		}
-		if result := txn.Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	} else {
-		if accountErr := d.DB().Save(&tmpAccount); accountErr.Error != nil {
-			return accountErr.Error
-		}
-		if result := d.DB().Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	}
-	return nil
-}
-
-// SetStakeRegistration saves a stake registration certificate and account
-func (d *MetadataStoreSqlite) SetStakeRegistration(
-	cert *lcommon.StakeRegistrationCertificate,
-	slot, deposit uint64,
-	txn *gorm.DB,
-) error {
-	stakeKey := cert.StakeRegistration.Credential.Bytes()
-	tmpItem := models.StakeRegistration{
-		StakingKey:    stakeKey,
-		AddedSlot:     slot,
-		DepositAmount: deposit,
-	}
-	if err := d.SetAccount(stakeKey, nil, nil, slot, true, txn); err != nil {
-		return err
-	}
-	if txn != nil {
-		if result := txn.Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	} else {
-		if result := d.DB().Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	}
-	return nil
-}
-
-// SetStakeRegistrationDelegation saves a stake registration delegation certificate and account
-func (d *MetadataStoreSqlite) SetStakeRegistrationDelegation(
-	cert *lcommon.StakeRegistrationDelegationCertificate,
-	slot, deposit uint64,
-	txn *gorm.DB,
-) error {
-	stakeKey := cert.StakeCredential.Credential.Bytes()
-	pkh := cert.PoolKeyHash[:]
-	tmpItem := models.StakeRegistrationDelegation{
-		StakingKey:    stakeKey,
-		PoolKeyHash:   pkh,
-		AddedSlot:     slot,
-		DepositAmount: deposit,
-	}
-	if err := d.SetAccount(stakeKey, pkh, nil, slot, true, txn); err != nil {
-		return err
-	}
-	if txn != nil {
-		if result := txn.Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	} else {
-		if result := d.DB().Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	}
-	return nil
-}
-
-// SetStakeVoteRegistrationDelegation saves a stake vote registration delegation certificate and account
-func (d *MetadataStoreSqlite) SetStakeVoteRegistrationDelegation(
-	cert *lcommon.StakeVoteRegistrationDelegationCertificate,
-	slot, deposit uint64,
-	txn *gorm.DB,
-) error {
-	stakeKey := cert.StakeCredential.Credential.Bytes()
-	pkh := cert.PoolKeyHash[:]
-	drep := cert.Drep.Credential[:]
-	tmpItem := models.StakeVoteRegistrationDelegation{
-		StakingKey:    stakeKey,
-		PoolKeyHash:   pkh,
-		Drep:          drep,
-		AddedSlot:     slot,
-		DepositAmount: deposit,
-	}
-	if err := d.SetAccount(stakeKey, pkh, drep, slot, true, txn); err != nil {
-		return err
-	}
-	if txn != nil {
-		if result := txn.Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	} else {
-		if result := d.DB().Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	}
-	return nil
-}
-
-// SetVoteRegistrationDelegation saves a vote registration delegation certificate and account
-func (d *MetadataStoreSqlite) SetVoteRegistrationDelegation(
-	cert *lcommon.VoteRegistrationDelegationCertificate,
-	slot, deposit uint64,
-	txn *gorm.DB,
-) error {
-	stakeKey := cert.StakeCredential.Credential.Bytes()
-	drep := cert.Drep.Credential[:]
-	tmpItem := models.VoteRegistrationDelegation{
-		StakingKey:    stakeKey,
-		Drep:          drep,
-		AddedSlot:     slot,
-		DepositAmount: deposit,
-	}
-	if err := d.SetAccount(stakeKey, nil, drep, slot, true, txn); err != nil {
-		return err
-	}
-	if txn != nil {
-		if result := txn.Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	} else {
-		if result := d.DB().Create(&tmpItem); result.Error != nil {
-			return result.Error
-		}
-	}
-	return nil
-}

package/database/plugin/metadata/sqlite/certs.go

@@ -1,58 +0,0 @@
-// Copyright 2025 Blink Labs Software
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package sqlite
-
-import (
-	"github.com/blinklabs-io/dingo/database/plugin/metadata/sqlite/models"
-	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
-	"gorm.io/gorm"
-)
-
-// GetStakeRegistrations returns stake registration certificates
-func (d *MetadataStoreSqlite) GetStakeRegistrations(
-	stakingKey []byte,
-	txn *gorm.DB,
-) ([]lcommon.StakeRegistrationCertificate, error) {
-	ret := []lcommon.StakeRegistrationCertificate{}
-	certs := []models.StakeRegistration{}
-	if txn != nil {
-		result := txn.Where("staking_key = ?", stakingKey).
-			Order("id DESC").
-			Find(&certs)
-		if result.Error != nil {
-			return ret, result.Error
-		}
-	} else {
-		result := d.DB().Where("staking_key = ?", stakingKey).
-			Order("id DESC").
-			Find(&certs)
-		if result.Error != nil {
-			return ret, result.Error
-		}
-	}
-	var tmpCert lcommon.StakeRegistrationCertificate
-	for _, cert := range certs {
-		tmpCert = lcommon.StakeRegistrationCertificate{
-			CertType: lcommon.CertificateTypeStakeRegistration,
-			StakeRegistration: lcommon.Credential{
-				// TODO: determine correct type
-				// CredType: lcommon.CredentialTypeAddrKeyHash,
-				Credential: lcommon.CredentialHash(cert.StakingKey),
-			},
-		}
-		ret = append(ret, tmpCert)
-	}
-	return ret, nil
-}

package/database/plugin/metadata/sqlite/commit_timestamp.go

@@ -1,68 +0,0 @@
-// Copyright 2025 Blink Labs Software
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package sqlite
-
-import (
-	"errors"
-
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-)
-
-const (
-	commitTimestampRowId = 1
-)
-
-// CommitTimestamp represents the sqlite table used to track the current commit timestamp
-type CommitTimestamp struct {
-	ID        uint `gorm:"primarykey"`
-	Timestamp int64
-}
-
-func (CommitTimestamp) TableName() string {
-	return "commit_timestamp"
-}
-
-func (d *MetadataStoreSqlite) GetCommitTimestamp() (int64, error) {
-	// Get value from sqlite
-	var tmpCommitTimestamp CommitTimestamp
-	result := d.DB().First(&tmpCommitTimestamp)
-	if result.Error != nil {
-		// It's not an error if there's no records found
-		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
-			return 0, nil
-		}
-		return 0, result.Error
-	}
-	return tmpCommitTimestamp.Timestamp, nil
-}
-
-func (d *MetadataStoreSqlite) SetCommitTimestamp(
-	txn *gorm.DB,
-	timestamp int64,
-) error {
-	tmpCommitTimestamp := CommitTimestamp{
-		ID:        commitTimestampRowId,
-		Timestamp: timestamp,
-	}
-	result := txn.Clauses(clause.OnConflict{
-		Columns:   []clause.Column{{Name: "id"}},
-		DoUpdates: clause.AssignmentColumns([]string{"timestamp"}),
-	}).Create(&tmpCommitTimestamp)
-	if result.Error != nil {
-		return result.Error
-	}
-	return nil
-}

package/database/plugin/metadata/sqlite/database.go

@@ -1,218 +0,0 @@
-// Copyright 2025 Blink Labs Software
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package sqlite
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"io/fs"
-	"log/slog"
-	"os"
-	"path/filepath"
-	"time"
-
-	"github.com/blinklabs-io/dingo/database/plugin"
-	"github.com/blinklabs-io/dingo/database/plugin/metadata/sqlite/models"
-	"github.com/glebarez/sqlite"
-	"gorm.io/gorm"
-	gormlogger "gorm.io/gorm/logger"
-	"gorm.io/plugin/opentelemetry/tracing"
-)
-
-// Register plugin
-func init() {
-	plugin.Register(
-		plugin.PluginEntry{
-			Type: plugin.PluginTypeMetadata,
-			Name: "sqlite",
-		},
-	)
-}
-
-// MetadataStoreSqlite stores all data in sqlite. Data may not be persisted
-type MetadataStoreSqlite struct {
-	dataDir     string
-	db          *gorm.DB
-	logger      *slog.Logger
-	timerVacuum *time.Timer
-}
-
-// New creates a new database
-func New(
-	dataDir string,
-	logger *slog.Logger,
-) (*MetadataStoreSqlite, error) {
-	var metadataDb *gorm.DB
-	var err error
-	if dataDir == "" {
-		// No dataDir, use in-memory config
-		metadataDb, err = gorm.Open(
-			sqlite.Open("file::memory:?cache=shared"),
-			&gorm.Config{
-				Logger:                 gormlogger.Discard,
-				SkipDefaultTransaction: true,
-			},
-		)
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		// Make sure that we can read data dir, and create if it doesn't exist
-		if _, err := os.Stat(dataDir); err != nil {
-			if !errors.Is(err, fs.ErrNotExist) {
-				return nil, fmt.Errorf("failed to read data dir: %w", err)
-			}
-			// Create data directory
-			if err := os.MkdirAll(dataDir, fs.ModePerm); err != nil {
-				return nil, fmt.Errorf("failed to create data dir: %w", err)
-			}
-		}
-		// Open sqlite DB
-		metadataDbPath := filepath.Join(
-			dataDir,
-			"metadata.sqlite",
-		)
-		// WAL journal mode, disable sync on write, increase cache size to 50MB (from 2MB)
-		metadataConnOpts := "_pragma=journal_mode(WAL)&_pragma=sync(OFF)&_pragma=cache_size(-50000)"
-		metadataDb, err = gorm.Open(
-			sqlite.Open(
-				fmt.Sprintf("file:%s?%s", metadataDbPath, metadataConnOpts),
-			),
-			&gorm.Config{
-				Logger:                 gormlogger.Discard,
-				SkipDefaultTransaction: true,
-			},
-		)
-		if err != nil {
-			return nil, err
-		}
-	}
-	db := &MetadataStoreSqlite{
-		db:      metadataDb,
-		dataDir: dataDir,
-		logger:  logger,
-	}
-	if err := db.init(); err != nil {
-		// MetadataStoreSqlite is available for recovery, so return it with error
-		return db, err
-	}
-	// Create table schemas
-	db.logger.Debug(fmt.Sprintf("creating table: %#v", &CommitTimestamp{}))
-	if err := db.db.AutoMigrate(&CommitTimestamp{}); err != nil {
-		return db, err
-	}
-	for _, model := range models.MigrateModels {
-		db.logger.Debug(fmt.Sprintf("creating table: %#v", model))
-		if err := db.db.AutoMigrate(model); err != nil {
-			return db, err
-		}
-	}
-	return db, nil
-}
-
-func (d *MetadataStoreSqlite) init() error {
-	if d.logger == nil {
-		// Create logger to throw away logs
-		// We do this so we don't have to add guards around every log operation
-		d.logger = slog.New(slog.NewJSONHandler(io.Discard, nil))
-	}
-	// Configure tracing for GORM
-	if err := d.db.Use(tracing.NewPlugin(tracing.WithoutMetrics())); err != nil {
-		return err
-	}
-	// Schedule daily database vacuum to free unused space
-	d.scheduleDailyVacuum()
-	return nil
-}
-
-func (d *MetadataStoreSqlite) runVacuum() error {
-	if d.dataDir == "" {
-		return nil
-	}
-	if result := d.DB().Raw("VACUUM"); result.Error != nil {
-		return result.Error
-	}
-	return nil
-}
-
-func (d *MetadataStoreSqlite) scheduleDailyVacuum() {
-	if d.timerVacuum != nil {
-		d.timerVacuum.Stop()
-	}
-	daily := time.Duration(24) * time.Hour
-	f := func() {
-		d.logger.Debug(
-			"running vacuum on sqlite metadata database",
-		)
-		// schedule next run
-		defer d.scheduleDailyVacuum()
-		if err := d.runVacuum(); err != nil {
-			d.logger.Error(
-				"failed to free unused space in metadata store",
-				"component", "database",
-			)
-		}
-	}
-	d.timerVacuum = time.AfterFunc(daily, f)
-}
-
-// AutoMigrate wraps the gorm AutoMigrate
-func (d *MetadataStoreSqlite) AutoMigrate(dst ...interface{}) error {
-	return d.DB().AutoMigrate(dst...)
-}
-
-// Close gets the database handle from our MetadataStore and closes it
-func (d *MetadataStoreSqlite) Close() error {
-	// get DB handle from gorm.DB
-	db, err := d.DB().DB()
-	if err != nil {
-		return err
-	}
-	return db.Close()
-}
-
-// Create creates a record
-func (d *MetadataStoreSqlite) Create(value interface{}) *gorm.DB {
-	return d.DB().Create(value)
-}
-
-// DB returns the database handle
-func (d *MetadataStoreSqlite) DB() *gorm.DB {
-	return d.db
-}
-
-// First returns the first DB entry
-func (d *MetadataStoreSqlite) First(args interface{}) *gorm.DB {
-	return d.DB().First(args)
-}
-
-// Order orders a DB query
-func (d *MetadataStoreSqlite) Order(args interface{}) *gorm.DB {
-	return d.DB().Order(args)
-}
-
-// Transaction creates a gorm transaction
-func (d *MetadataStoreSqlite) Transaction() *gorm.DB {
-	return d.DB().Begin()
-}
-
-// Where constrains a DB query
-func (d *MetadataStoreSqlite) Where(
-	query interface{},
-	args ...interface{},
-) *gorm.DB {
-	return d.DB().Where(query, args...)
-}