@blinklabs/dingo 0.6.0 → 0.7.0

package/ledger/state.go

@@ -41,14 +41,17 @@ import (
 const (
 	cleanupConsumedUtxosInterval   = 5 * time.Minute
 	cleanupConsumedUtxosSlotWindow = 50000 // TODO: calculate this from params (#395)
+
+	validateHistoricalThreshold = 14 * (24 * time.Hour) // 2 weeks
 )
 
 type LedgerStateConfig struct {
-	Logger            *slog.Logger
-	DataDir           string
-	EventBus          *event.EventBus
-	CardanoNodeConfig *cardano.CardanoNodeConfig
-	PromRegistry      prometheus.Registerer
+	Logger             *slog.Logger
+	DataDir            string
+	EventBus           *event.EventBus
+	CardanoNodeConfig  *cardano.CardanoNodeConfig
+	PromRegistry       prometheus.Registerer
+	ValidateHistorical bool
 	// Callback(s)
 	BlockfetchRequestRangeFunc BlockfetchRequestRangeFunc
 }
@@ -106,7 +109,7 @@ func NewLedgerState(cfg LedgerStateConfig) (*LedgerState, error) {
 	if err != nil {
 		var dbErr database.CommitTimestampError
 		if !errors.As(err, &dbErr) {
-			return nil, err
+			return nil, fmt.Errorf("failed to open database: %w", err)
 		}
 		ls.config.Logger.Warn(
 			"database initialization error, needs recovery",
@@ -124,7 +127,7 @@ func NewLedgerState(cfg LedgerStateConfig) (*LedgerState, error) {
 		true, // persistent
 	)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to load chain: %w", err)
 	}
 	ls.chain = chain
 	// Run recovery if needed
@@ -146,19 +149,19 @@ func NewLedgerState(cfg LedgerStateConfig) (*LedgerState, error) {
 	ls.scheduleCleanupConsumedUtxos()
 	// Load epoch info from DB
 	if err := ls.loadEpochs(nil); err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to load epoch info: %w", err)
 	}
 	// Load current protocol parameters from DB
 	if err := ls.loadPParams(); err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to load pparams: %w", err)
 	}
 	// Load current tip
 	if err := ls.loadTip(); err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to load tip: %w", err)
 	}
 	// Create genesis block
 	if err := ls.createGenesisBlock(); err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to create genesis block: %w", err)
 	}
 	// Start goroutine to process new blocks
 	go ls.ledgerProcessBlocks()
@@ -169,7 +172,7 @@ func (ls *LedgerState) recoverCommitTimestampConflict() error {
 	// Load current ledger tip
 	tmpTip, err := ls.db.GetTip(nil)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to get tip: %w", err)
 	}
 	// Check if we can lookup tip block in chain
 	_, err = ls.chain.BlockByPoint(tmpTip.Point, nil)
@@ -256,12 +259,12 @@ func (ls *LedgerState) rollback(point ocommon.Point) error {
 		if point.Slot > 0 {
 			rollbackBlock, err := ls.chain.BlockByPoint(point, txn)
 			if err != nil {
-				return err
+				return fmt.Errorf("failed to get rollback block: %w", err)
 			}
 			ls.currentTip.BlockNumber = rollbackBlock.Number
 		}
 		if err = ls.db.SetTip(ls.currentTip, txn); err != nil {
-			return err
+			return fmt.Errorf("failed to set tip: %w", err)
 		}
 		ls.updateTipMetrics()
 		return nil
@@ -271,7 +274,7 @@ func (ls *LedgerState) rollback(point ocommon.Point) error {
 	}
 	// Reload tip
 	if err := ls.loadTip(); err != nil {
-		return err
+		return fmt.Errorf("failed to load tip: %w", err)
 	}
 	var hash string
 	if point.Slot == 0 {
@@ -306,7 +309,7 @@ func (ls *LedgerState) transitionToEra(
 			ls.currentPParams,
 		)
 		if err != nil {
-			return err
+			return fmt.Errorf("hard fork failed: %w", err)
 		}
 		ls.currentPParams = newPParams
 		ls.config.Logger.Debug(
@@ -317,7 +320,7 @@ func (ls *LedgerState) transitionToEra(
 		// Write pparams update to DB
 		pparamsCbor, err := cbor.Encode(&ls.currentPParams)
 		if err != nil {
-			return err
+			return fmt.Errorf("failed to encode pparams: %w", err)
 		}
 		err = ls.db.SetPParams(
 			pparamsCbor,
@@ -327,7 +330,7 @@ func (ls *LedgerState) transitionToEra(
 			txn,
 		)
 		if err != nil {
-			return err
+			return fmt.Errorf("failed to set pparams: %w", err)
 		}
 	}
 	ls.currentEra = nextEra
@@ -357,45 +360,136 @@ func (ls *LedgerState) ledgerProcessBlocks() {
 		return
 	}
 	shouldBlock := false
+	shouldValidate := ls.config.ValidateHistorical
 	// We chose 500 as an arbitrary max batch size. A "chain extended" message will be logged after each batch
 	nextBatch := make([]*chain.ChainIteratorResult, 0, 500)
-	var next, nextRollback *chain.ChainIteratorResult
+	var next, nextRollback, cachedNext *chain.ChainIteratorResult
 	var tmpBlock ledger.Block
-	var needsRollback bool
+	var needsRollback, needsEpochRollover bool
+	var nextEpochEraId uint
 	var end, i int
 	var txn *database.Txn
 	for {
+		if needsEpochRollover {
+			needsEpochRollover = false
+			txn := ls.db.Transaction(true)
+			err := txn.Do(func(txn *database.Txn) error {
+				// Check for era change
+				if nextEpochEraId != ls.currentEra.Id {
+					// Transition through every era between the current and the target era
+					for nextEraId := ls.currentEra.Id + 1; nextEraId <= nextEpochEraId; nextEraId++ {
+						if err := ls.transitionToEra(txn, nextEraId, ls.currentEpoch.EpochId, ls.currentEpoch.StartSlot+uint64(ls.currentEpoch.LengthInSlots)); err != nil {
+							return err
+						}
+					}
+				}
+				// Process epoch rollover
+				if err := ls.processEpochRollover(txn); err != nil {
+					return err
+				}
+				return nil
+			})
+			if err != nil {
+				ls.config.Logger.Error(
+					"failed to process epoch rollover: " + err.Error(),
+				)
+				return
+			}
+		}
 		// Gather up next batch of blocks
 		for {
-			next, err = iter.Next(shouldBlock)
-			shouldBlock = false
-			if err != nil {
-				if !errors.Is(err, chain.ErrIteratorChainTip) {
-					ls.config.Logger.Error(
-						"failed to get next block from chain iterator: " + err.Error(),
-					)
-					return
+			if cachedNext != nil {
+				next = cachedNext
+				cachedNext = nil
+			} else {
+				next, err = iter.Next(shouldBlock)
+				shouldBlock = false
+				if err != nil {
+					if !errors.Is(err, chain.ErrIteratorChainTip) {
+						ls.config.Logger.Error(
+							"failed to get next block from chain iterator: " + err.Error(),
+						)
+						return
+					}
+					shouldBlock = true
+					// Break out of inner loop to flush DB transaction and log
+					break
 				}
-				shouldBlock = true
-				// Break out of inner loop to flush DB transaction and log
-				break
 			}
 			if next == nil {
 				ls.config.Logger.Error("next block from chain iterator is nil")
 				return
 			}
-			nextBatch = append(nextBatch, next)
-			// End batch if there's a rollback, since we need special processing
-			if next.Rollback {
+			// End batch and cache next if we get a block from after the current epoch end, or if we need the initial epoch
+			if next.Point.Slot >= (ls.currentEpoch.StartSlot+uint64(ls.currentEpoch.LengthInSlots)) ||
+				ls.currentEpoch.SlotLength == 0 {
+				cachedNext = next
+				needsEpochRollover = true
+				// Decode next block to get era ID
+				tmpBlock, err = next.Block.Decode()
+				if err != nil {
+					ls.config.Logger.Error(
+						"failed to decode block: " + err.Error(),
+					)
+					return
+				}
+				nextEpochEraId = uint(tmpBlock.Era().Id)
 				break
 			}
+			if next.Rollback {
+				// End existing batch and cache rollback if we have any blocks in the batch
+				// We need special processing for rollbacks below
+				if len(nextBatch) > 0 {
+					cachedNext = next
+					break
+				}
+				needsRollback = true
+			}
+			// Enable validation if we're getting near current tip
+			if !shouldValidate && len(nextBatch) == 0 {
+				// Determine wall time for next block slot
+				slotTime, err := ls.SlotToTime(next.Point.Slot)
+				if err != nil {
+					ls.config.Logger.Error(
+						"failed to convert slot to time: " + err.Error(),
+					)
+					return
+				}
+				// Check difference from current time
+				timeDiff := time.Since(slotTime)
+				if timeDiff < validateHistoricalThreshold {
+					shouldValidate = true
+					ls.config.Logger.Debug(
+						"enabling validation as we approach tip",
+					)
+				}
+			}
+			// Add to batch
+			nextBatch = append(nextBatch, next)
 			// Don't exceed our pre-allocated capacity
 			if len(nextBatch) == cap(nextBatch) {
 				break
 			}
 		}
+		// Process rollback
+		if needsRollback {
+			needsRollback = false
+			// The rollback should be alone in the batch
+			nextRollback = nextBatch[0]
+			ls.Lock()
+			if err = ls.rollback(nextRollback.Point); err != nil {
+				ls.Unlock()
+				ls.config.Logger.Error(
+					"failed to process rollback: " + err.Error(),
+				)
+				return
+			}
+			ls.Unlock()
+			// Clear out batch buffer
+			nextBatch = slices.Delete(nextBatch, 0, len(nextBatch))
+			continue
+		}
 		// Process batch in groups of 50 to stay under DB txn limits
-		needsRollback = false
 		for i = 0; i < len(nextBatch); i += 50 {
 			ls.Lock()
 			end = min(
@@ -405,18 +499,12 @@ func (ls *LedgerState) ledgerProcessBlocks() {
 			txn = ls.db.Transaction(true)
 			err = txn.Do(func(txn *database.Txn) error {
 				for _, next := range nextBatch[i:end] {
-					// Rollbacks need to be handled outside of the batch DB transaction
-					// A rollback should only occur at the end of a batch
-					if next.Rollback {
-						needsRollback = true
-						return nil
-					}
 					// Process block
 					tmpBlock, err = next.Block.Decode()
 					if err != nil {
-						return err
+						return fmt.Errorf("block decode failed: %w", err)
 					}
-					if err = ls.ledgerProcessBlock(txn, next.Point, tmpBlock); err != nil {
+					if err = ls.ledgerProcessBlock(txn, next.Point, tmpBlock, shouldValidate); err != nil {
 						return err
 					}
 					// Update tip
@@ -429,7 +517,7 @@ func (ls *LedgerState) ledgerProcessBlocks() {
 				}
 				// Update tip in database
 				if err := ls.db.SetTip(ls.currentTip, txn); err != nil {
-					return err
+					return fmt.Errorf("failed to set tip: %w", err)
 				}
 				ls.updateTipMetrics()
 				return nil
@@ -443,27 +531,6 @@ func (ls *LedgerState) ledgerProcessBlocks() {
 			}
 			ls.Unlock()
 		}
-		// Process rollback from end of batch
-		if needsRollback {
-			needsRollback = false
-			// The rollback should be at the end of the batch
-			nextRollback = nextBatch[len(nextBatch)-1]
-			ls.Lock()
-			if err = ls.rollback(nextRollback.Point); err != nil {
-				ls.Unlock()
-				ls.config.Logger.Error(
-					"failed to process rollback: " + err.Error(),
-				)
-				return
-			}
-			ls.Unlock()
-			// Skip "chain extended" logging below if batch only contains a rollback
-			if len(nextBatch) == 1 {
-				// Clear out batch buffer
-				nextBatch = slices.Delete(nextBatch, 0, len(nextBatch))
-				continue
-			}
-		}
 		if len(nextBatch) > 0 {
 			// Clear out batch buffer
 			nextBatch = slices.Delete(nextBatch, 0, len(nextBatch))
@@ -484,6 +551,7 @@ func (ls *LedgerState) ledgerProcessBlock(
 	txn *database.Txn,
 	point ocommon.Point,
 	block ledger.Block,
+	shouldValidate bool,
 ) error {
 	// Check that we're processing things in order
 	if len(ls.currentTip.Point.Hash) > 0 {
@@ -500,25 +568,52 @@ func (ls *LedgerState) ledgerProcessBlock(
 			)
 		}
 	}
-	// TODO: track this using protocol params and hard forks
-	// Check for era change
-	if uint(block.Era().Id) != ls.currentEra.Id {
-		targetEraId := uint(block.Era().Id)
-		// Transition through every era between the current and the target era
-		for nextEraId := ls.currentEra.Id + 1; nextEraId <= targetEraId; nextEraId++ {
-			if err := ls.transitionToEra(txn, nextEraId, ls.currentEpoch.EpochId, point.Slot); err != nil {
+	// Process transactions
+	var delta *LedgerDelta
+	for _, tx := range block.Transactions() {
+		if delta == nil {
+			delta = &LedgerDelta{
+				Point: point,
+			}
+		}
+		// Validate transaction
+		if shouldValidate {
+			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)
+				}
+			}
+		}
+		// Populate ledger delta from transaction
+		if err := delta.processTransaction(tx); err != nil {
+			return fmt.Errorf("process transaction: %w", err)
+		}
+		// Apply delta immediately if we may need the data to validate the next TX
+		if shouldValidate {
+			if err := delta.apply(ls, txn); err != nil {
 				return err
 			}
+			delta = nil
 		}
 	}
-	// Check for epoch rollover
-	if err := ls.processEpochRollover(txn, point); err != nil {
-		return err
-	}
-	// Process transactions
-	for _, tx := range block.Transactions() {
-		if err := ls.processTransaction(txn, tx, point); err != nil {
-			return err
+	if delta != nil {
+		if err := delta.apply(ls, txn); err != nil {
+			return fmt.Errorf("apply ledger delta: %w", err)
 		}
 	}
 	return nil
@@ -573,7 +668,7 @@ func (ls *LedgerState) loadTip() error {
 	if ls.currentTip.Point.Slot > 0 {
 		tipBlock, err := ls.chain.BlockByPoint(ls.currentTip.Point, nil)
 		if err != nil {
-			return err
+			return fmt.Errorf("failed to get tip block: %w", err)
 		}
 		ls.currentTipBlockNonce = tipBlock.Nonce
 	}
@@ -638,7 +733,7 @@ func (ls *LedgerState) GetIntersectPoint(
 				if errors.Is(err, chain.ErrBlockNotFound) {
 					continue
 				}
-				return err
+				return fmt.Errorf("failed to get block: %w", err)
 			}
 			// Update return value
 			ret.Slot = tmpBlock.Slot

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@blinklabs/dingo",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Dingo is a Cardano blockchain data node",
   "main": "index.js",
   "scripts": {
     "postinstall": "golang-npm install",
-    "preuninstall": "golang-npm uninstall",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "preuninstall": "golang-npm uninstall"
   },
   "repository": {
     "type": "git",
@@ -23,11 +22,12 @@
   },
   "homepage": "https://github.com/blinklabs-io/dingo#readme",
   "dependencies": {
-    "golang-npm": "^0.0.5"
+    "dingo": "^0.0.18",
+    "golang-npm": "^0.0.6"
   },
   "goBinary": {
     "name": "dingo",
     "path": "./bin",
-    "url": "https://github.com/blinklabs-io/dingo/releases/download/v{{version}}/dingo-{{version}}-{{platform}}-{{arch}}.tar.gz"
+    "url": "https://github.com/blinklabs-io/dingo/releases/download/v{{version}}/dingo-v{{version}}-{{platform}}-{{arch}}.tar.gz"
   }
 }

package/database/plugin/metadata/sqlite/models/deregistration_drep.go

@@ -1,26 +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 models
-
-type DeregistrationDrep struct {
-	ID             uint   `gorm:"primarykey"`
-	DrepCredential []byte `gorm:"index"`
-	AddedSlot      uint64
-	DepositAmount  uint64
-}
-
-func (DeregistrationDrep) TableName() string {
-	return "deregistration_drep"
-}

package/database/plugin/metadata/sqlite/models/registration_drep.go

@@ -1,28 +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 models
-
-type RegistrationDrep struct {
-	ID             uint   `gorm:"primarykey"`
-	DrepCredential []byte `gorm:"index"`
-	AddedSlot      uint64
-	DepositAmount  uint64
-	AnchorUrl      string
-	AnchorHash     []byte
-}
-
-func (RegistrationDrep) TableName() string {
-	return "registration_drep"
-}

package/database/plugin/metadata/sqlite/models/stake_registration_delegation.go

@@ -1,27 +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 models
-
-type StakeRegistrationDelegation struct {
-	ID            uint   `gorm:"primarykey"`
-	StakingKey    []byte `gorm:"index"`
-	PoolKeyHash   []byte `gorm:"index"`
-	AddedSlot     uint64
-	DepositAmount uint64
-}
-
-func (StakeRegistrationDelegation) TableName() string {
-	return "stake_registration_delegation"
-}

package/database/plugin/metadata/sqlite/models/stake_vote_registration_delegation.go

@@ -1,27 +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 models
-
-type StakeVoteRegistrationDelegation struct {
-	ID          uint   `gorm:"primarykey"`
-	StakingKey  []byte `gorm:"index"`
-	PoolKeyHash []byte `gorm:"index"`
-	Drep        []byte `gorm:"index"`
-	AddedSlot   uint64
-}
-
-func (StakeVoteRegistrationDelegation) TableName() string {
-	return "stake_vote_registration_delegation"
-}