@blinklabs/dingo 0.6.0 → 0.7.0

package/ledger/chainsync.go

@@ -28,7 +28,6 @@ import (
 	"github.com/blinklabs-io/dingo/ledger/eras"
 	ouroboros "github.com/blinklabs-io/gouroboros"
 	"github.com/blinklabs-io/gouroboros/cbor"
-	"github.com/blinklabs-io/gouroboros/ledger"
 	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
 	ocommon "github.com/blinklabs-io/gouroboros/protocol/common"
 )
@@ -98,7 +97,7 @@ func (ls *LedgerState) handleEventBlockfetch(evt event.Event) {
 
 func (ls *LedgerState) handleEventChainsyncRollback(e ChainsyncEvent) error {
 	if err := ls.chain.Rollback(e.Point); err != nil {
-		return err
+		return fmt.Errorf("chain rollback failed: %w", err)
 	}
 	return nil
 }
@@ -119,7 +118,7 @@ func (ls *LedgerState) handleEventChainsyncBlockHeader(e ChainsyncEvent) error {
 	// Add header to chain
 	if err := ls.chain.AddBlockHeader(e.BlockHeader); err != nil {
 		if !errors.As(err, &chain.BlockNotFitChainTipError{}) {
-			return err
+			return fmt.Errorf("failed adding chain block header: %w", err)
 		}
 		ls.config.Logger.Warn(
 			fmt.Sprintf(
@@ -200,7 +199,7 @@ func (ls *LedgerState) processBlockEvents() error {
 		err := txn.Do(func(txn *database.Txn) error {
 			for _, evt := range ls.chainsyncBlockEvents[batchOffset : batchOffset+batchSize] {
 				if err := ls.processBlockEvent(txn, evt); err != nil {
-					return err
+					return fmt.Errorf("failed processing block event: %w", err)
 				}
 			}
 			return nil
@@ -225,13 +224,13 @@ func (ls *LedgerState) createGenesisBlock() error {
 		byronGenesis := ls.config.CardanoNodeConfig.ByronGenesis()
 		genesisUtxos, err := byronGenesis.GenesisUtxos()
 		if err != nil {
-			return err
+			return fmt.Errorf("failed to generate genesis UTxOs: %w", err)
 		}
 		for _, utxo := range genesisUtxos {
 			outAddr := utxo.Output.Address()
 			outputCbor, err := cbor.Encode(utxo.Output)
 			if err != nil {
-				return err
+				return fmt.Errorf("encode UTxO: %w", err)
 			}
 			err = ls.db.NewUtxo(
 				utxo.Id.Id().Bytes(),
@@ -264,7 +263,10 @@ func (ls *LedgerState) calculateEpochNonce(
 		genesisHashBytes, err := hex.DecodeString(
 			ls.config.CardanoNodeConfig.ShelleyGenesisHash,
 		)
-		return genesisHashBytes, err
+		if err != nil {
+			return nil, fmt.Errorf("decode genesis hash: %w", err)
+		}
+		return genesisHashBytes, nil
 	}
 	// Calculate stability window
 	byronGenesis := ls.config.CardanoNodeConfig.ByronGenesis()
@@ -286,7 +288,7 @@ func (ls *LedgerState) calculateEpochNonce(
 		stabilityWindowStartSlot,
 	)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("lookup block before slot: %w", err)
 	}
 	// Get last block in previous epoch
 	blockLastPrevEpoch, err := database.BlockBeforeSlotTxn(
@@ -297,7 +299,7 @@ func (ls *LedgerState) calculateEpochNonce(
 		if errors.Is(err, database.ErrBlockNotFound) {
 			return blockBeforeStabilityWindow.Nonce, nil
 		}
-		return nil, err
+		return nil, fmt.Errorf("lookup block before slot: %w", err)
 	}
 	// Calculate nonce from inputs
 	ret, err := lcommon.CalculateEpochNonce(
@@ -310,8 +312,10 @@ func (ls *LedgerState) calculateEpochNonce(
 
 func (ls *LedgerState) processEpochRollover(
 	txn *database.Txn,
-	point ocommon.Point,
 ) error {
+	epochStartSlot := ls.currentEpoch.StartSlot + uint64(
+		ls.currentEpoch.LengthInSlots,
+	)
 	// Create initial epoch
 	if ls.currentEpoch.SlotLength == 0 {
 		// Create initial epoch record
@@ -319,14 +323,14 @@ func (ls *LedgerState) processEpochRollover(
 			ls.config.CardanoNodeConfig,
 		)
 		if err != nil {
-			return err
+			return fmt.Errorf("calculate epoch length: %w", err)
 		}
 		tmpNonce, err := ls.calculateEpochNonce(txn, 0)
 		if err != nil {
-			return err
+			return fmt.Errorf("calculate epoch nonce: %w", err)
 		}
 		err = ls.db.SetEpoch(
-			0, // start slot
+			epochStartSlot,
 			0, // epoch
 			tmpNonce,
 			ls.currentEra.Id,
@@ -335,71 +339,64 @@ func (ls *LedgerState) processEpochRollover(
 			txn,
 		)
 		if err != nil {
-			return err
+			return fmt.Errorf("set epoch: %w", err)
 		}
 		// Reload epoch info
 		if err := ls.loadEpochs(txn); err != nil {
-			return err
+			return fmt.Errorf("load epochs: %w", err)
 		}
 		ls.config.Logger.Debug(
 			"added initial epoch to DB",
 			"epoch", fmt.Sprintf("%+v", ls.currentEpoch),
 			"component", "ledger",
 		)
+		return nil
 	}
-	// Check for epoch rollover
-	if point.Slot > ls.currentEpoch.StartSlot+uint64(
-		ls.currentEpoch.LengthInSlots,
-	) {
-		// Apply pending pparam updates
-		err := ls.db.ApplyPParamUpdates(
-			point.Slot,
-			ls.currentEpoch.EpochId,
-			ls.currentEra.Id,
-			&ls.currentPParams,
-			ls.currentEra.DecodePParamsUpdateFunc,
-			ls.currentEra.PParamsUpdateFunc,
-			txn,
-		)
-		if err != nil {
-			return err
-		}
-		// Create next epoch record
-		epochSlotLength, epochLength, err := ls.currentEra.EpochLengthFunc(
-			ls.config.CardanoNodeConfig,
-		)
-		if err != nil {
-			return err
-		}
-		epochStartSlot := ls.currentEpoch.StartSlot + uint64(
-			ls.currentEpoch.LengthInSlots,
-		)
-		tmpNonce, err := ls.calculateEpochNonce(txn, epochStartSlot)
-		if err != nil {
-			return err
-		}
-		err = ls.db.SetEpoch(
-			epochStartSlot,
-			ls.currentEpoch.EpochId+1,
-			tmpNonce,
-			ls.currentEra.Id,
-			epochSlotLength,
-			epochLength,
-			txn,
-		)
-		if err != nil {
-			return err
-		}
-		// Reload epoch info
-		if err := ls.loadEpochs(txn); err != nil {
-			return err
-		}
-		ls.config.Logger.Debug(
-			"added next epoch to DB",
-			"epoch", fmt.Sprintf("%+v", ls.currentEpoch),
-			"component", "ledger",
-		)
+	// Apply pending pparam updates
+	err := ls.db.ApplyPParamUpdates(
+		epochStartSlot,
+		ls.currentEpoch.EpochId,
+		ls.currentEra.Id,
+		&ls.currentPParams,
+		ls.currentEra.DecodePParamsUpdateFunc,
+		ls.currentEra.PParamsUpdateFunc,
+		txn,
+	)
+	if err != nil {
+		return fmt.Errorf("apply pparam updates: %w", err)
+	}
+	// Create next epoch record
+	epochSlotLength, epochLength, err := ls.currentEra.EpochLengthFunc(
+		ls.config.CardanoNodeConfig,
+	)
+	if err != nil {
+		return fmt.Errorf("calculate epoch length: %w", err)
+	}
+	tmpNonce, err := ls.calculateEpochNonce(txn, epochStartSlot)
+	if err != nil {
+		return fmt.Errorf("calculate epoch nonce: %w", err)
+	}
+	err = ls.db.SetEpoch(
+		epochStartSlot,
+		ls.currentEpoch.EpochId+1,
+		tmpNonce,
+		ls.currentEra.Id,
+		epochSlotLength,
+		epochLength,
+		txn,
+	)
+	if err != nil {
+		return fmt.Errorf("set epoch: %w", err)
+	}
+	// Reload epoch info
+	if err := ls.loadEpochs(txn); err != nil {
+		return fmt.Errorf("load epochs: %w", err)
 	}
+	ls.config.Logger.Debug(
+		"added next epoch to DB",
+		"epoch", fmt.Sprintf("%+v", ls.currentEpoch),
+		"component", "ledger",
+	)
 	return nil
 }
 
@@ -418,7 +415,7 @@ func (ls *LedgerState) processBlockEvent(
 			e.Block,
 		)
 		if err != nil {
-			return err
+			return fmt.Errorf("calculate etaV: %w", err)
 		}
 		blockNonce = tmpNonce
 	}
@@ -427,7 +424,7 @@ func (ls *LedgerState) processBlockEvent(
 		// Ignore and log errors about block not fitting on chain or matching first header
 		if !errors.As(err, &chain.BlockNotFitChainTipError{}) &&
 			!errors.As(err, &chain.BlockNotMatchHeaderError{}) {
-			return err
+			return fmt.Errorf("add chain block: %w", err)
 		}
 		ls.config.Logger.Warn(
 			fmt.Sprintf(
@@ -439,77 +436,6 @@ func (ls *LedgerState) processBlockEvent(
 	return nil
 }
 
-func (ls *LedgerState) processTransaction(
-	txn *database.Txn,
-	tx ledger.Transaction,
-	point ocommon.Point,
-) error {
-	// Validate transaction
-	if ls.currentEra.ValidateTxFunc != nil {
-		lv := &LedgerView{
-			txn: txn,
-			ls:  ls,
-		}
-		err := ls.currentEra.ValidateTxFunc(
-			tx,
-			point.Slot,
-			lv,
-			ls.currentPParams,
-		)
-		if err != nil {
-			ls.config.Logger.Warn(
-				"TX " + tx.Hash().
-					String() +
-					" failed validation: " + err.Error(),
-			)
-			// return fmt.Errorf("TX validation failure: %w", err)
-		}
-	}
-	// Process consumed UTxOs
-	for _, consumed := range tx.Consumed() {
-		if err := ls.consumeUtxo(txn, consumed, point.Slot); err != nil {
-			return fmt.Errorf("remove consumed UTxO: %w", err)
-		}
-	}
-	// Process produced UTxOs
-	for _, produced := range tx.Produced() {
-		outAddr := produced.Output.Address()
-		err := ls.db.NewUtxo(
-			produced.Id.Id().Bytes(),
-			produced.Id.Index(),
-			point.Slot,
-			outAddr.PaymentKeyHash().Bytes(),
-			outAddr.StakeKeyHash().Bytes(),
-			produced.Output.Cbor(),
-			txn,
-		)
-		if err != nil {
-			return fmt.Errorf("add produced UTxO: %w", err)
-		}
-	}
-	// XXX: generate event for each TX/UTxO?
-	// Protocol parameter updates
-	if updateEpoch, paramUpdates := tx.ProtocolParameterUpdates(); updateEpoch > 0 {
-		for genesisHash, update := range paramUpdates {
-			err := ls.db.SetPParamUpdate(
-				genesisHash.Bytes(),
-				update.Cbor(),
-				point.Slot,
-				updateEpoch,
-				txn,
-			)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	// Certificates
-	if err := ls.processTransactionCertificates(txn, point, tx); err != nil {
-		return err
-	}
-	return nil
-}
-
 func (ls *LedgerState) blockfetchRequestRangeStart(
 	connId ouroboros.ConnectionId,
 	start ocommon.Point,
@@ -521,7 +447,7 @@ func (ls *LedgerState) blockfetchRequestRangeStart(
 		end,
 	)
 	if err != nil {
-		return err
+		return fmt.Errorf("request block range: %w", err)
 	}
 	// Create our blockfetch done signal channel
 	ls.chainsyncBlockfetchDoneChan = make(chan struct{})
@@ -550,7 +476,7 @@ func (ls *LedgerState) handleEventBlockfetchBatchDone(e BlockfetchEvent) error {
 	// Process pending block events
 	if err := ls.processBlockEvents(); err != nil {
 		ls.blockfetchRequestRangeCleanup(true)
-		return err
+		return fmt.Errorf("process block events: %w", err)
 	}
 	// Check for pending block range request
 	if !ls.chainsyncBlockfetchWaiting ||

package/ledger/delta.go

@@ -0,0 +1,99 @@
+// 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/conway.go

@@ -134,8 +134,16 @@ func CertDepositConway(
 		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
 	}

package/ledger/queries.go

@@ -61,12 +61,10 @@ func (ls *LedgerState) querySystemStart() (any, error) {
 			"unable to get shelley era genesis for system start",
 		)
 	}
-	// Nanosecond is always within uint64 range
-	// #nosec G115
 	ret := olocalstatequery.SystemStartResult{
-		Year:        shelleyGenesis.SystemStart.Year(),
+		Year:        *big.NewInt(int64(shelleyGenesis.SystemStart.Year())),
 		Day:         shelleyGenesis.SystemStart.YearDay(),
-		Picoseconds: uint64(shelleyGenesis.SystemStart.Nanosecond() * 1000),
+		Picoseconds: *big.NewInt(int64(shelleyGenesis.SystemStart.Nanosecond() * 1000)),
 	}
 	return ret, nil
 }