[Feat, Enhancement] Nice Chart upgrade (Premium)

[dev-adamant-im]

Summary

Nice Chart logic is currently embedded in mm_trader and does not produce stable, natural-looking price action consistently. This issue proposes extracting that logic into a dedicated mm_nice_chart module, adding persistent market history, and introducing an independent simulation flow that generates an HTML report for visual comparison across multiple timeframes.

Motivation

The current behavior can create uneven candles, abrupt moves, and chart artifacts that do not resemble liquid market behavior. At the same time, exchange trade history endpoints usually provide only a short recent window, which is not enough for stable chart shaping over a 30-day visible horizon.

A separate Nice Chart module with database-backed history solves both architecture and quality problems: logic becomes reusable and testable, restart continuity improves, and future features (for example, external-asset-follow mode) can be added without reworking trader core behavior.

Detailed description

The core change is a service-style module in trade/mm_nice_chart.js that handles trade ingestion, candle construction, next-trade price calculation, and best-effort candle-close correction. mm_trader should call this module through soft dependency loading and immediately fall back to legacy behavior if the module is unavailable or returns invalid output. This preserves backward compatibility and avoids runtime failures.

History must be kept both in memory and in MongoDB, with 90-day retention and a 30-day working window for chart shaping. Runtime ingestion should deduplicate records and continue operating in degraded mode when fresh exchange data is temporarily unavailable, using accumulated history and emitting warning logs.

Price decisions from Nice Chart must stay within operational limits defined by spread boundaries, Price Watcher constraints, selected MM policy, and order book liquidity safety. Candle-close correction is best-effort in the last seconds of a candle and must not violate risk or execution safety rules.

An independent simulation feature should be added under trade/tests and runnable from manual.test.js via an explicit parameter. It must support two seed-data modes: a single snapshot from getTradesHistory() and getOrderBook(), or existing database history. The simulation output is an HTML page with a two-column layout: first row compares 15m Nice Chart vs 15m baseline, followed by Nice Chart views from 1m to 1d for qualitative evaluation.

Screenshots or videos

Examples of bad-looking chart

Biconomy, 15m timeframe DigiFinex, 1h timeframe

Compare to a good-looking BTC chart

Biconomy, 15m timeframe

Alternatives

Keeping Nice Chart inside mm_trader is the lowest-effort option, but it increases coupling, makes testing harder, and slows down future extensions. A loop-driven standalone module with its own scheduling is another option, but it introduces additional state complexity earlier than needed. The chosen middle-ground is a service module with controlled integration points and optional simulation tooling.

Proposed technical implementation

The implementation should introduce trade/mm_nice_chart.js as a service module with explicit lifecycle and computation boundaries. At startup, mm_trader performs a soft load of the module and initializes it with current config, tradeParams, pair metadata, and required adapters. If the module cannot be loaded or initialized, mm_trader keeps its current behavior without interruption.

The Nice Chart module should maintain a lightweight in-memory working state and a persistent MongoDB history store. Runtime ingestion takes normalized records from getTradesHistory(), deduplicates by stable identity (tradeId, timestamp, side/price fallback), and updates a rolling dataset with 90-day retention. Candle construction should be timeframe-agnostic and built from the same trade stream, so simulation and runtime logic share the same aggregation path.

getNextPrice() should return a constrained target envelope rather than an unconstrained raw value. The envelope is then intersected with spread limits, Price Watcher bounds, and policy-dependent order book constraints in mm_trader before order placement. Candle-close correction should be invoked in a best-effort window near candle end, but only when execution safety checks pass.

The simulation path should reuse the same Nice Chart service primitives to avoid divergence between test and production behavior. trade/tests/manual.test.js should route to a dedicated simulation runner via a parameter. The runner executes baseline and Nice Chart scenarios over identical inputs, computes chart-quality metrics, and generates a static HTML report in trade/tests/reports with the required two-column visual layout.

For extensibility, data access should be abstracted behind a small source adapter in mm_nice_chart (tradesSource, optional future candlesSource) so adding getCandlesHistory() later does not require changing price-shaping logic.

Notes

This issue is intentionally scoped to spot trading. Perpetual support is out of scope for this iteration. The design should still keep extension points for optional candle endpoints (getCandlesHistory()) and future external trend-follow behavior.

Documentation updates should be included for simulation run instructions, mode selection, and output location. Logging should follow existing project conventions with explicit module and function context.

The feature is planned for Premium bot edition, while basic bot will continue using regular Trader module.

Verification checklist

• mm_nice_chart is implemented as a separate module and integrated into mm_trader via soft dependency
• mm_trader continues to run correctly when mm_nice_chart is absent
• Trade history persists across restarts and is retained for 90 days
• Degraded mode works when fresh API history is unavailable and logs warnings
• Price output respects spread, policy, liquidity, and watcher constraints
• Candle-close correction is best-effort and does not bypass safety checks
• Independent simulation can be started from manual.test.js with a parameter
• Both seed modes are supported: snapshot API mode and existing DB history mode
• HTML report is generated with a two-column layout and includes 15m comparison plus 1m–1d Nice Chart views
• Lint/tests and simulation smoke checks pass in the target config

[adamantmm]

Premium Chart Feature

Summary

This issue proposes turning the existing Nice Chart logic into a dedicated premium-grade market-shaping module: mm_nice_chart.

The goal is to make market-maker generated charts look more natural, liquid, and visually trustworthy over longer time horizons. Instead of producing random or uneven trade sequences, the bot should shape price action into smoother, more realistic candles while still respecting spread limits, Price Watcher constraints, liquidity safety, and selected market-making policy.

The new module will extract chart-shaping logic from mm_trader, add persistent market history, introduce a simulation/testing flow, and prepare the architecture for advanced premium modes — including following the price behavior of a strong reference asset such as BTC or ETH.

Motivation

A healthy-looking chart is one of the strongest visual signals of market quality.

When candles look artificial, uneven, or chaotic, users may perceive the market as illiquid, manipulated, or abandoned — even if the bot is technically active. Abrupt moves, strange wicks, flat zones, and inconsistent candle structure can damage market confidence and make a trading pair look unattractive.

The current Nice Chart logic is embedded directly inside mm_trader, which limits testability, reuse, and future development. It also relies mostly on recent exchange trade history, while exchanges often expose only a short recent window. That is not enough to shape a stable 30-day visible chart.

A dedicated Nice Chart module solves both product and architecture problems:

• Improves the visual quality of generated price action.
• Makes candles look closer to liquid, organic markets.
• Preserves chart continuity across bot restarts.
• Allows long-window shaping using database-backed history.
• Makes the logic easier to test, simulate, and improve.
• Prepares the system for premium chart modes, such as following BTC, ETH, or another strong market reference.

In short, this feature turns chart quality from a side effect into a controllable market-making capability.

Detailed description

The core change is to introduce a service-style module:

trade/mm_nice_chart.js

This module should be responsible for trade ingestion, candle construction, historical state management, next-trade price calculation, and best-effort candle-close correction.

mm_trader should load the module through soft dependency loading. If the module is unavailable or fails to initialize, the bot should continue operating with the current behavior and without interruption.

At startup, mm_trader initializes mm_nice_chart with the current config, tradeParams, pair metadata, and required adapters. The module should expose clear lifecycle and computation boundaries so it can be used both in runtime and in simulation.

The Nice Chart module should maintain:

• A lightweight in-memory working state.
• A persistent MongoDB-backed history store.
• 90-day trade history retention.
• A 30-day working window for active chart shaping.

Runtime ingestion should take normalized records from getTradesHistory(), deduplicate them by stable identity, and update the rolling dataset. Candle construction should be timeframe-agnostic and based on the same trade stream used by both runtime and simulation logic.

getNextPrice() should not return an unconstrained raw price. Instead, it should return a constrained target envelope. This envelope is then intersected in mm_trader with:

• Spread boundaries.
• Price Watcher limits.
• Selected market-making policy.
• Order book liquidity safety.
• Other execution and risk constraints.

Candle-close correction should work as a best-effort improvement near the end of a candle. It may try to guide the final trade price closer to a cleaner candle close, but it must never violate risk limits, execution safety, spread constraints, or liquidity rules.

The implementation should also introduce a small data-source abstraction inside mm_nice_chart, for example:

• tradesSource
• optional future candlesSource

This allows future support for getCandlesHistory() without rewriting the core price-shaping logic.

Premium mode: Follow strong asset price action

A key premium extension is the ability to make a pair visually follow the price behavior of a strong reference asset such as BTC, ETH, or another high-liquidity market.

This mode does not mean blindly copying the reference asset price. Instead, the Nice Chart module should use the reference asset as a directional and structural guide for the local pair’s chart.

For example, if BTC or ETH is trending upward with healthy volatility, the bot can shape the local chart to show a similar upward bias, adjusted to the pair’s own spread, liquidity, and market-making limits. If the reference asset is ranging, the generated chart can also become more range-bound. If the reference asset sells off sharply, the module may reduce bullish pressure or follow the move within safe boundaries.

The goal is to make the chart feel connected to broader market behavior.

This can help a small or new market look more natural because many traders intuitively expect altcoins, meme tokens, and low-cap assets to react to BTC or ETH movements. A pair that moves completely independently from the broader market can look artificial. A pair that loosely follows a major asset feels more alive and market-aware.

The reference-follow mode should support configurable parameters:

• Reference asset, for example BTC/USDT or ETH/USDT.
• Follow strength.
• Maximum allowed deviation per candle.
• Volatility multiplier.
• Trend sensitivity.
• Delay or smoothing factor.
• Minimum and maximum local price boundaries.
• Risk-safe fallback behavior when reference data is unavailable.

The module should translate the reference asset’s recent movement into a local target envelope, not into a direct forced price. That envelope must still pass through all normal constraints:

• Spread limits.
• Price Watcher rules.
• Liquidity safety.
• MM policy.
• Order placement feasibility.
• Candle-close safety.

This ensures that reference-follow mode improves chart realism without turning the bot into an unsafe price pusher.

Example behavior:

• BTC rises steadily over several hours → local chart receives a mild upward bias.
• ETH breaks out with increased volatility → local chart may allow stronger but still bounded upward candles.
• BTC moves sideways → local chart favors calmer, range-like candles.
• BTC drops sharply → local chart avoids unnatural bullish candles and may follow the downtrend within configured risk limits.
• Reference data is stale or unavailable → Nice Chart falls back to local history-based shaping.

This feature should be implemented as an optional premium mode inside mm_nice_chart, not as hardcoded behavior in mm_trader.

Simulation and testing

The implementation should include an independent simulation flow for testing Nice Chart behavior without relying on live trading.

The simulation should allow developers to replay historical trades, generate candles, test next-price decisions, and compare different shaping modes. This is especially important for tuning chart quality, candle-close correction, and reference-follow behavior.

Simulation should help answer questions such as:

• Does the chart look natural over 1 hour, 24 hours, and 30 days?
• Are candles too flat, too volatile, or too artificial?
• Does the module avoid abrupt price jumps?
• Does candle-close correction improve the chart without unsafe behavior?
• Does BTC/ETH-follow mode produce believable market movement?
• Does the module recover cleanly after restart?

The same aggregation path should be used in both simulation and runtime, so test results reflect real bot behavior as closely as possible.

Expected result

After implementation, Nice Chart should become a dedicated, reusable, and testable chart-quality engine.

The market maker should be able to produce smoother, more organic-looking candles while preserving all operational safety constraints. Chart shaping should survive restarts, use a longer historical window, and support future premium features such as BTC/ETH-follow mode.

The final result should make supported markets look more liquid, more active, and more trustworthy — without compromising execution safety.

[adamantmm]

Nice Chart is now available in the Premium edition of the ADAMANT market-making bot.

The bot can shape price action so charts look more natural and liquid — smoother candles, fewer abrupt jumps, and a more convincing market picture for traders and token holders. History is preserved across restarts, so the chart stays consistent over time instead of resetting after every reboot.

For teams and projects that care about how their token looks on the exchange, Nice Chart turns volume-making from “just trades” into a polished, professional chart experience.