feat(dashboard): fold Tari revenue into the energy/profit net calculation (#520) (#614)

dashboard.energy.tari_price adds Tari merge-mining earnings to the Energy
tab's net profit, using the same what-if Tari/day estimate the Tari tab
already shows. XvB stays excluded (raffle status, no clean per-day
estimate). The net-profit heading and tooltip now say exactly what's
included so the figure is never silently P2Pool-only.

Author: VijitSingh97

CHANGELOG.md

@@ -11,6 +11,19 @@ per the process in [`docs/releasing.md`](docs/releasing.md).
 
 ## [Unreleased]
 
+### Added
+
+- **Energy calculator: Tari revenue in net profit (#520).** `dashboard.energy.tari_price` (fiat
+  price of 1 XTM, default `0`/off) folds the estimated Tari merge-mining revenue into the Energy
+  tab's net profit once it's set alongside the existing `xmr_price` — previously net profit counted
+  P2Pool XMR only, undercounting a Tari merge-miner's actual revenue. Uses the same what-if Tari/day
+  estimate the Tari tab already shows, no new estimate invented. XvB stays excluded (raffle status,
+  not a clean per-day income estimate). The card's heading and Net/day tooltip now say exactly
+  what's counted ("P2Pool + Tari, after power" vs "P2Pool XMR only, after power") so the figure is
+  never silently partial. Static, operator-supplied price only — an opt-in Tor-routed price feed is
+  a deferred follow-up, not implemented here (fetching one is a clearnet egress this privacy-first
+  stack avoids).
+
 ## [1.7.0] - 2026-07-17
 
 The **Config UX & telemetry** cycle. Config editing becomes humane — worker

build/dashboard/mining_dashboard/config/config.py

@@ -315,7 +315,10 @@ def load_energy_config(path=None):
     ``xmr_price``    — operator-supplied fiat price of 1 XMR (0/unset ⇒ net profit hidden). No price
                        feed ships: fetching one is a clearnet egress this privacy-first stack avoids,
                        so the operator supplies it, in the same ``currency`` as ``cost_per_kwh``.
-    ``currency``     — display label for both figures (e.g. USD, EUR). Label only — no conversion.
+    ``tari_price``   — operator-supplied fiat price of 1 XTM (#520; 0/unset ⇒ net profit counts
+                       P2Pool XMR only). Same no-price-feed reasoning as ``xmr_price``; folds Tari's
+                       merge-mined earnings into net profit once both this and ``xmr_price`` are set.
+    ``currency``     — display label for all figures (e.g. USD, EUR). Label only — no conversion.
     """
     try:
         with open(path or HOST_CONFIG_PATH) as f:
@@ -336,6 +339,7 @@ def _nonneg(v):
     return {
         "cost_per_kwh": _nonneg(raw.get("cost_per_kwh")),
         "xmr_price": _nonneg(raw.get("xmr_price")),
+        "tari_price": _nonneg(raw.get("tari_price")),
         "currency": currency,
     }
 

build/dashboard/mining_dashboard/web/static/components.mjs

@@ -566,12 +566,21 @@ class EarningsCard extends Component {
 // Energy & profit tab body (#260). Fleet power draw + efficiency (always, when any power is known),
 // then energy cost once an electricity price is set, then net profit once an XMR price is also set —
 // each layer appears only when its inputs exist, so the operator never sees a fabricated figure.
-// `est` is the earnings for the shared what-if hashrate; the client does the kWh/cost/net math.
+// Setting a Tari price too (#520) folds the Tari merge-mining estimate into gross; the heading and
+// the Net/day tooltip say exactly what's counted so a Tari merge-miner's net is never silently
+// P2Pool-only. `est` is the earnings for the shared what-if hashrate; the client does the
+// kWh/cost/net math.
 function EnergyPanel({ energy, est }) {
   const en = computeEnergy(energy, est);
   const cur = energy.currency;
   const haveCost = energy.cost_per_kwh > 0;
   const haveNet = haveCost && energy.xmr_price > 0;
+  // Honest label (#520): say exactly what gross counts so the net figure is never silently
+  // partial. XvB never appears here — raffle status, not a clean per-day estimate.
+  const netLabel = en.includesTari ? "P2Pool + Tari, after power" : "P2Pool XMR only, after power";
+  const netTitle = en.includesTari
+    ? "P2Pool XMR + Tari (merge-mined) earnings at your set prices, minus power cost. Excludes XvB (raffle status, not a per-day income estimate)."
+    : "P2Pool XMR earnings at your XMR price, minus power cost. Excludes Tari (set dashboard.energy.tari_price to include it) and XvB (raffle status, not a per-day income estimate).";
   return html`
     <div class="stat-grid">
         <${StatCard} label="Fleet Power" value=${formatUnit(energy.total_watts, "W")}
@@ -590,7 +599,7 @@ function EnergyPanel({ energy, est }) {
     ${
       haveCost
         ? html`
-    <h4 class="text-small mt-2">Cost${haveNet ? " & Net Profit" : ""} (${cur})</h4>
+    <h4 class="text-small mt-2">Cost${haveNet ? ` & Net Profit — ${netLabel}` : ""} (${cur})</h4>
     <div class="stat-grid">
         <${StatCard} label="Power cost / day" value=${formatFiat(en.costDay, cur)} />
         <${StatCard} label="Power cost / month" value=${formatFiat(en.costMonth, cur)} />
@@ -600,7 +609,7 @@ function EnergyPanel({ energy, est }) {
             ? html`
         <${StatCard} label="Net / day" value=${formatFiat(en.netDay, cur)}
                      cls=${en.netDay !== null && en.netDay < 0 ? "c-bad" : "text-accent"}
-                     title="P2Pool XMR earnings at your XMR price, minus power cost. Excludes Tari and XvB." />
+                     title=${netTitle} />
         <${StatCard} label="Net / month" value=${formatFiat(en.netMonth, cur)}
                      cls=${en.netMonth !== null && en.netMonth < 0 ? "c-bad" : "text-accent"} />
         <${StatCard} label="Net / year" value=${formatFiat(en.netYear, cur)}

build/dashboard/mining_dashboard/web/static/logic.mjs

@@ -288,13 +288,20 @@ export function formatXtm(xtm) {
   return formatCoin(xtm, "XTM");
 }
 
-// Energy & profit (#260). Turns the server's measured fleet watts + operator prices into
-// kWh / cost / net over day·month·year for a what-if hashrate. Power draw is measured (does NOT
-// scale with the what-if hashrate — it's the real fleet), so only the earnings side scales:
-//   net = gross(what-if XMR/day × xmr_price) − cost(kWh × cost_per_kwh).
-// `est` is the already-computed earnings for this what-if hashrate (computeEarnings). Any figure
-// whose inputs are missing comes back null so the card shows "—" rather than a bogus number:
-// cost needs cost_per_kwh > 0; net additionally needs xmr_price > 0 and a valid XMR estimate.
+// Energy & profit (#260, Tari revenue #520). Turns the server's measured fleet watts + operator
+// prices into kWh / cost / net over day·month·year for a what-if hashrate. Power draw is measured
+// (does NOT scale with the what-if hashrate — it's the real fleet), so only the earnings side
+// scales: net = gross − cost(kWh × cost_per_kwh), where
+//   gross = (what-if XMR/day × xmr_price) + (what-if Tari/day × tari_price, when priced).
+// `est` is the already-computed earnings for this what-if hashrate (computeEarnings; `est.tariDay`
+// is the same Tari/day estimate the Tari tab already shows — no separate estimate invented here).
+// XvB stays excluded from gross: it's a raffle status (xvbTierComparison), not a clean per-day
+// credited estimate — guessing one would fabricate a figure.
+// Any figure whose inputs are missing comes back null so the card shows "—" rather than a bogus
+// number: cost needs cost_per_kwh > 0; net additionally needs xmr_price > 0 and a valid XMR
+// estimate — Tari only ever ADDS to that base (mirrors the existing xmr_price-gates-net contract,
+// #520 scope: no tari-price-only net). `includesTari` tells the UI which figure it got, so the
+// net-profit label is never silently partial (#520's honesty requirement).
 export function computeEnergy(energy, est) {
   const blank = {
     kwhDay: null,
@@ -306,18 +313,21 @@ export function computeEnergy(energy, est) {
     netDay: null,
     netMonth: null,
     netYear: null,
+    includesTari: false,
   };
   if (!energy || !energy.available || !(energy.total_watts > 0)) return blank;
   const kwhDay = (energy.total_watts / 1000) * 24;
   const price = energy.cost_per_kwh;
   const haveCost = Number.isFinite(price) && price > 0;
   const costDay = haveCost ? kwhDay * price : null;
   const xmrPrice = energy.xmr_price;
-  // Gross fiat/day from P2Pool XMR only (Tari lumpy/priced-separately, XvB is raffle status).
-  const grossDay =
-    Number.isFinite(xmrPrice) && xmrPrice > 0 && est && Number.isFinite(est.day)
-      ? est.day * xmrPrice
-      : null;
+  const tariPrice = energy.tari_price;
+  const haveXmr = Number.isFinite(xmrPrice) && xmrPrice > 0 && est && Number.isFinite(est.day);
+  const includesTari =
+    haveXmr && Number.isFinite(tariPrice) && tariPrice > 0 && Number.isFinite(est.tariDay);
+  const grossDay = haveXmr
+    ? est.day * xmrPrice + (includesTari ? est.tariDay * tariPrice : 0)
+    : null;
   const netDay = grossDay !== null && costDay !== null ? grossDay - costDay : null;
   const span = (v, mult) => (v === null ? null : v * mult);
   return {
@@ -330,6 +340,7 @@ export function computeEnergy(energy, est) {
     netDay,
     netMonth: span(netDay, DAYS_PER_MONTH),
     netYear: span(netDay, DAYS_PER_YEAR),
+    includesTari,
   };
 }
 

build/dashboard/mining_dashboard/web/views.py

@@ -845,21 +845,25 @@ def build_workers(workers):
 
 
 # --------------------------------------------------------------------------------------
-# Energy & profit calculator (Issue #260): fleet power draw + efficiency, and — once the operator
-# sets an electricity price (and an XMR price) — the net profit after power. The server totals the
-# measured draw and publishes the prices; the client does the per-day/month/year arithmetic and the
-# net = gross − cost, scaling gross with the same what-if hashrate the earnings card already uses
-# (one source of truth, #61). Deliberately NO price feed: fetching one is a clearnet egress this
-# privacy-first stack avoids (#160), so both prices are operator-supplied.
+# Energy & profit calculator (Issue #260, Tari revenue #520): fleet power draw + efficiency, and —
+# once the operator sets an electricity price (and an XMR price) — the net profit after power.
+# Setting a Tari price too folds the estimated Tari merge-mining revenue into gross so a Tari
+# merge-miner's net profit isn't silently undercounted (P2Pool-only was the #520 bug). The server
+# totals the measured draw and publishes the prices; the client does the per-day/month/year
+# arithmetic and the net = gross − cost, scaling gross with the same what-if hashrate the earnings
+# card already uses (one source of truth, #61). Deliberately NO price feed for either coin: fetching
+# one is a clearnet egress this privacy-first stack avoids (#160) — an opt-in Tor-routed feed is
+# deferred, see #520 — so all prices are operator-supplied.
 # --------------------------------------------------------------------------------------
 
 _ENERGY_DISCLAIMER = (
     "Power draw is measured (RAPL, 15s sample) or your per-worker estimate; a worker reporting "
     "neither is excluded and the fleet total is marked incomplete. kWh and cost extrapolate the "
     "current draw at a constant rate — a naive projection, not a metered bill. Net profit is "
-    "P2Pool XMR earnings valued at your XMR price, minus power cost: it excludes Tari (lumpy solo "
-    "merge-mining, priced separately) and XvB (raffle status, not income). Estimates, not "
-    "guarantees."
+    "P2Pool XMR earnings valued at your XMR price, plus Tari merge-mining earnings valued at your "
+    "Tari price once dashboard.energy.tari_price is set (0/unset counts P2Pool XMR only) — minus "
+    "power cost. XvB stays excluded: it's raffle status, not a clean per-day income estimate. "
+    "Estimates, not guarantees."
 )
 
 
@@ -924,6 +928,7 @@ def build_energy(workers):
         "incomplete": incomplete,
         "cost_per_kwh": cfg["cost_per_kwh"],
         "xmr_price": cfg["xmr_price"],
+        "tari_price": cfg["tari_price"],
         "currency": cfg["currency"],
         "per_worker": per_worker,
         "disclaimer": _ENERGY_DISCLAIMER,

build/dashboard/tests/config/test_config.py

@@ -304,15 +304,30 @@ def test_defaults_when_absent(self, tmp_path):
         assert self._load(tmp_path, {"dashboard": {}}) == {
             "cost_per_kwh": 0.0,
             "xmr_price": 0.0,
+            "tari_price": 0.0,
             "currency": "USD",
         }
 
     def test_valid_values_load(self, tmp_path):
         got = self._load(
             tmp_path,
-            {"dashboard": {"energy": {"cost_per_kwh": 0.18, "xmr_price": 150, "currency": "EUR"}}},
+            {
+                "dashboard": {
+                    "energy": {
+                        "cost_per_kwh": 0.18,
+                        "xmr_price": 150,
+                        "tari_price": 2.5,
+                        "currency": "EUR",
+                    }
+                }
+            },
         )
-        assert got == {"cost_per_kwh": 0.18, "xmr_price": 150.0, "currency": "EUR"}
+        assert got == {
+            "cost_per_kwh": 0.18,
+            "xmr_price": 150.0,
+            "tari_price": 2.5,
+            "currency": "EUR",
+        }
 
     def test_invalid_values_degrade_to_defaults(self, tmp_path):
         got = self._load(
@@ -322,23 +337,25 @@ def test_invalid_values_degrade_to_defaults(self, tmp_path):
                     "energy": {
                         "cost_per_kwh": -1,
                         "xmr_price": "expensive",
+                        "tari_price": -2,
                         "currency": "has space",
                     }
                 }
             },
         )
-        assert got == {"cost_per_kwh": 0.0, "xmr_price": 0.0, "currency": "USD"}
+        assert got == {"cost_per_kwh": 0.0, "xmr_price": 0.0, "tari_price": 0.0, "currency": "USD"}
 
     def test_non_object_energy_degrades_to_defaults(self, tmp_path):
         # A hand-edited `energy` that isn't an object mustn't crash — fall back to defaults.
         got = self._load(tmp_path, {"dashboard": {"energy": "nope"}})
-        assert got == {"cost_per_kwh": 0.0, "xmr_price": 0.0, "currency": "USD"}
+        assert got == {"cost_per_kwh": 0.0, "xmr_price": 0.0, "tari_price": 0.0, "currency": "USD"}
 
     def test_missing_file_reads_defaults(self, tmp_path):
         from mining_dashboard.config.config import load_energy_config
 
         assert load_energy_config(str(tmp_path / "absent.json")) == {
             "cost_per_kwh": 0.0,
             "xmr_price": 0.0,
+            "tari_price": 0.0,
             "currency": "USD",
         }

build/dashboard/tests/frontend/components.test.mjs

@@ -243,11 +243,42 @@ test('EarningsCard Energy tab shows cost then net as prices are set (#260)', ()
     assert.match(html, /Power cost \/ day/);
     assert.match(html, /set xmr_price/);
     assert.doesNotMatch(html, /Net \/ day/);
-    // Both prices set → net profit appears.
+    // Both prices set → net profit appears, labelled P2Pool-only since tari_price is still unset.
     s.energy.xmr_price = 150;
     html = renderApp({ state: s });
     assert.match(html, /Net \/ day/);
     assert.match(html, /Net \/ year/);
+    assert.match(html, /P2Pool XMR only, after power/);
+    assert.doesNotMatch(html, /P2Pool \+ Tari, after power/);
+});
+
+test('EarningsCard Energy tab folds Tari into net profit once tari_price is set and Tari is merge-mining (#520)', () => {
+    const s = clone();
+    s.earnings.available = true;
+    s.earnings.coeff_day = 1e-8;
+    s.earnings.tari_available = true;
+    s.earnings.tari_coeff_day = 1e-6;
+    s.energy.cost_per_kwh = 0.2;
+    s.energy.xmr_price = 150;
+    s.energy.tari_price = 2;
+    const html = renderApp({ state: s });
+    assert.match(html, /Net \/ day/);
+    assert.match(html, /P2Pool \+ Tari, after power/);
+    assert.doesNotMatch(html, /P2Pool XMR only, after power/);
+});
+
+test('EarningsCard Energy tab keeps the P2Pool-only label when tari_price is set but Tari is not merge-mining (#520)', () => {
+    const s = clone();
+    s.earnings.available = true;
+    s.earnings.coeff_day = 1e-8;
+    s.earnings.tari_available = false; // no Tari estimate to fold in
+    s.energy.cost_per_kwh = 0.2;
+    s.energy.xmr_price = 150;
+    s.energy.tari_price = 2;
+    const html = renderApp({ state: s });
+    assert.match(html, /Net \/ day/);
+    assert.match(html, /P2Pool XMR only, after power/);
+    assert.doesNotMatch(html, /P2Pool \+ Tari, after power/);
 });
 
 test('XvB comparison dropdown shows Expected/Cost/Net per tier, degrades on a stale estimate (#118)', () => {

build/dashboard/tests/frontend/fixtures/state.json

@@ -594,6 +594,7 @@
     "incomplete": false,
     "cost_per_kwh": 0.0,
     "xmr_price": 0.0,
+    "tari_price": 0.0,
     "currency": "USD",
     "per_worker": [
       {

build/dashboard/tests/frontend/logic.test.mjs

@@ -508,9 +508,50 @@ test('computeEnergy: unavailable / zero watts returns all nulls', () => {
         const en = computeEnergy(bad, { day: 1 });
         assert.equal(en.kwhDay, null);
         assert.equal(en.netDay, null);
+        assert.equal(en.includesTari, false);
     }
 });
 
+// --- Tari revenue in net profit (#520) ---------------------------------------------------
+
+test('computeEnergy: both prices set -> gross combines P2Pool XMR + Tari', () => {
+    const en = computeEnergy(
+        { available: true, total_watts: 1000, cost_per_kwh: 0.2, xmr_price: 150, tari_price: 2 },
+        { day: 0.1, tariDay: 5 }, // 0.1 XMR/day, 5 XTM/day
+    );
+    // gross = 0.1*150 + 5*2 = 15 + 10 = 25; cost = 24*0.2 = 4.8; net = 20.2
+    assert.ok(Math.abs(en.netDay - 20.2) < 1e-9);
+    assert.equal(en.includesTari, true);
+});
+
+test('computeEnergy: only xmr_price set -> P2Pool-only net, includesTari false', () => {
+    const en = computeEnergy(
+        { available: true, total_watts: 1000, cost_per_kwh: 0.2, xmr_price: 150, tari_price: 0 },
+        { day: 0.1, tariDay: 5 }, // Tari estimate exists but is unpriced
+    );
+    // gross = 0.1*150 = 15 (Tari excluded); cost = 4.8; net = 10.2
+    assert.ok(Math.abs(en.netDay - 10.2) < 1e-9);
+    assert.equal(en.includesTari, false);
+});
+
+test('computeEnergy: tari_price set but no xmr_price -> no net at all (xmr_price is the base gate)', () => {
+    const en = computeEnergy(
+        { available: true, total_watts: 1000, cost_per_kwh: 0.2, xmr_price: 0, tari_price: 2 },
+        { day: 0.1, tariDay: 5 },
+    );
+    assert.equal(en.netDay, null);
+    assert.equal(en.includesTari, false);
+});
+
+test('computeEnergy: tari_price set but Tari not merge-mining (tariDay null) -> P2Pool-only', () => {
+    const en = computeEnergy(
+        { available: true, total_watts: 1000, cost_per_kwh: 0.2, xmr_price: 150, tari_price: 2 },
+        { day: 0.1, tariDay: null },
+    );
+    assert.ok(Math.abs(en.netDay - 10.2) < 1e-9); // same as P2Pool-only case above
+    assert.equal(en.includesTari, false);
+});
+
 test('formatFiat: currency label, two decimals, keeps the sign', () => {
     assert.equal(formatFiat(12.5, 'USD'), 'USD 12.50');
     assert.equal(formatFiat(-3, 'EUR'), '-EUR 3.00');

build/dashboard/tests/web/test_views.py

@@ -2021,7 +2021,7 @@ def _energy(self, monkeypatch, workers, energy=None, descriptors=None):
         monkeypatch.setattr(
             views.config,
             "DASHBOARD_ENERGY",
-            energy or {"cost_per_kwh": 0.0, "xmr_price": 0.0, "currency": "USD"},
+            energy or {"cost_per_kwh": 0.0, "xmr_price": 0.0, "tari_price": 0.0, "currency": "USD"},
         )
         monkeypatch.setattr(views.config, "DASHBOARD_WORKERS", descriptors or [])
         return build_energy(workers)
@@ -2066,10 +2066,16 @@ def test_prices_pass_through(self, monkeypatch):
         got = self._energy(
             monkeypatch,
             [self._worker("r1", watts=100)],
-            energy={"cost_per_kwh": 0.2, "xmr_price": 150.0, "currency": "EUR"},
+            energy={
+                "cost_per_kwh": 0.2,
+                "xmr_price": 150.0,
+                "tari_price": 2.5,
+                "currency": "EUR",
+            },
         )
         assert got["cost_per_kwh"] == 0.2
         assert got["xmr_price"] == 150.0
+        assert got["tari_price"] == 2.5
         assert got["currency"] == "EUR"