ADAMANT v0.10.0: We Rebuilt the Developer On-Ramp to Blockchain Messaging

A refreshed API, rewritten documentation, a one-command local network, and a fresh testnet — everything you need to start building on ADAMANT.

Decentralized messaging only matters if developers can actually build on it. So alongside ADAMANT Node v0.10.0, we didn’t just ship a node release — we overhauled the entire developer experience around it. New API specification, rewritten documentation, a local network you can spin up in minutes, and a freshly restarted testnet.

The goal is simple: make integrating with the ADAMANT blockchain-messaging ecosystem fast, predictable, and pleasant — whether you’re building a wallet, a bot, a notification service, or something nobody has thought of yet.

Here’s what landed.

A modern, interactive API specification

The API contract now lives as a clean OpenAPI 3.2 specification, published as an interactive Swagger UI at schema.adamant.im.

This isn’t just a version-number bump. The schema was audited end-to-end against the live node so what you read is what the network actually returns — accounts, transactions, chats, delegates, blocks, key-value storage, and node endpoints, all in one explorable reference.

A few things developers will feel immediately:

• Try requests right in the browser. The spec ships with live server selection — the UI pings every public node, shows its current API version, and auto-selects a healthy mainnet node so your “try it out” calls just work.
• Search across every operation by path, method, name, or summary — no more scrolling through a wall of endpoints.
• Generate typed clients for free. Because the source of truth is a real OpenAPI document, you can generate TypeScript (or other) client types straight from it and drop them into your project. ADAMANT’s own adamant-api-jsclient does exactly this.

Deeper node insight

Some of the most useful v0.10.0 additions are small fields with big ergonomic payoffs:

• timestampMs on transactions — millisecond-precision timestamps alongside the existing second-level timestamp. For a messenger where ordering matters, this lets clients sort messages and transfers with sub-second accuracy. Clients should prefer it when present and fall back to timestamp * 1000 otherwise.
• Richer node status — the node-status response now exposes nodeTimestampMs, unixTimestampMs, and a loader object that reports sync progress (syncing, consensus, blocks, blocksCount). Operators and tooling can now reason about a node's health and sync state at a glance.
• A GET /peers/get endpoint — look up a specific peer by IP and port, useful for building network monitors and connectivity tooling.
• Cleaner chat/transaction queries — new returnUnconfirmed and includeDirectTransfers parameters give clients precise control over what comes back.

These are backward-compatible additions: existing integrations keep working, and new ones get more to work with.

Documentation you can actually build from

The API is only half the story. We rewrote and expanded the documentation at docs.adamant.im, version-tagged to the node release, so the guides and the network never drift apart.

New and expanded material includes:

• Consensus and transaction validation — how blocks are agreed on and what makes a transaction valid.
• Syncing and the loader/status endpoint — understand exactly what a node is doing while it catches up.
• Run your own node — installation guides (including macOS), configuration, autostart, bootstrapping, and node recovery.
• timestampMs semantics — documented end-to-end so you handle time correctly from day one.

Spin up a network in minutes: localnet + testnet

This is the part we’re most excited about for builders.

• Localnet. You can now stand up a complete ADAMANT network on your own machine. Develop and test against a real blockchain without touching public infrastructure, without waiting on confirmations from a busy network, and without spending real ADM. Iterate fast, reset freely.
• A freshly restarted testnet. When you’re ready to move beyond your laptop, the public testnet is back and aligned with v0.10.0 — a shared, safe environment to validate integrations against real network conditions before you ship to mainnet.

Local → testnet → mainnet is now a smooth, well-documented path instead of a cliff.

What you can build

With a typed API, runnable networks, and real documentation, the practical scenarios open up quickly:

• Wallets and messengers — ADAMANT is a fully decentralized, end-to-end encrypted messenger on its own blockchain. Build clients that send encrypted messages and value in the same protocol.
• Notification and alerting services — push on-chain events (payments, messages) into your own apps.
• Trading and exchange integrations — programmatic account, balance, and transfer handling with millisecond-accurate ordering.
• Bots and automation — chat bots, payment bots, monitoring bots; ADAMANT’s ecosystem already includes trade bots and more, all speaking this API.
• Machine-to-machine and IoT messaging — a censorship-resistant, anonymous channel for devices to coordinate and pay each other.
• Anonymous, serverless communication — apps where there’s no central server to subpoena, leak, or shut down.

Because messages and payments share one protocol, a lot of these combine: a wallet that chats, a bot that pays, a device that messages and settles — all on the same rails.

Get started

• API reference: schema.adamant.im
• Documentation: docs.adamant.im
• Node source: github.com/Adamant-im/adamant
• JS client: github.com/Adamant-im/adamant-api-jsclient

ADAMANT v0.10.0 is more than a node release — it’s an invitation. The on-ramp is paved. Come build.

ADAMANT v0.10.0: We Rebuilt the Developer On-Ramp to Blockchain Messaging was originally published in ADAMANT on Medium, where people are continuing the conversation by highlighting and responding to this story.