Preserve full trust-score precision in the Python SDK

Remove legacy 3-decimal rounding from exported trust helpers so Python no longer truncates trust values below Rust-authoritative precision. Add regression tests that prove the deprecated compatibility helpers preserve full precision instead of silently rounding.

Constraint: Root and child repo guidance explicitly require no round() on trust scores for Rust parity
Constraint: The deprecated helpers remain part of the exported SDK surface, so parity fixes must cover them too
Rejected: Leave the helpers unchanged because they are deprecated | still leaks rounded values to callers and breaks parity expectations
Confidence: high
Scope-risk: narrow
Reversibility: clean
Directive: Keep any future compatibility helpers precision-preserving unless Rust itself changes the wire/math contract
Tested: python -m pytest trustchain-py/tests/test_trust_legacy_precision.py -q; python -m pytest trustchain-py/tests/ -x -q
Not-tested: Cross-language end-to-end parity harness beyond the Python SDK suite

Author: viftode4

src/trustchain/trust.py

@@ -1103,7 +1103,7 @@ def compute_trust(pubkey: str, store: RecordStore) -> float:
         + weights["age"] * age_score
         + weights["entropy"] * normalized_entropy
     )
-    return round(min(max(trust, 0.0), 1.0), 3)
+    return min(max(trust, 0.0), 1.0)
 
 
 def is_sybil_cluster(pubkeys: Set[str], store: RecordStore) -> bool:
@@ -1150,7 +1150,7 @@ def compute_transitive_trust(pubkey: str, store: RecordStore, alpha: float = 0.8
     max_pr = max(pr.values())
     if max_pr == 0:
         return 0.0
-    return round(pr.get(pubkey, 0.0) / max_pr, 3)
+    return pr.get(pubkey, 0.0) / max_pr
 
 
 def compute_chain_trust(
@@ -1176,7 +1176,7 @@ def compute_chain_trust(
         penalized = base_trust * penalty
         if integrity == 0.0:
             penalized = min(penalized, 0.1)
-        return round(min(max(penalized, 0.0), 1.0), 3)
+        return min(max(penalized, 0.0), 1.0)
 
     return base_trust
 
@@ -1249,4 +1249,4 @@ def compute_trust_with_decay(
         + weights["age"] * age_score
         + weights["entropy"] * normalized_entropy
     )
-    return round(min(max(trust, 0.0), 1.0), 3)
+    return min(max(trust, 0.0), 1.0)

tests/test_trust_legacy_precision.py

@@ -0,0 +1,81 @@
+import networkx as nx
+import pytest
+
+from trustchain.block import GENESIS_HASH
+from trustchain.record import create_record
+from trustchain.store import RecordStore
+from trustchain.trust import (
+    compute_chain_trust,
+    compute_transitive_trust,
+    compute_trust,
+    compute_trust_with_decay,
+)
+
+
+def _single_completed_record(identity_a, identity_b) -> tuple[RecordStore, int]:
+    store = RecordStore()
+    record = create_record(
+        identity_a=identity_a,
+        identity_b=identity_b,
+        seq_a=0,
+        seq_b=0,
+        prev_hash_a=GENESIS_HASH,
+        prev_hash_b=GENESIS_HASH,
+        interaction_type="service",
+        outcome="completed",
+    )
+    store.add_record(record)
+    return store, record.timestamp
+
+
+def test_compute_trust_preserves_full_precision(identity_a, identity_b):
+    store, _ = _single_completed_record(identity_a, identity_b)
+
+    trust = compute_trust(identity_a.pubkey_hex, store)
+
+    assert trust == pytest.approx(0.3025, abs=1e-12)
+    assert trust != pytest.approx(0.302, abs=1e-12)
+
+
+def test_compute_trust_with_decay_preserves_full_precision(identity_a, identity_b):
+    store, timestamp = _single_completed_record(identity_a, identity_b)
+
+    trust = compute_trust_with_decay(identity_a.pubkey_hex, store, now=timestamp)
+
+    assert trust == pytest.approx(0.3025, abs=1e-12)
+    assert trust != pytest.approx(0.302, abs=1e-12)
+
+
+def test_compute_chain_trust_preserves_full_precision(identity_a, identity_b, monkeypatch):
+    store, _ = _single_completed_record(identity_a, identity_b)
+
+    monkeypatch.setattr("trustchain.chain.compute_chain_integrity", lambda pubkey, records: 0.5)
+
+    trust = compute_chain_trust(identity_a.pubkey_hex, store)
+
+    expected = 0.3025 * (1.0 - 0.15 * (1.0 - 0.5))
+    assert trust == pytest.approx(expected, abs=1e-12)
+    assert trust != pytest.approx(round(expected, 3), abs=1e-12)
+
+
+class _DummyStore:
+    def __init__(self, graph: nx.DiGraph):
+        self._graph = graph
+
+    def get_interaction_graph(self) -> nx.DiGraph:
+        return self._graph
+
+
+def test_compute_transitive_trust_preserves_full_precision(monkeypatch):
+    graph = nx.DiGraph()
+    graph.add_edge("agent-a", "agent-b", weight=1.0)
+    store = _DummyStore(graph)
+
+    pagerank = {"agent-a": 0.1234567, "agent-b": 0.9876543}
+    monkeypatch.setattr("trustchain.trust.nx.pagerank", lambda *_args, **_kwargs: pagerank)
+
+    trust = compute_transitive_trust("agent-a", store)
+    expected = pagerank["agent-a"] / pagerank["agent-b"]
+
+    assert trust == pytest.approx(expected, abs=1e-12)
+    assert trust != pytest.approx(round(expected, 3), abs=1e-12)