A Stronger Foundation for Decentralized Communication

Better recovery, richer APIs, and a smoother experience for the people who keep ADAMANT running

Decentralized infrastructure does not become stronger through slogans. It becomes stronger when independent operators can run it reliably, developers can understand what it is doing, and applications can get the data they need without fragile workarounds.

That is the purpose of ADAMANT Node v0.10.2.

The new release improves synchronization recovery, introduces verified checkpoints for derived state, expands REST and Socket.IO capabilities, fixes several important API edge cases, optimizes database queries, and refreshes dependencies. Together, these changes make ADAMANT easier to operate and easier to build on — while preserving the protocol behavior that keeps the network compatible.

You can find the complete release and changelog on GitHub:

ADAMANT Node v0.10.2

Reliability is part of decentralization

A decentralized network depends on real people running nodes in different places, on different hardware, under different conditions. If node software requires constant intervention, expensive infrastructure, or expert-level recovery work, participation becomes harder — and the network becomes less decentralized in practice.

v0.10.2 improves one of the most important parts of the operator experience: recovery when something goes wrong.

Previously, an interrupted callback or database error in the synchronization pipeline could leave a node believing that it was still syncing even though its block height was no longer moving. The node could remain stuck until an operator noticed and restarted it.

The new release adds a progress-based synchronization watchdog. It distinguishes between a slow node that is still applying blocks and a genuinely stalled sync run. If no block-height progress is made for the configured window, the node safely aborts that run, drains any in-flight state mutation, and allows synchronization to start again.

We also fixed database rejection paths that could silently leave block-processing callbacks unfinished. The watchdog provides recovery; the improved error propagation removes an important source of the problem.

This is not a consensus change. It does not decide which blocks are valid. It helps a node return to normal operation when the surrounding execution pipeline stalls.

Faster recovery without changing the source of truth

ADAMANT nodes maintain derived mem_* tables for balances, delegates, rounds, and related state. The blockchain remains canonical, but rebuilding all derived state after an interrupted shutdown can take a long time on a mature chain.

v0.10.2 introduces rotating, persisted checkpoints for that derived state.

Each checkpoint is tied to a known block and network, carries a canonical digest, and is validated before it can be used. When a node starts with inconsistent memory mirrors, it can restore the latest verified checkpoint and replay only the blocks that came after it.

The safety model is intentionally conservative:

• A checkpoint is accepted only after its metadata, digest, chain reference, network, and state invariants are verified.
• Unconfirmed state is rebuilt rather than trusted from a checkpoint.
• If any validation or partial replay step fails, the node falls back to the existing full deterministic rebuild.
• Canonical blocks and deterministic replay remain the source of truth.

This gives operators a faster recovery path without turning a local cache into protocol state.

Better APIs for explorers, messengers, and monitoring tools

ADAMANT is more than a blockchain database. It is a decentralized trust layer for communication products and services. Those products need clear, predictable access to node state.

v0.10.2 adds a consistent top-accounts endpoint with deterministic ordering, pagination, delegate filtering, and count-only requests. Explorers and analytics tools no longer need node-specific workarounds to obtain this data.

The release also exposes the node’s active consensus codename, effective activation schedule, complete reward milestone schedule, and each delegate’s lifetime forged amount. Monitoring systems and explorers can now read the effective schedules directly from a node instead of duplicating configuration in every client.

Several existing delegate APIs are more accurate as well:

• Single-delegate responses once again report the real rank and productivity context.
• Delegate voter queries no longer risk returning unrelated accounts when an address-list filter is used.
• Next-forger projections now use the correct next-block height at round boundaries.

The blocks API received both a correctness and a performance improvement. It now handles numberOfTransactions=0 correctly, while a new composite database index prevents an expensive scan when querying an unknown generator with the default height ordering.

These changes make the API more useful without removing or renaming existing response fields.

Live data with less polling

Applications that need timely updates can now opt in to two new client Socket.IO event families:

• compact newBlock notifications;
• balances/change notifications for confirmed balance, unconfirmed balance, or both.

The node maintains dedicated subscription indexes and batches affected account reads around block apply and rollback. That means it does not have to scan every connected client or perform unnecessary account queries when nobody subscribed to the changed data.

The design is deliberately honest about delivery guarantees. These events are best-effort and non-durable. Applications should restore subscriptions after reconnecting and continue to reconcile critical state through REST. Live events reduce polling; they do not replace verification.

A cleaner dependency baseline

The release updates dependencies within their existing major versions, removes an unused direct npm runtime dependency and its large bundled subtree, and applies a narrow compatibility override for a transitive toolchain dependency.

The verified npm audit baseline moved from four moderate and one high finding to zero moderate, high, or critical findings.

No cryptographic protocol, signature, mnemonic, peer-handshake, or transaction-validation behavior was changed as part of this maintenance.

Is the update mandatory?

No. Updating to v0.10.2 is not mandatory for network compatibility.

This release does not introduce a consensus fork. It does not change block or transaction serialization, signatures, delegate ordering, rewards, fees, activation heights, slot timing, or deterministic replay.

Existing compatible nodes can continue participating in the network. We still recommend the update to operators who want better synchronization recovery, faster restoration after interrupted shutdowns, security maintenance, improved query performance, and the new API capabilities.

In other words: the network protocol remains compatible, while the software operating experience becomes stronger.

What operators should know

ADAMANT Node continues to require Node.js 22.13.0 or newer.

The first startup after upgrading applies new database migrations. Operators should follow their normal backup procedure, stop the node gracefully, wait for Cleaned up successfully, and allow enough time and disk space for the checkpoint tables and new indexes to be created.

After startup, verify node status, synchronization progress, live block processing, and any REST or Socket.IO capabilities used by connected services.

Full technical notes and the complete list of changes are available in the GitHub Release:

Read the ADAMANT Node v0.10.2 release notes

Developers can also use the updated resources:

• ADAMANT Node documentation
• ADAMANT API schema
• Technical release discussion

A better node makes a stronger network

v0.10.2 is not about changing ADAMANT’s principles or chasing headline benchmark numbers. It is about making community-owned infrastructure more dependable.

A node that can recover from a stalled sync is easier to operate. A verified checkpoint can turn a long rebuild into a shorter replay. More accurate APIs reduce integration mistakes. Efficient live events help applications react quickly without wasteful polling. A cleaner dependency baseline reduces avoidable risk.

Each improvement lowers the practical cost of participating in and building on ADAMANT. That is how decentralized software becomes stronger: not through central control, but through better tools for everyone who chooses to run it.

A Stronger Foundation for Decentralized Communication was originally published in ADAMANT on Medium, where people are continuing the conversation by highlighting and responding to this story.