openentity 0.3.1__tar.gz → 0.5.0__tar.gz

{openentity-0.3.1 → openentity-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: openentity
-Version: 0.3.1
+Version: 0.5.0
 Summary: Open Entity (OEIS-1) client: JCS, did:key, eddsa-jcs-2022, Merkle proofs, adopt().
 Project-URL: Homepage, https://openentity.org
 Project-URL: Documentation, https://oeis.dev
@@ -41,4 +41,8 @@ Exit codes match the npm CLI: 0 ok, 1 usage, 2 network, 3 verification failed, 4
 
 Library, each taking the 32-byte seed and a registry URL: `adopt(name, registry=...)`, `withdraw(seed, registry)`, `record(seed, [(kind, payload), ...], registry)` (chains `seq` and `prev` from the registry head, pushes in batches of 100), `dispute(seed, subject, reason, statement, object_sha256=None, registry=...)`, `find(registry, capability=..., q=..., alias_type=..., level=...)`, `present(seed, audience, nonce, registry=None)`. Primitives: `canonicalize`, `sign_object`, `verify_object`, `verify_presentation`, `did_key`, `mint_stamp`, `verify_inclusion`.
 
+Shared core: `Identity.load_or_create()` (key in the OS keychain, else `~/.openentity/identity.key` at 0600; pass `.seed` to the calls above), `adopt(..., client="adk")` (an unsigned label: adk, goose, langchain, ui-tars, cli, other), `trust(eid)` (a `TrustReport` from registry reads only, every signature verified locally, cached 5 minutes, `ok=False` on any failure), and `openentity.issuer` (`attestation`, `revocation`, `did_document`, `openentity_json`).
+
+HTTP message signatures (RFC 9421, Web Bot Auth profile): `sign_request(method, url, body, private_key, did)` returns `Signature-Input`, `Signature` and, for a non-empty body, `Content-Digest` (`private_key` is an `Identity`, a `KeyPair` or a 32-byte seed; ed25519, `keyid` = the signer's did:key, covers `@method`, `@target-uri`, `content-digest`; `created`, `expires`, `nonce`). `verify_request(method, url, headers, body)` returns `{"did", "keyid", "created", "expires", "nonce"}` or raises `HttpSigError` with a `.code` (`missing_headers`, `unknown_alg`, `bad_keyid`, `digest_mismatch`, `created_in_future`, `created_too_old`, `expired`, `lifetime_too_long`, `missing_nonce`, `bad_signature`). Nonce replay tracking is yours. Shared vectors: `test-vectors/http-signature.json`.
+
 Written from the spec text alone, independent of the TypeScript SDK.

{openentity-0.3.1 → openentity-0.5.0}/README.md

@@ -28,4 +28,8 @@ Exit codes match the npm CLI: 0 ok, 1 usage, 2 network, 3 verification failed, 4
 
 Library, each taking the 32-byte seed and a registry URL: `adopt(name, registry=...)`, `withdraw(seed, registry)`, `record(seed, [(kind, payload), ...], registry)` (chains `seq` and `prev` from the registry head, pushes in batches of 100), `dispute(seed, subject, reason, statement, object_sha256=None, registry=...)`, `find(registry, capability=..., q=..., alias_type=..., level=...)`, `present(seed, audience, nonce, registry=None)`. Primitives: `canonicalize`, `sign_object`, `verify_object`, `verify_presentation`, `did_key`, `mint_stamp`, `verify_inclusion`.
 
+Shared core: `Identity.load_or_create()` (key in the OS keychain, else `~/.openentity/identity.key` at 0600; pass `.seed` to the calls above), `adopt(..., client="adk")` (an unsigned label: adk, goose, langchain, ui-tars, cli, other), `trust(eid)` (a `TrustReport` from registry reads only, every signature verified locally, cached 5 minutes, `ok=False` on any failure), and `openentity.issuer` (`attestation`, `revocation`, `did_document`, `openentity_json`).
+
+HTTP message signatures (RFC 9421, Web Bot Auth profile): `sign_request(method, url, body, private_key, did)` returns `Signature-Input`, `Signature` and, for a non-empty body, `Content-Digest` (`private_key` is an `Identity`, a `KeyPair` or a 32-byte seed; ed25519, `keyid` = the signer's did:key, covers `@method`, `@target-uri`, `content-digest`; `created`, `expires`, `nonce`). `verify_request(method, url, headers, body)` returns `{"did", "keyid", "created", "expires", "nonce"}` or raises `HttpSigError` with a `.code` (`missing_headers`, `unknown_alg`, `bad_keyid`, `digest_mismatch`, `created_in_future`, `created_too_old`, `expired`, `lifetime_too_long`, `missing_nonce`, `bad_signature`). Nonce replay tracking is yours. Shared vectors: `test-vectors/http-signature.json`.
+
 Written from the spec text alone, independent of the TypeScript SDK.

openentity-0.5.0/openentity/__init__.py

@@ -0,0 +1,8 @@
+from .client import adopt, dispute, find, present, record, rotate, withdraw  # noqa: F401
+from .core import *  # noqa: F401,F403
+from . import issuer  # noqa: F401
+from .httpsig import HttpSigError, sign_request, verify_request  # noqa: F401
+from .identity import Identity  # noqa: F401
+from .report import TrustReport, trust  # noqa: F401
+
+__version__ = "0.5.0"

{openentity-0.3.1 → openentity-0.5.0}/openentity/cli.py

@@ -143,7 +143,7 @@ def _adopt(args):
     if not args.agree:
         raise CliError(EXIT_USAGE, "adopt signs the Open Entity Declaration. Read it, then re-run with --agree:\n\n" + core.DECLARATION_TEXT)
     reg = _registry(args)
-    res = client.adopt(args.name, args.description, reg)
+    res = client.adopt(args.name, args.description, reg, client="cli")
     key_path = _save_key({**res, "name": args.name, "registry": reg})
     if not res["record_pushed"]:
         print("warning: the declaration record entry was not accepted; push it later", file=sys.stderr)

{openentity-0.3.1 → openentity-0.5.0}/openentity/client.py

@@ -8,6 +8,7 @@ import urllib.request
 from . import core
 
 DEFAULT_REGISTRY = "https://openentity.org"
+CLIENTS = ("adk", "goose", "langchain", "ui-tars", "cli", "other")  # the registry's allowlist for the unsigned `client` label
 
 
 class RegistryError(Exception):
@@ -59,13 +60,16 @@ def build_adoption(kp: core.KeyPair, name: str, description: str, registry: str)
 
 
 def adopt(name: str, description: str = "An Open Entity adopted through the Python client.",
-          registry: str = DEFAULT_REGISTRY, seed: bytes | None = None) -> dict:
-    """Adopt on `registry`. Returns the registry response plus `did` and `seed_hex` (keep the seed)."""
+          registry: str = DEFAULT_REGISTRY, seed: bytes | None = None, client: str | None = None) -> dict:
+    """Adopt on `registry`. Returns the registry response plus `did` and `seed_hex` (keep the seed).
+    `client` is an optional label (one of CLIENTS) for the registry's per-client count; it is not signed."""
+    if client is not None and client not in CLIENTS:
+        raise ValueError(f"client must be one of {', '.join(CLIENTS)}")
     registry = registry.rstrip("/")
     kp = core.KeyPair(seed)
     bits = int(_request(f"{registry}/v1/spec")["stamp_bits"])
     document, declaration = build_adoption(kp, name, description, registry)
-    out = _request(f"{registry}/v1/adopt", {"document": document, "declaration": declaration},
+    out = _request(f"{registry}/v1/adopt", {"document": document, "declaration": declaration, **({"client": client} if client else {})},
                    {"x-oe-stamp": core.mint_stamp(bits, kp.did)})
     # Seq-1 declaration entry (spec 7.3). The registry never writes entries; on failure the signed
     # entry is returned so the caller can push it later.

{openentity-0.3.1 → openentity-0.5.0}/openentity/core.py

@@ -140,15 +140,16 @@ def _signing_input(obj: dict, proof: dict) -> bytes:
     return canonical_hash(config) + canonical_hash(doc)
 
 
-def sign_proof(obj: dict, kp: KeyPair, created: str | None = None) -> dict:
+def sign_proof(obj: dict, kp: KeyPair, created: str | None = None, method: str | None = None) -> dict:
+    """`method` names the verification method; it defaults to the did:key of `kp`, a did:web signer passes `did:web:x#key-1`."""
     proof = {"type": "DataIntegrityProof", "cryptosuite": "eddsa-jcs-2022", "created": created or now(),
-             "verificationMethod": verification_method(kp.did), "proofPurpose": "assertionMethod"}
+             "verificationMethod": method or verification_method(kp.did), "proofPurpose": "assertionMethod"}
     sig = kp.private.sign(_signing_input(obj, proof))
     return {**proof, "proofValue": "z" + b58encode(sig)}
 
 
-def sign_object(obj: dict, kp: KeyPair, created: str | None = None) -> dict:
-    return {**{k: v for k, v in obj.items() if k != "proof"}, "proof": sign_proof(obj, kp, created)}
+def sign_object(obj: dict, kp: KeyPair, created: str | None = None, method: str | None = None) -> dict:
+    return {**{k: v for k, v in obj.items() if k != "proof"}, "proof": sign_proof(obj, kp, created, method)}
 
 
 # ---- continuity (spec 9) ----

openentity-0.5.0/openentity/httpsig.py

@@ -0,0 +1,110 @@
+"""RFC 9421 HTTP message signatures, Open Entity profile: ed25519, keyid = the signer's did:key,
+covered ("@method" "@target-uri" "content-digest"), Content-Digest per RFC 9530, label sig1."""
+import base64
+import hashlib
+import os
+import re
+import time
+from collections.abc import Mapping
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey, Ed25519PublicKey
+
+from . import core
+
+SKEW = 5  # seconds of clock skew allowed on `created`
+
+
+class HttpSigError(Exception):
+    def __init__(self, code: str):
+        super().__init__(code)
+        self.code = code
+
+
+def _b64url(b: bytes) -> str:
+    return base64.urlsafe_b64encode(b).rstrip(b"=").decode()
+
+
+def _digest(body: bytes) -> str:
+    return f"sha-256=:{base64.b64encode(hashlib.sha256(body).digest()).decode()}:"
+
+
+def _base(method: str, url: str, components: list[str], digest: str | None, params: str) -> bytes:
+    lines = []
+    for c in components:
+        v = {"@method": method.upper(), "@target-uri": url, "content-digest": digest}[c]
+        lines.append(f'"{c}": {v}')
+    lines.append(f'"@signature-params": {params}')
+    return "\n".join(lines).encode()
+
+
+def _seed(key) -> bytes:
+    for attr in ("seed", "kp"):  # Identity -> KeyPair -> seed
+        if hasattr(key, attr):
+            return _seed(getattr(key, attr))
+    if isinstance(key, (bytes, bytearray)) and len(key) == 32:
+        return bytes(key)
+    raise ValueError("private_key must be an Identity, a KeyPair or a 32-byte Ed25519 seed")
+
+
+def sign_request(method: str, url: str, body: bytes, private_key, did: str, *, created: int | None = None,
+                 expires_in: int = 60, nonce: str | None = None) -> dict[str, str]:
+    created = int(time.time()) if created is None else created
+    nonce = nonce or _b64url(os.urandom(16))
+    out = {}
+    comps = ["@method", "@target-uri"]
+    if body:
+        out["Content-Digest"] = _digest(body)
+        comps.append("content-digest")
+    params = f'({" ".join(chr(34) + c + chr(34) for c in comps)});created={created};expires={created + expires_in};nonce="{nonce}";keyid="{did}";alg="ed25519"'
+    sig = Ed25519PrivateKey.from_private_bytes(_seed(private_key)).sign(_base(method, url, comps, out.get("Content-Digest"), params))
+    out["Signature-Input"] = f"sig1={params}"
+    out["Signature"] = f"sig1=:{base64.b64encode(sig).decode()}:"
+    return out
+
+
+def verify_request(method: str, url: str, headers: Mapping[str, str], body: bytes, *, now: int | None = None,
+                   max_age: int = 300) -> dict:
+    h = {k.lower(): v for k, v in headers.items()}
+    if "signature-input" not in h or "signature" not in h:
+        raise HttpSigError("missing_headers")
+    m = re.search(r"(?:^|,)\s*sig1=(\(([^)]*)\)((?:;[a-z]+=(?:\d+|\"[^\"]*\"))*))", h["signature-input"])
+    s = re.search(r"(?:^|,)\s*sig1=:([A-Za-z0-9+/]+={0,2}):", h["signature"])
+    if not m or not s:
+        raise HttpSigError("missing_headers")
+    params, comps = m.group(1), re.findall(r'"([^"]*)"', m.group(2))
+    p = {k: (v[1:-1] if v.startswith('"') else int(v)) for k, v in re.findall(r";([a-z]+)=(\d+|\"[^\"]*\")", m.group(3))}
+    if p.get("alg") != "ed25519":
+        raise HttpSigError("unknown_alg")
+    keyid = p.get("keyid", "")
+    try:
+        public = core.public_from_did_key(keyid)
+        if core.did_key(public) != keyid:
+            raise ValueError
+    except Exception:
+        raise HttpSigError("bad_keyid") from None
+    if not (isinstance(p.get("created"), int) and isinstance(p.get("expires"), int)):
+        raise HttpSigError("missing_headers")
+    if len(p.get("nonce", "")) < 22:  # 16 bytes in base64url
+        raise HttpSigError("missing_nonce")
+    if comps[:2] != ["@method", "@target-uri"] or comps[2:] not in ([], ["content-digest"]):
+        raise HttpSigError("missing_headers")
+    digest = None
+    if body or "content-digest" in comps:
+        digest = h.get("content-digest")
+        if "content-digest" not in comps or digest != _digest(body):
+            raise HttpSigError("digest_mismatch")
+    now = int(time.time()) if now is None else now
+    if p["created"] > now + SKEW:
+        raise HttpSigError("created_in_future")
+    if now - p["created"] > max_age:
+        raise HttpSigError("created_too_old")
+    if p["expires"] < now:
+        raise HttpSigError("expired")
+    if p["expires"] - p["created"] > max_age:
+        raise HttpSigError("lifetime_too_long")
+    try:
+        Ed25519PublicKey.from_public_bytes(public).verify(base64.b64decode(s.group(1)), _base(method, url, comps, digest, params))
+    except (InvalidSignature, ValueError):
+        raise HttpSigError("bad_signature") from None
+    return {"did": keyid, "keyid": keyid, "created": p["created"], "expires": p["expires"], "nonce": p["nonce"]}

openentity-0.5.0/openentity/identity.py

@@ -0,0 +1,72 @@
+"""Identity.load_or_create(): the entity's key from the OS keychain, else ~/.openentity/identity.key (mode 0600).
+A fresh key goes to the keychain when one answers, otherwise to the file. Set OPENENTITY_KEYCHAIN=off to use the file only."""
+import os
+import pathlib
+import subprocess
+import sys
+
+from . import core
+
+SERVICE, ACCOUNT = "openentity", "identity"
+
+
+def _run(argv: list[str], stdin: str | None = None) -> str | None:
+    try:
+        r = subprocess.run(argv, input=stdin, capture_output=True, text=True, timeout=10)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return r.stdout.strip() if r.returncode == 0 else None
+
+
+def _keychain_get() -> str | None:
+    if os.environ.get("OPENENTITY_KEYCHAIN") == "off":
+        return None
+    if sys.platform == "darwin":
+        return _run(["security", "find-generic-password", "-s", SERVICE, "-a", ACCOUNT, "-w"])
+    if sys.platform.startswith("linux"):
+        return _run(["secret-tool", "lookup", "service", SERVICE, "account", ACCOUNT])
+
+
+def _keychain_set(seed_hex: str) -> bool:
+    if os.environ.get("OPENENTITY_KEYCHAIN") == "off":
+        return False
+    if sys.platform == "darwin":  # ponytail: the seed is briefly on argv, visible to this user's processes only
+        return _run(["security", "add-generic-password", "-U", "-s", SERVICE, "-a", ACCOUNT, "-w", seed_hex]) is not None
+    if sys.platform.startswith("linux"):
+        return _run(["secret-tool", "store", "--label=Open Entity key", "service", SERVICE, "account", ACCOUNT], seed_hex) is not None
+    return False
+
+
+def _file() -> pathlib.Path:
+    return pathlib.Path(os.environ.get("OPENENTITY_HOME", "~/.openentity")).expanduser() / "identity.key"
+
+
+class Identity:
+    def __init__(self, seed: bytes, source: str):
+        self.kp, self.source = core.KeyPair(seed), source
+
+    @property
+    def did(self) -> str:
+        return self.kp.did
+
+    @property
+    def seed(self) -> bytes:  # pass to adopt(), present(), record() and the other seed-keyed calls
+        return self.kp.seed
+
+    @classmethod
+    def load_or_create(cls) -> "Identity":
+        for source, read in (("keychain", _keychain_get), ("file", lambda: _file().read_text().strip() if _file().exists() else None)):
+            if h := read():
+                return cls(bytes.fromhex(h), source)
+        seed = os.urandom(32)
+        if _keychain_set(seed.hex()):
+            return cls(seed, "keychain")
+        path = _file()
+        path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        try:
+            fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+        except FileExistsError:  # another process created it first
+            return cls(bytes.fromhex(path.read_text().strip()), "file")
+        with os.fdopen(fd, "w") as f:
+            f.write(seed.hex())
+        return cls(seed, "file")

openentity-0.5.0/openentity/issuer.py

@@ -0,0 +1,61 @@
+"""Issuer helpers (ADR 0003): sign attestations and revocations, build a did:web issuer's two well-known files.
+
+`issuer` defaults to the signer's did:key. A did:web issuer passes its DID; the proof then names `<issuer>#<key_id>`,
+the key `did_document` publishes. Registry submission stays with `client` (POST /v1/attestations, stamped, spec 10.4)."""
+from datetime import datetime, timedelta, timezone
+
+from . import core
+
+MAX_TTL = timedelta(days=365)  # spec 8.4
+
+
+def _ts(t: datetime) -> str:
+    return t.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _method(kp: core.KeyPair, issuer: str | None, key_id: str) -> str | None:
+    return f"{issuer}#{key_id}" if issuer and issuer != kp.did else None
+
+
+def attestation(kp: core.KeyPair, subject: str, claim_type: str, claim: dict, *, issuer: str | None = None,
+                key_id: str = "key-1", evidence: dict | None = None, confidence: float | None = None,
+                ttl: timedelta = timedelta(days=90), now: datetime | None = None) -> dict:
+    """A signed Attestation (spec 8.2). `ttl` is capped at one year."""
+    if not timedelta(0) < ttl <= MAX_TTL:
+        raise ValueError("ttl must be positive and at most 1 year")
+    t = now or datetime.now(timezone.utc)
+    created = _ts(t)
+    obj = {"spec": core.SPEC, "type": "Attestation", "issuer": issuer or kp.did, "subject": subject,
+           "claim_type": claim_type, "claim": claim, **({"evidence": evidence} if evidence else {}),
+           **({"confidence": confidence} if confidence is not None else {}), "created": created, "expires": _ts(t + ttl)}
+    return core.sign_object(obj, kp, created, _method(kp, issuer, key_id))
+
+
+def revocation(kp: core.KeyPair, attested: dict | str, *, issuer: str | None = None, key_id: str = "key-1",
+               reason: str | None = None, now: datetime | None = None) -> dict:
+    """A signed Revocation naming the attestation (the object, or its SHA-256 hex) (spec 8.4)."""
+    sha = core.canonical_hash(attested).hex() if isinstance(attested, dict) else attested
+    created = _ts(now or datetime.now(timezone.utc))
+    obj = {"spec": core.SPEC, "type": "Revocation", "issuer": issuer or kp.did, "attestation_sha256": sha,
+           **({"reason": reason} if reason else {}), "created": created}
+    return core.sign_object(obj, kp, created, _method(kp, issuer, key_id))
+
+
+def did_document(did: str, public: bytes, key_id: str = "key-1") -> dict:
+    """The body of `https://<domain>/.well-known/did.json` for a did:web issuer."""
+    vm = f"{did}#{key_id}"
+    return {"@context": ["https://www.w3.org/ns/did/v1", "https://w3id.org/security/multikey/v1"], "id": did,
+            "verificationMethod": [{"id": vm, "type": "Multikey", "controller": did,
+                                    "publicKeyMultibase": core.did_key(public).removeprefix("did:key:")}],
+            "assertionMethod": [vm], "authentication": [vm]}
+
+
+def openentity_json(did: str, public: bytes, name: str, description: str, *, key_id: str = "key-1",
+                    operator: dict | None = None, extensions: dict | None = None) -> dict:
+    """The unsigned body of `https://<domain>/.well-known/openentity.json`: the domain alias proof (spec 3.4) and,
+    under `extensions["openentity:observer"]`, an observer's methodology (spec 8.4)."""
+    return {"spec": core.SPEC, "eid": did, "name": name, "description": description,
+            "keys": [{"id": f"{did}#{key_id}", "type": "Multikey",
+                      "publicKeyMultibase": core.did_key(public).removeprefix("did:key:")}],
+            "operator": operator or {"kind": "organization", "name": name, "custody": "operator", "can_change": []},
+            **({"extensions": extensions} if extensions else {})}

openentity-0.5.0/openentity/report.py

@@ -0,0 +1,101 @@
+"""trust(eid): one TrustReport from registry reads only (ADR 0002). Every attestation and revocation is verified
+locally against its issuer's key; any failure returns an untrusted report (fail closed). Cached for 5 minutes."""
+import time
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from urllib.parse import unquote
+
+from . import client, core
+
+MOLTBOTDEN, CLAWGRC = "did:web:moltbotden.com", "did:web:api.clawgrc.com"
+SMA = ("did:web:securemyagent.ai", "did:pkh:eip155:8453:0x62fef02E2859726EC1c0B534853Ad2cdd5FdDE1a")
+TIER, POSTURE, VIOLATION = "trust_tier", "custom:securemyagent:security_posture", "custom:clawgrc:violation"
+ACCEPT = {TIER: (MOLTBOTDEN, CLAWGRC), POSTURE: SMA, VIOLATION: (CLAWGRC,)}  # claim_type -> issuers read; others are ignored
+CACHE_SECONDS = 300
+_cache: dict = {}
+
+
+@dataclass(frozen=True)
+class TrustReport:
+    eid: str
+    ok: bool  # False: a read failed or a signature did not verify. Treat the entity as untrusted.
+    error: str | None = None
+    level: str | None = None  # registry level, "L0" to "L3"
+    withdrawn: bool = False
+    trust_tier: dict = field(default_factory=dict)  # issuer DID -> newest live tier (0 to 4)
+    security_posture: dict | None = None  # claim of the newest live custom:securemyagent:security_posture
+    violations: list = field(default_factory=list)  # live custom:clawgrc:violation: issuer, severity, policy, observed_at, sha256
+    revocations: list = field(default_factory=list)  # verified revocations of the accepted attestations
+
+
+def did_web_resolver(fetch=client._request):
+    """did:web through /.well-known/did.json (or <path>/did.json); everything else offline."""
+    def resolve(did: str) -> dict:
+        if not did.startswith("did:web:"):
+            return core.default_resolver(did)
+        host, *path = [unquote(p) for p in did[8:].split(":")]
+        doc = fetch(f"https://{host}/{'/'.join(path) if path else '.well-known'}/did.json")
+        if doc.get("id") != did:
+            raise ValueError(f"{did} document names {doc.get('id')}")
+        keys = []
+        for vm in doc.get("verificationMethod", []):
+            try:
+                keys.append(core.public_from_did_key("did:key:" + vm["publicKeyMultibase"]))
+            except (KeyError, ValueError):
+                continue  # not an Ed25519 Multikey
+        return {"ed25519": keys}
+    return resolve
+
+
+def trust(eid: str, registry: str = client.DEFAULT_REGISTRY, *, now: datetime | None = None, fetch=client._request,
+          resolver=None) -> TrustReport:
+    key = (registry, eid)
+    hit = _cache.get(key)
+    if hit and time.monotonic() - hit[0] < CACHE_SECONDS:
+        return hit[1]
+    try:
+        report = _read(eid, registry.rstrip("/"), now or datetime.now(timezone.utc), fetch, resolver or did_web_resolver(fetch))
+    except Exception as e:  # fail closed on anything: network, registry, schema, signature
+        return TrustReport(eid, False, f"{type(e).__name__}: {e}")
+    _cache[key] = (time.monotonic(), report)
+    return report
+
+
+def _read(eid, base, now, fetch, resolver) -> TrustReport:
+    if not eid.startswith("did:"):
+        raise ValueError("eid must be a DID")
+    ent = fetch(f"{base}/v1/entities/{eid}")
+    if ent["eid"] != eid:
+        raise ValueError(f"registry answered for {ent['eid']}")
+    rows = fetch(f"{base}/v1/entities/{eid}/attestations")["attestations"]
+    tiers, posture, violations, revocations = {}, None, [], []
+    for r in sorted(rows, key=lambda r: r["attestation"]["created"], reverse=True):
+        a, ct = r["attestation"], r["attestation"].get("claim_type")
+        if a.get("issuer", "").lower() not in {i.lower() for i in ACCEPT.get(ct, ())}:
+            continue
+        if r.get("inherited_from") and ct != VIOLATION:
+            continue  # a rotation does not carry positive claims; a strike follows the entity
+        sha, ended = r["sha256"], core._ts(a["expires"]) <= now
+        if a["subject"] != (r.get("inherited_from") or eid) or core.canonical_hash(a).hex() != sha:
+            raise ValueError(f"attestation {sha} does not match what the registry served")
+        ok, signer = core.verify_object(a, resolver)
+        if not ok or signer != a["issuer"]:
+            raise ValueError(f"attestation {sha}: {signer}")
+        rv = r.get("revocation")
+        if rv:
+            ok, signer = core.verify_object(rv, resolver)
+            if not ok or signer != a["issuer"] or rv["attestation_sha256"] != sha:
+                raise ValueError(f"revocation of {sha}: {signer}")
+            revocations.append({"sha256": sha, "claim_type": ct, "issuer": a["issuer"], "reason": rv.get("reason"), "at": rv["created"]})
+        elif r.get("revoked_at"):
+            raise ValueError(f"registry reports a revocation of {sha} it does not carry")
+        if ended or rv:
+            continue
+        c = a["claim"]
+        if ct == TIER:
+            tiers.setdefault(a["issuer"], c["tier"])
+        elif ct == POSTURE:
+            posture = posture or c
+        else:
+            violations.append({"issuer": a["issuer"], "severity": c["severity"], "policy": c["policy"], "observed_at": c["observed_at"], "sha256": sha})
+    return TrustReport(eid, True, None, ent["level"], bool(ent.get("withdrawn")), tiers, posture, violations, revocations)

{openentity-0.3.1 → openentity-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openentity"
-version = "0.3.1"
+version = "0.5.0"
 description = "Open Entity (OEIS-1) client: JCS, did:key, eddsa-jcs-2022, Merkle proofs, adopt()."
 readme = "README.md"
 license = "MIT"

{openentity-0.3.1 → openentity-0.5.0}/tests/test_core.py

@@ -155,7 +155,7 @@ class _Stub(BaseHTTPRequestHandler):
             return self._send(200, {"accepted": 1})
         doc, decl = body["document"], body["declaration"]
         stamp = self.headers["x-oe-stamp"]
-        _Stub.seen = {"stamp": stamp, "doc": doc, "decl": decl}
+        _Stub.seen = {"stamp": stamp, "doc": doc, "decl": decl, "client": body.get("client")}
         assert core.check_stamp(stamp, 8, doc["eid"]) is None
         assert core.verify_object(doc)[0] and core.verify_object(decl)[0]
         assert decl["text_sha256"] == core.DECLARATION_SHA256 and doc["eid"] == decl["eid"]
@@ -168,13 +168,16 @@ def test_adopt_and_cli(tmp_path, monkeypatch, capsys):
     url = f"http://127.0.0.1:{srv.server_port}"
     try:
         from openentity import adopt
-        res = adopt("Tester", registry=url, seed=SEED)
+        res = adopt("Tester", registry=url, seed=SEED, client="adk")
+        assert _Stub.seen["client"] == "adk"  # the unsigned label travels beside the signed objects
+        with pytest.raises(ValueError):
+            adopt("Tester", registry=url, seed=SEED, client="nope")
         assert res["eid"] == res["did"] == core.KeyPair(SEED).did
         assert res["record_pushed"] and _Stub.seen["entry"]["eid"] == res["eid"]
         monkeypatch.setenv("OPENENTITY_HOME", str(tmp_path))
         assert cli.main(["adopt", "--name", "T2", "--agree", "--registry", url, "--json"]) == 0
         out = json.loads(capsys.readouterr().out)
-        assert "seed_hex" not in out and Path(out["key_file"]).exists()
+        assert "seed_hex" not in out and Path(out["key_file"]).exists() and _Stub.seen["client"] == "cli"
         assert cli.main(["adopt", "--name", "T3", "--registry", url]) == 1  # no --agree, nothing signed
     finally:
         srv.shutdown()
@@ -183,7 +186,7 @@ def test_adopt_and_cli(tmp_path, monkeypatch, capsys):
 def test_cli_version(capsys):
     with pytest.raises(SystemExit) as e:
         cli.main(["--version"])
-    assert e.value.code == 0 and "0.3.1" in capsys.readouterr().out
+    assert e.value.code == 0 and "0.5.0" in capsys.readouterr().out
 
 
 # ---- shared vectors, checked with the independent verifier's own logic ----

openentity-0.5.0/tests/test_httpsig.py

@@ -0,0 +1,116 @@
+import base64
+import json
+from pathlib import Path
+
+import pytest
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+from openentity import HttpSigError, Identity, core, sign_request, verify_request
+from openentity.httpsig import _base, _digest
+
+VEC = json.loads((Path(__file__).resolve().parents[3] / "test-vectors/http-signature.json").read_text())
+SEED = bytes(range(1, 33))  # published throwaway seed, test-vectors/keys.json
+KP = core.KeyPair(SEED)
+URL, NOW, BODY = "https://gw.example.com/v1/x", 1_800_000_000, b'{"a":1}'
+NONCE = "AAECAwQFBgcICQoLDA0ODw"
+
+
+def req(**kw):
+    return sign_request("POST", URL, BODY, SEED, KP.did, created=NOW, nonce=NONCE, **kw)
+
+
+def check(h, code, **kw):
+    with pytest.raises(HttpSigError) as e:
+        verify_request(kw.pop("method", "POST"), kw.pop("url", URL), h, kw.pop("body", BODY), now=kw.pop("now", NOW), **kw)
+    assert e.value.code == code
+
+
+def forge(params, comps=("@method", "@target-uri", "content-digest"), body=BODY, key=SEED):
+    """A correctly signed request with arbitrary Signature-Input parameters."""
+    h = {"Content-Digest": _digest(body)} if body else {}
+    sig = Ed25519PrivateKey.from_private_bytes(key).sign(_base("POST", URL, list(comps), h.get("Content-Digest"), params))
+    return {**h, "Signature-Input": f"sig1={params}", "Signature": f"sig1=:{base64.b64encode(sig).decode()}:"}
+
+
+def params(created=NOW, expires=NOW + 60, nonce=NONCE, keyid=KP.did, alg="ed25519", comps='"@method" "@target-uri" "content-digest"'):
+    n = f';nonce="{nonce}"' if nonce else ""
+    return f'({comps});created={created};expires={expires}{n};keyid="{keyid}";alg="{alg}"'
+
+
+@pytest.mark.parametrize("case", VEC["valid"], ids=lambda c: c["name"])
+def test_vectors_sign_and_verify(case):
+    h = sign_request(case["method"], case["url"], case["body"].encode(), SEED, VEC["did"], created=case["created"],
+                     expires_in=case["expires_in"], nonce=case["nonce"])
+    assert h == case["headers"]  # byte-identical to the TS SDK
+    out = verify_request(case["method"], case["url"], case["headers"], case["body"].encode(), now=VEC["now"])
+    assert out == {"did": VEC["did"], "keyid": VEC["did"], "created": case["created"], "expires": case["created"] + 60, "nonce": case["nonce"]}
+
+
+@pytest.mark.parametrize("case", VEC["invalid"], ids=lambda c: c["name"])
+def test_vectors_reject(case):
+    check(case["headers"], case["code"], method=case["method"], url=case["url"], body=case["body"].encode(), now=case.get("now", VEC["now"]))
+
+
+def test_roundtrip_and_key_types():
+    assert verify_request("post", URL, req(), BODY, now=NOW)["did"] == KP.did
+    for key in (KP, Identity(SEED, "test")):
+        assert sign_request("POST", URL, BODY, key, KP.did, created=NOW, nonce=NONCE) == req()
+    h = sign_request("GET", URL, b"", SEED, KP.did)
+    assert "Content-Digest" not in h and "content-digest" not in h["Signature-Input"]
+    assert verify_request("GET", URL, h, b"")["did"] == KP.did
+
+
+def test_header_lookup_is_case_insensitive():
+    h = {k.lower(): v for k, v in req().items()}
+    assert verify_request("POST", URL, h, BODY, now=NOW)
+
+
+def test_missing_headers():
+    check({}, "missing_headers")
+    check({k: v for k, v in req().items() if k != "Signature"}, "missing_headers")
+    check({**req(), "Signature": "garbage"}, "missing_headers")
+
+
+def test_unknown_alg():
+    check(forge(params(alg="rsa-pss-sha512")), "unknown_alg")
+
+
+def test_bad_keyid():
+    check(forge(params(keyid="did:web:example.com")), "bad_keyid")
+    check(forge(params(keyid="did:key:zQ3shokFTS3brHcDQrn82RUDfCZESWL1ZdCEJwekUDPQiYBme")), "bad_keyid")  # secp256k1
+
+
+def test_digest_mismatch():
+    check(req(), "digest_mismatch", body=b"other")
+    check({k: v for k, v in req().items() if k != "Content-Digest"}, "digest_mismatch")
+    check(forge(params(comps='"@method" "@target-uri"')), "digest_mismatch")  # body present, digest not covered
+
+
+def test_created_in_future_and_skew():
+    check(req(), "created_in_future", now=NOW - 6)
+    assert verify_request("POST", URL, req(), BODY, now=NOW - 5)
+
+
+def test_created_too_old():
+    check(forge(params(created=NOW - 400, expires=NOW + 10)), "created_too_old")
+    check(req(), "created_too_old", now=NOW + 301, max_age=300)
+
+
+def test_expired():
+    check(req(), "expired", now=NOW + 61)
+
+
+def test_lifetime_too_long():
+    check(forge(params(expires=NOW + 301)), "lifetime_too_long")
+    check(sign_request("POST", URL, BODY, SEED, KP.did, created=NOW, nonce=NONCE, expires_in=200), "lifetime_too_long", max_age=100)
+
+
+def test_missing_nonce():
+    check(forge(params(nonce=None)), "missing_nonce")
+    check(forge(params(nonce="short")), "missing_nonce")
+
+
+def test_bad_signature():
+    check(req(), "bad_signature", url=URL + "?y=1")
+    check(req(), "bad_signature", method="GET")
+    check(forge(params(), key=bytes(32)), "bad_signature")  # signed by another key

openentity-0.5.0/tests/test_identity.py

@@ -0,0 +1,47 @@
+import os
+import stat
+
+import pytest
+
+from openentity import identity
+from openentity.identity import Identity
+
+
+@pytest.fixture(autouse=True)
+def home(tmp_path, monkeypatch):
+    monkeypatch.setenv("OPENENTITY_HOME", str(tmp_path))
+    monkeypatch.setenv("OPENENTITY_KEYCHAIN", "off")
+    return tmp_path
+
+
+def test_file_fallback_is_0600_and_stable():
+    a = Identity.load_or_create()
+    f = identity._file()
+    assert a.source == "file" and stat.S_IMODE(f.stat().st_mode) == 0o600 and stat.S_IMODE(f.parent.stat().st_mode) == 0o700
+    b = Identity.load_or_create()
+    assert (b.did, b.source) == (a.did, "file") and b.seed == a.seed
+
+
+def test_keychain_wins_and_holds_the_only_copy(monkeypatch):
+    store = {}
+
+    def run(argv, stdin=None):
+        if argv[0] == "security" and argv[1] == "find-generic-password":
+            return store.get("k")
+        if argv[0] == "security":
+            store["k"] = argv[-1]
+            return ""
+        return None
+
+    monkeypatch.delenv("OPENENTITY_KEYCHAIN")
+    monkeypatch.setattr(identity, "_run", run)
+    monkeypatch.setattr(identity.sys, "platform", "darwin")
+    a = Identity.load_or_create()
+    assert a.source == "keychain" and store["k"] == a.seed.hex() and not identity._file().exists()
+    assert Identity.load_or_create().did == a.did
+
+
+def test_keychain_failure_falls_back_to_file(monkeypatch):
+    monkeypatch.delenv("OPENENTITY_KEYCHAIN")
+    monkeypatch.setattr(identity, "_run", lambda argv, stdin=None: None)  # no `security`, no `secret-tool`
+    assert Identity.load_or_create().source == "file"

openentity-0.5.0/tests/test_issuer.py

@@ -0,0 +1,46 @@
+"""Issuer helpers: a did:web issuer signs, anyone verifies against the published did.json."""
+from datetime import datetime, timedelta, timezone
+
+import pytest
+
+from openentity import core, issuer
+
+KP = core.KeyPair(bytes(range(1, 33)))  # published throwaway seed from test-vectors
+SUBJECT = core.KeyPair(bytes(range(33, 65))).did
+DID = "did:web:issuer.example"
+NOW = datetime(2026, 10, 27, 12, 0, tzinfo=timezone.utc)
+
+
+def resolver(did):
+    assert did == DID
+    return {"ed25519": [core.public_from_did_key("did:key:" + issuer.did_document(DID, KP.public)["verificationMethod"][0]["publicKeyMultibase"])]}
+
+
+def test_attestation_verifies_against_did_json_and_expires_on_ttl():
+    a = issuer.attestation(KP, SUBJECT, "trust_tier", {"tier": 2, "platform": "x"}, issuer=DID, ttl=timedelta(days=30), now=NOW)
+    assert (a["issuer"], a["created"], a["expires"]) == (DID, "2026-10-27T12:00:00Z", "2026-11-26T12:00:00Z")
+    assert a["proof"]["verificationMethod"] == f"{DID}#key-1"
+    assert core.verify_object(a, resolver) == (True, DID)
+    assert not core.verify_object({**a, "claim": {"tier": 4, "platform": "x"}}, resolver)[0]
+
+
+def test_did_key_issuer_needs_no_key_id_and_ttl_is_capped():
+    a = issuer.attestation(KP, SUBJECT, "stage", {"stage": "agent", "profile": "p"}, evidence={"kind": "t"}, confidence=0.5, now=NOW)
+    assert a["issuer"] == KP.did and core.verify_object(a) == (True, KP.did)
+    for ttl in (timedelta(0), timedelta(days=366)):
+        with pytest.raises(ValueError):
+            issuer.attestation(KP, SUBJECT, "stage", {}, ttl=ttl)
+
+
+def test_revocation_names_the_attestation_hash():
+    a = issuer.attestation(KP, SUBJECT, "custom:x:y", {}, issuer=DID, now=NOW)
+    r = issuer.revocation(KP, a, issuer=DID, reason="superseded", now=NOW)
+    assert r["attestation_sha256"] == core.canonical_hash(a).hex() == issuer.revocation(KP, r["attestation_sha256"], issuer=DID, now=NOW)["attestation_sha256"]
+    assert core.verify_object(r, resolver) == (True, DID)
+
+
+def test_well_known_files_agree_on_the_key():
+    d, o = issuer.did_document(DID, KP.public), issuer.openentity_json(DID, KP.public, "Issuer", "An issuer.", extensions={"openentity:observer": {}})
+    assert d["id"] == o["eid"] == DID
+    assert d["verificationMethod"][0]["publicKeyMultibase"] == o["keys"][0]["publicKeyMultibase"]
+    assert d["assertionMethod"] == [o["keys"][0]["id"]]

openentity-0.5.0/tests/test_trust.py

@@ -0,0 +1,106 @@
+"""trust(): built from registry reads, every signature checked locally, fail closed."""
+from datetime import datetime, timedelta, timezone
+
+import pytest
+
+from openentity import core, issuer, report
+from openentity.report import CLAWGRC, MOLTBOTDEN, POSTURE, SMA, TIER, VIOLATION, trust
+
+SUBJECT = core.KeyPair(b"\1" * 32).did
+KEYS = {d: core.KeyPair(bytes([i]) * 32) for i, d in enumerate([MOLTBOTDEN, CLAWGRC, SMA[0], "did:web:evil.example"], 10)}
+NOW = datetime.now(timezone.utc)
+
+
+def att(did, ct, claim, **kw):
+    return issuer.attestation(KEYS[did], SUBJECT, ct, claim, issuer=did, now=kw.pop("now", NOW - timedelta(hours=1)), **kw)
+
+
+def row(a, rev=None, **kw):
+    return {"sha256": core.canonical_hash(a).hex(), "attestation": a, "revocation": rev, "revoked_at": rev and rev["created"], **kw}
+
+
+class Registry:
+    """A fake registry plus the issuers' did.json files."""
+    def __init__(self, rows, **entity):
+        self.rows, self.entity, self.calls = rows, {"eid": SUBJECT, "level": "L2", "withdrawn": False, **entity}, []
+
+    def __call__(self, url, body=None, headers=None):
+        self.calls.append(url)
+        if url.endswith("/did.json"):
+            host = url.split("/")[2]
+            return issuer.did_document(f"did:web:{host}", KEYS[f"did:web:{host}"].public)
+        return {"attestations": self.rows} if url.endswith("/attestations") else self.entity
+
+
+@pytest.fixture(autouse=True)
+def fresh():
+    report._cache.clear()
+
+
+def full():
+    tier_old = att(MOLTBOTDEN, TIER, {"tier": 1, "platform": "moltbotden"}, ttl=timedelta(days=60), now=NOW - timedelta(days=2))
+    tier_new = att(MOLTBOTDEN, TIER, {"tier": 3, "platform": "moltbotden"})
+    grc = att(CLAWGRC, TIER, {"tier": 2, "platform": "clawgrc"})
+    posture = att(SMA[0], POSTURE, {"score_band": "A", "checks_passed": [], "scanner_version": "1", "evidence_hash": "0" * 64})
+    viol = att(CLAWGRC, VIOLATION, {"policy": "p", "severity": "high", "evidence_hash": "0" * 64, "observed_at": "2026-10-01T00:00:00Z"})
+    old_viol = att(CLAWGRC, VIOLATION, {"policy": "q", "severity": "low", "evidence_hash": "0" * 64, "observed_at": "2026-09-01T00:00:00Z"})
+    rev = issuer.revocation(KEYS[CLAWGRC], old_viol, issuer=CLAWGRC, reason="dispute upheld", now=NOW)
+    return [row(a) for a in (tier_old, tier_new, grc, posture, viol)] + [row(old_viol, rev)], viol, old_viol
+
+
+def test_report_from_registry_reads_only():
+    rows, viol, old = full()
+    reg = Registry(rows)
+    r = trust(SUBJECT, fetch=reg)
+    assert r.ok and r.level == "L2" and not r.withdrawn
+    assert r.trust_tier == {MOLTBOTDEN: 3, CLAWGRC: 2}  # newest per issuer
+    assert r.security_posture["score_band"] == "A"
+    assert [(v["severity"], v["policy"]) for v in r.violations] == [("high", "p")]  # the revoked strike is not active
+    assert [(x["sha256"], x["reason"]) for x in r.revocations] == [(core.canonical_hash(old).hex(), "dispute upheld")]
+    assert all(u.startswith(("https://openentity.org/v1/", "https://moltbotden.com", "https://api.clawgrc.com", "https://securemyagent.ai")) for u in reg.calls)
+
+
+def test_cache_holds_five_minutes():
+    reg = Registry(full()[0])
+    trust(SUBJECT, fetch=reg)
+    n = len(reg.calls)
+    assert trust(SUBJECT, fetch=reg) is trust(SUBJECT, fetch=reg) and len(reg.calls) == n
+    report._cache[("https://openentity.org", SUBJECT)] = (report.time.monotonic() - 301, None)
+    assert trust(SUBJECT, fetch=reg).ok and len(reg.calls) > n
+
+
+def test_fails_closed():
+    good = att(MOLTBOTDEN, TIER, {"tier": 4, "platform": "moltbotden"})
+    forged = {**good, "claim": {"tier": 4, "platform": "evil"}}
+    other_key = issuer.attestation(KEYS["did:web:evil.example"], SUBJECT, TIER, {"tier": 4, "platform": "x"}, issuer=MOLTBOTDEN, now=NOW)
+    viol = att(CLAWGRC, VIOLATION, {"policy": "p", "severity": "critical", "evidence_hash": "0" * 64, "observed_at": "2026-10-01T00:00:00Z"})
+    fake_rev = issuer.revocation(KEYS[MOLTBOTDEN], viol, issuer=CLAWGRC, now=NOW)  # signed by a key that is not the issuer's
+    cases = {
+        "forged claim": [{**row(good), "attestation": forged}],
+        "signed by another key": [row(other_key)],
+        "hidden strike (bad revocation)": [row(viol, fake_rev)],
+        "revocation not carried": [{**row(viol), "revoked_at": "2026-10-02T00:00:00Z"}],
+        "wrong subject": [row(issuer.attestation(KEYS[MOLTBOTDEN], SUBJECT[:-1] + "x", TIER, {"tier": 4}, issuer=MOLTBOTDEN, now=NOW))],
+    }
+    for name, rows in cases.items():
+        r = trust(SUBJECT, fetch=Registry(rows))
+        assert not r.ok and r.error and r.trust_tier == {} and r.level is None, name
+        report._cache.clear()
+
+    def down(*a, **k):
+        raise OSError("registry down")
+    assert not trust(SUBJECT, fetch=down).ok
+    assert not trust("not-a-did", fetch=Registry([])).ok
+    assert not trust(SUBJECT, fetch=Registry([], eid="did:key:other")).ok  # registry answered for someone else
+
+
+def test_expired_and_unlisted_issuers_are_ignored_and_not_fetched():
+    expired = att(MOLTBOTDEN, TIER, {"tier": 4, "platform": "m"}, ttl=timedelta(days=1), now=NOW - timedelta(days=3))
+    stranger = att("did:web:evil.example", TIER, {"tier": 4, "platform": "x"})
+    reg = Registry([row(expired), row(stranger)])
+    r = trust(SUBJECT, fetch=reg)
+    assert r.ok and r.trust_tier == {} and not any("evil.example" in u for u in reg.calls)
+
+
+def test_withdrawn_is_reported():
+    assert trust(SUBJECT, fetch=Registry([], withdrawn=True)).withdrawn

{openentity-0.3.1 → openentity-0.5.0}/tests/test_verifier.py

@@ -15,6 +15,9 @@ ROOT = Path(__file__).resolve().parents[3]
 spec = importlib.util.spec_from_file_location("iv", ROOT / "scripts/independent_verifier.py")
 iv = importlib.util.module_from_spec(spec)
 spec.loader.exec_module(iv)
+spec = importlib.util.spec_from_file_location("rc", ROOT / "scripts/rebuild_check.py")
+rc = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(rc)
 ORIGIN = "openentity.org/log"
 
 
@@ -129,18 +132,18 @@ def _bucket(tmp_path, n=5, tamper=False):
 
 def test_rebuild_matches_checkpoint(tmp_path):
     n, root = _bucket(tmp_path)
-    ok, lines = iv.rebuild(tmp_path, (n, root))
+    ok, lines = rc.rebuild(tmp_path, (n, root))
     assert ok, lines
-    assert iv.tile_path(1234067) == "x001/x234/067"
+    assert rc.tile_path(1234067) == "x001/x234/067"
 
 
 def test_rebuild_catches_wrong_root_missing_leaf_and_bad_tile(tmp_path):
     n, root = _bucket(tmp_path)
-    assert not iv.rebuild(tmp_path, (n, b"\0" * 32))[0]
-    assert not iv.rebuild(tmp_path, (n + 1, root))[0]
+    assert not rc.rebuild(tmp_path, (n, b"\0" * 32))[0]
+    assert not rc.rebuild(tmp_path, (n + 1, root))[0]
     t = tmp_path / "t"; t.mkdir()
     n, root = _bucket(t, tamper=True)
-    assert not iv.rebuild(t, (n, root))[0]
+    assert not rc.rebuild(t, (n, root))[0]
 
 
 def test_rebuild_checks_objects_against_leaves(tmp_path):
@@ -159,10 +162,10 @@ def test_rebuild_checks_objects_against_leaves(tmp_path):
     (tmp_path / "objects").mkdir()
     line = {"idx": 0, "type": "Declaration", "eid": "did:key:z1", "object_sha256": sha, "object": obj}
     (tmp_path / "objects/2026-10-25.jsonl").write_text(json.dumps(line) + "\n")
-    ok, lines = iv.rebuild(tmp_path, (n, root))
+    ok, lines = rc.rebuild(tmp_path, (n, root))
     assert ok and any("objects: 1 of" in x for x in lines), lines
     (tmp_path / "objects/2026-10-25.jsonl").write_text(json.dumps({**line, "object": {**obj, "n": 2}}) + "\n")
-    assert not iv.rebuild(tmp_path, (n, root))[0]
+    assert not rc.rebuild(tmp_path, (n, root))[0]
     red = {"seq": 2, "redacted": True, "hash": sha, "redaction": {}}
     (tmp_path / "objects/2026-10-25.jsonl").write_text(json.dumps({**line, "object": red}) + "\n")
-    assert iv.rebuild(tmp_path, (n, root))[0]
+    assert rc.rebuild(tmp_path, (n, root))[0]

{openentity-0.3.1 → openentity-0.5.0}/uv.lock

@@ -189,7 +189,7 @@ wheels = [
 
 [[package]]
 name = "openentity"
-version = "0.3.1"
+version = "0.5.0"
 source = { editable = "." }
 dependencies = [
     { name = "cryptography" },

openentity-0.3.1/openentity/__init__.py

@@ -1,4 +0,0 @@
-from .client import adopt, dispute, find, present, record, rotate, withdraw  # noqa: F401
-from .core import *  # noqa: F401,F403
-
-__version__ = "0.3.1"