How do I set up a merged mining dashboard for tracking revenue by coin and difficulty in real time?

To set up a merged mining dashboard that tracks revenue by coin and difficulty in real time, you need three parts:

1. Data collection from the mining software / node / pool APIs
2. Processing to calculate revenue, hash rate, difficulty, and profitability per coin
3. Visualization in a dashboard that refreshes continuously

Here’s a practical setup.

---

1) Define what you want to track

For merged mining, you usually want metrics like:

• Primary coin
• Auxiliary coins being merged mined
• Per-coin hashrate
• Current network difficulty
• Block reward
• Estimated revenue/day
• Realized revenue
• Stale/rejected shares
• Share difficulty / effective difficulty
• Payouts received
• Profit per coin and total combined profit

If you want “real time,” decide whether you mean:

• seconds-level monitoring of shares/hashrate, or
• minute-level profitability updates

Most mining dashboards update every 10–60 seconds for operational metrics and every 1–5 minutes for profitability.

---

2) Identify your data sources

Depending on your setup, data can come from:

A. Mining software API

Examples:

• cgminer/bfgminer API
• custom miner telemetry
• pool-side stats API if you mine through a pool

Useful for:

• accepted shares
• rejected shares
• current hashrate
• miner status
• temperature / power if available

B. Coin node or explorer API

Needed for each coin to get:

• current block height
• block reward
• difficulty
• network status
• confirmation count
• recent block times

C. Price API

Needed to convert coin rewards into fiat:

• CoinGecko
• CoinMarketCap
• exchange API
• custom oracle if needed

D. Pool API or merged mining infrastructure

If using merged mining via a pool:

• per-coin payout records
• merged share credit
• orphan/stale data
• payout schedule

---

3) Create a data model

A clean schema makes the dashboard much easier.

Example tables/collections

miner_stats

• timestamp
• miner_id
• hash_rate
• shares_accepted
• shares_rejected
• temperature
• uptime

coin_stats

• timestamp
• coin_name
• difficulty
• block_reward
• block_height
• network_hashrate
• price_usd
• estimated_reward_per_day
• estimated_revenue_usd_per_day

payouts

• timestamp
• coin_name
• amount_coin
• amount_usd
• txid
• status

merged_mining_profit

• timestamp
• coin_name
• estimated_daily_rev
• realized_rev
• variance
• profitability_rank

---

4) Calculate revenue by coin

For each coin, revenue is typically estimated as:

Estimated daily revenue

[ \text{Revenue/day} = \frac{\text{Your hashrate}}{\text{Network hashrate}} \times \text{Blocks/day} \times \text{Block reward} ]

Where:

[ \text{Network hashrate} = \frac{\text{Difficulty} \times 2^{32}}{\text{Block time}} ]

Or use a mining profitability formula from the coin’s consensus algorithm if applicable.

Fiat revenue

[ \text{Revenue USD/day} = \text{Coin/day} \times \text{Market price} ]

For merged mining, compute this per coin, then sum them: [ \text{Total revenue} = \sum_{i=1}^{n} \text{Revenue}_i ]

Also track:

• estimated revenue
• actual realized revenue
• variance
• network difficulty trend

---

5) Set up a real-time data pipeline

A simple and reliable architecture:

Option A: Lightweight stack

• Python script / Node.js service polls APIs
• Store metrics in:
  • PostgreSQL, InfluxDB, or TimescaleDB
• Dashboard:
  • Grafana

Option B: Event-driven stack

• Miner/pool sends events to:
  • MQTT / Kafka / Redis Streams
• Backend service processes events
• Database stores time-series data
• Dashboard reads from DB/API

For most mining dashboards, TimescaleDB + Grafana is a very good choice.

---

6) Build the backend collector

Write a collector that polls:

• miner API every 10–30 sec
• coin difficulty APIs every 1–5 min
• price APIs every 1–5 min
• payout APIs every 1–10 min

Logic flow

1. Query miner hashrate and accepted shares
2. Query each coin’s difficulty and reward
3. Query prices
4. Compute estimated revenue by coin
5. Store results in database
6. Expose API endpoints for dashboard

---

7) Choose a dashboard tool

Best options

Grafana

Best for:

• time-series charts
• real-time panels
• alerts
• multi-metric dashboards

Metabase / Redash

Best for:

• SQL-based reporting
• simpler business-style analytics

Custom dashboard

Best if you want:

• merged-mining-specific UI
• profitability ranking
• wallet/payout drilldown
• custom alerts

If you want real-time mining monitoring, Grafana is usually the easiest.

---

8) Suggested Grafana panels

Create panels like:

• Total revenue per hour
• Revenue by coin
• Difficulty by coin
• Price by coin
• Estimated vs realized revenue
• Hashrate over time
• Shares accepted/rejected
• Payout history
• Profitability heatmap

For each coin, a panel can show:

• current difficulty
• estimated daily revenue
• realized earnings
• price
• trend line

---

9) Add alerts

Set alerts for:

• hash rate drops
• difficulty spikes
• payout missing
• stale share spikes
• revenue falls below threshold
• network price crash
• node/API unresponsive

Example:

• alert if revenue per coin drops by 20% in 1 hour
• alert if accepted shares stop increasing for 5 minutes

---

10) Example implementation stack

A practical setup:

• Collector: Python
  • requests / aiohttp
  • periodic jobs with APScheduler or Celery
• Database: TimescaleDB
• Dashboard: Grafana
• Containerization: Docker / Docker Compose
• Optional messaging: Redis
• Logging: Loki / ELK

---

11) Minimal architecture diagram

Mining Rig / Pool API / Coin Node / Price API
              ↓
        Collector Service
              ↓
     TimescaleDB / PostgreSQL
              ↓
           Grafana Dashboard
              ↓
         Alerts / Notifications

---

12) Basic implementation example

Python pseudo-flow

for coin in merged_mined_coins:
    difficulty = get_difficulty(coin)
    reward = get_block_reward(coin)
    price = get_price_usd(coin)
    hashrate = get_miner_hashrate()

    network_hashrate = calculate_network_hashrate(difficulty, coin.block_time)
    coin_per_day = (hashrate / network_hashrate) * (86400 / coin.block_time) * reward
    usd_per_day = coin_per_day * price

    store_metrics(coin, difficulty, reward, price, coin_per_day, usd_per_day)

---

13) Important merged mining considerations

Merged mining is not the same as independent mining, so also track:

• whether the aux chain actually shares work from the parent chain
• payout attribution rules
• block validity / orphan risk
• pool accounting differences
• whether a coin’s revenue is estimated or directly paid
• different block times and reward schedules

For some merged-mined coins, “difficulty” doesn’t translate cleanly to profitability without considering:

• parent coin hash power
• aux chain payout policy
• chain-specific block rewards
• pool fee allocation

---

14) If you want near real-time accuracy

Use:

• miner API updates every 10–15 sec
• difficulty updates every few minutes
• price updates every 1 min
• payout reconciliation every 5–15 min

And show the dashboard with:

• last updated timestamp
• source for each metric
• “estimated” vs “confirmed” labels

---

15) Recommended next step

If you want, I can help you with one of these:

1. A concrete Grafana + TimescaleDB setup
2. A Python collector script
3. A Docker Compose stack
4. A dashboard schema for specific coins
5. A revenue formula for your exact merged mining coins

If you tell me:

• which coins you’re merged mining,
• whether you use a pool or solo setup,
• and what hardware/software you’re using,

I can sketch the exact dashboard and data pipeline for your case.