@blinklabs/dingo 0.7.0 → 0.8.0

package/database/commit_timestamp.go

@@ -1,77 +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 database
-
-import (
-	"fmt"
-)
-
-// CommitTimestampError contains the timestamps of the metadata and blob stores
-type CommitTimestampError struct {
-	MetadataTimestamp int64
-	BlobTimestamp     int64
-}
-
-// Error returns the stringified error
-func (e CommitTimestampError) Error() string {
-	return fmt.Sprintf(
-		"commit timestamp mismatch: %d (metadata) != %d (blob)",
-		e.MetadataTimestamp,
-		e.BlobTimestamp,
-	)
-}
-
-func (b *Database) checkCommitTimestamp() error {
-	// Get value from metadata
-	metadataTimestamp, metadataErr := b.Metadata().GetCommitTimestamp()
-	if metadataErr != nil {
-		return fmt.Errorf(
-			"failed to get metadata timestamp from plugin: %w",
-			metadataErr,
-		)
-	}
-	// No timestamp in the database
-	if metadataTimestamp <= 0 {
-		return nil
-	}
-	// Get value from blob
-	blobTimestamp, blobErr := b.Blob().GetCommitTimestamp()
-	if blobErr != nil {
-		return fmt.Errorf(
-			"failed to get blob timestamp from plugin: %w",
-			blobErr,
-		)
-	}
-	// Compare values
-	if blobTimestamp != metadataTimestamp {
-		return CommitTimestampError{
-			MetadataTimestamp: metadataTimestamp,
-			BlobTimestamp:     blobTimestamp,
-		}
-	}
-	return nil
-}
-
-func (b *Database) updateCommitTimestamp(txn *Txn, timestamp int64) error {
-	// Update metadata
-	if err := b.Metadata().SetCommitTimestamp(txn.Metadata(), timestamp); err != nil {
-		return err
-	}
-	// Update blob
-	if err := b.Blob().SetCommitTimestamp(txn.Blob(), timestamp); err != nil {
-		return err
-	}
-	return nil
-}

package/database/database.go

@@ -1,118 +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 database
-
-import (
-	"errors"
-	"io"
-	"log/slog"
-
-	"github.com/blinklabs-io/dingo/database/plugin/blob"
-	"github.com/blinklabs-io/dingo/database/plugin/metadata"
-)
-
-// Database represents our data storage services
-type Database struct {
-	logger   *slog.Logger
-	blob     blob.BlobStore
-	metadata metadata.MetadataStore
-	dataDir  string
-}
-
-// Blob returns the underling blob store instance
-func (d *Database) Blob() blob.BlobStore {
-	return d.blob
-}
-
-// DataDir returns the path to the data directory used for storage
-func (d *Database) DataDir() string {
-	return d.dataDir
-}
-
-// Logger returns the logger instance
-func (d *Database) Logger() *slog.Logger {
-	return d.logger
-}
-
-// Metadata returns the underlying metadata store instance
-func (d *Database) Metadata() metadata.MetadataStore {
-	return d.metadata
-}
-
-// Transaction starts a new database transaction and returns a handle to it
-func (d *Database) Transaction(readWrite bool) *Txn {
-	return NewTxn(d, readWrite)
-}
-
-// BlobTxn starts a new blob-only database transaction and returns a handle to it
-func (d *Database) BlobTxn(readWrite bool) *Txn {
-	return NewBlobOnlyTxn(d, readWrite)
-}
-
-// MetadataTxn starts a new metadata-only database transaction and returns a handle to it
-func (d *Database) MetadataTxn(readWrite bool) *Txn {
-	return NewMetadataOnlyTxn(d, readWrite)
-}
-
-// Close cleans up the database connections
-func (d *Database) Close() error {
-	var err error
-	// Close metadata
-	metadataErr := d.Metadata().Close()
-	err = errors.Join(err, metadataErr)
-	// Close blob
-	blobErr := d.Blob().Close()
-	err = errors.Join(err, blobErr)
-	return err
-}
-
-func (d *Database) 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))
-	}
-	// Check commit timestamp
-	if err := d.checkCommitTimestamp(); err != nil {
-		return err
-	}
-	return nil
-}
-
-// New creates a new database instance with optional persistence using the provided data directory
-func New(
-	logger *slog.Logger,
-	dataDir string,
-) (*Database, error) {
-	metadataDb, err := metadata.New("sqlite", dataDir, logger)
-	if err != nil {
-		return nil, err
-	}
-	blobDb, err := blob.New("badger", dataDir, logger)
-	if err != nil {
-		return nil, err
-	}
-	db := &Database{
-		logger:   logger,
-		blob:     blobDb,
-		metadata: metadataDb,
-		dataDir:  dataDir,
-	}
-	if err := db.init(); err != nil {
-		// Database is available for recovery, so return it with error
-		return db, err
-	}
-	return db, nil
-}

package/database/database_test.go

@@ -1,62 +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 database_test
-
-import (
-	"testing"
-	"time"
-
-	"github.com/blinklabs-io/dingo/database"
-	"gorm.io/gorm"
-)
-
-type TestTable struct {
-	gorm.Model
-}
-
-// TestInMemorySqliteMultipleTransaction tests that our sqlite connection allows multiple
-// concurrent transactions when using in-memory mode. This requires special URI flags, and
-// this is mostly making sure that we don't lose them
-func TestInMemorySqliteMultipleTransaction(t *testing.T) {
-	var db *database.Database
-	doQuery := func(sleep time.Duration) error {
-		txn := db.Metadata().Transaction()
-		if result := txn.First(&TestTable{}); result.Error != nil {
-			return result.Error
-		}
-		time.Sleep(sleep)
-		if result := txn.Commit(); result.Error != nil {
-			return result.Error
-		}
-		return nil
-	}
-	db, err := database.New(nil, "") // in-memory
-	if err != nil {
-		t.Fatalf("unexpected error: %s", err)
-	}
-	if err := db.Metadata().DB().AutoMigrate(&TestTable{}); err != nil {
-		t.Fatalf("unexpected error: %s", err)
-	}
-	if result := db.Metadata().DB().Create(&TestTable{}); result.Error != nil {
-		t.Fatalf("unexpected error: %s", result.Error)
-	}
-	// The linter calls us on the lack of error checking, but it's a goroutine...
-	//nolint:errcheck
-	go doQuery(5 * time.Second)
-	time.Sleep(1 * time.Second)
-	if err := doQuery(0); err != nil {
-		t.Fatalf("unexpected error: %s", err)
-	}
-}

package/database/drep.go

@@ -1,47 +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 database
-
-import (
-	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
-)
-
-// SetRegistrationDrep saves a registration drep certificate
-func (d *Database) SetRegistrationDrep(
-	cert *lcommon.RegistrationDrepCertificate,
-	slot, deposit uint64,
-	txn *Txn,
-) error {
-	return d.metadata.SetRegistrationDrep(
-		cert,
-		slot,
-		deposit,
-		txn.Metadata(),
-	)
-}
-
-// SetDeregistrationDrep saves a deregistration drep certificate
-func (d *Database) SetDeregistrationDrep(
-	cert *lcommon.DeregistrationDrepCertificate,
-	slot, deposit uint64,
-	txn *Txn,
-) error {
-	return d.metadata.SetDeregistrationDrep(
-		cert,
-		slot,
-		deposit,
-		txn.Metadata(),
-	)
-}

package/database/epoch.go

@@ -1,121 +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 database
-
-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"
-}
-
-func (d *Database) GetEpochLatest(txn *Txn) (Epoch, error) {
-	tmpEpoch := Epoch{}
-	if txn == nil {
-		latestEpoch, err := d.metadata.GetEpochLatest(nil)
-		if err != nil {
-			return tmpEpoch, err
-		}
-		tmpEpoch = Epoch(latestEpoch)
-	} else {
-		latestEpoch, err := d.metadata.GetEpochLatest(txn.Metadata())
-		if err != nil {
-			return tmpEpoch, err
-		}
-		tmpEpoch = Epoch(latestEpoch)
-	}
-	return tmpEpoch, nil
-}
-
-func (d *Database) GetEpochsByEra(eraId uint, txn *Txn) ([]Epoch, error) {
-	tmpEpochs := []Epoch{}
-	if txn == nil {
-		epochs, err := d.metadata.GetEpochsByEra(eraId, nil)
-		if err != nil {
-			return tmpEpochs, err
-		}
-		for _, epoch := range epochs {
-			tmpEpochs = append(tmpEpochs, Epoch(epoch))
-		}
-	} else {
-		epochs, err := txn.db.metadata.GetEpochsByEra(eraId, txn.Metadata())
-		if err != nil {
-			return tmpEpochs, err
-		}
-		for _, epoch := range epochs {
-			tmpEpochs = append(tmpEpochs, Epoch(epoch))
-		}
-	}
-	return tmpEpochs, nil
-}
-
-func (d *Database) GetEpochs(txn *Txn) ([]Epoch, error) {
-	tmpEpochs := []Epoch{}
-	if txn == nil {
-		epochs, err := d.metadata.GetEpochs(nil)
-		if err != nil {
-			return tmpEpochs, err
-		}
-		for _, epoch := range epochs {
-			tmpEpochs = append(tmpEpochs, Epoch(epoch))
-		}
-	} else {
-		epochs, err := txn.db.metadata.GetEpochs(txn.Metadata())
-		if err != nil {
-			return tmpEpochs, err
-		}
-		for _, epoch := range epochs {
-			tmpEpochs = append(tmpEpochs, Epoch(epoch))
-		}
-	}
-	return tmpEpochs, nil
-}
-
-func (d *Database) SetEpoch(
-	slot, epoch uint64,
-	nonce []byte,
-	era, slotLength, lengthInSlots uint,
-	txn *Txn,
-) error {
-	if txn == nil {
-		err := d.metadata.SetEpoch(
-			slot,
-			epoch,
-			nonce,
-			era,
-			slotLength,
-			lengthInSlots,
-			nil,
-		)
-		if err != nil {
-			return err
-		}
-	} else {
-		err := d.metadata.SetEpoch(slot, epoch, nonce, era, slotLength, lengthInSlots, txn.Metadata())
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}

package/database/immutable/chunk.go

@@ -1,182 +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 immutable
-
-import (
-	"errors"
-	"fmt"
-	"math"
-	"os"
-
-	"github.com/blinklabs-io/gouroboros/cbor"
-)
-
-const (
-	chunkFileExtension = ".chunk"
-)
-
-type chunk struct {
-	file         *os.File
-	fileSize     int64
-	secondary    *secondaryIndex
-	currentEntry *secondaryIndexEntry
-	nextEntry    *secondaryIndexEntry
-}
-
-func newChunk() *chunk {
-	return &chunk{}
-}
-
-func (c *chunk) Open(path string, secondary *secondaryIndex) error {
-	f, err := os.Open(path)
-	if err != nil {
-		return err
-	}
-	c.file = f
-	c.secondary = secondary
-	if stat, err := f.Stat(); err != nil {
-		return err
-	} else {
-		c.fileSize = stat.Size()
-	}
-	currentEntry, err := secondary.Next()
-	if err != nil {
-		return err
-	}
-	c.currentEntry = currentEntry
-	nextEntry, err := secondary.Next()
-	if err != nil {
-		return err
-	}
-	c.nextEntry = nextEntry
-	return nil
-}
-
-func (c *chunk) Close() error {
-	if err := c.secondary.Close(); err != nil {
-		return err
-	}
-	return c.file.Close()
-}
-
-func (c *chunk) Next() (*Block, error) {
-	if c.currentEntry == nil {
-		return nil, nil
-	}
-	if c.nextEntry == nil {
-		if c.currentEntry.BlockOffset > math.MaxInt64 {
-			return nil, errors.New("current block offset integer overflow")
-		}
-		// This triggers even though we check it above
-		// #nosec G115
-		currOffset := int64(c.currentEntry.BlockOffset)
-
-		// We've reached the last entry in the chunk, so we calculate
-		// block size based on the size of the file
-		blockSize := c.fileSize - currOffset
-		blockData := make([]byte, blockSize)
-		// Seek to offset
-		if _, err := c.file.Seek(currOffset, 0); err != nil {
-			return nil, err
-		}
-		n, err := c.file.Read(blockData)
-		if err != nil {
-			return nil, err
-		}
-		if int64(n) < blockSize {
-			return nil, fmt.Errorf(
-				"did not read expected amount of block data: expected %d, got %d",
-				blockSize,
-				n,
-			)
-		}
-		blkType, blkBytes, err := c.unwrapBlock(blockData)
-		if err != nil {
-			return nil, err
-		}
-		ret := &Block{
-			Type:  blkType,
-			Slot:  c.currentEntry.BlockOrEbb,
-			Hash:  c.currentEntry.HeaderHash[:],
-			IsEbb: c.currentEntry.IsEbb,
-			Cbor:  blkBytes[:],
-		}
-		c.currentEntry = nil
-		c.nextEntry = nil
-		return ret, nil
-	} else {
-		// Calculate block size based on the offsets for the current and next entries
-		if c.currentEntry.BlockOffset > math.MaxInt64 {
-			return nil, errors.New("current block offset integer overflow")
-		}
-		// This triggers even though we check it above
-		// #nosec G115
-		currOffset := int64(c.currentEntry.BlockOffset)
-
-		if c.nextEntry.BlockOffset > math.MaxInt64 {
-			return nil, errors.New("next block offset integer overflow")
-		}
-		// This triggers even though we check it above
-		// #nosec G115
-		nextOffset := int64(c.nextEntry.BlockOffset)
-
-		blockSize := nextOffset - currOffset
-		blockData := make([]byte, blockSize)
-		// Seek to offset
-		if _, err := c.file.Seek(currOffset, 0); err != nil {
-			return nil, err
-		}
-		n, err := c.file.Read(blockData)
-		if err != nil {
-			return nil, err
-		}
-		if int64(n) < blockSize {
-			return nil, fmt.Errorf(
-				"did not read expected amount of block data: expected %d, got %d",
-				blockSize,
-				n,
-			)
-		}
-		blkType, blkBytes, err := c.unwrapBlock(blockData)
-		if err != nil {
-			return nil, err
-		}
-		ret := &Block{
-			Type: blkType,
-			Slot: c.currentEntry.BlockOrEbb,
-			Hash: c.currentEntry.HeaderHash[:],
-			Cbor: blkBytes[:],
-		}
-		c.currentEntry = c.nextEntry
-		nextEntry, err := c.secondary.Next()
-		if err != nil {
-			return nil, err
-		}
-		c.nextEntry = nextEntry
-		return ret, nil
-	}
-}
-
-func (c *chunk) unwrapBlock(data []byte) (uint, []byte, error) {
-	tmpData := struct {
-		cbor.StructAsArray
-		BlockType uint
-		BlockCbor cbor.RawMessage
-	}{}
-	if _, err := cbor.Decode(data, &tmpData); err != nil {
-		return 0, nil, err
-	}
-	return tmpData.BlockType, []byte(tmpData.BlockCbor), nil
-}