@blinklabs/dingo 0.6.0 → 0.8.0

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...)
-}

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

@@ -1,120 +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"
-	"strconv"
-
-	"github.com/blinklabs-io/dingo/database/plugin/metadata/sqlite/models"
-	"gorm.io/gorm"
-)
-
-// GetEpochLatest returns the latest epoch
-func (d *MetadataStoreSqlite) GetEpochLatest(
-	txn *gorm.DB,
-) (models.Epoch, error) {
-	ret := models.Epoch{}
-	if txn != nil {
-		result := txn.Order("epoch_id DESC").First(&ret)
-		if result.Error != nil {
-			if !errors.Is(result.Error, gorm.ErrRecordNotFound) {
-				return ret, result.Error
-			}
-		}
-	} else {
-		result := d.DB().Order("epoch_id DESC").First(&ret)
-		if result.Error != nil {
-			if !errors.Is(result.Error, gorm.ErrRecordNotFound) {
-				return ret, result.Error
-			}
-		}
-	}
-	return ret, nil
-}
-
-// GetEpochsByEra returns the list of epochs by era
-func (d *MetadataStoreSqlite) GetEpochsByEra(
-	eraId uint,
-	txn *gorm.DB,
-) ([]models.Epoch, error) {
-	ret := []models.Epoch{}
-	if txn != nil {
-		result := txn.Where("era_id = ?", eraId).Order("epoch_id").Find(&ret)
-		if result.Error != nil {
-			return ret, result.Error
-		}
-	} else {
-		result := d.DB().Where("era_id = ?", eraId).Order("epoch_id").Find(&ret)
-		if result.Error != nil {
-			return ret, result.Error
-		}
-	}
-	return ret, nil
-}
-
-// GetEpochs returns the list of epochs
-func (d *MetadataStoreSqlite) GetEpochs(
-	txn *gorm.DB,
-) ([]models.Epoch, error) {
-	ret := []models.Epoch{}
-	if txn != nil {
-		result := txn.Order("epoch_id").Find(&ret)
-		if result.Error != nil {
-			return ret, result.Error
-		}
-	} else {
-		result := d.DB().Order("epoch_id").Find(&ret)
-		if result.Error != nil {
-			return ret, result.Error
-		}
-	}
-	return ret, nil
-}
-
-// SetEpoch saves an epoch
-func (d *MetadataStoreSqlite) SetEpoch(
-	slot, epoch uint64,
-	nonce []byte,
-	era, slotLength, lengthInSlots uint,
-	txn *gorm.DB,
-) error {
-	tmpItem := models.Epoch{
-		EpochId:       epoch,
-		StartSlot:     slot,
-		Nonce:         nonce,
-		EraId:         era,
-		SlotLength:    slotLength,
-		LengthInSlots: lengthInSlots,
-	}
-	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
-		}
-	}
-	// Run a vacuum, on error only log
-	if err := d.runVacuum(); err != nil {
-		d.logger.Error(
-			"failed to free space in metdata store",
-			"epoch", strconv.FormatUint(epoch, 10),
-			"error", err,
-		)
-	}
-	return nil
-}

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

@@ -1,81 +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 models
-
-type Account struct {
-	ID         uint   `gorm:"primarykey"`
-	StakingKey []byte `gorm:"index,unique"`
-	Pool       []byte `gorm:"index"`
-	Drep       []byte `gorm:"index"`
-	AddedSlot  uint64
-	Active     bool `gorm:"default:true"`
-}
-
-func (a *Account) TableName() string {
-	return "account"
-}
-
-type Deregistration struct {
-	ID         uint   `gorm:"primarykey"`
-	StakingKey []byte `gorm:"index"`
-	AddedSlot  uint64
-}
-
-func (Deregistration) TableName() string {
-	return "deregistration"
-}
-
-type Registration struct {
-	ID            uint   `gorm:"primarykey"`
-	StakingKey    []byte `gorm:"index"`
-	AddedSlot     uint64
-	DepositAmount uint64
-}
-
-func (Registration) TableName() string {
-	return "registration"
-}
-
-type StakeDelegation struct {
-	ID          uint   `gorm:"primarykey"`
-	StakingKey  []byte `gorm:"index"`
-	PoolKeyHash []byte `gorm:"index"`
-	AddedSlot   uint64
-}
-
-func (StakeDelegation) TableName() string {
-	return "stake_delegation"
-}
-
-type StakeDeregistration struct {
-	ID         uint   `gorm:"primarykey"`
-	StakingKey []byte `gorm:"index"`
-	AddedSlot  uint64
-}
-
-func (StakeDeregistration) TableName() string {
-	return "stake_deregistration"
-}
-
-type StakeRegistration struct {
-	ID            uint   `gorm:"primarykey"`
-	StakingKey    []byte `gorm:"index"`
-	AddedSlot     uint64
-	DepositAmount uint64
-}
-
-func (StakeRegistration) TableName() string {
-	return "stake_registration"
-}

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

@@ -1,26 +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 models
-
-type AuthCommitteeHot struct {
-	ID             uint   `gorm:"primarykey"`
-	ColdCredential []byte `gorm:"index"`
-	HostCredential []byte `gorm:"index"`
-	AddedSlot      uint64
-}
-
-func (AuthCommitteeHot) TableName() string {
-	return "auth_committee_hot"
-}

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

@@ -1,26 +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 models
-
-type DeregistrationDrep struct {
-	ID             uint   `gorm:"primarykey"`
-	DrepCredential []byte `gorm:"index"`
-	AddedSlot      uint64
-	DepositAmount  uint64
-}
-
-func (DeregistrationDrep) TableName() string {
-	return "deregistration_drep"
-}

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

@@ -1,27 +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 models
-
-type Drep struct {
-	ID         uint   `gorm:"primarykey"`
-	Credential []byte `gorm:"index"`
-	AnchorUrl  string
-	AnchorHash []byte
-	AddedSlot  uint64
-}
-
-func (d *Drep) TableName() string {
-	return "drep"
-}

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

@@ -1,31 +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 models
-
-type Epoch struct {
-	ID uint `gorm:"primarykey"`
-	// NOTE: we would normally use this as the primary key, but GORM doesn't
-	// like a primary key value of 0
-	EpochId       uint64 `gorm:"uniqueIndex"`
-	StartSlot     uint64
-	Nonce         []byte
-	EraId         uint
-	SlotLength    uint
-	LengthInSlots uint
-}
-
-func (Epoch) TableName() string {
-	return "epoch"
-}