blockmachine 0.22.0__tar.gz → 0.22.1__tar.gz

{blockmachine-0.22.0 → blockmachine-0.22.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blockmachine
-Version: 0.22.0
+Version: 0.22.1
 Summary: Blockmachine CLI - Miner and validator operator interface
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/taostat/blockmachine

{blockmachine-0.22.0 → blockmachine-0.22.1}/blockmachine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blockmachine
-Version: 0.22.0
+Version: 0.22.1
 Summary: Blockmachine CLI - Miner and validator operator interface
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/taostat/blockmachine

{blockmachine-0.22.0 → blockmachine-0.22.1}/blockmachine.egg-info/SOURCES.txt

@@ -36,6 +36,8 @@ tests/test_leaderboard_cli.py
 tests/test_miner_add_class.py
 tests/test_miner_ban_line.py
 tests/test_miner_capacity.py
+tests/test_miner_capacity_helper.py
+tests/test_miner_capacity_pack.py
 tests/test_miner_compat_reason.py
 tests/test_miner_eligibility.py
 tests/test_miner_eth_tier.py

{blockmachine-0.22.0 → blockmachine-0.22.1}/commands/epoch.py

@@ -103,27 +103,67 @@ def render_payout(body: dict, top: int = TOP_MINERS) -> list[str]:
     return lines
 
 
+def _has_cu_split(miner: dict) -> bool:
+    """Does this body separate served CU from the base-incentive subsidy?
+
+    Registries built before taostat/blockmachine_playground#1529 send one
+    unqualified ``cu`` and nothing else. Printing zero served CU against
+    those would be a new lie, so the old single column is kept for them.
+    """
+    return "cu_served" in miner and "cu_base_incentive" in miner
+
+
 def render_miner(body: dict, miner: dict) -> list[str]:
     """One miner with every (chain, class) line."""
     header = render_payout(body)
     lines = header[: header.index("")]
+    split = _has_cu_split(miner)
+    cu_total = int(miner.get("cu_total") or 0)
     lines.append("")
     lines.append(
         f"UID {miner.get('uid')}  {miner.get('hotkey')}\n"
         f"  {float(miner.get('alpha') or 0):.1f} α  "
         f"(${_fmt_usd(miner.get('usd'))}, "
-        f"{float(miner.get('share') or 0) * 100:.1f}% of the pool, "
-        f"{int(miner.get('cu_total') or 0):,} CU)"
+        f"{float(miner.get('share') or 0) * 100:.1f}% of the pool"
+        + (")" if split else f", {cu_total:,} CU)")
     )
+    if split:
+        lines.append(
+            f"  {cu_total:,} CU: {int(miner.get('cu_served') or 0):,} served "
+            f"+ {int(miner.get('cu_base_incentive') or 0):,} base incentive"
+        )
     lines.append("")
-    lines.append(f"  {'chain/class':<18} {'CU':>15} {'alpha':>9} {'USD':>9}")
+    if split:
+        lines.append(
+            f"  {'chain/class':<18} {'served CU':>15} "
+            f"{'base incentive CU':>19} {'alpha':>9} {'USD':>9}"
+        )
+    else:
+        lines.append(f"  {'chain/class':<18} {'CU':>15} {'alpha':>9} {'USD':>9}")
     for e in miner.get("breakdown") or []:
         node = f"{e.get('chain')}/{e.get('node_class')}"
+        cu_col = (
+            f"{int(e.get('cu_served') or 0):>15,} "
+            f"{int(e.get('cu_base_incentive') or 0):>19,}"
+            if split
+            else f"{int(e.get('cu') or 0):>15,}"
+        )
         lines.append(
-            f"  {node:<18} {int(e.get('cu') or 0):>15,} "
+            f"  {node:<18} {cu_col} "
             f"{float(e.get('alpha') or 0):>9.1f} {_fmt_usd(e.get('usd')):>9}"
         )
     lines.append("")
+    if split:
+        lines.append(
+            "Served CU is the customer traffic this miner answered. Base incentive "
+            "CU is the"
+        )
+        lines.append(
+            "subnet's own top-up, injected as CU — nobody sent those requests. "
+            "Both count"
+        )
+        lines.append("toward the payout, and together they are the CU total above.")
+        lines.append("")
     lines.append(
         "USD is an estimate at the α price the finalizer recorded; the chain pays in α."
     )
@@ -146,6 +186,10 @@ def payout(
     was finalized), share of the miner pool, and the alpha split by chain
     and node class. Available the moment an epoch finalizes; the chain pays
     it out over the following epoch.
+
+    With --uid, CU is shown as two columns: the customer traffic the miner
+    answered, and the base-incentive subsidy injected as synthetic CU. Both
+    count toward the payout; only the first is traffic.
     """
     path = "/epochs/latest/payout" if epoch is None else f"/epochs/{epoch}/payout"
     with RegistryClient(load_config()) as client:

{blockmachine-0.22.0 → blockmachine-0.22.1}/commands/leaderboard.py

@@ -560,7 +560,7 @@ def show(
         None,
         "--chain",
         "-c",
-        help="Filter to a single chain (e.g. eth, tao, bsc, base, polygon, optimism, arbitrum, avalanche, scroll, mantle, robinhood, tron). Default: all chains.",
+        help="Filter to a single chain (e.g. eth, tao, bsc, base, polygon, optimism, arbitrum, avalanche, arc, scroll, mantle, robinhood, tron). Default: all chains.",
     ),
     verbose: bool = typer.Option(
         False,

{blockmachine-0.22.0 → blockmachine-0.22.1}/commands/miner.py

@@ -1,9 +1,12 @@
 """Miner commands: node registration, secrets, and pricing"""
 
 import getpass
+import hashlib
 import io
 import json
 import logging
+import os
+import platform
 import zipfile
 from typing import Callable, Optional
 from urllib.parse import urlparse
@@ -254,7 +257,7 @@ def add(
         if needs_pricing and not price:
             price = typer.prompt("Price (USD/1M CU)")
 
-        node_id = _create_node(
+        _create_node(
             client,
             endpoint,
             alias,
@@ -263,7 +266,6 @@ def add(
             cert_fingerprint=fp,
             node_class=node_class,
         )
-        _maybe_print_eth_software_notice(client, chain, node_id)
 
         if needs_pricing and price:
             _create_default_pricing_rule(client, chain, price)
@@ -281,44 +283,6 @@ def _default_alias(endpoint: str, chain: str = DEFAULT_CHAIN) -> str:
     return f"{chain}-{host.replace('.', '-')}"
 
 
-def _maybe_print_eth_software_notice(
-    client: RegistryClient, chain: str, node_id: str
-) -> None:
-    """Print a network-policy notice when the operator registers an Erigon
-    ETH backend.
-
-    The gateway's network rule routes Erigon to `eth_getProof` only —
-    history methods always land on Reth. Surface that explicitly at
-    registration so the operator knows what to expect; no prompt, no
-    flag, no veto.
-
-    The follow-up GET is best-effort. A transient error here (timeout,
-    connection reset, malformed body) must NOT fail the surrounding
-    ``bm miner add`` flow — the node is already registered at this
-    point, the notice is purely informational, and a re-run would
-    surface a confusing "alias already exists" 409 instead of the
-    success the operator just got.
-    """
-    if chain != "eth":
-        return
-    try:
-        resp = client.get(f"/nodes/{node_id}")
-        if resp.status_code != 200:
-            return
-        sw = (resp.json().get("software_name") or "").lower()
-    except Exception:
-        # Best-effort: any failure (transport, decode, non-string
-        # software_name) is silently swallowed. Registration already
-        # succeeded; the operator sees normal "Node registered" output.
-        return
-    if "erigon" in sw:
-        console.print(
-            "[yellow]Network policy notice:[/yellow] Erigon backends "
-            "currently serve only eth_getProof. Other ETH RPC traffic "
-            "will be routed to Reth backends in the network."
-        )
-
-
 def _eth_tier(node: Optional[dict]) -> str:
     """Derive an EVM display tier for one node row from ``GET /nodes``.
 
@@ -637,6 +601,22 @@ def _as_dict_list(value: object) -> list[dict]:
     return [item for item in value if isinstance(item, dict)]
 
 
+def _held_rounds(elig: dict) -> int:
+    """How many consecutive batteries could not conclude (0 = the state is
+    fresh). Defensive: an older registry omits the key."""
+    value = elig.get("could_not_test_streak")
+    return value if isinstance(value, int) and value > 0 else 0
+
+
+def _unmeasured_checks(elig: dict) -> str:
+    """The checks the last battery marked could-not-test, comma-joined."""
+    return ", ".join(
+        str(entry.get("check") or "-")
+        for entry in _as_dict_list(elig.get("last_battery"))
+        if entry.get("status") == "could_not_test"
+    )
+
+
 def _eligibility_display(node: dict) -> tuple[str, str, str]:
     """(short label, long label, colour) for a node's eligibility state."""
     elig = _eligibility(node)
@@ -707,6 +687,21 @@ def _print_eligibility(node: dict) -> None:
         table.add_row("Since", format_timestamp(elig.get("since")))
         table.add_row("Last Tested", format_timestamp(elig.get("last_tested_at")))
         table.add_row("Next Re-test", format_timestamp(elig.get("next_retest_at")))
+        held = _held_rounds(elig)
+        if held:
+            # The state shown is the last verdict that concluded, not this
+            # battery's: say so, and name what could not be measured, so an
+            # operator does not read a held state as a fresh judgement.
+            table.add_row(
+                "Held",
+                Text(
+                    f"{held} battery round(s) since "
+                    f"{format_timestamp(elig.get('could_not_test_since'))} could "
+                    f"not reach a verdict; could not measure: "
+                    f"{_unmeasured_checks(elig) or '-'}",
+                    style="dim",
+                ),
+            )
     console.print(table)
 
     if elig is None:
@@ -1951,11 +1946,101 @@ def price_simulate(
     )
 
 
+@app.command("capacity-helper")
+def capacity_helper(
+    out: str = typer.Option(
+        "capacity-helper",
+        "--out",
+        "-o",
+        help="Where to write it (default ./capacity-helper)",
+    ),
+    arch: str = typer.Option(
+        None,
+        "--arch",
+        help="Architecture, as `uname -m` reports it (default: this machine's)",
+    ),
+) -> None:
+    """Download the capacity helper, to run next to an archive node.
+
+    OPTIONAL. Without it your node is capacity-tested exactly as it is today.
+    With it, our questions are put to your node from inside your own server and
+    only a short summary of each answer crosses the internet, so the time a large
+    answer takes to reach us is not counted against your node.
+
+    Run it on the same machine as your node, and route /capacity-test on the
+    endpoint you registered to it. See the miner README.
+    """
+    wanted = arch or platform.machine()
+    config = load_config()
+    with RegistryClient(config) as client:
+        response = client.get("/quality/capacity-helper", params={"arch": wanted})
+        if response.status_code == 404:
+            # ITS WORDS, NOT OURS. Only the registry knows which architectures
+            # this build can serve, and being told "not for your machine" is a
+            # different thing from being told the download is broken.
+            console.print(f"[yellow]No capacity helper for {wanted}.[/yellow]")
+            console.print(_detail(response, "That architecture is not served."))
+            raise typer.Exit(1)
+        if response.status_code != 200:
+            console.print(f"[red]Could not fetch it: {_detail(response)}[/red]")
+            raise typer.Exit(1)
+        blob = response.content
+
+    # WHAT ARRIVED, CHECKED, BEFORE IT REACHES THE DISK. An empty or truncated
+    # file written and made executable is a download that looks like it worked,
+    # and the operator finds out when a test does not improve.
+    if len(blob) < 1_000_000:
+        console.print(
+            f"[red]That download is only {len(blob)} bytes, which is too small to "
+            "be the helper. Please report it rather than running it.[/red]"
+        )
+        raise typer.Exit(1)
+
+    # THE DIGEST, CHECKED RATHER THAN PRINTED. A size check only catches an empty
+    # file; this catches a download that stopped early or was mangled in transit
+    # (bm-pm, review of #1703). Absent means an older registry, which is not a
+    # reason to refuse a binary that is otherwise the right size — so it is said
+    # out loud instead.
+    got = hashlib.sha256(blob).hexdigest()
+    expected = response.headers.get("X-Capacity-Helper-Sha256")
+    if expected and got != expected:
+        console.print(
+            "[red]That download does not match the checksum it was served with, so "
+            "it arrived damaged or altered. Nothing has been written.[/red]"
+        )
+        console.print(f"  served: {expected}\n  got:    {got}")
+        raise typer.Exit(1)
+
+    with open(out, "wb") as fh:
+        fh.write(blob)
+    os.chmod(out, 0o755)
+
+    served = response.headers.get("X-Capacity-Helper-Arch", wanted)
+    console.print(f"[green]Wrote {out}[/green] — {len(blob)} bytes, {served}.")
+    if expected:
+        console.print(f"  sha256 {got} (matches what was served)")
+    else:
+        console.print(
+            "  [yellow]no checksum was served with it, so it could not be "
+            "verified beyond its size[/yellow]"
+        )
+    console.print(
+        "\n  Run it beside your node, with the secret you registered:\n"
+        f"  [cyan]CAPACITY_HELPER_SECRET='<your node secret>' ./{out} \\\n"
+        "      --node ws://127.0.0.1:8546 --family evm --listen 127.0.0.1:9955[/cyan]\n"
+        "\n  On a tao node use --node ws://127.0.0.1:9944 --family substrate.\n"
+        "\n  Then route /capacity-test on your registered endpoint to it, and check it:\n"
+        f"  [cyan]./{out} check --endpoint wss://<your endpoint> --secret '<your node secret>'[/cyan]"
+    )
+
+
 @app.command("capacity-pack")
 def capacity_pack(
     chain: str = typer.Option(..., "--chain", "-c", help="Which chain's pack"),
     node_class: str = typer.Option(
-        "archive", "--class", help="archive or full (default archive)"
+        "archive",
+        "--class",
+        help="archive or full (default archive; only archive nodes have a pack)",
     ),
     out: str = typer.Option(
         None,
@@ -1981,12 +2066,29 @@ def capacity_pack(
 
     Your number will not match ours exactly. We measure a node through its
     registration with it taken out of customer traffic; you measure yours
-    directly, while it serves.
+    directly, while it serves. Both warm every connection with unscored
+    head reads first, time each workload from its first question sent to
+    its last correct answer received, and take the round trip to the node
+    off that once, so distance from us is not what is scored.
     """
     chain = _validate_chain(chain) or chain
     if node_class not in ("archive", "full"):
         console.print(f"[red]--class must be archive or full, not {node_class}[/red]")
         raise typer.Exit(1)
+    if node_class == "full":
+        # SAID HERE, WITHOUT ASKING. There is no full-class pack and there
+        # never will be: a full node is asked about the newest blocks, so the
+        # tester keeps no question set for that class at all. Sending the
+        # request and printing "one appears after the next run" told a miner
+        # to wait for a file no run can produce (Ben, 21 Sep).
+        console.print(
+            "[yellow]There is no self-test pack for full nodes.[/yellow] A full "
+            "node's capacity questions are the newest blocks on the chain, "
+            "drawn fresh at the moment it's tested, so there is no fixed set "
+            "to hand out. Packs exist for archive nodes only:\n\n"
+            f"  [cyan]bm miner capacity-pack --chain {chain}[/cyan]"
+        )
+        raise typer.Exit(1)
     out = out or f"capacity-test-{chain}.zip"
 
     config = load_config()
@@ -1996,9 +2098,21 @@ def capacity_pack(
             params={"chain": chain, "is_archive": node_class == "archive"},
         )
         if response.status_code == 404:
+            # THE REGISTRY'S OWN WORDS, not ours. There are two reasons for
+            # this 404 — nothing stored for the chain yet, or everything
+            # stored is in a question-set format the shipped test binary
+            # cannot read — and only the registry knows which. Printing our
+            # own "nothing stored yet" over the second one tells the operator
+            # to wait for a run that has already happened.
             console.print(
-                f"[yellow]No capacity run stored for {chain} ({node_class}) yet.[/yellow] "
-                "One appears after the next run of that chain."
+                f"[yellow]No capacity pack for {chain} ({node_class}).[/yellow]"
+            )
+            console.print(
+                _detail(
+                    response,
+                    "Nothing is stored for that chain yet. One appears after "
+                    "the next run of that chain.",
+                )
             )
             raise typer.Exit(1)
         if response.status_code != 200:

{blockmachine-0.22.0 → blockmachine-0.22.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "blockmachine"
-version = "0.22.0"
+version = "0.22.1"
 description = "Blockmachine CLI - Miner and validator operator interface"
 requires-python = ">=3.10"
 license = "MIT"

{blockmachine-0.22.0 → blockmachine-0.22.1}/settings.py

@@ -98,6 +98,7 @@ EVM_CHAINS = (
     "optimism",
     "arbitrum",
     "avalanche",
+    "arc",
     "scroll",
     "mantle",
     "robinhood",

{blockmachine-0.22.0 → blockmachine-0.22.1}/tests/test_epoch_payout_cli.py

@@ -153,6 +153,102 @@ def test_uid_shows_every_breakdown_line(monkeypatch):
     assert "+" not in out.split("chain/class")[1]  # nothing elided
 
 
+# One real row from taostat/blockmachine_playground#1529: uid 178's avalanche
+# archive node on epoch 9111361 was credited 2,964,586,197 CU, of which 321,030
+# was traffic anyone asked for. The rest is the base-incentive subsidy.
+SERVED, SUBSIDY = 321_030, 2_964_265_167
+
+
+def _split_miner(uid, alpha, share, rows, hotkey=HK):
+    """A miner as a registry that separates served CU from the subsidy
+    reports it. ``rows`` is (chain, class, alpha, served cu, subsidy cu)."""
+    breakdown = [
+        {
+            "chain": c,
+            "node_class": k,
+            "cu": served + subsidy,
+            "cu_served": served,
+            "cu_base_incentive": subsidy,
+            "alpha": a,
+            "usd": a * 2.15,
+        }
+        for c, k, a, served, subsidy in rows
+    ]
+    return {
+        "uid": uid,
+        "hotkey": hotkey,
+        "alpha": alpha,
+        "usd": alpha * 2.15,
+        "share": share,
+        "cu_total": sum(b["cu"] for b in breakdown),
+        "cu_served": sum(b["cu_served"] for b in breakdown),
+        "cu_base_incentive": sum(b["cu_base_incentive"] for b in breakdown),
+        "breakdown": breakdown,
+    }
+
+
+SPLIT_MINER = _split_miner(
+    178,
+    708.3,
+    0.240,
+    [
+        ("avalanche", "arch", 700.0, SERVED, SUBSIDY),
+        ("tao", "full", 8.3, 1_000_000, 0),
+    ],
+)
+SPLIT_BODY = {**BODY, "miners": [SPLIT_MINER], "miner_count": 1}
+
+
+def test_uid_separates_served_cu_from_the_base_incentive_subsidy(monkeypatch):
+    """The defect this fixes: one unqualified CU figure reads as traffic
+    when almost all of it is the subsidy we injected."""
+    result = _run(monkeypatch, _Resp(SPLIT_BODY), "--uid", "178")
+    assert result.exit_code == 0, result.output
+    out = result.output
+    # The total says which half is which rather than printing one number.
+    assert "708.3 α  ($1,523, 24.0% of the pool)" in out
+    assert "  2,965,586,197 CU: 1,321,030 served + 2,964,265,167 base incentive" in out
+    assert "2,965,586,197 CU)" not in out  # the old unqualified total is gone
+    # Two columns per chain/class row, and they sum to what `cu` was.
+    assert (
+        "  chain/class              served CU   base incentive CU     alpha       USD"
+        in out
+    )
+    assert (
+        "  avalanche/arch             321,030       2,964,265,167     700.0     1,505"
+        in out
+    )
+    assert (
+        "  tao/full                 1,000,000                   0       8.3        18"
+        in out
+    )
+    assert "Served CU is the customer traffic this miner answered." in out
+    assert "nobody sent those requests" in out
+
+
+def test_uid_json_carries_both_halves_on_every_row(monkeypatch):
+    """The production check on taostat/blockmachine_playground#1529 reads these
+    fields: served + base incentive == cu_total, on the miner and every row."""
+    result = _run(monkeypatch, _Resp(SPLIT_BODY), "--json", "--uid", "178")
+    assert result.exit_code == 0, result.output
+    m = json.loads(result.output)
+    assert m["cu_served"] + m["cu_base_incentive"] == m["cu_total"]
+    for row in m["breakdown"]:
+        assert row["cu_served"] + row["cu_base_incentive"] == row["cu"]
+
+
+def test_a_registry_without_the_split_still_gets_the_old_single_column(monkeypatch):
+    """Newer CLI against an older registry: the fields are absent, and
+    printing zero served CU there would be a fresh lie. Old layout instead."""
+    result = _run(monkeypatch, _Resp(BODY), "--uid", "178")
+    assert result.exit_code == 0, result.output
+    out = result.output
+    assert "708.3 α  ($1,523, 24.0% of the pool, 1,000 CU)" in out
+    assert "  chain/class                     CU     alpha       USD" in out
+    assert "served CU" not in out
+    assert "base incentive" not in out
+
+
 def test_uid_not_paid_is_a_sentence(monkeypatch):
     result = _run(monkeypatch, _Resp(BODY), "--uid", "5")
     assert result.exit_code == 1

{blockmachine-0.22.0 → blockmachine-0.22.1}/tests/test_miner_add_class.py

@@ -132,7 +132,6 @@ class TestThePromptKeepsThePrintedCommandWorking:
             patch(
                 "cli.commands.miner._needs_chain_default_pricing", return_value=False
             ),
-            patch("cli.commands.miner._maybe_print_eth_software_notice"),
             patch("cli.commands.miner._create_node", return_value="node-1") as create,
             patch("cli.commands.miner.typer.prompt", return_value="archive") as prompt,
         ):

blockmachine-0.22.1/tests/test_miner_capacity_helper.py

@@ -0,0 +1,243 @@
+"""What ``bm miner capacity-helper`` does with each answer it can get.
+
+The capacity helper is OPTIONAL: a node without one is tested exactly as it was
+before. So every failure here is a disappointment and never a penalty, and the
+command has to say which one it is rather than leave an operator with a file that
+will not run.
+
+Two of these are about a download that looks like it worked:
+
+* **The wrong architecture.** The registry image is built for one architecture,
+  so it can only serve that one. A binary for another does not execute, and an
+  operator reads that as our download being broken. The registry says which it
+  serves and the CLI prints its words.
+* **A short file.** A truncated or empty body written to disk and chmod +x is a
+  helper that fails at run time, and the operator finds out when a test does not
+  improve. The size is checked before anything is written.
+"""
+
+from __future__ import annotations
+
+import hashlib
+
+from types import SimpleNamespace
+
+import typer
+from rich.console import Console
+
+from cli.commands import miner as miner_mod
+
+
+class _Resp:
+    def __init__(
+        self,
+        payload=None,
+        status_code: int = 404,
+        content: bytes = b"",
+        headers: dict | None = None,
+    ) -> None:
+        self._payload = payload
+        self.status_code = status_code
+        self.content = content
+        self.text = ""
+        self.headers = headers or {}
+
+    def json(self):
+        if self._payload is None:
+            raise ValueError("not json")
+        return self._payload
+
+
+class _RecordingClient:
+    """Records every request, so "what it asked for" is an assertion."""
+
+    calls: list[tuple]
+
+    def __init__(self, response: _Resp) -> None:
+        self._response = response
+        self.calls = []
+
+    def __enter__(self) -> "_RecordingClient":
+        return self
+
+    def __exit__(self, *args) -> None:
+        return None
+
+    def get(self, path: str, params=None) -> _Resp:
+        self.calls.append((path, params))
+        return self._response
+
+
+def _run(monkeypatch, response: _Resp, out: str, arch=None, machine="x86_64"):
+    console = Console(record=True, width=200)
+    monkeypatch.setattr(miner_mod, "console", console)
+    monkeypatch.setattr(miner_mod, "load_config", lambda: SimpleNamespace())
+    monkeypatch.setattr(miner_mod.platform, "machine", lambda: machine)
+    client = _RecordingClient(response)
+    monkeypatch.setattr(miner_mod, "RegistryClient", lambda config: client)
+    raised = None
+    try:
+        miner_mod.capacity_helper(out=out, arch=arch)
+    except typer.Exit as exc:
+        raised = exc
+    return " ".join(console.export_text().split()), client, raised
+
+
+def test_it_asks_for_this_machines_architecture_unless_told_otherwise(
+    monkeypatch, tmp_path
+):
+    """An operator on an arm box must not be sent an x86 binary because the
+    default was hardcoded."""
+    out = str(tmp_path / "capacity-helper")
+    _, client, _ = _run(monkeypatch, _Resp(status_code=503), out=out, machine="aarch64")
+
+    assert client.calls == [("/quality/capacity-helper", {"arch": "aarch64"})]
+
+
+def test_an_explicit_arch_overrides_the_machines_own(monkeypatch, tmp_path):
+    out = str(tmp_path / "capacity-helper")
+    _, client, _ = _run(
+        monkeypatch, _Resp(status_code=503), out=out, arch="x86_64", machine="aarch64"
+    )
+
+    assert client.calls == [("/quality/capacity-helper", {"arch": "x86_64"})]
+
+
+def test_an_unserved_architecture_is_the_registrys_words_not_ours(
+    monkeypatch, tmp_path
+):
+    """Only the registry knows which architectures its build can serve. Being
+    told "not for your machine" is a different fact from "the download broke"."""
+    detail = (
+        "no capacity helper is served for aarch64; this build serves x86_64. "
+        "Your node is tested exactly as it is today without a helper, so "
+        "nothing is lost by not running one"
+    )
+    out = str(tmp_path / "capacity-helper")
+    printed, _, raised = _run(
+        monkeypatch,
+        _Resp({"detail": detail}, status_code=404),
+        out=out,
+        machine="aarch64",
+    )
+
+    assert raised is not None and raised.exit_code == 1
+    assert "No capacity helper for aarch64" in printed
+    assert "this build serves x86_64" in printed
+    # AND IT SAYS THEY LOSE NOTHING. An operator who reads only this line must
+    # not think their node has been penalised for not having one.
+    assert "tested exactly as it is today" in printed
+    # Nothing was written, so there is no unrunnable file left behind.
+    assert not (tmp_path / "capacity-helper").exists()
+
+
+def test_a_short_body_is_refused_rather_than_written_and_made_executable(
+    monkeypatch, tmp_path
+):
+    """THE ONE THAT BITES SILENTLY. A truncated body written and chmod +x is a
+    helper that fails at run time, and the operator finds out weeks later when
+    their score has not moved."""
+    out = str(tmp_path / "capacity-helper")
+    printed, _, raised = _run(
+        monkeypatch,
+        _Resp(status_code=200, content=b"not a binary"),
+        out=out,
+    )
+
+    assert raised is not None and raised.exit_code == 1
+    assert "too small to be the helper" in printed
+    assert "rather than running it" in printed
+    assert not (tmp_path / "capacity-helper").exists(), (
+        "a body too small to be the helper must not reach the disk at all"
+    )
+
+
+def test_a_body_that_does_not_match_its_checksum_is_refused(monkeypatch, tmp_path):
+    """A size check only catches an empty file. A download that stopped early, or
+    was mangled by a proxy or a stale cache, is the right size and the wrong
+    bytes — and an operator finds out when their score does not move."""
+    out = str(tmp_path / "capacity-helper")
+    blob = b"\x7fELF" + b"\0" * 2_000_000
+    printed, _, raised = _run(
+        monkeypatch,
+        _Resp(
+            status_code=200,
+            content=blob,
+            headers={"X-Capacity-Helper-Sha256": "0" * 64},
+        ),
+        out=out,
+    )
+
+    assert raised is not None and raised.exit_code == 1
+    assert "does not match the checksum" in printed
+    assert "Nothing has been written" in printed
+    assert not (tmp_path / "capacity-helper").exists(), (
+        "a body that failed its checksum must not reach the disk"
+    )
+
+
+def test_a_matching_checksum_is_verified_and_printed(monkeypatch, tmp_path):
+    out = str(tmp_path / "capacity-helper")
+    blob = b"\x7fELF" + b"\0" * 2_000_000
+    digest = hashlib.sha256(blob).hexdigest()
+    printed, _, raised = _run(
+        monkeypatch,
+        _Resp(
+            status_code=200,
+            content=blob,
+            headers={"X-Capacity-Helper-Sha256": digest},
+        ),
+        out=out,
+    )
+
+    assert raised is None
+    assert (tmp_path / "capacity-helper").read_bytes() == blob
+    assert digest in printed
+    assert "matches what was served" in printed
+
+
+def test_no_checksum_served_is_said_out_loud_rather_than_treated_as_a_pass(
+    monkeypatch, tmp_path
+):
+    """An older registry serves no digest. That is not a reason to refuse a binary
+    that is otherwise the right size, but the operator must not be told it was
+    verified when it was not."""
+    out = str(tmp_path / "capacity-helper")
+    blob = b"\x7fELF" + b"\0" * 2_000_000
+    printed, _, raised = _run(
+        monkeypatch, _Resp(status_code=200, content=blob), out=out
+    )
+
+    assert raised is None
+    assert (tmp_path / "capacity-helper").read_bytes() == blob
+    assert "no checksum was served" in printed
+    assert "matches what was served" not in printed
+
+
+def test_a_real_download_is_written_executable_and_says_how_to_run_it(
+    monkeypatch, tmp_path
+):
+    out = str(tmp_path / "capacity-helper")
+    blob = b"\x7fELF" + b"\0" * 2_000_000
+    printed, _, raised = _run(
+        monkeypatch,
+        _Resp(
+            status_code=200,
+            content=blob,
+            headers={"X-Capacity-Helper-Arch": "x86_64"},
+        ),
+        out=out,
+    )
+
+    assert raised is None, "a good download must not exit non-zero"
+    written = tmp_path / "capacity-helper"
+    assert written.read_bytes() == blob
+    # Executable, or the next line an operator types fails with "permission
+    # denied" and reads as a broken download.
+    assert written.stat().st_mode & 0o111, "the helper has to be executable"
+    assert "2000004 bytes, x86_64" in printed
+    # The three things they now have to do, in the order they do them.
+    assert "CAPACITY_HELPER_SECRET" in printed
+    assert "--family evm" in printed
+    assert "ws://127.0.0.1:9944 --family substrate" in printed
+    assert "check --endpoint" in printed

blockmachine-0.22.1/tests/test_miner_capacity_pack.py

@@ -0,0 +1,117 @@
+"""What ``bm miner capacity-pack`` tells an operator when there is no pack.
+
+Two of its three refusals used to be the same sentence — "No capacity run
+stored for <chain> (<class>) yet. One appears after the next run of that
+chain." — and in two of the three cases that sentence is false:
+
+* **The full class has no pack and never will.** A full node is asked about
+  the newest blocks, so ``capacity-tester``'s run keeps a question set only
+  for the archive class (``run.rs``: "no manifest for the full class"). A
+  miner asked Ben on 21 Sep 2026 why his scored eth full node had no pack; the
+  CLI had told him to wait for a run that cannot produce one.
+* **A stored set from before a format bump is stored, not missing.** Right
+  after ``CAPACITY_SET_FORMAT`` moved 9 → 10 on 23 Sep 2026, every chain's
+  newest set was one the shipped binary could not read. Ben hit it on tao.
+
+So: the full class is refused here, before any request, and the registry's own
+words are printed for every other 404 rather than replaced with ours.
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+import typer
+from rich.console import Console
+
+from cli.commands import miner as miner_mod
+
+
+class _Resp:
+    def __init__(self, payload, status_code: int = 404, text: str = "") -> None:
+        self._payload = payload
+        self.status_code = status_code
+        self.text = text
+
+    def json(self):
+        if self._payload is None:
+            raise ValueError("not json")
+        return self._payload
+
+
+class _RecordingClient:
+    """Records every request, so "it never asked" is an assertion and not an
+    assumption."""
+
+    calls: list[tuple]
+
+    def __init__(self, response: _Resp) -> None:
+        self._response = response
+        self.calls = []
+
+    def __enter__(self) -> "_RecordingClient":
+        return self
+
+    def __exit__(self, *args) -> None:
+        return None
+
+    def get(self, path: str, params=None) -> _Resp:
+        self.calls.append((path, params))
+        return self._response
+
+
+def _run(monkeypatch, node_class: str, response: _Resp) -> tuple[str, _RecordingClient]:
+    console = Console(record=True, width=200)
+    monkeypatch.setattr(miner_mod, "console", console)
+    monkeypatch.setattr(miner_mod, "load_config", lambda: SimpleNamespace())
+    client = _RecordingClient(response)
+    monkeypatch.setattr(miner_mod, "RegistryClient", lambda config: client)
+    with pytest.raises(typer.Exit) as exc:
+        # `out` empty, not None: nothing is written on any of these paths, and
+        # the command's own annotation says `str`.
+        miner_mod.capacity_pack(chain="eth", node_class=node_class, out="")
+    assert exc.value.exit_code == 1
+    return " ".join(console.export_text().split()), client
+
+
+def test_the_full_class_is_refused_without_asking_and_is_never_told_to_wait(
+    monkeypatch,
+):
+    out, client = _run(monkeypatch, "full", _Resp({"detail": "should never be read"}))
+
+    assert client.calls == [], (
+        "the full class has no pack on any chain, so the CLI must say so "
+        f"without making the request; it made {client.calls}"
+    )
+    assert "There is no self-test pack for full nodes" in out
+    assert "drawn fresh at the moment it's tested" in out
+    assert "bm miner capacity-pack --chain eth" in out
+    # The false promise, in either wording. This is the whole bug.
+    assert "next run" not in out
+    assert "yet" not in out
+
+
+def test_a_404_reaches_the_operator_in_the_registrys_own_words(monkeypatch):
+    """The registry knows which absence it is; the CLI does not. It prints what
+    it was told."""
+    detail = (
+        "This chain's stored test questions are from before the current test "
+        "version, so there's no pack to download yet. One is stored at the "
+        "chain's next capacity run, usually within a day."
+    )
+    out, client = _run(monkeypatch, "archive", _Resp({"detail": detail}))
+
+    assert [c[0] for c in client.calls] == ["/quality/capacity-bundle"]
+    assert detail in out
+    # Not overwritten with the old class-blind sentence.
+    assert "No capacity run stored for eth" not in out
+
+
+def test_a_404_with_no_readable_body_still_says_something_true(monkeypatch):
+    """An old registry, or a proxy's own 404 page, carries no ``detail``. The
+    fallback must still be a sentence, and must not invent a reason."""
+    out, _ = _run(monkeypatch, "archive", _Resp(None, text=""))
+
+    assert "No capacity pack for eth (archive)" in out
+    assert "Nothing is stored for that chain yet" in out

{blockmachine-0.22.0 → blockmachine-0.22.1}/tests/test_miner_eligibility.py

@@ -196,6 +196,30 @@ class TestDetailView:
         assert "Last Tested" in out
         assert "Next Re-test" in out and "2026-08-23 21:00:00" in out
 
+    def test_a_held_verdict_says_so_and_names_what_could_not_be_measured(
+        self, monkeypatch
+    ):
+        """#1465: a state carried through could-not-test rounds is the last
+        verdict that concluded, not this battery's — the view says how many
+        rounds, since when, and which checks could not be read, so an
+        operator does not read a held state as a fresh judgement."""
+        held = _elig(
+            could_not_test_streak=62,
+            could_not_test_since="2026-08-23T10:00:00+00:00",
+        )
+        out = _run(monkeypatch, [_node(eligibility=held)], "show")
+        assert "Held" in out
+        assert "62 battery round(s) since 2026-08-23 10:00:00" in out
+        assert "could not measure: mempool_feed" in out
+
+        # A fresh verdict (streak 0) or an older registry (no key): no row.
+        fresh = _run(monkeypatch, [_node(eligibility=_elig())], "show")
+        assert "Held" not in fresh
+        zero = _run(
+            monkeypatch, [_node(eligibility=_elig(could_not_test_streak=0))], "show"
+        )
+        assert "Held" not in zero
+
     def test_prints_every_battery_check_with_its_outcome_and_detail(self, monkeypatch):
         out = _run(monkeypatch, [_node(eligibility=_elig())], "show")
         assert "archive_depth" in out

blockmachine-0.22.1/tests/test_miner_eth_tier.py

@@ -0,0 +1,61 @@
+"""Tests for the ETH tier display on the ``bm miner`` CLI surface.
+
+The Erigon network-policy notice this file also used to cover is GONE
+(#1517). It told an operator registering an Erigon ETH backend that
+"Erigon backends currently serve only eth_getProof. Other ETH RPC
+traffic will be routed to Reth backends in the network." That was true
+only while Erigon was off ETH's audit allowlist; with Erigon on it,
+Erigon backends serve the ordinary customer methods like any other
+client and the notice was simply false. A false notice at registration
+is worse than none: it tells an operator their box will not earn on the
+traffic it is about to serve."""
+
+from __future__ import annotations
+
+
+from cli.commands.miner import _eth_tier
+
+
+def _node(declared_class=None, **caps):
+    """One row as ``GET /nodes`` returns it."""
+    node = {"capabilities": caps or None}
+    if declared_class is not None:
+        node["declared_class"] = declared_class
+    return node
+
+
+class TestEthTier:
+    def test_archive_proof_when_declared_archive_and_serving_proofs(self):
+        assert (
+            _eth_tier(_node("archive", is_archive=True, serves_proofs=True))
+            == "archive_proof"
+        )
+
+    def test_archive_when_only_history(self):
+        # Today's Reth-archive shape: history retained, no historical proofs.
+        assert (
+            _eth_tier(_node("archive", is_archive=True, serves_proofs=False))
+            == "archive"
+        )
+
+    def test_full_when_declared_full(self):
+        assert _eth_tier(_node("full", is_archive=False, serves_proofs=False)) == "full"
+
+    def test_the_tier_follows_the_declaration_not_the_sweep(self):
+        """#1018. The operator must be shown the class they are PAID as. The
+        capabilities on both rows below say the opposite of the declaration
+        — the contradiction the card found on two live production rows — and
+        the tier has to follow the declaration in both directions."""
+        assert _eth_tier(_node("full", is_archive=True, serves_proofs=True)) == "full"
+        assert (
+            _eth_tier(_node("archive", is_archive=False, serves_proofs=False))
+            == "archive"
+        )
+
+    def test_dash_when_the_row_carries_no_declared_class(self):
+        """A registry too old to send one. ``-`` is "we do not know", which
+        is the only honest answer; guessing from ``capabilities`` is the
+        defect."""
+        assert _eth_tier(None) == "-"
+        assert _eth_tier({}) == "-"
+        assert _eth_tier({"capabilities": {"is_archive": True}}) == "-"

blockmachine-0.22.0/tests/test_miner_eth_tier.py

@@ -1,195 +0,0 @@
-"""Tests for ETH tier display + Erigon network-policy notice on the
-``bm miner`` CLI surface."""
-
-from __future__ import annotations
-
-from unittest.mock import MagicMock
-
-from cli.commands.miner import (
-    _eth_tier,
-    _maybe_print_eth_software_notice,
-)
-
-
-def _node(declared_class=None, **caps):
-    """One row as ``GET /nodes`` returns it."""
-    node = {"capabilities": caps or None}
-    if declared_class is not None:
-        node["declared_class"] = declared_class
-    return node
-
-
-class TestEthTier:
-    def test_archive_proof_when_declared_archive_and_serving_proofs(self):
-        assert (
-            _eth_tier(_node("archive", is_archive=True, serves_proofs=True))
-            == "archive_proof"
-        )
-
-    def test_archive_when_only_history(self):
-        # Today's Reth-archive shape: history retained, no historical proofs.
-        assert (
-            _eth_tier(_node("archive", is_archive=True, serves_proofs=False))
-            == "archive"
-        )
-
-    def test_full_when_declared_full(self):
-        assert _eth_tier(_node("full", is_archive=False, serves_proofs=False)) == "full"
-
-    def test_the_tier_follows_the_declaration_not_the_sweep(self):
-        """#1018. The operator must be shown the class they are PAID as. The
-        capabilities on both rows below say the opposite of the declaration
-        — the contradiction the card found on two live production rows — and
-        the tier has to follow the declaration in both directions."""
-        assert _eth_tier(_node("full", is_archive=True, serves_proofs=True)) == "full"
-        assert (
-            _eth_tier(_node("archive", is_archive=False, serves_proofs=False))
-            == "archive"
-        )
-
-    def test_dash_when_the_row_carries_no_declared_class(self):
-        """A registry too old to send one. ``-`` is "we do not know", which
-        is the only honest answer; guessing from ``capabilities`` is the
-        defect."""
-        assert _eth_tier(None) == "-"
-        assert _eth_tier({}) == "-"
-        assert _eth_tier({"capabilities": {"is_archive": True}}) == "-"
-
-
-class TestErigonSoftwareNotice:
-    def _fake_client(self, software_name: str | None) -> MagicMock:
-        client = MagicMock()
-        resp = MagicMock()
-        resp.status_code = 200
-        resp.json.return_value = {"software_name": software_name}
-        client.get.return_value = resp
-        return client
-
-    def test_erigon_prints_notice(self, capsys):
-        from cli.commands import miner as miner_mod
-
-        client = self._fake_client("erigon/v3.0.4")
-        # Stash the original console and replace with a capturing one.
-        original = miner_mod.console
-        from rich.console import Console
-
-        miner_mod.console = Console(force_terminal=False, no_color=True)
-        try:
-            _maybe_print_eth_software_notice(client, "eth", "node-id")
-            captured = capsys.readouterr()
-        finally:
-            miner_mod.console = original
-        assert "Network policy notice" in captured.out
-        assert "eth_getProof" in captured.out
-
-    def test_reth_no_notice(self, capsys):
-        from cli.commands import miner as miner_mod
-
-        client = self._fake_client("reth/v1.5.1")
-        original = miner_mod.console
-        from rich.console import Console
-
-        miner_mod.console = Console(force_terminal=False, no_color=True)
-        try:
-            _maybe_print_eth_software_notice(client, "eth", "node-id")
-            captured = capsys.readouterr()
-        finally:
-            miner_mod.console = original
-        assert "Network policy notice" not in captured.out
-
-    def test_non_eth_chain_no_notice(self, capsys):
-        from cli.commands import miner as miner_mod
-
-        client = self._fake_client("erigon/v3.0.4")
-        original = miner_mod.console
-        from rich.console import Console
-
-        miner_mod.console = Console(force_terminal=False, no_color=True)
-        try:
-            _maybe_print_eth_software_notice(client, "tao", "node-id")
-            captured = capsys.readouterr()
-        finally:
-            miner_mod.console = original
-        assert "Network policy notice" not in captured.out
-        # And we should not even have queried the registry.
-        client.get.assert_not_called()
-
-
-class TestErigonNoticeBestEffort:
-    """Codex P2: the follow-up GET must NOT propagate exceptions —
-    a transient registry error after a successful POST /nodes would
-    otherwise fail ``bm miner add`` and lead the operator into a
-    duplicate-node retry."""
-
-    def _swallowing_capture(self, capsys, runnable):
-        """Helper: run ``runnable`` while console output is captured."""
-        from cli.commands import miner as miner_mod
-        from rich.console import Console
-
-        original = miner_mod.console
-        miner_mod.console = Console(force_terminal=False, no_color=True)
-        try:
-            runnable()
-            return capsys.readouterr().out
-        finally:
-            miner_mod.console = original
-
-    def test_get_raises_connection_error_swallowed(self, capsys):
-        client = MagicMock()
-        client.get.side_effect = ConnectionError("network down")
-
-        def run():
-            _maybe_print_eth_software_notice(client, "eth", "node-id")
-
-        out = self._swallowing_capture(capsys, run)
-        assert "Network policy notice" not in out
-
-    def test_get_raises_timeout_swallowed(self, capsys):
-        client = MagicMock()
-        client.get.side_effect = TimeoutError("read timeout")
-
-        def run():
-            _maybe_print_eth_software_notice(client, "eth", "node-id")
-
-        out = self._swallowing_capture(capsys, run)
-        assert "Network policy notice" not in out
-
-    def test_get_returns_500_swallowed(self, capsys):
-        client = MagicMock()
-        resp = MagicMock()
-        resp.status_code = 500
-        client.get.return_value = resp
-
-        def run():
-            _maybe_print_eth_software_notice(client, "eth", "node-id")
-
-        out = self._swallowing_capture(capsys, run)
-        assert "Network policy notice" not in out
-
-    def test_json_decode_failure_swallowed(self, capsys):
-        client = MagicMock()
-        resp = MagicMock()
-        resp.status_code = 200
-        resp.json.side_effect = ValueError("invalid json")
-        client.get.return_value = resp
-
-        def run():
-            _maybe_print_eth_software_notice(client, "eth", "node-id")
-
-        out = self._swallowing_capture(capsys, run)
-        assert "Network policy notice" not in out
-
-    def test_software_name_missing_swallowed(self, capsys):
-        """Response body without ``software_name`` field — old registry
-        version. Falls through the ``or ""`` then skips the print."""
-        client = MagicMock()
-        resp = MagicMock()
-        resp.status_code = 200
-        resp.json.return_value = {}
-        client.get.return_value = resp
-
-        def run():
-            _maybe_print_eth_software_notice(client, "eth", "node-id")
-
-        out = self._swallowing_capture(capsys, run)
-        assert "Network policy notice" not in out