@blinklabs/dingo 0.7.0 → 0.8.0

package/ledger/eras/conway.go

@@ -1,166 +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.RegistrationDrepCertificate:
-		return uint64(tmpPparams.DRepDeposit), nil
-	case *lcommon.StakeRegistrationCertificate:
-		return uint64(tmpPparams.KeyDeposit), nil
-	case *lcommon.StakeRegistrationDelegationCertificate:
-		return uint64(tmpPparams.KeyDeposit), nil
-	case *lcommon.StakeVoteRegistrationDelegationCertificate:
-		return uint64(tmpPparams.KeyDeposit), nil
-	case *lcommon.VoteRegistrationDelegationCertificate:
-		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,
-}

package/ledger/eras/mary.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/mary"
-)
-
-var MaryEraDesc = EraDesc{
-	Id:                      mary.EraIdMary,
-	Name:                    mary.EraNameMary,
-	DecodePParamsFunc:       DecodePParamsMary,
-	DecodePParamsUpdateFunc: DecodePParamsUpdateMary,
-	PParamsUpdateFunc:       PParamsUpdateMary,
-	HardForkFunc:            HardForkMary,
-	EpochLengthFunc:         EpochLengthShelley,
-	CalculateEtaVFunc:       CalculateEtaVMary,
-	CertDepositFunc:         CertDepositMary,
-	ValidateTxFunc:          ValidateTxMary,
-}
-
-func DecodePParamsMary(data []byte) (lcommon.ProtocolParameters, error) {
-	var ret mary.MaryProtocolParameters
-	if _, err := cbor.Decode(data, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
-}
-
-func DecodePParamsUpdateMary(data []byte) (any, error) {
-	var ret mary.MaryProtocolParameterUpdate
-	if _, err := cbor.Decode(data, &ret); err != nil {
-		return nil, err
-	}
-	return ret, nil
-}
-
-func PParamsUpdateMary(
-	currentPParams lcommon.ProtocolParameters,
-	pparamsUpdate any,
-) (lcommon.ProtocolParameters, error) {
-	maryPParams, ok := currentPParams.(*mary.MaryProtocolParameters)
-	if !ok {
-		return nil, fmt.Errorf(
-			"current PParams (%T) is not expected type",
-			currentPParams,
-		)
-	}
-	maryPParamsUpdate, ok := pparamsUpdate.(mary.MaryProtocolParameterUpdate)
-	if !ok {
-		return nil, fmt.Errorf(
-			"PParams update (%T) is not expected type",
-			pparamsUpdate,
-		)
-	}
-	maryPParams.Update(&maryPParamsUpdate)
-	return maryPParams, nil
-}
-
-func HardForkMary(
-	nodeConfig *cardano.CardanoNodeConfig,
-	prevPParams lcommon.ProtocolParameters,
-) (lcommon.ProtocolParameters, error) {
-	allegraPParams, ok := prevPParams.(*allegra.AllegraProtocolParameters)
-	if !ok {
-		return nil, fmt.Errorf(
-			"previous PParams (%T) are not expected type",
-			prevPParams,
-		)
-	}
-	ret := mary.UpgradePParams(*allegraPParams)
-	return &ret, nil
-}
-
-func CalculateEtaVMary(
-	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().(*mary.MaryBlockHeader)
-	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 CertDepositMary(
-	cert lcommon.Certificate,
-	pp lcommon.ProtocolParameters,
-) (uint64, error) {
-	tmpPparams, ok := pp.(*mary.MaryProtocolParameters)
-	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 ValidateTxMary(
-	tx lcommon.Transaction,
-	slot uint64,
-	ls lcommon.LedgerState,
-	pp lcommon.ProtocolParameters,
-) error {
-	errs := []error{}
-	for _, validationFunc := range mary.UtxoValidationRules {
-		errs = append(
-			errs,
-			validationFunc(tx, slot, ls, pp),
-		)
-	}
-	return errors.Join(errs...)
-}

package/ledger/eras/shelley.go

@@ -1,164 +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"
-	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
-	"github.com/blinklabs-io/gouroboros/ledger/shelley"
-)
-
-var ShelleyEraDesc = EraDesc{
-	Id:                      shelley.EraIdShelley,
-	Name:                    shelley.EraNameShelley,
-	DecodePParamsFunc:       DecodePParamsShelley,
-	DecodePParamsUpdateFunc: DecodePParamsUpdateShelley,
-	PParamsUpdateFunc:       PParamsUpdateShelley,
-	HardForkFunc:            HardForkShelley,
-	EpochLengthFunc:         EpochLengthShelley,
-	CalculateEtaVFunc:       CalculateEtaVShelley,
-	CertDepositFunc:         CertDepositShelley,
-	ValidateTxFunc:          ValidateTxShelley,
-}
-
-func DecodePParamsShelley(data []byte) (lcommon.ProtocolParameters, error) {
-	var ret shelley.ShelleyProtocolParameters
-	if _, err := cbor.Decode(data, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
-}
-
-func DecodePParamsUpdateShelley(data []byte) (any, error) {
-	var ret shelley.ShelleyProtocolParameterUpdate
-	if _, err := cbor.Decode(data, &ret); err != nil {
-		return nil, err
-	}
-	return ret, nil
-}
-
-func PParamsUpdateShelley(
-	currentPParams lcommon.ProtocolParameters,
-	pparamsUpdate any,
-) (lcommon.ProtocolParameters, error) {
-	shelleyPParams, ok := currentPParams.(*shelley.ShelleyProtocolParameters)
-	if !ok {
-		return nil, fmt.Errorf(
-			"current PParams (%T) is not expected type",
-			currentPParams,
-		)
-	}
-	shelleyPParamsUpdate, ok := pparamsUpdate.(shelley.ShelleyProtocolParameterUpdate)
-	if !ok {
-		return nil, fmt.Errorf(
-			"PParams update (%T) is not expected type",
-			pparamsUpdate,
-		)
-	}
-	shelleyPParams.Update(&shelleyPParamsUpdate)
-	return shelleyPParams, nil
-}
-
-func HardForkShelley(
-	nodeConfig *cardano.CardanoNodeConfig,
-	prevPParams lcommon.ProtocolParameters,
-) (lcommon.ProtocolParameters, error) {
-	// There's no Byron protocol parameters to upgrade from, so this is mostly
-	// a dummy call for consistency
-	ret := shelley.UpgradePParams(nil)
-	shelleyGenesis := nodeConfig.ShelleyGenesis()
-	ret.UpdateFromGenesis(shelleyGenesis)
-	return &ret, nil
-}
-
-func EpochLengthShelley(
-	nodeConfig *cardano.CardanoNodeConfig,
-) (uint, uint, error) {
-	shelleyGenesis := nodeConfig.ShelleyGenesis()
-	if shelleyGenesis == nil {
-		return 0, 0, errors.New("unable to get shelley genesis")
-	}
-	// These are known to be within uint range
-	// #nosec G115
-	return uint(shelleyGenesis.SlotLength * 1000),
-		uint(shelleyGenesis.EpochLength),
-		nil
-}
-
-func CalculateEtaVShelley(
-	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().(*shelley.ShelleyBlockHeader)
-	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 CertDepositShelley(
-	cert lcommon.Certificate,
-	pp lcommon.ProtocolParameters,
-) (uint64, error) {
-	tmpPparams, ok := pp.(*shelley.ShelleyProtocolParameters)
-	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 ValidateTxShelley(
-	tx lcommon.Transaction,
-	slot uint64,
-	ls lcommon.LedgerState,
-	pp lcommon.ProtocolParameters,
-) error {
-	errs := []error{}
-	for _, validationFunc := range shelley.UtxoValidationRules {
-		errs = append(
-			errs,
-			validationFunc(tx, slot, ls, pp),
-		)
-	}
-	return errors.Join(errs...)
-}

package/ledger/error.go

@@ -1,19 +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 ledger
-
-import "errors"
-
-var ErrBlockNotFound = errors.New("block not found")

package/ledger/event.go

@@ -1,50 +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 ledger
-
-import (
-	"github.com/blinklabs-io/dingo/event"
-	ouroboros "github.com/blinklabs-io/gouroboros"
-	"github.com/blinklabs-io/gouroboros/ledger"
-	ochainsync "github.com/blinklabs-io/gouroboros/protocol/chainsync"
-	ocommon "github.com/blinklabs-io/gouroboros/protocol/common"
-)
-
-const (
-	BlockfetchEventType event.EventType = "blockfetch.event"
-	ChainsyncEventType  event.EventType = "chainsync.event"
-)
-
-// BlockfetchEvent represents either a Block or BatchDone blockfetch event. We use
-// a single event type for both to make synchronization easier.
-type BlockfetchEvent struct {
-	ConnectionId ouroboros.ConnectionId // Connection ID associated with event
-	Point        ocommon.Point          // Chain point for block
-	Block        ledger.Block
-	Type         uint // Block type ID
-	BatchDone    bool // Set to true for a BatchDone event
-}
-
-// ChainsyncEvent represents either a RollForward or RollBackward chainsync event.
-// We use a single event type for both to make synchronization easier.
-type ChainsyncEvent struct {
-	ConnectionId ouroboros.ConnectionId // Connection ID associated with event
-	Point        ocommon.Point          // Chain point for roll forward/backward
-	Tip          ochainsync.Tip         // Upstream chain tip
-	BlockNumber  uint64
-	BlockHeader  ledger.BlockHeader
-	Type         uint // Block or header type ID
-	Rollback     bool
-}

package/ledger/metrics.go

@@ -1,53 +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 ledger
-
-import (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-)
-
-type stateMetrics struct {
-	blockNum    prometheus.Gauge
-	density     prometheus.Gauge
-	epochNum    prometheus.Gauge
-	slotInEpoch prometheus.Gauge
-	slotNum     prometheus.Gauge
-}
-
-func (m *stateMetrics) init(promRegistry prometheus.Registerer) {
-	promautoFactory := promauto.With(promRegistry)
-	m.blockNum = promautoFactory.NewGauge(prometheus.GaugeOpts{
-		Name: "cardano_node_metrics_blockNum_int",
-		Help: "current block number",
-	})
-	// TODO: figure out how to calculate this (#390)
-	m.density = promautoFactory.NewGauge(prometheus.GaugeOpts{
-		Name: "cardano_node_metrics_density_real",
-		Help: "chain density",
-	})
-	m.epochNum = promautoFactory.NewGauge(prometheus.GaugeOpts{
-		Name: "cardano_node_metrics_epoch_int",
-		Help: "current epoch number",
-	})
-	m.slotInEpoch = promautoFactory.NewGauge(prometheus.GaugeOpts{
-		Name: "cardano_node_metrics_slotInEpoch_int",
-		Help: "current relative slot number in epoch",
-	})
-	m.slotNum = promautoFactory.NewGauge(prometheus.GaugeOpts{
-		Name: "cardano_node_metrics_slotNum_int",
-		Help: "current slot number",
-	})
-}