satroot 3.0.1__tar.gz → 3.0.2__tar.gz

{satroot-3.0.1/src/satroot.egg-info → satroot-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: satroot
-Version: 3.0.1
+Version: 3.0.2
 Summary: SATROOT-1: one native satoshi as root witness for unbounded semantic token state.
 Author-email: parthod0x <parthms.id@gmail.com>
 License: Apache-2.0

{satroot-3.0.1 → satroot-3.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "satroot"
-version = "3.0.1"
+version = "3.0.2"
 description = "SATROOT-1: one native satoshi as root witness for unbounded semantic token state."
 readme = "README.md"
 requires-python = ">=3.10"

{satroot-3.0.1 → satroot-3.0.2/src/satroot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: satroot
-Version: 3.0.1
+Version: 3.0.2
 Summary: SATROOT-1: one native satoshi as root witness for unbounded semantic token state.
 Author-email: parthod0x <parthms.id@gmail.com>
 License: Apache-2.0

{satroot-3.0.1 → satroot-3.0.2}/src/satroot_export.py

@@ -290,10 +290,24 @@ def verify_export(
     events = _read_json(export_path / "bundle" / "signed_events.json")
     verifier = sr.make_ed25519_verifier(public_keys)
 
+    # The order of the records is not evidence, so it is reported, not
+    # enforced. Each anchor is checked on its own below: its state hash
+    # against the ledger prefix it names, its action-log head against the log,
+    # its token against its checkpoint - which is what detects rewriting and
+    # truncation, in any order. Requiring a strictly rising event_count made
+    # three honest histories unverifiable for good: two anchors at one
+    # event_count because only the action log had moved (a new checkpoint),
+    # repeated records of one checkpoint written by a scheduler before the
+    # producer stopped re-anchoring unchanged states, and two overlapping
+    # anchor runs whose timestamps returned in the opposite order. A token's
+    # genTime, not a line number, is when a checkpoint existed.
     published = 0
     pinned_count = 0
-    previous_count = -1
     pinned_event_count = 0
+    present_event_count = 0
+    in_order = True
+    repeated = 0
+    previous_position = None
     attestations = []
     for index, anchor in enumerate(anchors):
         for field in ("root_id", "state_hash", "event_count"):
@@ -303,12 +317,16 @@ def verify_export(
             raise VerificationError(f"anchor {index}: root_id does not match")
 
         count = anchor["event_count"]
-        if count <= previous_count:
-            raise VerificationError(
-                f"anchor {index}: event_count {count} does not advance on "
-                f"{previous_count}; the anchor history runs backwards"
-            )
-        previous_count = count
+        if not isinstance(count, int) or isinstance(count, bool) or count < 1:
+            raise VerificationError(f"anchor {index}: event_count {count!r} is not a positive integer")
+        position = (count, anchor.get("action_log_entries"), anchor.get("action_log_head"))
+        if previous_position is not None:
+            if position == previous_position:
+                repeated += 1
+            elif (count, position[1] or 0) < (previous_position[0], previous_position[1] or 0):
+                in_order = False
+        previous_position = position
+        present_event_count = max(present_event_count, count)
         if count > len(events):
             raise VerificationError(
                 f"anchor {index} commits to {count} events but the ledger holds "
@@ -460,6 +478,9 @@ def verify_export(
             # itself carries.
             "token_signature_verified": published > 0,
             "signers_pinned": pinned_count,
+            # Reported, not enforced: see the comment above the loop.
+            "in_file_order": in_order,
+            "repeated_checkpoints": repeated,
             # The only field that means third-party evidence.
             "third_party_timestamp_verified": pinned_count == published > 0,
             "attestations": attestations,
@@ -480,7 +501,7 @@ def verify_export(
         "ledger_completeness_checked": False,
         # Only anchors that actually carry a verified signature count.
         "history_pinned_to_event": pinned_event_count,
-        "anchors_present_pin_to_event": previous_count if anchors else 0,
+        "anchors_present_pin_to_event": present_event_count,
     }
 
 

{satroot-3.0.1 → satroot-3.0.2}/tests/test_export_verifier.py

@@ -85,3 +85,59 @@ def test_run_isolated_from_inside_the_export_planted_code_never_runs(export):
 
 def test_exports_no_longer_need_to_carry_code():
     assert not (FIXTURE / "verify_export.py").exists() and not (FIXTURE / "tokenverify.py").exists()
+
+
+# ---- 3.0.2: the order of anchor records is reported, not enforced ---------------------------
+
+def _offline_anchor(export, entries):
+    """An unpublished anchor at event 1 attesting the first `entries` action-log entries."""
+    import satroot1 as sr
+    from satroot_onchain_envelope_smoke import CONTENT_TYPE, build_envelope_payload, build_envelope_script
+
+    events = json.loads((export / "bundle" / "signed_events.json").read_text(encoding="utf-8"))
+    keys = json.loads((export / "bundle" / "public_keys.json").read_text(encoding="utf-8"))
+    state_hash = sr.replay(events[:1], verifier=sr.make_ed25519_verifier(keys), allow_unbound_keys=True).state_hash()
+    log = [json.loads(line) for line in (export / "action_log.jsonl").read_text(encoding="utf-8").splitlines() if line.strip()]
+    payload = build_envelope_payload(events[0]["root_id"], state_hash)
+    return {"content_type": CONTENT_TYPE, "root_id": events[0]["root_id"], "state_hash": state_hash,
+            "envelope_script_hex": build_envelope_script(CONTENT_TYPE, payload).hex(),
+            "payload_json": payload.decode("utf-8"), "event_count": 1, "published": False,
+            "action_log_entries": entries, "action_log_head": log[entries - 1]["entry_hash"] if entries else "genesis"}
+
+
+def _write_anchors(export, anchors):
+    (export / "anchor_commitments.json").write_text(json.dumps(anchors, indent=2) + "\n", encoding="utf-8")
+
+
+def test_anchors_at_one_event_count_verify_when_only_the_action_log_moved(export):
+    """Found on a production ledger: an action recorded between two anchors gives a new
+    checkpoint at the same event_count, and the strictly-rising rule refused the export for good."""
+    _write_anchors(export, [_offline_anchor(export, 0), _offline_anchor(export, 1)])
+    result = sx.verify_export(export)
+    assert result["anchors"]["count"] == 2
+    assert result["anchors"]["in_file_order"] is True and result["anchors"]["repeated_checkpoints"] == 0
+    assert result["anchors_present_pin_to_event"] == 1
+
+
+def test_repeated_and_reordered_anchor_records_are_reported_not_refused(export):
+    first, second = _offline_anchor(export, 0), _offline_anchor(export, 1)
+    _write_anchors(export, [second, second, first])
+    result = sx.verify_export(export)
+    assert result["anchors"]["repeated_checkpoints"] == 1
+    assert result["anchors"]["in_file_order"] is False
+
+
+def test_order_does_not_rescue_a_rewritten_anchor(export):
+    forged = _offline_anchor(export, 1)
+    forged["state_hash"] = "sha256:" + "99" * 32
+    _write_anchors(export, [_offline_anchor(export, 0), forged])
+    with pytest.raises(sx.VerificationError):
+        sx.verify_export(export)
+
+
+def test_an_anchor_event_count_must_be_a_positive_integer(export):
+    bad = _offline_anchor(export, 0)
+    bad["event_count"] = 0
+    _write_anchors(export, [bad])
+    with pytest.raises(sx.VerificationError, match="positive integer"):
+        sx.verify_export(export)