global: fixes

packages/brk_client/tests/mempool_compat/fees/test_mempool_blocks.py

@@ -3,25 +3,43 @@
 from _lib import assert_same_structure, show
 
 
-def test_fees_mempool_blocks(brk, mempool):
-    """Projected mempool blocks must have the same element structure."""
+MAX_PROJECTED_BLOCKS = 8
+BRK_FEE_RANGE_LEN = 7
+
+
+def test_fees_mempool_blocks_structure(brk, mempool):
+    """Projected mempool blocks envelope must match across the full list."""
     path = "/api/v1/fees/mempool-blocks"
-    b = brk.get_json(path)
+    b = brk.get_mempool_blocks()
     m = mempool.get_json(path)
     show("GET", path, f"({len(b)} blocks)", f"({len(m)} blocks)")
     assert isinstance(b, list) and isinstance(m, list)
-    assert len(b) > 0
-    if b and m:
-        assert_same_structure(b[0], m[0])
+    assert len(b) > 0, "expected non-empty projected blocks"
+    assert_same_structure(b, m)
 
 
-def test_fees_mempool_blocks_fee_range(brk, mempool):
-    """Each projected block must have a 7-element feeRange."""
-    path = "/api/v1/fees/mempool-blocks"
-    for label, client in [("brk", brk), ("mempool", mempool)]:
-        blocks = client.get_json(path)
-        for i, block in enumerate(blocks[:3]):
-            assert "feeRange" in block, f"{label} block {i} missing feeRange"
-            assert len(block["feeRange"]) == 7, (
-                f"{label} block {i} feeRange has {len(block['feeRange'])} items, expected 7"
-            )
+def test_fees_mempool_blocks_invariants(brk):
+    """Block counts, sizes, fees, medianFee in feeRange, ordering by descending medianFee."""
+    b = brk.get_mempool_blocks()
+    show("GET", "/api/v1/fees/mempool-blocks", f"({len(b)} blocks)", "-")
+    assert 1 <= len(b) <= MAX_PROJECTED_BLOCKS, (
+        f"projected block count out of range: {len(b)}"
+    )
+    medians = [block["medianFee"] for block in b]
+    assert medians == sorted(medians, reverse=True), (
+        f"blocks not ordered by descending medianFee: {medians}"
+    )
+    for i, block in enumerate(b):
+        assert block["blockSize"] > 0, f"block {i} has non-positive blockSize"
+        assert block["blockVSize"] > 0, f"block {i} has non-positive blockVSize"
+        assert block["nTx"] > 0, f"block {i} has non-positive nTx"
+        assert block["totalFees"] >= 0, f"block {i} has negative totalFees"
+        assert block["medianFee"] > 0, f"block {i} has non-positive medianFee"
+        fr = block["feeRange"]
+        assert len(fr) == BRK_FEE_RANGE_LEN, (
+            f"block {i} feeRange has {len(fr)} items, expected {BRK_FEE_RANGE_LEN}"
+        )
+        assert fr == sorted(fr), f"block {i} feeRange not ascending: {fr}"
+        assert fr[0] <= block["medianFee"] <= fr[-1], (
+            f"block {i} medianFee {block['medianFee']} outside feeRange [{fr[0]}, {fr[-1]}]"
+        )

packages/brk_client/tests/mempool_compat/fees/test_precise.py

@@ -3,40 +3,37 @@
 from _lib import assert_same_structure, show
 
 
-EXPECTED_FEE_KEYS = [
-    "fastestFee", "halfHourFee", "hourFee", "economyFee", "minimumFee",
-]
+EXPECTED_FEE_KEYS = ["fastestFee", "halfHourFee", "hourFee", "economyFee", "minimumFee"]
 
 
 def test_fees_precise_structure(brk, mempool):
-    """Precise fees must have the same structure as recommended."""
+    """Precise fees envelope must match mempool's keys and numeric types."""
     path = "/api/v1/fees/precise"
-    b = brk.get_json(path)
+    b = brk.get_precise_fees()
     m = mempool.get_json(path)
     show("GET", path, b, m)
     assert_same_structure(b, m)
+
+
+def test_fees_precise_invariants(brk):
+    """All tiers numeric, positive, and monotonically non-increasing."""
+    b = brk.get_precise_fees()
+    show("GET", "/api/v1/fees/precise", b, "-")
     for key in EXPECTED_FEE_KEYS:
-        assert key in b
+        assert key in b, f"missing '{key}'"
+        assert isinstance(b[key], (int, float)), f"'{key}' not numeric: {type(b[key])}"
+        assert b[key] > 0, f"'{key}' must be positive, got {b[key]}"
+    assert b["fastestFee"] >= b["halfHourFee"] >= b["hourFee"], (
+        f"fast tiers not ordered: {b}"
+    )
+    assert b["hourFee"] >= b["economyFee"] >= b["minimumFee"], (
+        f"slow tiers not ordered: {b}"
+    )
 
 
-def test_fees_precise_ordering(brk, mempool):
-    """Precise fee tiers must be ordered: fastest >= halfHour >= hour >= economy >= minimum."""
-    path = "/api/v1/fees/precise"
-    for label, client in [("brk", brk), ("mempool", mempool)]:
-        d = client.get_json(path)
-        assert d["fastestFee"] >= d["halfHourFee"] >= d["hourFee"], (
-            f"{label}: precise fee ordering violated {d}"
-        )
-        assert d["hourFee"] >= d["economyFee"] >= d["minimumFee"], (
-            f"{label}: precise fee ordering violated {d}"
-        )
-
-
-def test_fees_precise_numeric(brk):
-    """Each tier in /precise must be a non-negative number."""
-    d = brk.get_json("/api/v1/fees/precise")
-    show("GET", "/api/v1/fees/precise", d, "—")
-    for key in EXPECTED_FEE_KEYS:
-        v = d[key]
-        assert isinstance(v, (int, float)), f"{key} not numeric: {type(v).__name__}"
-        assert v >= 0, f"{key} is negative: {v}"
+def test_fees_precise_mempool_ordering_sanity(mempool):
+    """Sanity: mempool itself follows the documented ordering."""
+    d = mempool.get_json("/api/v1/fees/precise")
+    assert d["fastestFee"] >= d["halfHourFee"] >= d["hourFee"] >= d["economyFee"] >= d["minimumFee"], (
+        f"mempool tiers not ordered: {d}"
+    )

packages/brk_client/tests/mempool_compat/fees/test_recommended.py

@@ -3,31 +3,37 @@
 from _lib import assert_same_structure, show
 
 
-EXPECTED_FEE_KEYS = [
-    "fastestFee", "halfHourFee", "hourFee", "economyFee", "minimumFee",
-]
+EXPECTED_FEE_KEYS = ["fastestFee", "halfHourFee", "hourFee", "economyFee", "minimumFee"]
 
 
-def test_fees_recommended(brk, mempool):
-    """Recommended fees must have the same keys and numeric types."""
+def test_fees_recommended_structure(brk, mempool):
+    """Recommended fees envelope must match mempool's keys and numeric types."""
     path = "/api/v1/fees/recommended"
-    b = brk.get_json(path)
+    b = brk.get_recommended_fees()
     m = mempool.get_json(path)
     show("GET", path, b, m)
     assert_same_structure(b, m)
+
+
+def test_fees_recommended_invariants(brk):
+    """All tiers numeric, positive, and monotonically non-increasing."""
+    b = brk.get_recommended_fees()
+    show("GET", "/api/v1/fees/recommended", b, "-")
     for key in EXPECTED_FEE_KEYS:
-        assert key in b, f"brk missing '{key}'"
-        assert isinstance(b[key], (int, float)), f"'{key}' is not numeric: {type(b[key])}"
+        assert key in b, f"missing '{key}'"
+        assert isinstance(b[key], (int, float)), f"'{key}' not numeric: {type(b[key])}"
+        assert b[key] > 0, f"'{key}' must be positive, got {b[key]}"
+    assert b["fastestFee"] >= b["halfHourFee"] >= b["hourFee"], (
+        f"fast tiers not ordered: {b}"
+    )
+    assert b["hourFee"] >= b["economyFee"] >= b["minimumFee"], (
+        f"slow tiers not ordered: {b}"
+    )
 
 
-def test_fees_recommended_ordering(brk, mempool):
-    """Fee tiers must be ordered: fastest >= halfHour >= hour >= economy >= minimum."""
-    path = "/api/v1/fees/recommended"
-    for label, client in [("brk", brk), ("mempool", mempool)]:
-        d = client.get_json(path)
-        assert d["fastestFee"] >= d["halfHourFee"] >= d["hourFee"], (
-            f"{label}: fee ordering violated {d}"
-        )
-        assert d["hourFee"] >= d["economyFee"] >= d["minimumFee"], (
-            f"{label}: fee ordering violated {d}"
-        )
+def test_fees_recommended_mempool_ordering_sanity(mempool):
+    """Sanity: mempool itself follows the documented ordering (pins our reading of the contract)."""
+    d = mempool.get_json("/api/v1/fees/recommended")
+    assert d["fastestFee"] >= d["halfHourFee"] >= d["hourFee"] >= d["economyFee"] >= d["minimumFee"], (
+        f"mempool tiers not ordered: {d}"
+    )