fix: resolve protocol parameter type errors across era transitions

- Add era-safe GetEraById() to prevent crashes from unknown era IDs
- Implement genesis protocol parameter bootstrapping for empty database
- Fix database error handling in GetPParams
- Support complete era transition chain (Byron -> Conway)

Signed-off-by: GitHub Copilot <noreply@github.com>
Signed-off-by: Chris Gianelloni <wolf31o2@blinklabs.io>

Author: wolf31o2

database/models/account_test.go

@@ -25,12 +25,12 @@ import (
 
 func TestAccount_String(t *testing.T) {
 	tests := []struct {
-		name          string
-		stakingKey    []byte
-		wantErr       bool
-		wantErrMsg    string
-		validateAddr  bool
-		expectedHRP   string
+		name         string
+		stakingKey   []byte
+		wantErr      bool
+		wantErrMsg   string
+		validateAddr bool
+		expectedHRP  string
 	}{
 		{
 			name: "valid staking key - 28 bytes",

database/pparams.go

@@ -30,7 +30,7 @@ func (d *Database) GetPParams(
 	var err error
 	if txn == nil {
 		pparams, ppErr := d.metadata.GetPParams(epoch, nil)
-		if err != nil {
+		if ppErr != nil {
 			return ret, ppErr
 		}
 		if len(pparams) == 0 {
@@ -41,7 +41,7 @@ func (d *Database) GetPParams(
 		ret, err = decodeFunc(tmpPParams.Cbor)
 	} else {
 		pparams, ppErr := d.metadata.GetPParams(epoch, txn.Metadata())
-		if err != nil {
+		if ppErr != nil {
 			return ret, ppErr
 		}
 		if len(pparams) == 0 {
@@ -98,6 +98,12 @@ func (d *Database) ApplyPParamUpdates(
 		return err
 	}
 	// Update current pparams
+	if *currentPParams == nil {
+		return fmt.Errorf(
+			"current PParams is nil - cannot apply protocol parameter updates for epoch %d",
+			epoch,
+		)
+	}
 	newPParams, err := updateFunc(
 		*currentPParams,
 		tmpPParamUpdate,

ledger/certs.go

@@ -15,9 +15,11 @@
 package ledger
 
 import (
+	"errors"
 	"fmt"
 
 	"github.com/blinklabs-io/dingo/database"
+	"github.com/blinklabs-io/dingo/ledger/eras"
 	"github.com/blinklabs-io/gouroboros/ledger"
 	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
 	pcommon "github.com/blinklabs-io/gouroboros/protocol/common"
@@ -27,15 +29,15 @@ func (ls *LedgerState) processTransactionCertificates(
 	txn *database.Txn,
 	blockPoint pcommon.Point,
 	certs []ledger.Certificate,
+	blockEraId uint,
 ) error {
 	var tmpCert lcommon.Certificate
 	for _, tmpCert = range certs {
-		certDeposit, err := ls.currentEra.CertDepositFunc(
-			tmpCert,
-			ls.currentPParams,
-		)
+		// Calculate certificate deposits using the block's era functions
+		// This ensures we use the correct era-specific logic instead of current era
+		certDeposit, err := ls.calculateCertificateDeposit(tmpCert, blockEraId)
 		if err != nil {
-			return fmt.Errorf("failed load cert deposit func: %w", err)
+			return fmt.Errorf("get certificate deposit: %w", err)
 		}
 		switch cert := tmpCert.(type) {
 		case *lcommon.DeregistrationCertificate:
@@ -189,3 +191,36 @@ func (ls *LedgerState) processTransactionCertificates(
 	}
 	return nil
 }
+
+// calculateCertificateDeposit calculates the certificate deposit using the appropriate era's
+// certificate deposit function. This ensures we use the correct era-specific logic instead
+// of always using the current era, which may not match the block's era for historical data.
+func (ls *LedgerState) calculateCertificateDeposit(
+	cert lcommon.Certificate,
+	blockEraId uint,
+) (uint64, error) {
+	// Get the era descriptor for this block
+	blockEra := eras.GetEraById(blockEraId)
+	if blockEra == nil {
+		return 0, fmt.Errorf("unknown era ID %d", blockEraId)
+	}
+
+	// If this era doesn't support certificates (like Byron), return 0
+	if blockEra.CertDepositFunc == nil {
+		return 0, nil
+	}
+
+	// Use the block era's certificate deposit function with current protocol parameters
+	certDeposit, err := blockEra.CertDepositFunc(cert, ls.currentPParams)
+	if err != nil {
+		// Handle era type mismatch - this can happen when processing historical blocks
+		// with newer protocol parameters, or when the certificate type didn't exist
+		// in that era
+		if errors.Is(err, eras.ErrIncompatibleProtocolParams) {
+			return 0, nil
+		}
+		return 0, err
+	}
+
+	return certDeposit, nil
+}

ledger/delta.go

@@ -30,6 +30,7 @@ type TransactionRecord struct {
 
 type LedgerDelta struct {
 	Point        ocommon.Point
+	BlockEraId   uint
 	Transactions []TransactionRecord
 }
 
@@ -100,6 +101,7 @@ func (d *LedgerDelta) apply(ls *LedgerState, txn *database.Txn) error {
 			txn,
 			d.Point,
 			tr.Tx.Certificates(),
+			d.BlockEraId,
 		)
 		if err != nil {
 			return fmt.Errorf("process transaction certificates: %w", err)

ledger/eras/allegra.go

@@ -125,7 +125,7 @@ func CertDepositAllegra(
 ) (uint64, error) {
 	tmpPparams, ok := pp.(*allegra.AllegraProtocolParameters)
 	if !ok {
-		return 0, errors.New("pparams are not expected type")
+		return 0, ErrIncompatibleProtocolParams
 	}
 	switch cert.(type) {
 	case *lcommon.PoolRegistrationCertificate:

ledger/eras/alonzo.go

@@ -129,7 +129,7 @@ func CertDepositAlonzo(
 ) (uint64, error) {
 	tmpPparams, ok := pp.(*alonzo.AlonzoProtocolParameters)
 	if !ok {
-		return 0, errors.New("pparams are not expected type")
+		return 0, ErrIncompatibleProtocolParams
 	}
 	switch cert.(type) {
 	case *lcommon.PoolRegistrationCertificate:

ledger/eras/babbage.go

@@ -125,7 +125,7 @@ func CertDepositBabbage(
 ) (uint64, error) {
 	tmpPparams, ok := pp.(*babbage.BabbageProtocolParameters)
 	if !ok {
-		return 0, errors.New("pparams are not expected type")
+		return 0, ErrIncompatibleProtocolParams
 	}
 	switch cert.(type) {
 	case *lcommon.PoolRegistrationCertificate:

ledger/eras/conway.go

@@ -133,7 +133,7 @@ func CertDepositConway(
 ) (uint64, error) {
 	tmpPparams, ok := pp.(*conway.ConwayProtocolParameters)
 	if !ok {
-		return 0, errors.New("pparams are not expected type")
+		return 0, ErrIncompatibleProtocolParams
 	}
 	switch cert.(type) {
 	case *lcommon.PoolRegistrationCertificate:

ledger/eras/eras.go

@@ -15,11 +15,15 @@
 package eras
 
 import (
+	"errors"
+
 	"github.com/blinklabs-io/dingo/config/cardano"
 	"github.com/blinklabs-io/gouroboros/ledger"
 	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
 )
 
+var ErrIncompatibleProtocolParams = errors.New("pparams are not expected type")
+
 type EraDesc struct {
 	DecodePParamsFunc       func([]byte) (lcommon.ProtocolParameters, error)
 	DecodePParamsUpdateFunc func([]byte) (any, error)
@@ -57,3 +61,14 @@ var ProtocolMajorVersionToEra = map[uint]EraDesc{
 	9:  ConwayEraDesc,
 	10: ConwayEraDesc,
 }
+
+// GetEraById returns the era descriptor for the given era ID.
+// Returns nil if the era ID is not found.
+func GetEraById(eraId uint) *EraDesc {
+	for i := range Eras {
+		if Eras[i].Id == eraId {
+			return &Eras[i]
+		}
+	}
+	return nil
+}