@blinklabs/dingo 0.7.0 → 0.8.0

package/ledger/delta.go

@@ -1,99 +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 ledger
-
-import (
-	"fmt"
-	"slices"
-
-	"github.com/blinklabs-io/dingo/database"
-	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
-	ocommon "github.com/blinklabs-io/gouroboros/protocol/common"
-)
-
-type LedgerDelta struct {
-	Point             ocommon.Point
-	Produced          []lcommon.Utxo
-	Consumed          []lcommon.TransactionInput
-	PParamUpdateEpoch uint64
-	PParamUpdates     map[lcommon.Blake2b224]lcommon.ProtocolParameterUpdate
-	Certificates      []lcommon.Certificate
-}
-
-// nolint:unparam
-func (d *LedgerDelta) processTransaction(tx lcommon.Transaction) error {
-	// Consumed UTxOs
-	d.Consumed = slices.Concat(d.Consumed, tx.Consumed())
-	// Produced UTxOs
-	d.Produced = slices.Concat(d.Produced, tx.Produced())
-	// Protocol parameter updates
-	if updateEpoch, paramUpdates := tx.ProtocolParameterUpdates(); updateEpoch > 0 {
-		d.PParamUpdateEpoch = updateEpoch
-		if d.PParamUpdates == nil {
-			d.PParamUpdates = make(
-				map[lcommon.Blake2b224]lcommon.ProtocolParameterUpdate,
-			)
-		}
-		for genesisHash, update := range paramUpdates {
-			d.PParamUpdates[genesisHash] = update
-		}
-	}
-	// Certificates
-	d.Certificates = slices.Concat(d.Certificates, tx.Certificates())
-	return nil
-}
-
-func (d *LedgerDelta) apply(ls *LedgerState, txn *database.Txn) error {
-	// Process consumed UTxOs
-	for _, consumed := range d.Consumed {
-		if err := ls.consumeUtxo(txn, consumed, d.Point.Slot); err != nil {
-			return fmt.Errorf("remove consumed UTxO: %w", err)
-		}
-	}
-	// Process produced UTxOs
-	for _, produced := range d.Produced {
-		outAddr := produced.Output.Address()
-		err := ls.db.NewUtxo(
-			produced.Id.Id().Bytes(),
-			produced.Id.Index(),
-			d.Point.Slot,
-			outAddr.PaymentKeyHash().Bytes(),
-			outAddr.StakeKeyHash().Bytes(),
-			produced.Output.Cbor(),
-			txn,
-		)
-		if err != nil {
-			return fmt.Errorf("add produced UTxO: %w", err)
-		}
-	}
-	// Protocol parameter updates
-	for genesisHash, update := range d.PParamUpdates {
-		err := ls.db.SetPParamUpdate(
-			genesisHash.Bytes(),
-			update.Cbor(),
-			d.Point.Slot,
-			d.PParamUpdateEpoch,
-			txn,
-		)
-		if err != nil {
-			return fmt.Errorf("set pparam update: %w", err)
-		}
-	}
-	// Certificates
-	if err := ls.processTransactionCertificates(txn, d.Point, d.Certificates); err != nil {
-		return fmt.Errorf("process transaction certificates: %w", err)
-	}
-	return nil
-}

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
-}