@blinklabs/dingo 0.6.0 → 0.8.0

package/ledger/eras/allegra.go

@@ -1,154 +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 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

@@ -1,156 +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 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

@@ -1,154 +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 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

@@ -1,42 +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 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

@@ -1,158 +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 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

@@ -1,44 +0,0 @@
-// 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,
-}