@blinklabs/dingo 0.6.0

package/ledger/eras/allegra.go

@@ -0,0 +1,154 @@
+// 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 eras
+
+import (
+	"encoding/hex"
+	"errors"
+	"fmt"
+
+	"github.com/blinklabs-io/dingo/config/cardano"
+	"github.com/blinklabs-io/gouroboros/cbor"
+	"github.com/blinklabs-io/gouroboros/ledger"
+	"github.com/blinklabs-io/gouroboros/ledger/allegra"
+	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
+	"github.com/blinklabs-io/gouroboros/ledger/shelley"
+)
+
+var AllegraEraDesc = EraDesc{
+	Id:                      allegra.EraIdAllegra,
+	Name:                    allegra.EraNameAllegra,
+	DecodePParamsFunc:       DecodePParamsAllegra,
+	DecodePParamsUpdateFunc: DecodePParamsUpdateAllegra,
+	PParamsUpdateFunc:       PParamsUpdateAllegra,
+	HardForkFunc:            HardForkAllegra,
+	EpochLengthFunc:         EpochLengthShelley,
+	CalculateEtaVFunc:       CalculateEtaVAllegra,
+	CertDepositFunc:         CertDepositAllegra,
+	ValidateTxFunc:          ValidateTxAllegra,
+}
+
+func DecodePParamsAllegra(data []byte) (lcommon.ProtocolParameters, error) {
+	var ret allegra.AllegraProtocolParameters
+	if _, err := cbor.Decode(data, &ret); err != nil {
+		return nil, err
+	}
+	return &ret, nil
+}
+
+func DecodePParamsUpdateAllegra(data []byte) (any, error) {
+	var ret allegra.AllegraProtocolParameterUpdate
+	if _, err := cbor.Decode(data, &ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+func PParamsUpdateAllegra(
+	currentPParams lcommon.ProtocolParameters,
+	pparamsUpdate any,
+) (lcommon.ProtocolParameters, error) {
+	allegraPParams, ok := currentPParams.(*allegra.AllegraProtocolParameters)
+	if !ok {
+		return nil, fmt.Errorf(
+			"current PParams (%T) is not expected type",
+			currentPParams,
+		)
+	}
+	allegraPParamsUpdate, ok := pparamsUpdate.(allegra.AllegraProtocolParameterUpdate)
+	if !ok {
+		return nil, fmt.Errorf(
+			"PParams update (%T) is not expected type",
+			pparamsUpdate,
+		)
+	}
+	allegraPParams.Update(&allegraPParamsUpdate)
+	return allegraPParams, nil
+}
+
+func HardForkAllegra(
+	nodeConfig *cardano.CardanoNodeConfig,
+	prevPParams lcommon.ProtocolParameters,
+) (lcommon.ProtocolParameters, error) {
+	shelleyPParams, ok := prevPParams.(*shelley.ShelleyProtocolParameters)
+	if !ok {
+		return nil, fmt.Errorf(
+			"previous PParams (%T) are not expected type",
+			prevPParams,
+		)
+	}
+	ret := allegra.UpgradePParams(*shelleyPParams)
+	return &ret, nil
+}
+
+func CalculateEtaVAllegra(
+	nodeConfig *cardano.CardanoNodeConfig,
+	prevBlockNonce []byte,
+	block ledger.Block,
+) ([]byte, error) {
+	if len(prevBlockNonce) == 0 {
+		tmpNonce, err := hex.DecodeString(nodeConfig.ShelleyGenesisHash)
+		if err != nil {
+			return nil, err
+		}
+		prevBlockNonce = tmpNonce
+	}
+	h, ok := block.Header().(*allegra.AllegraBlockHeader)
+	if !ok {
+		return nil, errors.New("unexpected block type")
+	}
+	tmpNonce, err := lcommon.CalculateRollingNonce(
+		prevBlockNonce,
+		h.Body.NonceVrf.Output,
+	)
+	if err != nil {
+		return nil, err
+	}
+	return tmpNonce.Bytes(), nil
+}
+
+func CertDepositAllegra(
+	cert lcommon.Certificate,
+	pp lcommon.ProtocolParameters,
+) (uint64, error) {
+	tmpPparams, ok := pp.(*allegra.AllegraProtocolParameters)
+	if !ok {
+		return 0, errors.New("pparams are not expected type")
+	}
+	switch cert.(type) {
+	case *lcommon.PoolRegistrationCertificate:
+		return uint64(tmpPparams.PoolDeposit), nil
+	case *lcommon.StakeRegistrationCertificate:
+		return uint64(tmpPparams.KeyDeposit), nil
+	default:
+		return 0, nil
+	}
+}
+
+func ValidateTxAllegra(
+	tx lcommon.Transaction,
+	slot uint64,
+	ls lcommon.LedgerState,
+	pp lcommon.ProtocolParameters,
+) error {
+	errs := []error{}
+	for _, validationFunc := range allegra.UtxoValidationRules {
+		errs = append(
+			errs,
+			validationFunc(tx, slot, ls, pp),
+		)
+	}
+	return errors.Join(errs...)
+}

package/ledger/eras/alonzo.go

@@ -0,0 +1,156 @@
+// 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 eras
+
+import (
+	"encoding/hex"
+	"errors"
+	"fmt"
+
+	"github.com/blinklabs-io/dingo/config/cardano"
+	"github.com/blinklabs-io/gouroboros/cbor"
+	"github.com/blinklabs-io/gouroboros/ledger"
+	"github.com/blinklabs-io/gouroboros/ledger/alonzo"
+	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
+	"github.com/blinklabs-io/gouroboros/ledger/mary"
+)
+
+var AlonzoEraDesc = EraDesc{
+	Id:                      alonzo.EraIdAlonzo,
+	Name:                    alonzo.EraNameAlonzo,
+	DecodePParamsFunc:       DecodePParamsAlonzo,
+	DecodePParamsUpdateFunc: DecodePParamsUpdateAlonzo,
+	PParamsUpdateFunc:       PParamsUpdateAlonzo,
+	HardForkFunc:            HardForkAlonzo,
+	EpochLengthFunc:         EpochLengthShelley,
+	CalculateEtaVFunc:       CalculateEtaVAlonzo,
+	CertDepositFunc:         CertDepositAlonzo,
+	ValidateTxFunc:          ValidateTxAlonzo,
+}
+
+func DecodePParamsAlonzo(data []byte) (lcommon.ProtocolParameters, error) {
+	var ret alonzo.AlonzoProtocolParameters
+	if _, err := cbor.Decode(data, &ret); err != nil {
+		return nil, err
+	}
+	return &ret, nil
+}
+
+func DecodePParamsUpdateAlonzo(data []byte) (any, error) {
+	var ret alonzo.AlonzoProtocolParameterUpdate
+	if _, err := cbor.Decode(data, &ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+func PParamsUpdateAlonzo(
+	currentPParams lcommon.ProtocolParameters,
+	pparamsUpdate any,
+) (lcommon.ProtocolParameters, error) {
+	alonzoPParams, ok := currentPParams.(*alonzo.AlonzoProtocolParameters)
+	if !ok {
+		return nil, fmt.Errorf(
+			"current PParams (%T) is not expected type",
+			currentPParams,
+		)
+	}
+	alonzoPParamsUpdate, ok := pparamsUpdate.(alonzo.AlonzoProtocolParameterUpdate)
+	if !ok {
+		return nil, fmt.Errorf(
+			"PParams update (%T) is not expected type",
+			pparamsUpdate,
+		)
+	}
+	alonzoPParams.Update(&alonzoPParamsUpdate)
+	return alonzoPParams, nil
+}
+
+func HardForkAlonzo(
+	nodeConfig *cardano.CardanoNodeConfig,
+	prevPParams lcommon.ProtocolParameters,
+) (lcommon.ProtocolParameters, error) {
+	maryPParams, ok := prevPParams.(*mary.MaryProtocolParameters)
+	if !ok {
+		return nil, fmt.Errorf(
+			"previous PParams (%T) are not expected type",
+			prevPParams,
+		)
+	}
+	ret := alonzo.UpgradePParams(*maryPParams)
+	alonzoGenesis := nodeConfig.AlonzoGenesis()
+	ret.UpdateFromGenesis(alonzoGenesis)
+	return &ret, nil
+}
+
+func CalculateEtaVAlonzo(
+	nodeConfig *cardano.CardanoNodeConfig,
+	prevBlockNonce []byte,
+	block ledger.Block,
+) ([]byte, error) {
+	if len(prevBlockNonce) == 0 {
+		tmpNonce, err := hex.DecodeString(nodeConfig.ShelleyGenesisHash)
+		if err != nil {
+			return nil, err
+		}
+		prevBlockNonce = tmpNonce
+	}
+	h, ok := block.Header().(*alonzo.AlonzoBlockHeader)
+	if !ok {
+		return nil, errors.New("unexpected block type")
+	}
+	tmpNonce, err := lcommon.CalculateRollingNonce(
+		prevBlockNonce,
+		h.Body.NonceVrf.Output,
+	)
+	if err != nil {
+		return nil, err
+	}
+	return tmpNonce.Bytes(), nil
+}
+
+func CertDepositAlonzo(
+	cert lcommon.Certificate,
+	pp lcommon.ProtocolParameters,
+) (uint64, error) {
+	tmpPparams, ok := pp.(*alonzo.AlonzoProtocolParameters)
+	if !ok {
+		return 0, errors.New("pparams are not expected type")
+	}
+	switch cert.(type) {
+	case *lcommon.PoolRegistrationCertificate:
+		return uint64(tmpPparams.PoolDeposit), nil
+	case *lcommon.StakeRegistrationCertificate:
+		return uint64(tmpPparams.KeyDeposit), nil
+	default:
+		return 0, nil
+	}
+}
+
+func ValidateTxAlonzo(
+	tx lcommon.Transaction,
+	slot uint64,
+	ls lcommon.LedgerState,
+	pp lcommon.ProtocolParameters,
+) error {
+	errs := []error{}
+	for _, validationFunc := range alonzo.UtxoValidationRules {
+		errs = append(
+			errs,
+			validationFunc(tx, slot, ls, pp),
+		)
+	}
+	return errors.Join(errs...)
+}

package/ledger/eras/babbage.go

@@ -0,0 +1,154 @@
+// 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 eras
+
+import (
+	"encoding/hex"
+	"errors"
+	"fmt"
+
+	"github.com/blinklabs-io/dingo/config/cardano"
+	"github.com/blinklabs-io/gouroboros/cbor"
+	"github.com/blinklabs-io/gouroboros/ledger"
+	"github.com/blinklabs-io/gouroboros/ledger/alonzo"
+	"github.com/blinklabs-io/gouroboros/ledger/babbage"
+	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
+)
+
+var BabbageEraDesc = EraDesc{
+	Id:                      babbage.EraIdBabbage,
+	Name:                    babbage.EraNameBabbage,
+	DecodePParamsFunc:       DecodePParamsBabbage,
+	DecodePParamsUpdateFunc: DecodePParamsUpdateBabbage,
+	PParamsUpdateFunc:       PParamsUpdateBabbage,
+	HardForkFunc:            HardForkBabbage,
+	EpochLengthFunc:         EpochLengthShelley,
+	CalculateEtaVFunc:       CalculateEtaVBabbage,
+	CertDepositFunc:         CertDepositBabbage,
+	ValidateTxFunc:          ValidateTxBabbage,
+}
+
+func DecodePParamsBabbage(data []byte) (lcommon.ProtocolParameters, error) {
+	var ret babbage.BabbageProtocolParameters
+	if _, err := cbor.Decode(data, &ret); err != nil {
+		return nil, err
+	}
+	return &ret, nil
+}
+
+func DecodePParamsUpdateBabbage(data []byte) (any, error) {
+	var ret babbage.BabbageProtocolParameterUpdate
+	if _, err := cbor.Decode(data, &ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+func PParamsUpdateBabbage(
+	currentPParams lcommon.ProtocolParameters,
+	pparamsUpdate any,
+) (lcommon.ProtocolParameters, error) {
+	babbagePParams, ok := currentPParams.(*babbage.BabbageProtocolParameters)
+	if !ok {
+		return nil, fmt.Errorf(
+			"current PParams (%T) is not expected type",
+			currentPParams,
+		)
+	}
+	babbagePParamsUpdate, ok := pparamsUpdate.(babbage.BabbageProtocolParameterUpdate)
+	if !ok {
+		return nil, fmt.Errorf(
+			"PParams update (%T) is not expected type",
+			pparamsUpdate,
+		)
+	}
+	babbagePParams.Update(&babbagePParamsUpdate)
+	return babbagePParams, nil
+}
+
+func HardForkBabbage(
+	nodeConfig *cardano.CardanoNodeConfig,
+	prevPParams lcommon.ProtocolParameters,
+) (lcommon.ProtocolParameters, error) {
+	alonzoPParams, ok := prevPParams.(*alonzo.AlonzoProtocolParameters)
+	if !ok {
+		return nil, fmt.Errorf(
+			"previous PParams (%T) are not expected type",
+			prevPParams,
+		)
+	}
+	ret := babbage.UpgradePParams(*alonzoPParams)
+	return &ret, nil
+}
+
+func CalculateEtaVBabbage(
+	nodeConfig *cardano.CardanoNodeConfig,
+	prevBlockNonce []byte,
+	block ledger.Block,
+) ([]byte, error) {
+	if len(prevBlockNonce) == 0 {
+		tmpNonce, err := hex.DecodeString(nodeConfig.ShelleyGenesisHash)
+		if err != nil {
+			return nil, err
+		}
+		prevBlockNonce = tmpNonce
+	}
+	h, ok := block.Header().(*babbage.BabbageBlockHeader)
+	if !ok {
+		return nil, errors.New("unexpected block type")
+	}
+	tmpNonce, err := lcommon.CalculateRollingNonce(
+		prevBlockNonce,
+		h.Body.VrfResult.Output,
+	)
+	if err != nil {
+		return nil, err
+	}
+	return tmpNonce.Bytes(), nil
+}
+
+func CertDepositBabbage(
+	cert lcommon.Certificate,
+	pp lcommon.ProtocolParameters,
+) (uint64, error) {
+	tmpPparams, ok := pp.(*babbage.BabbageProtocolParameters)
+	if !ok {
+		return 0, errors.New("pparams are not expected type")
+	}
+	switch cert.(type) {
+	case *lcommon.PoolRegistrationCertificate:
+		return uint64(tmpPparams.PoolDeposit), nil
+	case *lcommon.StakeRegistrationCertificate:
+		return uint64(tmpPparams.KeyDeposit), nil
+	default:
+		return 0, nil
+	}
+}
+
+func ValidateTxBabbage(
+	tx lcommon.Transaction,
+	slot uint64,
+	ls lcommon.LedgerState,
+	pp lcommon.ProtocolParameters,
+) error {
+	errs := []error{}
+	for _, validationFunc := range babbage.UtxoValidationRules {
+		errs = append(
+			errs,
+			validationFunc(tx, slot, ls, pp),
+		)
+	}
+	return errors.Join(errs...)
+}

package/ledger/eras/byron.go

@@ -0,0 +1,42 @@
+// 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 eras
+
+import (
+	"errors"
+
+	"github.com/blinklabs-io/dingo/config/cardano"
+	"github.com/blinklabs-io/gouroboros/ledger/byron"
+)
+
+var ByronEraDesc = EraDesc{
+	Id:              byron.EraIdByron,
+	Name:            byron.EraNameByron,
+	EpochLengthFunc: EpochLengthByron,
+}
+
+func EpochLengthByron(
+	nodeConfig *cardano.CardanoNodeConfig,
+) (uint, uint, error) {
+	byronGenesis := nodeConfig.ByronGenesis()
+	if byronGenesis == nil {
+		return 0, 0, errors.New("unable to get byron genesis")
+	}
+	// These are known to be within uint range
+	// #nosec G115
+	return uint(byronGenesis.BlockVersionData.SlotDuration),
+		uint(byronGenesis.ProtocolConsts.K * 10),
+		nil
+}

package/ledger/eras/conway.go

@@ -0,0 +1,158 @@
+// 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 eras
+
+import (
+	"encoding/hex"
+	"errors"
+	"fmt"
+
+	"github.com/blinklabs-io/dingo/config/cardano"
+	"github.com/blinklabs-io/gouroboros/cbor"
+	"github.com/blinklabs-io/gouroboros/ledger"
+	"github.com/blinklabs-io/gouroboros/ledger/babbage"
+	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
+	"github.com/blinklabs-io/gouroboros/ledger/conway"
+)
+
+var ConwayEraDesc = EraDesc{
+	Id:                      conway.EraIdConway,
+	Name:                    conway.EraNameConway,
+	DecodePParamsFunc:       DecodePParamsConway,
+	DecodePParamsUpdateFunc: DecodePParamsUpdateConway,
+	PParamsUpdateFunc:       PParamsUpdateConway,
+	HardForkFunc:            HardForkConway,
+	EpochLengthFunc:         EpochLengthShelley,
+	CalculateEtaVFunc:       CalculateEtaVConway,
+	CertDepositFunc:         CertDepositConway,
+	ValidateTxFunc:          ValidateTxConway,
+}
+
+func DecodePParamsConway(data []byte) (lcommon.ProtocolParameters, error) {
+	var ret conway.ConwayProtocolParameters
+	if _, err := cbor.Decode(data, &ret); err != nil {
+		return nil, err
+	}
+	return &ret, nil
+}
+
+func DecodePParamsUpdateConway(data []byte) (any, error) {
+	var ret conway.ConwayProtocolParameterUpdate
+	if _, err := cbor.Decode(data, &ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+func PParamsUpdateConway(
+	currentPParams lcommon.ProtocolParameters,
+	pparamsUpdate any,
+) (lcommon.ProtocolParameters, error) {
+	conwayPParams, ok := currentPParams.(*conway.ConwayProtocolParameters)
+	if !ok {
+		return nil, fmt.Errorf(
+			"current PParams (%T) is not expected type",
+			currentPParams,
+		)
+	}
+	conwayPParamsUpdate, ok := pparamsUpdate.(conway.ConwayProtocolParameterUpdate)
+	if !ok {
+		return nil, fmt.Errorf(
+			"PParams update (%T) is not expected type",
+			pparamsUpdate,
+		)
+	}
+	conwayPParams.Update(&conwayPParamsUpdate)
+	return conwayPParams, nil
+}
+
+func HardForkConway(
+	nodeConfig *cardano.CardanoNodeConfig,
+	prevPParams lcommon.ProtocolParameters,
+) (lcommon.ProtocolParameters, error) {
+	babbagePParams, ok := prevPParams.(*babbage.BabbageProtocolParameters)
+	if !ok {
+		return nil, fmt.Errorf(
+			"previous PParams (%T) are not expected type",
+			prevPParams,
+		)
+	}
+	ret := conway.UpgradePParams(*babbagePParams)
+	conwayGenesis := nodeConfig.ConwayGenesis()
+	ret.UpdateFromGenesis(conwayGenesis)
+	return &ret, nil
+}
+
+func CalculateEtaVConway(
+	nodeConfig *cardano.CardanoNodeConfig,
+	prevBlockNonce []byte,
+	block ledger.Block,
+) ([]byte, error) {
+	if len(prevBlockNonce) == 0 {
+		tmpNonce, err := hex.DecodeString(nodeConfig.ShelleyGenesisHash)
+		if err != nil {
+			return nil, err
+		}
+		prevBlockNonce = tmpNonce
+	}
+	h, ok := block.Header().(*conway.ConwayBlockHeader)
+	if !ok {
+		return nil, errors.New("unexpected block type")
+	}
+	tmpNonce, err := lcommon.CalculateRollingNonce(
+		prevBlockNonce,
+		h.Body.VrfResult.Output,
+	)
+	if err != nil {
+		return nil, err
+	}
+	return tmpNonce.Bytes(), nil
+}
+
+func CertDepositConway(
+	cert lcommon.Certificate,
+	pp lcommon.ProtocolParameters,
+) (uint64, error) {
+	tmpPparams, ok := pp.(*conway.ConwayProtocolParameters)
+	if !ok {
+		return 0, errors.New("pparams are not expected type")
+	}
+	switch cert.(type) {
+	case *lcommon.PoolRegistrationCertificate:
+		return uint64(tmpPparams.PoolDeposit), nil
+	case *lcommon.RegistrationCertificate:
+		return uint64(tmpPparams.KeyDeposit), nil
+	case *lcommon.StakeRegistrationCertificate:
+		return uint64(tmpPparams.KeyDeposit), nil
+	default:
+		return 0, nil
+	}
+}
+
+func ValidateTxConway(
+	tx lcommon.Transaction,
+	slot uint64,
+	ls lcommon.LedgerState,
+	pp lcommon.ProtocolParameters,
+) error {
+	errs := []error{}
+	for _, validationFunc := range conway.UtxoValidationRules {
+		errs = append(
+			errs,
+			validationFunc(tx, slot, ls, pp),
+		)
+	}
+	return errors.Join(errs...)
+}

package/ledger/eras/eras.go

@@ -0,0 +1,44 @@
+// Copyright 2024 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 eras
+
+import (
+	"github.com/blinklabs-io/dingo/config/cardano"
+	"github.com/blinklabs-io/gouroboros/ledger"
+	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
+)
+
+type EraDesc struct {
+	Id                      uint
+	Name                    string
+	DecodePParamsFunc       func([]byte) (lcommon.ProtocolParameters, error)
+	DecodePParamsUpdateFunc func([]byte) (any, error)
+	PParamsUpdateFunc       func(lcommon.ProtocolParameters, any) (lcommon.ProtocolParameters, error)
+	HardForkFunc            func(*cardano.CardanoNodeConfig, lcommon.ProtocolParameters) (lcommon.ProtocolParameters, error)
+	EpochLengthFunc         func(*cardano.CardanoNodeConfig) (uint, uint, error)
+	CalculateEtaVFunc       func(*cardano.CardanoNodeConfig, []byte, ledger.Block) ([]byte, error)
+	CertDepositFunc         func(lcommon.Certificate, lcommon.ProtocolParameters) (uint64, error)
+	ValidateTxFunc          func(lcommon.Transaction, uint64, lcommon.LedgerState, lcommon.ProtocolParameters) error
+}
+
+var Eras = []EraDesc{
+	ByronEraDesc,
+	ShelleyEraDesc,
+	AllegraEraDesc,
+	MaryEraDesc,
+	AlonzoEraDesc,
+	BabbageEraDesc,
+	ConwayEraDesc,
+}