@blinklabs/dingo 0.6.0

package/database/plugin/register.go

@@ -0,0 +1,118 @@
+// 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 plugin
+
+import (
+	"flag"
+	"fmt"
+)
+
+type PluginType int
+
+const (
+	PluginTypeMetadata PluginType = 1
+	PluginTypeBlob     PluginType = 2
+)
+
+func PluginTypeName(pluginType PluginType) string {
+	switch pluginType {
+	case PluginTypeMetadata:
+		return "metadata"
+	case PluginTypeBlob:
+		return "blob"
+	default:
+		return ""
+	}
+}
+
+type PluginEntry struct {
+	Type               PluginType
+	Name               string
+	Description        string
+	Options            []PluginOption
+	NewFromOptionsFunc func() Plugin
+}
+
+var pluginEntries []PluginEntry
+
+func Register(pluginEntry PluginEntry) {
+	pluginEntries = append(pluginEntries, pluginEntry)
+}
+
+func PopulateCmdlineOptions(fs *flag.FlagSet) error {
+	for _, plugin := range pluginEntries {
+		for _, option := range plugin.Options {
+			if err := option.AddToFlagSet(fs, PluginTypeName(plugin.Type), plugin.Name); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func ProcessEnvVars() error {
+	for _, plugin := range pluginEntries {
+		// Generate env var prefix based on plugin type and name
+		envVarPrefix := fmt.Sprintf(
+			"%s-%s-",
+			PluginTypeName(plugin.Type),
+			plugin.Name,
+		)
+		for _, option := range plugin.Options {
+			if err := option.ProcessEnvVars(envVarPrefix); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func ProcessConfig(
+	pluginConfig map[string]map[string]map[interface{}]interface{},
+) error {
+	for _, plugin := range pluginEntries {
+		if pluginTypeData, ok := pluginConfig[PluginTypeName(plugin.Type)]; ok {
+			if pluginData, ok := pluginTypeData[plugin.Name]; ok {
+				for _, option := range plugin.Options {
+					if err := option.ProcessConfig(pluginData); err != nil {
+						return err
+					}
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func GetPlugins(pluginType PluginType) []PluginEntry {
+	ret := []PluginEntry{}
+	for _, plugin := range pluginEntries {
+		if plugin.Type == pluginType {
+			ret = append(ret, plugin)
+		}
+	}
+	return ret
+}
+
+func GetPlugin(pluginType PluginType, name string) Plugin {
+	for _, plugin := range pluginEntries {
+		if plugin.Type == pluginType {
+			if plugin.Name == name {
+				return plugin.NewFromOptionsFunc()
+			}
+		}
+	}
+	return nil
+}

package/database/pparams.go

@@ -0,0 +1,145 @@
+// 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"
+
+	"github.com/blinklabs-io/gouroboros/cbor"
+	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
+)
+
+func (d *Database) GetPParams(
+	epoch uint64,
+	decodeFunc func([]byte) (lcommon.ProtocolParameters, error),
+	txn *Txn,
+) (lcommon.ProtocolParameters, error) {
+	var ret lcommon.ProtocolParameters
+	var err error
+	if txn == nil {
+		pparams, ppErr := d.metadata.GetPParams(epoch, nil)
+		if err != nil {
+			return ret, ppErr
+		}
+		if len(pparams) == 0 {
+			return ret, nil
+		}
+		// pparams is ordered, so grab the first
+		tmpPParams := pparams[0]
+		ret, err = decodeFunc(tmpPParams.Cbor)
+	} else {
+		pparams, ppErr := d.metadata.GetPParams(epoch, txn.Metadata())
+		if err != nil {
+			return ret, ppErr
+		}
+		if len(pparams) == 0 {
+			return ret, nil
+		}
+		// pparams is ordered, so grab the first
+		tmpPParams := pparams[0]
+		ret, err = decodeFunc(tmpPParams.Cbor)
+	}
+	return ret, err
+}
+
+func (d *Database) SetPParams(
+	params []byte,
+	slot, epoch uint64,
+	era uint,
+	txn *Txn,
+) error {
+	if txn == nil {
+		err := d.metadata.SetPParams(params, slot, epoch, era, nil)
+		if err != nil {
+			return err
+		}
+	} else {
+		err := d.metadata.SetPParams(params, slot, epoch, era, txn.Metadata())
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (d *Database) ApplyPParamUpdates(
+	slot, epoch uint64,
+	era uint,
+	currentPParams *lcommon.ProtocolParameters,
+	decodeFunc func([]byte) (any, error),
+	updateFunc func(lcommon.ProtocolParameters, any) (lcommon.ProtocolParameters, error),
+	txn *Txn,
+) error {
+	// Check for pparam updates that apply at the end of the epoch
+	pparamUpdates, err := d.metadata.GetPParamUpdates(epoch, txn.Metadata())
+	if err != nil {
+		return err
+	}
+	if len(pparamUpdates) == 0 {
+		// nothing to do
+		return nil
+	}
+	// We only want the latest for the epoch
+	pparamUpdate := pparamUpdates[0]
+	tmpPParamUpdate, err := decodeFunc(pparamUpdate.Cbor)
+	if err != nil {
+		return err
+	}
+	// Update current pparams
+	newPParams, err := updateFunc(
+		*currentPParams,
+		tmpPParamUpdate,
+	)
+	if err != nil {
+		return err
+	}
+	*currentPParams = newPParams
+	d.logger.Debug(
+		"updated protocol params",
+		"pparams",
+		fmt.Sprintf("%#v", currentPParams),
+	)
+	// Write pparams update to DB
+	pparamsCbor, err := cbor.Encode(&currentPParams)
+	if err != nil {
+		return err
+	}
+	return d.metadata.SetPParams(
+		pparamsCbor,
+		slot,
+		uint64(epoch+1),
+		era,
+		txn.Metadata(),
+	)
+}
+
+func (d *Database) SetPParamUpdate(
+	genesis, params []byte,
+	slot, epoch uint64,
+	txn *Txn,
+) error {
+	if txn == nil {
+		err := d.metadata.SetPParamUpdate(genesis, params, slot, epoch, nil)
+		if err != nil {
+			return err
+		}
+	} else {
+		err := d.metadata.SetPParamUpdate(genesis, params, slot, epoch, txn.Metadata())
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

package/database/tip.go

@@ -0,0 +1,45 @@
+// 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 ochainsync "github.com/blinklabs-io/gouroboros/protocol/chainsync"
+
+// GetTip returns the current tip as represented by the protocol
+func (d *Database) GetTip(txn *Txn) (ochainsync.Tip, error) {
+	tmpTip := ochainsync.Tip{}
+	if txn == nil {
+		tip, err := d.metadata.GetTip(nil)
+		if err != nil {
+			return tmpTip, err
+		}
+		tmpTip = tip
+	} else {
+		tip, err := d.metadata.GetTip(txn.Metadata())
+		if err != nil {
+			return tmpTip, err
+		}
+		tmpTip = tip
+	}
+	return tmpTip, nil
+}
+
+// SetTip saves the current tip
+func (d *Database) SetTip(tip ochainsync.Tip, txn *Txn) error {
+	if txn == nil {
+		return d.metadata.SetTip(tip, nil)
+	} else {
+		return d.metadata.SetTip(tip, txn.Metadata())
+	}
+}

package/database/txn.go

@@ -0,0 +1,147 @@
+// 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"
+	"sync"
+	"time"
+
+	"github.com/dgraph-io/badger/v4"
+	"gorm.io/gorm"
+)
+
+// Txn is a wrapper around the transaction objects for the underlying DB engines
+type Txn struct {
+	lock        sync.Mutex
+	finished    bool
+	db          *Database
+	readWrite   bool
+	blobTxn     *badger.Txn
+	metadataTxn *gorm.DB
+}
+
+func NewTxn(db *Database, readWrite bool) *Txn {
+	return &Txn{
+		db:          db,
+		readWrite:   readWrite,
+		blobTxn:     db.Blob().NewTransaction(readWrite),
+		metadataTxn: db.Metadata().Transaction(),
+	}
+}
+
+func NewBlobOnlyTxn(db *Database, readWrite bool) *Txn {
+	return &Txn{
+		db:        db,
+		readWrite: readWrite,
+		blobTxn:   db.Blob().NewTransaction(readWrite),
+	}
+}
+
+func NewMetadataOnlyTxn(db *Database, readWrite bool) *Txn {
+	return &Txn{
+		db:          db,
+		readWrite:   readWrite,
+		metadataTxn: db.Metadata().Transaction(),
+	}
+}
+
+func (t *Txn) DB() *Database {
+	return t.db
+}
+
+func (t *Txn) Metadata() *gorm.DB {
+	return t.metadataTxn
+}
+
+func (t *Txn) Blob() *badger.Txn {
+	return t.blobTxn
+}
+
+// Do executes the specified function in the context of the transaction. Any errors returned will result
+// in the transaction being rolled back
+func (t *Txn) Do(fn func(*Txn) error) error {
+	if err := fn(t); err != nil {
+		if err2 := t.Rollback(); err2 != nil {
+			return fmt.Errorf(
+				"rollback failed: %w: original error: %w",
+				err2,
+				err,
+			)
+		}
+		return err
+	}
+	if err := t.Commit(); err != nil {
+		return fmt.Errorf("commit failed: %w", err)
+	}
+	return nil
+}
+
+func (t *Txn) Commit() error {
+	t.lock.Lock()
+	defer t.lock.Unlock()
+	if t.finished {
+		return nil
+	}
+	// No need to commit for read-only, but we do want to free up resources
+	if !t.readWrite {
+		return t.rollback()
+	}
+	// Update the commit timestamp in both DBs if using both
+	if t.blobTxn != nil && t.metadataTxn != nil {
+		commitTimestamp := time.Now().UnixMilli()
+		if err := t.db.updateCommitTimestamp(t, commitTimestamp); err != nil {
+			return err
+		}
+	}
+	// Commit sqlite transaction
+	if t.metadataTxn != nil {
+		if result := t.metadataTxn.Commit(); result.Error != nil {
+			// Failed to commit metadata DB, so discard blob txn
+			t.blobTxn.Discard()
+			return result.Error
+		}
+	}
+	// Commit badger transaction
+	if t.blobTxn != nil {
+		if err := t.blobTxn.Commit(); err != nil {
+			return err
+		}
+	}
+	t.finished = true
+	return nil
+}
+
+func (t *Txn) Rollback() error {
+	t.lock.Lock()
+	defer t.lock.Unlock()
+	return t.rollback()
+}
+
+func (t *Txn) rollback() error {
+	if t.finished {
+		return nil
+	}
+	if t.blobTxn != nil {
+		t.blobTxn.Discard()
+	}
+	if t.metadataTxn != nil {
+		if result := t.metadataTxn.Rollback(); result.Error != nil {
+			return result.Error
+		}
+	}
+	t.finished = true
+	return nil
+}

package/database/types/types.go

@@ -0,0 +1,74 @@
+// 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 types
+
+import (
+	"database/sql/driver"
+	"fmt"
+	"math/big"
+	"strconv"
+)
+
+//nolint:recvcheck
+type Rat struct {
+	*big.Rat
+}
+
+func (r Rat) Value() (driver.Value, error) {
+	if r.Rat == nil {
+		return "", nil
+	}
+	return r.String(), nil
+}
+
+func (r *Rat) Scan(val any) error {
+	if r.Rat == nil {
+		r.Rat = new(big.Rat)
+	}
+	v, ok := val.(string)
+	if !ok {
+		return fmt.Errorf(
+			"value was not expected type, wanted string, got %T",
+			val,
+		)
+	}
+	if _, ok := r.SetString(v); !ok {
+		return fmt.Errorf("failed to set big.Rat value from string: %s", v)
+	}
+	return nil
+}
+
+//nolint:recvcheck
+type Uint64 uint64
+
+func (u Uint64) Value() (driver.Value, error) {
+	return strconv.FormatUint(uint64(u), 10), nil
+}
+
+func (u *Uint64) Scan(val any) error {
+	v, ok := val.(string)
+	if !ok {
+		return fmt.Errorf(
+			"value was not expected type, wanted string, got %T",
+			val,
+		)
+	}
+	tmpUint, err := strconv.ParseUint(v, 10, 64)
+	if err != nil {
+		return err
+	}
+	*u = Uint64(tmpUint)
+	return nil
+}

package/database/types/types_test.go

@@ -0,0 +1,83 @@
+// 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 types_test
+
+import (
+	"database/sql"
+	"database/sql/driver"
+	"math/big"
+	"reflect"
+	"testing"
+
+	"github.com/blinklabs-io/dingo/database/types"
+)
+
+func TestTypesScanValue(t *testing.T) {
+	testDefs := []struct {
+		origValue     any
+		expectedValue any
+	}{
+		{
+			origValue: func(v types.Uint64) *types.Uint64 { return &v }(
+				types.Uint64(123),
+			),
+			expectedValue: "123",
+		},
+		{
+			origValue: func(v types.Rat) *types.Rat { return &v }(
+				types.Rat{
+					Rat: big.NewRat(3, 5),
+				},
+			),
+			expectedValue: "3/5",
+		},
+	}
+	var ok bool
+	var tmpScanner sql.Scanner
+	var tmpValuer driver.Valuer
+	for _, testDef := range testDefs {
+		tmpValuer, ok = testDef.origValue.(driver.Valuer)
+		if !ok {
+			t.Fatalf("test original value does not implement driver.Valuer")
+		}
+		valueOut, err := tmpValuer.Value()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if !reflect.DeepEqual(valueOut, testDef.expectedValue) {
+			t.Fatalf(
+				"did not get expected value from Value(): got %#v, expected %#v",
+				valueOut,
+				testDef.expectedValue,
+			)
+		}
+		tmpScanner, ok = testDef.origValue.(sql.Scanner)
+		if !ok {
+			t.Fatalf(
+				"test original value does not implement sql.Scanner (it must be a pointer)",
+			)
+		}
+		if err := tmpScanner.Scan(valueOut); err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if !reflect.DeepEqual(tmpScanner, testDef.origValue) {
+			t.Fatalf(
+				"did not get expected value after Scan(): got %#v, expected %#v",
+				tmpScanner,
+				testDef.origValue,
+			)
+		}
+	}
+}