Crypto exchange does not have to mean accounts, dashboards, browser sessions, or handing custody to a third party. With ADAMANT Exchange Bot, the exchange flow happens directly inside ADAMANT Messenger: a user sends one asset in chat, specifies the asset they want back, and the bot quotes, verifies, and pays out.

Today, we are releasing ADAMANT Exchange Bot v3.0.0 — a major new version of our self-hosted anonymous exchanger for the ADAMANT ecosystem.

This is more than a routine update. It is a full modernization of the exchange engine, with a strong focus on security, reliability, and real-world operator usability.

What makes this exchanger different

Most exchange products start with the web: accounts, forms, sessions, browser fingerprinting, and a large attack surface. We took a different route.

ADAMANT Exchange Bot runs inside messenger chats. There is no web interface, no user registration, and no KYC surface built into the product flow. The operator runs the bot on their own infrastructure and controls their own hot wallets.

That creates a very different experience:

• exchange requests happen directly in chat
• the interface is simple and familiar
• operators stay in control of infrastructure and funds
• the attack surface is dramatically smaller than a conventional web exchanger

For communities that value privacy, simplicity, and self-hosting, this model makes a lot of sense.

What is new in v3.0.0

This release delivers improvements across the whole stack.

On the user-facing side, the bot is now more forgiving and more practical in everyday use. We added a /cancel command so users can cancel a pending exchange when the bot is still waiting for clarification and receive an automatic refund minus the network fee. We also improved handling for abandoned or interrupted exchange flows, so stale deposits are less likely to leave users and operators in limbo.

On the operator side, configuration is stricter, startup checks are clearer, and resilience is better. The bot now validates its configuration more aggressively and fails fast when it sees a setup it cannot safely serve. It also handles node connectivity more robustly with automatic failover across multiple RPC or REST endpoints.

And under the hood, this is the strongest version of the exchanger we have shipped so far.

Built for real funds, not demo flows

When software moves cryptocurrency, “mostly works” is not good enough. Small race conditions or unclear transaction ownership rules can become real losses.

That is why a big part of v3.0.0 is about funds safety.

We introduced a more defensive deposit tracking and claim model, including mempool-aware monitoring and dispute handling. We also added per-UTXO locking for Bitcoin-like chains to prevent concurrent spends, and per-sender request serialization to eliminate chat-level race conditions around exchange and cancellation requests.

For Dash, the bot now supports InstantSend handling, allowing faster recognition of eligible transfers. We also added more explicit safeguards for unsupported-coin scenarios and transport-level failures, so the system fails in a more controlled and reviewable way.

In plain English: the bot is now much better at handling the messy edge cases that appear in production, especially when multiple events happen at the same time or infrastructure behaves imperfectly.

A modernized technical foundation

v3.0.0 is also a major technology refresh.

We moved the project to a current modern Node.js baseline and updated key blockchain and infrastructure libraries:

• Node.js 22.13+
• ethers v6 for Ethereum and ERC-20 handling
• bitcoinjs-lib v7 with PSBT for Bitcoin, Dash, and Dogecoin transaction construction
• MongoDB Driver 7
• adamant-api 3.x
• modernized linting, formatting, and test tooling

We also removed legacy pieces that no longer fit the project’s direction, including old Lisk-related support.

This matters because long-lived crypto infrastructure needs more than features. It needs a foundation that developers can maintain, audit, and extend without dragging years of technical debt behind it.

Supported assets and exchange flow

ADAMANT Exchange Bot supports exchanges involving:

• ADM
• BTC
• ETH
• DASH
• DOGE
• USDT
• USDC
• DAI
• ERC-20 tokens

The exchange flow is intentionally straightforward: the user interacts with the bot in ADAMANT Messenger, sends the source asset, specifies the target asset, and the bot processes the rest — quote, validation, confirmation tracking, payout, or refund if something prevents safe completion.

That simplicity on the surface is backed by a modular processing pipeline underneath: message parsing, quote generation, deep blockchain validation, confirmation tracking, payout handling, refund handling, and final settlement checks.

Better tested, better documented

This release also raises the bar on engineering discipline.

v3.0.0 ships with a substantially expanded automated test suite covering the exchange pipeline, crypto adapters, config validation, and helper logic. The project now has hundreds of unit tests across dozens of test suites, with no dependency on live blockchains or a real database during test runs.

We also refreshed the documentation and contributor guidance so operators and developers can understand the system more quickly and work with it more safely.

For an exchange product, that is not a side benefit. It is part of the product.

Why we built it this way

There is a growing demand for crypto tools that are:

• private by default
• easy to self-host
• operationally simple
• not dependent on a monolithic web platform

We believe chat-based financial tools are still underexplored. Messaging is already where people coordinate, transact, and automate. Building exchange functionality directly into that environment opens a different design space — one that feels lighter, more direct, and often more aligned with privacy-first communities.

ADAMANT Exchange Bot is our answer to that idea.

Available now

ADAMANT Exchange Bot v3.0.0 is available now as open-source software.

If you want to run your own anonymous instant exchanger inside ADAMANT Messenger, this release is the best place to start. It brings a more mature architecture, safer transaction handling, better recovery behavior, and a much cleaner operator experience.

Release: https://github.com/Adamant-im/adamant-exchangebot/releases/tag/v3.0.0
ADAMANT Messenger: https://adamant.im

The next generation of exchange tools does not have to live in a browser. Sometimes, a secure chat is the better interface.

We Just Released a New Anonymous Crypto Exchanger Inside ADAMANT Messenger was originally published in ADAMANT on Medium, where people are continuing the conversation by highlighting and responding to this story.

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.

ADAMANT is not chasing vanity throughput numbers. It is building a decentralized trust layer for communication — infrastructure that messengers, wallets, and communication forks can rely on without surrendering privacy to a central operator. v0.10.0 is a practical step in that direction.

Why this release matters

Better APIs for real messengers

Clients need precise transaction ordering, millisecond timestamps, and the ability to surface unconfirmed messages while a chat is still propagating across the network. v0.10.0 delivers:

• timestampMs — sub-second ordering for transactions without breaking the existing timestamp field.
• ?returnUnconfirmed=1 — list endpoints can include mempool transactions where appropriate.
• includeDirectTransfers — cleaner chat filtering without legacy withoutDirectTransfers quirks.
• count as a number — simpler client parsing across list endpoints.

These are the kinds of details that separate a demo blockchain from infrastructure you can ship in a production messenger.

Faster, more resilient networking

Nodes can now maintain WebSocket connections between peers, not only HTTP. That reduces latency for block and transaction propagation and gives operators more flexibility in how their nodes participate in the mesh. Combined with improved sync logic and a rewritten transaction pool, the node handles busy network conditions more predictably.

Operator tooling that respects your time

Running a node should not require a PhD in legacy JavaScript. v0.10.0 ships modernized installation and repair scripts for Ubuntu/Debian and CentOS/RHEL, localnet helpers for developers, config overrides for staged rollouts, and structured logging with rotation so you can actually diagnose problems at 3 a.m.

We also documented graceful shutdown practices. A forced kill -9 on a live node can corrupt in-memory state mirrors — v0.10.0 makes the right way to stop a node explicit in operator docs.

Security without drama

This release migrates cryptography to sodium-native bindings and tightens P2P transaction admission: timestamp checks that already protected the Public API now also apply when transactions arrive via peer gossip (#246). That closes a real-world pool-poisoning vector without touching consensus replay paths.

Dependency refreshes across multiple phases reduce exposure to known issues in the Node.js ecosystem.

Do delegates and node runners have to upgrade?

Recommended, not mandatory.

v0.10.0 does not introduce a new mandatory consensus fork for networks that are already synced and operating normally. Height-gated protocol behavior remains configuration-driven.

That said, we encourage delegates and independent node operators to upgrade when practical:

• Newer messengers and APIs expect v0.10.0 features (timestampMs, unconfirmed queries, WebSocket transport).
• Installation and logging improvements make day-two operations materially easier.
• Security hardening (native sodium, P2P admission checks) benefits the whole mesh even when consensus rules are unchanged.

Staying on very old node versions eventually means supporting clients alone — and missing the reliability work the community ships in releases like this one.

Technical highlights at a glance

Area / What changed

Runtime Node.js ≥ 22.13.0 required (Node 18 dropped)

API timestampMs, returnUnconfirmed, includeDirectTransfers, numeric count

P2P WebSocket peer transport; timestamp admission on gossip path

Ops Modern install/fix scripts, localnet, live test scenarios, config overrides

DX AGENTS.md, expanded CONTRIBUTING, structured logging

Cleanup Deprecated HTTP endpoints removed; docs.adamant.im is the documentation home

Full structured notes and the complete PR list: GitHub Release v0.10.0

Get started

• Existing operators: review upgrade notes, upgrade Node.js, pull v0.10.0, restart gracefully.
• New operators: use the official install scripts from the release tag.
• Developers: see CONTRIBUTING.md for localnet and live scenario testing.

ADAMANT grows when its infrastructure is boringly reliable — when anyone can run a node, delegates forge with confidence, and clients trust the network beneath them. v0.10.0 is built for that kind of decentralization: not marketing fluff, but the unglamorous work that keeps private communication free.

ADAMANT is community-owned infrastructure. Questions, issues, and contributions welcome at github.com/Adamant-im/adamant.

ADAMANT Node v0.10.0: 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.

A release built around real-world usability

What makes this release important is its focus on fundamentals. ADAMANT v4.11.0 strengthens networking behavior, modernizes the UI across the app, removes deprecated product scope, upgrades the build and contributor toolchain, and expands regression coverage for both desktop and mobile surfaces. In other words, this is a release designed to make the app feel more dependable, more coherent, and easier to evolve further.

Stronger node resiliency and better network behavior

One of the biggest improvements in v4.11.0 is node reliability. The release adds alternative IP failover for nodes when domain access is unavailable, improves the healthcheck lifecycle and timeout handling, and strengthens recovery after device sleep or offline states. It also refines node status messaging and reduces false sync signals in the Nodes screen. The official release notes separately list the same direction of work through items such as health-check improvements, node status fixes, and alt_ip accessibility checks.

For users, this matters a lot more than it may sound at first glance. Messaging and wallet apps are judged not only by features, but by how they behave when the network is unstable, when the device wakes from sleep, or when a node becomes temporarily unreachable. This release directly targets those failure points, making ADAMANT more resilient in the kinds of messy real-world conditions that often define everyday usage.

A cleaner and more modern interface

Another major pillar of v4.11.0 is UI modernization. The release merge PR highlights broad visual improvements across chats, wallets, send-funds flows, settings, dialogs, and navigation. It introduces shared design tokens, tighter spacing rules, improved typography, layout primitives, and theming cleanup driven by CSS variables. It also adds wider layout regression coverage to help preserve UI quality in future releases. The official release page echoes this with its “Unify styles, modernize UI/UX, fix visual inconsistencies” task grouping.

This kind of work is easy to underestimate, but it is what makes an application feel mature. A modern product is not only about new screens or features — it is about visual consistency, predictable spacing, clear hierarchy, and the absence of small UX irritations that build up over time. ADAMANT v4.11.0 clearly invests in that level of refinement.

Better chat experience where it matters

The messaging side of ADAMANT also receives meaningful attention in this release. The PR notes improvements to opened-chat layout, message status handling, retry indicators, emoji picker behavior, reply overflow handling, public key loading, message grouping, and safer composer keyboard behavior. It also fixes stale date refresh behavior and null-scroll regressions when switching chats rapidly. Several of these changes are mirrored in the release notes through grouped bug fixes and feature entries tied to chat behavior and layout quality.

These are the kinds of upgrades that may not dominate a headline, but they strongly affect daily perception of quality. When chat dates refresh correctly, replies do not break markup, fast switching between conversations does not cause errors, and grouped messages improve readability, the whole messenger feels smoother and more trustworthy.

Wallets and send-funds flows got more polished too

Financial screens also received substantial polish in v4.11.0. The release PR mentions improved wallet cards, wallet tabs, balance states, transaction list layout, and send-funds spacing. It also fixes self-transfer amount normalization for BTC, DOGE, and DASH, addresses transaction navigation and localized UI regressions, and normalizes persisted wallet symbols on restore to keep upgraded state consistent. The official release notes list matching fixes for those same wallet and transaction issues.

That matters because wallet UX is one of the most sensitive parts of any crypto-enabled application. In a messaging app with integrated asset flows, clarity and consistency are essential. Even small navigation or amount-display issues can erode confidence. This release shows a strong effort to make those flows feel cleaner, safer, and more predictable.

Klayr support was removed end-to-end

A notable product-scope decision in this release is the full removal of Klayr (KLY) support. The release merge PR states that Klayr support was removed across wallets, nodes, transactions, configs, icons, queries, node clients, store paths, and related UI. The official release page also lists “Remove Klayr (KLY) support in full” as a dedicated task completed for v4.11.0.

From a product perspective, this is a sign of maturity rather than reduction. Healthy software evolves not only by adding features, but also by removing outdated scope that no longer justifies its maintenance burden. Pruning legacy paths helps simplify the codebase, reduce user-facing complexity, and free up focus for the features and networks that matter most.

A more modern toolchain for contributors and releases

Behind the scenes, v4.11.0 also modernizes the project’s development and release infrastructure. The PR explicitly calls out the upgrade from Node.js 20 to 22, dependency refreshes, migration to ESLint 9, Electron build updates, improved logging and CSP behavior, universal macOS build support, expanded Playwright smoke and regression workflows, and refreshed release automation. The official release notes separately confirm the Node.js 22 upgrade, ESLint 9-related fixes, and the broader tooling upgrade scope.

These improvements are not just internal housekeeping. A stronger toolchain means fewer build issues, better testing discipline, cleaner maintenance, and more confidence when shipping future updates. For an open-source product, that is a major part of long-term sustainability.

Documentation and project readiness also moved forward

The release also includes updated project documentation. According to the merge PR, README.md was refreshed with clearer positioning, self-hosting guidance, community deployment notes, CSP guidance, and platform build instructions. The repository also added AI operating guidelines in AGENTS.md, while release metadata for 4.11.0 was refreshed as part of the delivery scope. The official release page lists those documentation tasks as well.

That is another good sign for the project: v4.11.0 is not only about shipping code, but also about making the repository easier to understand, contribute to, and operate. Strong documentation is a force multiplier for any community-driven product.

Why this release matters

ADAMANT v4.11.0 is important because it improves the product where users feel it most: reliability, consistency, and day-to-day comfort. It reduces fragility in node behavior, makes the interface cleaner, strengthens chat and wallet flows, modernizes the engineering base, and trims outdated scope. The result is not just a newer version number — it is a stronger foundation for everything that comes next.

Final thoughts

Not every major release needs a single headline-grabbing feature. Sometimes the most valuable progress comes from deep product care: fewer edge-case failures, less visual noise, better recovery behavior, cleaner flows, and a healthier codebase.

That is exactly what ADAMANT v4.11.0 delivers.

It is a release about making the product more solid, more polished, and more future-ready — for users, contributors, and the broader ADAMANT ecosystem alike.

Thanks to all contributors!

ADAMANT v4.11.0: More Reliable, Polished, Mature was originally published in ADAMANT on Medium, where people are continuing the conversation by highlighting and responding to this story.

In ADAMANT Market-making bot, we already support dynamic order book management, spread control, liquidity provisioning, and volume strategies. But without accurate fill analytics, we only see half the picture.

Issue #87 introduces a major architectural upgrade:

Implementation of a VWAP engine and Order Fills engine (Premium module)

This is not just a feature. It is a foundation for professional-grade execution analytics.

Overview. Why VWAP?

Most exchange APIs provide fragmented information:

• Orders may be partially filled
• Status updates can lag
• Some exchanges return incomplete execution data
• Restarts can cause loss of internal execution context

If a bot does not persist and verify fill data correctly:

• PnL becomes inaccurate
• Position tracking becomes unreliable
• Risk management logic breaks
• Spread and liquidity adjustments are based on assumptions, not reality

To operate at an institutional level, we use:

1. Persistent execution tracking
2. Verified fill reconciliation
3. Proper VWAP computation
4. Inventory-aware analytics

The solution: Dedicated VWAP & Fills engine

Issue #87 proposes introducing a dedicated subsystem responsible for:

1️⃣ Raw fill event storage (Append-Only)

A dedicated fillsDb:

• Stores raw execution events
• Works in append-only mode
• Persists across restarts
• Does not immediately aggregate data

This ensures no execution data is lost or overwritten.

2️⃣ Exchange verification layer

Each fill event must be:

• Verified against exchange API
• Confirmed as fully or partially executed
• Marked as processed only after confirmation

This prevents false-positive fills when:

• Bot has no connectivity
• Exchange nodes are unavailable
• API responses are incomplete

Execution verification only happen when:

• Network connectivity exists
• Exchange endpoints are reachable

Otherwise, we risk incorrectly marking valid trades as failed.

Core function:

/**
 * Verifies a fill order using exchange API.
 *
 * Policy "always verify if possible":
 *  - If api.getOrderDetails() is missing -> cannot disprove -> treat as confirmed
 *  - If status missing or exception -> return undefined (try again later)
 *  - If API says 'filled' -> confirmed
 *  - If API says explicitly not filled ('new'|'part_filled'|'cancelled') -> rejected
 *  - If API says 'unknown' -> keep (cannot disprove) but warn
 *
 * @param {FillOrder|Object} order Fill order record or Order object
 * @param {any} api API instance (spot first/second account, or other compatible trader api)
 * @param {string} callerName Log context id (usually module and method which calls) to quickly find related logs
 * @returns {Promise<VerifyFillResult | undefined>}
 */
async function verifyOrderFilled(order, api, callerName)

3️⃣ Aggregated execution statistics

A second persistent store filledStatsDb accumulates:

• Total base asset bought
• Total base asset sold
• Total quote asset spent/received
• Counters of full/partial/rejected/missing fills

From this, we compute core metrics.

Core Metrics

Metrics overview:

/**
 * Creates a base FillsEngineStatsResult object with zeroed / default values.
 *
 * @param {string} statsId Format: `${exchange}:${pair}:${purpose}:${startTs}`
 * @param {string} pair Trading pair, e.g., `BTC/USDT`
 * @param {FilledStatsRecord | undefined | null} stats Epoch stats (optional)
 * @returns {FillsEngineStatsResult}
 */
function createBaseEpochStats(statsId, pair, stats) {
  return {
    statsId,
    pair,
    updatedAt: stats?.updatedAt || 0,

    buy: stats?.buy ? { ...stats.buy } : emptySide(),
    sell: stats?.sell ? { ...stats.sell } : emptySide(),

    // Calculated later
    boughtVwap: 0,
    soldVwap: 0,

    hasBothSides: false,
    vwapSpread: 0,
    vwapSpreadPercent: 0,

    pnlQuoteCashflow: 0,
    inventoryBase: 0,
    markPrice: undefined,
    pnlQuoteMtm: undefined,
  };
}

📊 VWAP (Volume Weighted Average Price)

VWAP per side: Buy VWAP and Sell VWAP.

Formula:

VWAP = Total Quote Volume / Total Base Volume

This reflects actual execution quality, not just order placement price.

📉 VWAP spread

Difference between Buy VWAP and Sell VWAP.

This shows real realized trading spread, not theoretical spread.

📦 Inventory Delta

Difference between Total base bought and Total base sold.

Used for:

• Risk management
• Position exposure tracking
• Rebalancing logic

💰 Realized PnL

Cashflow-based result from executed trades.

And optional Mark-to-market PnL using current market price.

Why Fills engine matters

Without proper fill analytics, a trading bot operates in partial darkness. It may place orders efficiently, but it has no real understanding of how those orders are actually executed in the market.

A well-designed VWAP engine changes that dynamic completely. It allows the system to measure execution quality with precision, evaluate real performance instead of theoretical placement, and base its logic on confirmed trading activity.

This becomes critically important in environments where the bot is used for token market making, where execution quality directly impacts perceived liquidity and price stability.

Advanced strategies such as liquidity bucket management or dynamic spread maintenance rely heavily on accurate execution data to function correctly. For premium trading modules, execution analytics is not a bonus feature — it is a core requirement for professional-grade operation.

Architectural Impact

The new engine is designed as a fully modular component that integrates cleanly into the existing architecture without disrupting the current order placement logic. It operates alongside existing systems rather than replacing them, preserving stability while adding a deeper analytical layer.

At the same time, this architecture lays the groundwork for future expansion. It transforms TradeBot from an order placement tool into a true execution analytics system.

Simplified diagram representation:

          Exchange API
                │
                ▼
       Order Placement Engine
                │
                ▼
         Fills Collector
                │
                ▼
       Verification Engine
                │
                ▼
         Aggregation Engine
                │
                ▼
      VWAP / Inventory / PnL
                │
                ▼
    Risk & Strategy Modules

Conclusion

Issue #87 represents a major step toward institutional-grade trading infrastructure inside ADAMANT TradeBot. We significantly improve robustness, transparency, and strategic capability.

This is a foundational upgrade — not a cosmetic enhancement.

The feature is available in the Premium mm bot version.

If you want to use the ADAMANT Market-making bot for your token, start with the free basic version.

Building VWAP & Order fills engine in ADAMANT Market-making bot was originally published in ADAMANT on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction

The open-source project ADAMANT recently raised an important infrastructure task in Issue #148 on GitHub. As the project evolves, maintaining a robust testnet environment becomes critical. This article walks through the key motivations and provides a ready-to-use bootstrap image for developers and contributors.

Why the Testnet matters

A healthy testnet is the foundation of reliable blockchain development. In the issue description, the maintainers note:

“The ADAMANT testnet infrastructure needs to be updated and stabilized to support development, testing, and community contributions.”

They also emphasise that:

“Developers and contributors require easy access to test ADM coins and a straightforward way to bootstrap their nodes.”

These statements underscore two key points:

• Accessibility: New contributors should be able to spin up a node quickly without complex setup
• Stability: The test nodes must run reliably so that testing mirrors production-like conditions

What’s provided: Bootstrap image for ADM Testnet

To support easier onboarding, a snapshot of the testnet database has been made available for download:

Download link:

https://testnet.adamant.im/db_test_backup.sql.gz

Using this image, you can bootstrap a fresh node that’s already synced to the testnet state — significantly reducing the time to get started.

How to bootstrap your Testnet ADM node

Here is a suggested workflow to get your testnet node boostrapped after you installed it.

Download the bootstrap testnet database snapshot:

wget https://testnet.adamant.im/db_test_backup.sql.gz

Unzip the image:

gunzip db_test_backup.sql.gz

Finally load the image into the testnet node’s database:

psql adamant_test < db_test_backup.sql

List of public Testnet nodes

The ADAMANT testnet provides a predefined list of public nodes for peer discovery, network synchronization, and API access for applications. The primary source of this list is the official configuration file:

adamant/test/config.default.json at dev · Adamant-im/adamant

As of the time of writing, the testnet node list contains the following entries:

"list": [
  {
    "ip": "162.55.32.80",  // adm-testnode1 (testnode1.adamant.im), testnet explorer
    "port": 36667
  },
  {
    "ip": "81.0.247.181",  // adm-testnode2 (no domain, IP only, public API disabled)
    "port": 36667
  },
  {
    "ip": "95.217.19.144",  // adm-testnode3 (testnode3.adm.im)
    "port": 36667
  }
]

Example endpoints for apps:

• http://95.217.19.144:36667/api/node/status
• https://testnode3.adm.im/api/node/status (same node by domain)

Run tests

If you are contributing or validating features, run the unit tests and API tests against your node, as per the project’s guidelines.

Request Testnet ADM coins and access the app

You can request 3500 ADM on testnet using the same faucet as mainnet https://adamant.im/free-adm-tokens.

Access Testnet messenger app: https://dev-adamant-testnet.surge.sh — autobuild from dev branch.

Testnet explorer: https://testnet.adamant.im

Happy testing! 🚀

Updating the Testnet Infrastructure for ADAMANT was originally published in ADAMANT on Medium, where people are continuing the conversation by highlighting and responding to this story.

Since the first lines of code were written in 2017, ADAMANT has sought to prove that everyday messaging, payments and data exchange can be friction-free and sovereign. Eight years later, the project’s roadmap now spans mature products, an expanding ecosystem, and a newly community-driven governance model. Below is a compact look back — and a clear look forward — at where ADAMANT stands today and where it is headed next.

Here is the updated Roadmap: https://adamant.im/roadmap

From Conception to Reliable Multiplatform Wallets

(2017 — Q1 2024 )

By the end of Q1 2024, ADAMANT had evolved from a single-purpose blockchain messenger into a battle-tested, multi-asset communications stack with native wallets, exchange tools, and business-grade automation.

Since the ADAMANT conception in 2017, our mission has been rooted in privacy, transparency, and technological independence. We launched the ADAMANT mainnet in Q4 2017 and have since introduced many groundbreaking features:

• In-chat crypto transactions supporting multiple currencies (BTC, ETH, DOGE, DASH, LSK, BNB, and more)
• Messenger and wallet apps for iOS, Android, PWA, and desktop
• Blockchain 2FA, market-making bots, and decentralized services
• Support for Tor and anonymous access
• Console tools, API libraries, and full-node management

By Q1 2024, we had shipped:

• New website and media kit
• Major releases of PWA and iOS apps with heightened reliability
• Airdrop tools, health checks, and reactions
• ADM listings on major exchanges like Coinstore, DigiFinex, FameEX, and Tapbit

It might be interesting to read:

• Are Present Online-Messengers Safe?
• Secure Messengers Do Not Exist — They’re Impossible
• Ideas and beliefs of ADAMANT
• 40 ETH contest is over: Privacy beats Hackers 1–0
• ADAMANT is a Blockchain for Business
• Decentralized messaging needs a time

Q1 2024 → Q1 2025: A Year of Deepening Reliability

Significantly, Q1 2025 marked the dissolution of the ADAMANT Foundation, transitioning us fully to community-driven development — a true milestone in our decentralization journey.

The last year has been pivotal for expanding infrastructure and decentralization:

• PWA v4.5 and iOS v3.5–3.10: Introduced wallet lists, stronger encryption, and IPFS file transfers
• Major bot updates: Market-making bot v6 and v7, CoinOptimus v2
• Multiple ADM exchange listings: Biconomy, BigONE, Hotcoin, KoinBX, and more
• Launch of supporting products: MarketMaking.app, Currencyinfo.dev, and Console v3.0
• JavaScript API v2.4, Node v0.9, and Ethereum indexer v2.4.1 released
• IPFS integration in iOS and PWA for decentralized file sharing
• Partnership with Massa Chain and Messenger deployment in DeWeb and GitHub

Q2 2025 → Q1 2026: What Comes Next

By Q1 2026, ADAMANT users will enjoy always-reachable, censorship-resistant messengers backed by faster nodes, protocol-level anti-spam, and first-class cold-storage support — all steered by an open community.

And, the most important, we are targeting to provide free, more private messaging over existing blockchain bandwidth.

Q2 2025: Censorship-resistant delivery & performance

Partnership with Massa Chain for DeWeb hosting; WebSocket node-to-node protocol (Node 0.10); split-screen PWA 4.10; iOS 3.11 UX tweaks; first testnet PWAs; extra download mirrors (GitHub, adm.im).

Q3 2025: Reliability & automation

Push notifications for PWA; local-storage fast login (iOS); ANS — ADAMANT Notification Service; reproducible builds auto-deployed to Massa DeWeb, adm.im & Google Play; Forging Pool 3.1; ADM Airdrop 3.0; Currencyinfo.dev portal for devs; groundwork for business integrations.

Q4 2025: Freedom-first messaging

Free, more private messaging over existing blockchain bandwidth; secret wallets & biometric login (PWA/iOS); WalletConnect on iOS; Explorer 2.0; anti-spam at protocol level; AIP-20: group chats opens social layer.

Q1 2026: Cold-grade security & fee overhaul

Offline signing + Cold-wallet mode (PWA); WalletConnect in PWA; AIP-19 to modernise fee calculation and cut delegate costs; on-chain group chat/channel prototypes; dedicated wallet website.

From Q2 2026 Onward: Vision & Stretch Goals

(2026–2027, long-range possibilities, subject to community votes and funding)

• Deletable & pinnable chats, ADAMANT Mixer for on-chain obfuscation, secure note/password vault, Bot Factory API, and a Tor-native site + campaign.
• Random Chat rollout, global ad and sponsorship push, renewed pool promotions, deeper enterprise pilots.
• ADM on top-tier CEXs
• “ADAMANT Naming” human-readable addresses, multi-account UI.
• Blockchain-signed document vaults, voice calling, and a third-party security audit to certify the full stack.

The Road Ahead

ADAMANT’s past year underscored its capacity to ship complex features — IPFS transfers, WebSocket networking, self-healing health-checks — while simultaneously reinventing its governance. The upcoming four quarters focus on censorship resistance, flawless reliability, and friction-less onboarding. Beyond that, the roadmap sketches ambitious — but attainable — innovations in privacy, identity and real-time communication.

ADAMANT continues to evolve as a beacon for privacy, decentralization, and censorship resistance. Every line of code, every update, and every user counts in this journey.

With an increasingly engaged community now steering the helm, ADAMANT seems poised to turn the “possible” column of its roadmap into tomorrow’s everyday features — one quarter at a time.

We invite you to explore our tools, follow the roadmap, and join a growing movement of cypherpunks, crypto enthusiasts, and freedom advocates building a more private digital future:

Roadmap: https://adamant.im/roadmap

X (Twitter): @adamant_im

Stay tuned. Stay private. Stay ADAMANT.

ADAMANT Roadmap Update: Steady Progress, Fresh Momentum was originally published in ADAMANT on Medium, where people are continuing the conversation by highlighting and responding to this story.

Tested on: macOS 13 Ventura and newer
Node type: mainnet or testnet
Time required: ~15–30 minutes

See also:

• How to run ADAMANT Node on Ubuntu or CentOS Linux
• How to run ADAMANT node on Windows

Preparation

Running an ADAMANT node helps support a fully decentralized, privacy-focused blockchain powering the ADAMANT Messenger. It strengthens the network, gives you direct access to blockchain data, and allows to receive dPoS rewards if you become a validator/delegate.

Prerequisites

• Mac computer with macOS 13 (Ventura) or newer
• User account with administrator privileges
• Stable internet connection
• Around 50 GB of free disk space
• Basic comfort with using Terminal (no prior experience required — we’ll walk you through it)

How to Open Terminal

To run the commands in this guide, you’ll need to use the Terminal app:

1. Press Cmd + Space to open Spotlight Search
2. Type Terminal, then press Enter
3. You’ll see a window with a command prompt like this:

your-mac:~ yourname$

This is where you’ll copy and paste the commands provided in the next sections.

Install Apple Command Line Tools

Apple’s developer tools are required to compile code and use Git.

xcode-select --install

A pop-up will ask you to confirm installation. Accept it. Wait until it’s complete before continuing.

Install Homebrew

Homebrew is a package manager for macOS, used to install PostgreSQL and other dependencies.

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Confirm with Enter key. After installation, follow the instructions it prints in the “Next steps” section (usually to add Homebrew to your shell config like ~/.zprofile or ~/.bash_profile).

Reload your shell:

source ~/.zprofile  # or ~/.bash_profile depending on your shell

Install Required Packages

Install PostgreSQL, Redis, Git, and other necessary tools:

brew install postgresql redis git make automake autoconf libtool jq htop

Start and enable PostgreSQL and Redis:

brew services start postgresql
brew services start redis

Set Up PostgreSQL Database

Create a PostgreSQL user and database for ADAMANT (run command-by-command):

# Customize these as needed
DB_USER=adamant
DB_NAME=adamant_main
DB_PASSWORD=securepassword

psql postgres -c "CREATE ROLE $DB_USER LOGIN PASSWORD '$DB_PASSWORD';"
psql postgres -c "CREATE DATABASE $DB_NAME OWNER $DB_USER;"

Install NVM and Node.js

Install Node Version Manager (NVM) and the Node.js 22 LTS (codename Jod):

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash
source ~/.nvm/nvm.sh
nvm install 22

Install pm2 (Node.js process manager):

npm install -g pm2

Set up pm2 log rotation (optional but recommended):

pm2 install pm2-logrotate
pm2 set pm2-logrotate:max_size 500M
pm2 set pm2-logrotate:retain 5
pm2 set pm2-logrotate:compress true
pm2 set pm2-logrotate:rotateInterval '0 0 0 1 *'

Clone and Set Up ADAMANT Node

You can install the ADAMANT node anywhere you prefer. For a more organized setup, we’ll use the ~/Applications directory (a personal folder in your home directory—not the system-wide /Applications).

mkdir -p ~/Applications
cd ~/Applications

Now clone the ADAMANT repository from GitHub into the selected directory (run command-by-command):

# Customize these as needed
NETWORK=mainnet   # or testnet
BRANCH=master     # or desired Git branch

git clone https://github.com/Adamant-im/adamant --branch $BRANCH
cd adamant
npm install

This creates a folder named adamant with the ADAMANT node software inside your ~/Applications directory, and installs project dependencies:

Next, set the ADM node config file:

cp config.default.json config.json
sed -i '' "s/\"password\": \"password\"/\"password\": \"$DB_PASSWORD\"/" config.json

This will clone default config file into your own, and enter the DB password you’ve set earlier.

You can also edit config manually in nano text editor:

nano config.json

Note, if you want running a testnet node, use these commands instead:

cp test/config.default.json test/config.json
sed -i '' "s/\"password\": \"password\"/\"password\": \"$DB_PASSWORD\"/" test/config.json

Download Blockchain Snapshot (Optional, Mainnet Only)

If you really want to support the decentralization, skip this step.

This speeds up ADAMANT blockchain syncing:

curl -O https://explorer.adamant.im/db_backup.sql.gz
gunzip db_backup.sql.gz
psql $DB_NAME < db_backup.sql
rm db_backup.sql

This step will take up to 20 minutes, but save a week of sync process.

Running ADM node

Finally, you can run the ADAMANT node on your Mac. To ensure everything went smooth, run it temporary right in Terminal:

node app.js

If everything right, you’ll see something like this:

And you’ll notice that blockchain is syncing and node height arises:

Now you can stop running node in Terminal with Ctrl + C command, and start the ADM node with pm2—this will allow it running even when you closes Terminal:

# Mainnet
pm2 start --name adamant app.js

# Or, for testnet
# pm2 start --name adamanttest app.js -- --config test/config.json --genesis test/genesisBlock.json

Save the pm2 process list:

pm2 save

Verify that it’s running well:

pm2 logs adamant

Restart Node After macOS Reboot

This step allows automatically restart ADAMANT node if you reboot your Mac.

Option 1: Manual Start After Reboot

Each time your Mac restarts, run:

source ~/.nvm/nvm.sh
pm2 resurrect

You can automate this by adding the above lines to your shell profile (e.g., ~/.zprofile):

echo 'source ~/.nvm/nvm.sh && pm2 resurrect' >> ~/.zprofile

Option 2: Automatic Startup with pm2 startup

pm2 has a startup command, but it may not work seamlessly with macOS System Integrity Protection (SIP). Instead, you can create a launchd service:

pm2 startup launchd

It will output a command like: sudo env PATH=$PATH:/Users/youruser/.nvm/versions/node/vXX.X.X/bin pm2 startup launchd -u youruser — hp /Users/youruser. Run it in Terminal.

Then save pm2 process list:

pm2 save

pm2 will now restart your ADAMANT node automatically on boot. If you want to cancel it some time later, run: pm2 unstartup launchd.

Verify Installation

Check status:

pm2 show adamant

Check node block height:

curl http://localhost:36666/api/blocks/getHeight

Get node status:

curl http://localhost:36666/api/node/status

You’ll see: {“success”:true,”nodeTimestamp”:245014273,”loader”:{“loaded”:true,”now”:3631,”syncing”:true,”consensus”:0,”blocks”:47102906,”blocksCount”:0},”network”:{“broadhash”:”bd330166898377fb28743ceef5e43a5d9d0a3efd9b3451fb7bc53530bb0a6d64",”epoch”:”2017–09–02T17:00:00.000Z”,”height”:46966,”fee”:50000000,”milestone”:0,”nethash”:”bd330166898377fb28743ceef5e43a5d9d0a3efd9b3451fb7bc53530bb0a6d64",”reward”:0,”supply”:9800000000000000},”version”:{“build”:””,”commit”:”44ebedfa7714aaa817628dba40208a62f428259f”,”version”:”0.9.0"},”wsClient”:{“enabled”:true,”port”:36668}}

The “syncing”:true means that your node is not yet synced, wait for full blockchain synchronization. If you’ve chosen using Blockchain Snapshot, it will be much faster to finish.

🎉 You’re Done!

You’ve successfully installed and configured an ADAMANT node on your macOS system. Thank you for supporting decentralized messaging!

Read further:

• Node documentation
• How to Become an ADAMANT Delegate/Validator

How to Install an ADAMANT Node on macOS was originally published in ADAMANT on Medium, where people are continuing the conversation by highlighting and responding to this story.

Dear Onyx Community,

I left the Onyx project. Next, VT will take a more proactive position.

Under my leadership, Onyx has experienced fascinating ups and downs. I’m sure the best is yet to come.

Thank you for support.

I will continue my development path.

See you on the vastness of Web3.

Alex.

The Onyx DAO has agreed in the previous v2 launch plan to ensure there is a method of recovery for v1 users to reclaim their capital from the previous exploit due to the rounding error of the oPEPE market launch.

Outlined below will be a comprehensive plan to ensure those v1 users will be reimbursed in their totality based on the Onyx Protocol’s revenue.

Recovery Plan

• All oToken user balances will be snapshotted based on the date of incident
• USD calculations will be made based on the market prices from the incident, with the exception of XCN, which will be compensated 1-to-1 in the XCN units
• Every quarter the Onyx DAO will make a proposal to withdraw protocol revenue, convert it to USDT and distribute via an airdrop to those addresses collected in step 1
• The Onyx DAO will make an additional recovery airdrop to use the DAO Treasury to enhance the recovery airdrop of no less than $100,000 distributed in XCN
• Based on this formula the latest it should take is approximately 20 quarters for a full recovery for users.

The first recovery plan will be initiated in April 2024 and following every quarter thereafter. This will allow the v1 users to be reimbursed in full based on their loss amounts during the Onyx Protocol incident. We hope to use this as a stepping stone to ensure safety and stability to the Onyx Protocol ecosystem.