@blinklabs/dingo 0.41.0 → 0.46.0

package/README.md

@@ -249,19 +249,18 @@ This imports:
 - Protocol parameters, governance state, treasury/reserves
 - Complete epoch history for slot-to-time calculations
 
-What is NOT included: Individual transaction records, certificate history, witness/script/datum storage, and governance vote records for blocks before the snapshot. These are not needed for consensus, block production, or serving blocks to peers. New blocks processed after bootstrap will have full metadata.
+Individual transaction records, certificate history, witness/script/datum storage, and governance vote records for blocks before the snapshot are not stored by the snapshot itself. In `core` mode these are not needed — consensus, block production, and serving blocks to peers work without them, and new blocks processed after bootstrap will have full metadata. In `api` mode, `dingo mithril sync` automatically runs a backfill step after loading the snapshot to populate this historical data, so API servers (Blockfrost, UTxO RPC, Mesh) have complete records from genesis.
 
 Performance (preview network, ~4M blocks):
 
-| Phase | Time |
-|-------|------|
-| Download snapshot (~2.6 GB) | ~1-2 min |
-| Extract + download ancillary | ~1 min |
-| Import ledger state (UTxOs, accounts, pools, DReps, epochs) | ~12 min |
-| Load blocks into blob store | ~36 min |
-| Total | ~50 min |
-
-For indexers and API nodes that need full historical data (transaction lookups, certificate queries, datum/script resolution), configure the storage mode to `api` and `dingo mithril sync` will automatically backfill historical metadata after loading the snapshot.
+| Phase | core mode | api mode |
+|-------|-----------|----------|
+| Download snapshot (~2.6 GB) | ~1-2 min | ~1-2 min |
+| Extract + download ancillary | ~1 min | ~1 min |
+| Import ledger state (UTxOs, accounts, pools, DReps, epochs) | ~12 min | ~12 min |
+| Load blocks into blob store | ~36 min | ~36 min |
+| Backfill historical metadata | — | ~varies |
+| Total | ~50 min | ~50 min + backfill |
 
 ### Disk Space Requirements
 

package/RELEASE_NOTES.md

@@ -1,5 +1,300 @@
 # Release Notes
 
+## v0.45.0 (May 12, 2026)
+
+**Title:** Batched backfill, ledger safety fixes, and stronger PV11 readiness
+
+**Date:** May 12, 2026
+
+**Version:** v0.45.0
+
+Hi folks! Here’s what we shipped in v0.45.0.
+
+### ✨ What's New
+
+* Added **batch historical backfill work for smoother replay progress:** Historical metadata replay now writes work in larger batches, which helps long backfills move forward more smoothly and keeps checkpoint recovery safer when replay resumes.
+
+### 💪 Improvements
+
+* Improved **verify upcoming protocol-step readiness on a live multi-node path:** Release validation now checks the Conway to vanRossem progression more directly, which increases confidence that mixed-node networks can cross that protocol step cleanly.
+* Refined **expand fuzz-driven regression coverage across core behaviors:** More parsing, storage, networking, and configuration paths now receive broader stress coverage, which helps surface edge cases before they reach operators and integrators.
+* Enhanced **keep publish workflows moving while package indexing catches up:** Release publishing now avoids a broken package refresh step, which keeps releases moving even when package index updates take longer to appear.
+* Updated **keep release history current through v0.44.0:** `RELEASE_NOTES.md` now includes the v0.44.0 entry, which keeps recent release history easier to follow.
+
+### 🔧 Fixes
+
+* Fixed **recover sparse chain intersections more reliably after missing history gaps:** Synchronization can now fall back to safer recent chain points more consistently, which helps recovery continue when recent ledger history is incomplete.
+* Corrected **reject headers that run ahead of safe ledger rules:** Ledger validation now stops headers that claim a protocol step too far beyond the active rules, which reduces the risk of unsafe acceptance during version transitions.
+* Strengthened **skip rollback work that moves past the known ledger tip:** Recovery now avoids applying rollbacks that run ahead of recorded ledger progress, which keeps replay and catch-up behavior safer when metadata trails the raw chain.
+
+### 📋 What You Need to Know
+
+* Clarified **backfill batching and safer replay progress:** Historical replay now batches more backfill work and keeps checkpoint progress safer, which helps long catch-up runs resume more smoothly after interruptions.
+* Highlighted **safer ledger validation, rollback handling, and sparse recovery:** Ledger validation now rejects headers that jump too far ahead, rollback handling no longer pushes past the known ledger tip, and sparse intersect recovery finds safer restart points more reliably.
+* Emphasized **stronger PV11 and fuzz regression coverage:** Release validation now exercises PV11 crossing behavior more directly, and broader stress coverage checks more parsing, storage, networking, and configuration paths for regressions.
+* Summarized **publish maintenance and package-index timing:** Release publishing keeps moving even while package index refreshes may lag because the refresh pull remains disabled.
+
+### Recommended Network Compatibility ⚠️
+
+| Network             | Compatible |
+|---------------------|------------|
+| mainnet             | ⛔         |
+| preprod-testnet     | ⛔         |
+| preview-testnet     | ✅         |
+
+### 🙏 Thank You
+
+Thank you for trying!
+
+---
+
+## v0.44.0 (May 11, 2026)
+
+**Title:** Blockfrost transaction endpoints, steadier Mithril backfill, and safer chain recovery
+
+**Date:** May 11, 2026
+
+**Version:** v0.44.0
+
+Hi folks! Here’s what we shipped in v0.44.0.
+
+### ✨ What's New
+
+* Added **expand Blockfrost transaction access:** Blockfrost compatible services can now look up transaction details, metadata, UTxOs, certificates, redeemers, required signers, and signed CBOR, and they can also submit transactions with clearer submit responses.
+
+### 💪 Improvements
+
+* Improved **preserve Mithril backfill progress across interruptions:** Mithril bootstrap now keeps more recovery state and resumes metadata backfill more safely, which helps interrupted runs continue without losing important progress.
+* Refined **give full devnet validation more time:** Devnet validation now has a longer default timeout, which reduces avoidable failures during full environment checks.
+* Enhanced **recover forked chains across more rollback paths:** Chain reconciliation now handles more rollback and fork combinations without dropping useful chain history, which makes recovery steadier after difficult fork scenarios.
+* Updated **align operational tooling with newer cardano-cli support:** Operational tooling now stays aligned with the newer `cardano-cli` release for smoother maintenance.
+* Modernized **align data handling with newer CBOR support:** Data handling now stays aligned with the newer CBOR library release for steadier compatibility maintenance.
+* Strengthened **align secrets handling with newer sops support:** Encrypted configuration and secrets handling now stay aligned with the newer `sops` release for steadier maintenance.
+* Advanced **align compression support with newer library updates:** Compression support now stays aligned with the newer `klauspost/compress` release for routine compatibility maintenance.
+* Polished **align system support with newer platform updates:** System level compatibility now stays aligned with the newer `golang.org/x/sys` release for steadier maintenance.
+* Restored **keep release history current through v0.43.0:** `RELEASE_NOTES.md` now includes the v0.43.0 entry, which keeps recent release history easier to follow.
+
+### 🔧 Fixes
+
+* Fixed **return safer intersect points from sparse ledger history:** Chains can now find safer meeting points even when recent ledger history is sparse, which helps sync and recovery continue more reliably.
+
+### 📋 What You Need to Know
+
+* Clarified **broader Blockfrost transaction coverage and submit handling:** Blockfrost compatible integrations can now use transaction detail and submit endpoints with clearer coverage across metadata, UTxOs, certificates, redeemers, required signers, signed CBOR, and submit outcomes.
+* Highlighted **safer Mithril backfill and resume handling:** Mithril bootstrap now preserves more recovery state and resumes metadata backfill more safely, which lowers the chance of losing progress after an interrupted run.
+* Emphasized **safer fork and intersect recovery behavior:** Chain recovery now handles sparse intersect points and more fork reconciliation scenarios more safely, which helps nodes recover from difficult rollback paths with less risk of getting stuck.
+* Summarized **maintenance, validation, dependency, and release history updates:** Validation timing, dependency compatibility, and release tracking were refreshed to keep operations and maintenance steadier around this release.
+
+### Recommended Network Compatibility ⚠️
+
+| Network             | Compatible |
+|---------------------|------------|
+| mainnet             | ⛔         |
+| preprod-testnet     | ⛔         |
+| preview-testnet     | ✅         |
+
+### 🙏 Thank You
+
+Thank you for trying!
+
+---
+
+## v0.43.0 (May 9, 2026)
+
+**Title:** Safer block-producer startup, deeper observability, and easier dashboard imports
+
+**Date:** May 9, 2026
+
+**Version:** v0.43.0
+
+Hi folks! Here’s what we shipped in v0.43.0.
+
+### ✨ What's New
+
+* Added **catch block-producer credential problems during startup:** Block producers now stop early when forging credentials are missing, mismatched, expired, or not yet valid, which prevents later surprises after launch.
+* Expanded **track protocol activity and peer state changes:** Operators can now see clearer network behavior signals, which makes it easier to spot unhealthy connections and shifting peer conditions.
+* Introduced **prompt for the Prometheus datasource during dashboard imports:** Bundled Grafana dashboards now ask for the right Prometheus datasource during import, which makes dashboard setup smoother across different Grafana environments.
+
+### 💪 Improvements
+
+* Improved **show epoch progress against wall-clock time in dashboards:** Operators can now compare current epoch slot progress with a wall-clock reference line, which makes slot stalls easier to notice.
+* Refined **track compatibility with gouroboros 0.168.0:** Protocol compatibility now stays aligned with the newer `gouroboros` `0.168.0` release for steadier maintenance and integration tracking.
+* Enhanced **keep release history current through v0.42.0:** `RELEASE_NOTES.md` now includes the v0.42.0 entry, which keeps recent release history easier to follow.
+
+### 🔧 Fixes
+
+* Updated **limit slow fallback block lookups in large databases:** Large databases and fork recovery paths now avoid long lookup stalls because fallback scans stop quickly and move on to safer recovery paths.
+* Modernized **restart ledger recovery after stale rollback iterators:** Rollback recovery now restarts cleanly when an iterator points at stale chain data, which helps forked chains continue without getting stuck on the wrong branch.
+
+### 📋 What You Need to Know
+
+* Clarified **fail-fast forging startup checks:** Block-producer startup now validates VRF, KES, and operational certificate inputs against Shelley genesis data and available ledger state, so misconfigured or expired credentials stop the node early instead of failing later.
+* Highlighted **broader observability and easier dashboard imports:** Operators now get new protocol and peer observability metrics, and bundled dashboards are easier to import because Grafana prompts for the Prometheus datasource.
+* Emphasized **safer rollback recovery and block-hash lookups:** Rollback recovery and block-hash lookups now behave more safely on forked chains and very large databases because stale iterators restart cleanly and expensive fallback scans stop quickly.
+* Summarized **dependency and release tracking updates:** Maintenance tracking now includes the `gouroboros` `0.168.0` update, and release history continuity is refreshed through the added v0.42.0 entry.
+
+### Recommended Network Compatibility ⚠️
+
+| Network             | Compatible |
+|---------------------|------------|
+| mainnet             | ⛔         |
+| preprod-testnet     | ⛔         |
+| preview-testnet     | ✅         |
+
+### 🙏 Thank You
+
+Thank you for trying!
+
+---
+
+## v0.42.0 (May 8, 2026)
+
+**Title:** Batch stake account lookups for faster delegation queries
+
+**Date:** May 8, 2026
+
+**Version:** v0.42.0
+
+Hi folks! Here’s what we shipped in v0.42.0.
+
+### ✨ What's New
+
+* Added **batch stake account lookups for faster delegation queries:** Stake-key-heavy delegation and reward account requests now return more smoothly because Dingo can load many stake accounts in one pass.
+
+### 💪 Improvements
+
+* Improved **catch-up checks that no longer stall sync work:** Catch-up runs now stay smoother because hard-fork readiness checks evaluate in the background instead of pausing the main sync path.
+* Refined **larger deep catch-up block batches:** Nodes now pull much larger block batches during deep catch-up, which helps long syncs move forward faster with less stop-and-go behavior.
+* Enhanced **quieter inbound listener logging:** Routine inbound connection handling now produces calmer logs, which makes real connection problems easier to spot.
+* Updated **test environments aligned with cardano-node 11.0.1:** Validation and demo environments now track `cardano-node` `11.0.1`, which keeps operational testing closer to current network expectations.
+* Modernized **project alignment with Go 1.26.x:** Build, test, and release workflows now align on Go `1.26.x`, which keeps maintenance and contributor environments current.
+* Strengthened **Mithril bootstrap rollover coverage:** Regression coverage now checks Mithril bootstrap and candidate nonce rollover paths more thoroughly, which improves confidence around snapshot recovery.
+* Restored **release history continuity:** `RELEASE_NOTES.md` now includes the v0.41.0 entry, which keeps recent release history easier to follow.
+
+### 🔧 Fixes
+
+* Fixed **governance imports that now preserve proposal history:** Mithril-bootstrapped nodes now keep parent action links, full proposal details, and ratified hard-fork timing so governance stays aligned after snapshot startup.
+* Corrected **archive demo teardown that no longer hangs on pruning shutdown:** The archive demonstration now cleans up pruning data with the right permissions, which makes teardown finish reliably.
+* Stabilized **clearer Bark and UTxO RPC startup failures:** Bark and UTxO RPC now return deterministic startup errors for TLS and port-binding problems, which makes failed launches easier to diagnose.
+* Preserved **Mithril governance roots across snapshot startup:** Mithril bootstrap now seeds governance roots so chained governance proposals keep progressing instead of silently expiring after startup.
+* Hardened **safer peer-sharing defaults by node role:** Block producers now keep peer sharing off by default, while non-block producers fall back to `cardano-node` behavior when the setting is unset.
+* Prevented **rollback recovery from replaying applied headers:** Chainsync rollback recovery now skips headers the node already applied, which prevents recovery from wedging after rollback scenarios.
+* Repaired **benchmark runs that no longer leave stray cloud paths in the worktree:** Benchmark tests now keep temporary cloud-backend metadata out of the worktree, which leaves local checkouts cleaner.
+* Eliminated **pinned-tip rollback loops during no-op rollbacks:** No-op rollbacks at the current tip no longer trigger repeated local resync loops, which keeps chainsync from wedging at a pinned tip.
+* Renamed **Dingo-owned metrics under the dingo_metrics prefix:** Dingo-owned metric families moved from `cardano_node_metrics_*` names to `dingo_metrics_*` names, bundled dashboards now use the new names, and operators who use any affected metrics must update alerts, dashboards, and monitoring queries.
+
+### 📋 What You Need to Know
+
+* Clarified **faster stake account queries:** Batched account lookups now improve delegation and reward account queries for stake-key-heavy workloads.
+* Highlighted **faster and smoother catch-up behavior:** Catch-up behavior is faster and smoother because blockfetch batching scales much more aggressively, and hard-fork initiation checks no longer block the ledger path the same way.
+* Emphasized **safer governance continuity after Mithril bootstrap:** Mithril-bootstrapped nodes should see safer governance continuity because governance roots, parent action links, and ratification timing are now preserved more accurately after snapshot import.
+* Reviewed **operator updates for startup, peer sharing, and metrics:** Operators using Bark, UTxO RPC, PeerSharing, or any affected metrics must update alerts, dashboards, and monitoring queries for the Dingo-owned metric families that moved from `cardano_node_metrics_*` names to `dingo_metrics_*` names:
+  * `cardano_node_metrics_txsEvictedNum_int` -> `dingo_metrics_txsEvictedNum_int`
+  * `cardano_node_metrics_txsExpiredNum_int` -> `dingo_metrics_txsExpiredNum_int`
+  * `cardano_node_metrics_slotBattlesTotal_int` -> `dingo_metrics_slotBattlesTotal_int`
+  * `cardano_node_metrics_blockForgingLatency_seconds` -> `dingo_metrics_blockForgingLatency_seconds`
+  * `cardano_node_metrics_forgedBlockSize_bytes` -> `dingo_metrics_forgedBlockSize_bytes`
+  * `cardano_node_metrics_forgedBlockTxCount_int` -> `dingo_metrics_forgedBlockTxCount_int`
+  * `cardano_node_metrics_leader_slot_checks_total` -> `dingo_metrics_leader_slot_checks_total`
+  * `cardano_node_metrics_leader_slot_won_total` -> `dingo_metrics_leader_slot_won_total`
+  * `cardano_node_metrics_leader_slot_not_won_total` -> `dingo_metrics_leader_slot_not_won_total`
+  * `cardano_node_metrics_leader_vrf_eval_duration_seconds` -> `dingo_metrics_leader_vrf_eval_duration_seconds`
+  * `cardano_node_metrics_leader_stake_lookup_duration_seconds` -> `dingo_metrics_leader_stake_lookup_duration_seconds`
+  * `cardano_node_metrics_leader_last_epoch_slots_checked_int` -> `dingo_metrics_leader_last_epoch_slots_checked_int`
+  * `cardano_node_metrics_leader_last_epoch_slots_won_int` -> `dingo_metrics_leader_last_epoch_slots_won_int`
+  * `cardano_node_metrics_leader_last_epoch_slots_not_won_int` -> `dingo_metrics_leader_last_epoch_slots_not_won_int`
+  * `cardano_node_metrics_leader_last_evaluated_epoch_int` -> `dingo_metrics_leader_last_evaluated_epoch_int`
+  * `cardano_node_metrics_stake_snapshot_capture_duration_seconds` -> `dingo_metrics_stake_snapshot_capture_duration_seconds`
+  * `cardano_node_metrics_stake_snapshot_capture_success_total` -> `dingo_metrics_stake_snapshot_capture_success_total`
+  * `cardano_node_metrics_stake_snapshot_capture_failure_total` -> `dingo_metrics_stake_snapshot_capture_failure_total`
+  * `cardano_node_metrics_stake_snapshot_pool_count_int` -> `dingo_metrics_stake_snapshot_pool_count_int`
+  * `cardano_node_metrics_stake_snapshot_total_active_stake_lovelace` -> `dingo_metrics_stake_snapshot_total_active_stake_lovelace`
+  * `cardano_node_metrics_stake_snapshot_last_successful_epoch_int` -> `dingo_metrics_stake_snapshot_last_successful_epoch_int`
+  * `cardano_node_metrics_peerSelection_peers_by_source` -> `dingo_metrics_peerSelection_peers_by_source`
+  * `cardano_node_metrics_peerSelection_churn_demotions_by_source` -> `dingo_metrics_peerSelection_churn_demotions_by_source`
+  * `cardano_node_metrics_peerSelection_churn_promotions_by_source` -> `dingo_metrics_peerSelection_churn_promotions_by_source`
+  * `cardano_node_metrics_peerSelection_InboundWarmTarget` -> `dingo_metrics_peerSelection_InboundWarmTarget`
+  * `cardano_node_metrics_peerSelection_InboundHotQuota` -> `dingo_metrics_peerSelection_InboundHotQuota`
+  * `cardano_node_metrics_peerSelection_InboundWarmHeld` -> `dingo_metrics_peerSelection_InboundWarmHeld`
+  * `cardano_node_metrics_peerSelection_InboundHotHeld` -> `dingo_metrics_peerSelection_InboundHotHeld`
+  * `cardano_node_metrics_peerSelection_InboundPruned` -> `dingo_metrics_peerSelection_InboundPruned`
+  * `cardano_node_metrics_peerSelection_InboundArrivalsTotal` -> `dingo_metrics_peerSelection_InboundArrivalsTotal`
+  * `cardano_node_metrics_peerSelection_InboundTopologyMatched` -> `dingo_metrics_peerSelection_InboundTopologyMatched`
+  * `cardano_node_metrics_peerSelection_InboundDuplexHeld` -> `dingo_metrics_peerSelection_InboundDuplexHeld`
+  * `cardano_node_metrics_peerSelection_InboundPrunedByReason` -> `dingo_metrics_peerSelection_InboundPrunedByReason`
+  * `cardano_node_metrics_peerSelection_InboundLifecycleTotal` -> `dingo_metrics_peerSelection_InboundLifecycleTotal`
+  * `cardano_node_metrics_peerSelection_InboundHotQuotaUsage` -> `dingo_metrics_peerSelection_InboundHotQuotaUsage`
+  * `cardano_node_metrics_peerSelection_InboundWarmTargetOccupancy` -> `dingo_metrics_peerSelection_InboundWarmTargetOccupancy`
+* Summarized **refreshed tooling, validation, and release tracking:** Tooling, validation, and release tracking were refreshed through Go `1.26.x` alignment, `cardano-node` `11.0.1` test coverage, stronger Mithril rollover regression coverage, archive-demo reliability improvements, and the restored v0.41.0 release-history entry.
+
+### Recommended Network Compatibility ⚠️
+
+| Network             | Compatible |
+|---------------------|------------|
+| mainnet             | ⛔         |
+| preprod-testnet     | ⛔         |
+| preview-testnet     | ✅         |
+
+### 🙏 Thank You
+
+Thank you for trying!
+
+---
+
+## v0.41.0 (May 6, 2026)
+
+**Title:** Batched metadata writes, leaner memory use, and safer node behavior
+
+**Date:** May 6, 2026
+
+**Version:** v0.41.0
+
+Hi folks! Here’s what we shipped in v0.41.0.
+
+### ✨ What's New
+
+* Added **batched metadata persistence across supported databases:** Metadata transaction data can now flush in batches across sqlite, MySQL, and Postgres backends, which makes high-volume metadata persistence easier to manage.
+* Expanded **archive node demonstration tooling:** Teams can now run an archive node demonstration with MinIO-backed archive storage, a pruning node, helper scripts, and an end-to-end runnable flow.
+
+### 💪 Improvements
+
+* Improved **leaner default subscriber buffering:** Default subscriber buffers are now much smaller, while high-burst consumers keep large queues where needed, which reduces idle memory use.
+* Refined **era test harness organization:** The era test harness now lives in a clearer shared location, which makes validation work easier to follow.
+* Enhanced **Conway and PV11 readiness confidence:** Readiness coverage now checks Conway and PV11 behavior more clearly, which improves validation confidence.
+* Cleaned **stale rate limit maintenance:** The project now drops an outdated rate-limit constant, which keeps maintenance cleaner without changing runtime behavior.
+* Restored **release history continuity:** RELEASE_NOTES.md now includes the v0.40.0 entry, which keeps recent release history easier to scan.
+* Strengthened **archive node validation coverage:** The archive node demonstration now checks the full runnable flow more thoroughly, which makes the operational demo easier to trust.
+
+### 🔧 Fixes
+
+* Fixed **safer Mithril startup around recoverable metadata gaps:** Missing blob commit-timestamp keys now resolve as empty values, and recoverable mismatches no longer block Mithril or related startup paths.
+* Corrected **iterator handling after storage closes:** Iterator creation now returns an error after Badger closes, which prevents a shutdown panic.
+* Synchronized **stability window reads during era changes:** Stability-window reads now stay aligned with concurrent era updates, which avoids race-driven failures.
+* Released **pruning locks earlier:** Pruning now releases the metadata and prune lock sooner, which reduces contention and improves diagnostics.
+* Preserved **eligible peer continuity during local tip plateaus:** Nodes no longer disconnect their only eligible peer when a local tip plateau appears.
+* Unified **peer identity handling across DNS fallbacks:** Hostname and IP variants now stay consistent for deduplication, deny lists, and DNS-failure logging.
+
+### 📋 What You Need to Know
+
+* Clarified **batched metadata persistence availability:** Batched metadata persistence is now available across sqlite, MySQL, and Postgres backends.
+* Highlighted **lower idle heap usage:** Idle heap usage should be lower because default event subscriber buffers are smaller.
+* Emphasized **safer startup and shutdown paths:** Mithril startup and shutdown behavior is safer around recoverable database edge cases.
+* Summarized **more robust sync and peer management:** Sync and peer-management behavior is safer because plateau recovery and DNS-fallback peer handling are more robust.
+* Reviewed **archive demo and release history updates:** The project now includes an archive-node demonstration plus refreshed release history coverage.
+
+### Recommended Network Compatibility ⚠️
+
+| Network             | Compatible |
+|---------------------|------------|
+| mainnet             | ⛔         |
+| preprod-testnet     | ⛔         |
+| preview-testnet     | ✅         |
+
+### 🙏 Thank You
+
+Thank you for trying!
+
+---
 
 ## v0.40.0 (May 5, 2026)
 

package/dingo.yaml.example

@@ -232,9 +232,10 @@ intersectTip: false
 
 # Maximum total size (in bytes) of all transactions allowed in the mempool.
 # Transactions exceeding this limit will be rejected.
-# Default: 1048576 (1 MB)
+# Default: 1048576 (1 MiB) for Praos modes; 26214400 (25 MiB) for Leios.
+# Leave commented to use the mode default; uncomment to override.
 # CLI: --mempool-capacity
-mempoolCapacity: 1048576
+# mempoolCapacity: 1048576
 
 # Forging tolerances (0 = defaults)
 # forgeSyncToleranceSlots controls how far the local chain can lag the upstream

package/docs/dashboards/README.md

@@ -151,7 +151,7 @@ Some metrics only emit when their feature is active. Panels display "No data" un
 |--------|---------------|
 | `cardano_node_metrics_Forge_node_is_leader_int` | Forging is enabled |
 | `cardano_node_metrics_Forge_adopted_int` | Block is forged and adopted |
-| `cardano_node_metrics_blockForgingLatency_seconds_bucket` | Block is forged |
+| `dingo_metrics_blockForgingLatency_seconds_bucket` | Block is forged |
 | `cardano_node_metrics_remainingKESPeriods_int` | KES key is configured |
 | `dingo_forge_tip_gap_slots` | Forging is enabled |
 | `dingo_database_size_bytes` | Database stores are initialized |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blinklabs/dingo",
-  "version": "0.41.0",
+  "version": "0.46.0",
   "description": "Dingo is a Cardano blockchain data node",
   "main": "index.js",
   "bin": {