inamprotocol 0.2.0__tar.gz

inamprotocol-0.2.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: inamprotocol
+Version: 0.2.0
+Summary: Reference Python SDK for the INAM Protocol — agent identity, execution receipts, jobs, and reputation
+Author: INAM Protocol
+License: Apache-2.0
+Project-URL: Homepage, https://inamprotocol.org
+Project-URL: Documentation, https://docs.inamprotocol.org
+Project-URL: Repository, https://github.com/inamprotocol/inam-protocol
+Project-URL: Specification, https://docs.inamprotocol.org/spec/
+Project-URL: Changelog, https://github.com/inamprotocol/inam-protocol/blob/main/CHANGELOG.md
+Keywords: inam,agent,ai-agent,identity,reputation,did,protocol
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: base58>=2.1.0
+
+# inamprotocol (Python SDK)
+
+Reference Python client for the INAM Protocol — parity with the TypeScript `InamClient` in `../src/sdk/client.ts`. See [`../SPEC.md`](../SPEC.md) for the full protocol specification.
+
+## Install (development)
+
+```
+python -m venv .venv
+./.venv/Scripts/python.exe -m pip install -e . pytest   # Windows
+# ./.venv/bin/python -m pip install -e . pytest          # macOS/Linux
+```
+
+## Test
+
+```
+./.venv/Scripts/python.exe -m pytest -v
+```
+
+`tests/test_interop.py` is the important one: it checks this SDK's `did:key` encoding, canonical JSON, and Ed25519 signing against fixed values generated once by the TypeScript reference implementation (`../scripts/interop-vectors.ts`). If a change here ever breaks that test, a receipt signed by this SDK would stop verifying against a registry or another SDK written in a different language — that's the whole point of the test.
+
+## Usage
+
+```python
+from inamprotocol import InamClient, generate_keypair
+
+keypair = generate_keypair()
+client = InamClient("http://localhost:4021", keypair)
+
+profile = client.register_agent(["document-extraction"], {"name": "My Agent"})
+print(profile["id"])  # did:key:z...
+
+reputation = client.get_reputation(profile["id"])
+```
+
+See `examples/interop_worker.py` for a full worker-side flow (register, link an external identity, submit signed Execution Receipt drafts), and `../scripts/run-interop-demo.sh` for the end-to-end cross-language demo (a TypeScript requester and this Python worker doing real business through the same live registry).

inamprotocol-0.2.0/README.md

@@ -0,0 +1,35 @@
+# inamprotocol (Python SDK)
+
+Reference Python client for the INAM Protocol — parity with the TypeScript `InamClient` in `../src/sdk/client.ts`. See [`../SPEC.md`](../SPEC.md) for the full protocol specification.
+
+## Install (development)
+
+```
+python -m venv .venv
+./.venv/Scripts/python.exe -m pip install -e . pytest   # Windows
+# ./.venv/bin/python -m pip install -e . pytest          # macOS/Linux
+```
+
+## Test
+
+```
+./.venv/Scripts/python.exe -m pytest -v
+```
+
+`tests/test_interop.py` is the important one: it checks this SDK's `did:key` encoding, canonical JSON, and Ed25519 signing against fixed values generated once by the TypeScript reference implementation (`../scripts/interop-vectors.ts`). If a change here ever breaks that test, a receipt signed by this SDK would stop verifying against a registry or another SDK written in a different language — that's the whole point of the test.
+
+## Usage
+
+```python
+from inamprotocol import InamClient, generate_keypair
+
+keypair = generate_keypair()
+client = InamClient("http://localhost:4021", keypair)
+
+profile = client.register_agent(["document-extraction"], {"name": "My Agent"})
+print(profile["id"])  # did:key:z...
+
+reputation = client.get_reputation(profile["id"])
+```
+
+See `examples/interop_worker.py` for a full worker-side flow (register, link an external identity, submit signed Execution Receipt drafts), and `../scripts/run-interop-demo.sh` for the end-to-end cross-language demo (a TypeScript requester and this Python worker doing real business through the same live registry).

inamprotocol-0.2.0/inamprotocol/__init__.py

@@ -0,0 +1,14 @@
+from .keys import Keypair, generate_keypair, public_key_to_did, did_to_public_key, sign, verify
+from .canonical import canonicalize
+from .client import InamClient
+
+__all__ = [
+    "Keypair",
+    "generate_keypair",
+    "public_key_to_did",
+    "did_to_public_key",
+    "sign",
+    "verify",
+    "canonicalize",
+    "InamClient",
+]

inamprotocol-0.2.0/inamprotocol/canonical.py

@@ -0,0 +1,32 @@
+"""Canonical JSON serialization — must match src/crypto/canonical.ts byte-for-byte.
+
+This is the one piece of logic every INAM SDK, in any language, has to agree
+on precisely: receipt signatures are verified by independently re-canonicalizing
+the same structured data on the other side, so any divergence here would make
+cross-language signatures fail to verify. See SPEC.md section 7.
+"""
+
+import json
+from typing import Any
+
+
+def canonicalize(value: Any) -> str:
+    return _stringify(value)
+
+
+def _stringify(value: Any) -> str:
+    if isinstance(value, dict):
+        keys = sorted(value.keys())
+        entries = []
+        for key in keys:
+            v = value[key]
+            if v is None:
+                # Mirrors the JS side filtering out `undefined`-valued keys —
+                # None is our cross-language stand-in for "field omitted",
+                # never a meaningful JSON null in these schemas.
+                continue
+            entries.append(json.dumps(key, ensure_ascii=False) + ":" + _stringify(v))
+        return "{" + ",".join(entries) + "}"
+    if isinstance(value, list):
+        return "[" + ",".join(_stringify(v) for v in value) + "]"
+    return json.dumps(value, ensure_ascii=False)

inamprotocol-0.2.0/inamprotocol/client.py

@@ -0,0 +1,203 @@
+"""INAM Protocol reference client — parity with src/sdk/client.ts (InamClient).
+
+Everything here is transport plumbing plus the two signature schemes (HTTP
+request signing, receipt content signing). An agent framework's tool-calling
+layer would wrap these same calls as `search_jobs` / `verify_agent` /
+`submit_work`-style tools.
+"""
+
+import json
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Dict, List, Optional
+
+from .canonical import canonicalize
+from .keys import Keypair, sha256_hex, sign, to_base64
+from .receipt import build_signable_content
+
+
+class InamApiError(Exception):
+    def __init__(self, method: str, path: str, status: int, payload: Any):
+        self.status = status
+        self.payload = payload
+        super().__init__(f"{method} {path} -> {status}: {payload}")
+
+
+class InamClient:
+    def __init__(self, base_url: str, keypair: Keypair):
+        self.base_url = base_url.rstrip("/")
+        self.keypair = keypair
+
+    @property
+    def did(self) -> str:
+        return self.keypair.did
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        body: Optional[Dict[str, Any]] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Any:
+        raw_body = json.dumps(body, separators=(",", ":")) if body is not None else ""
+        timestamp = str(int(time.time() * 1000))
+        body_hash = sha256_hex(raw_body)
+        signing_string = f"{method.upper()}\n{path}\n{timestamp}\n{body_hash}"
+        signature = to_base64(sign(signing_string.encode("utf-8"), self.keypair.private_key))
+
+        headers = {
+            "content-type": "application/json",
+            # Cloudflare's bot protection on *.workers.dev flags Python's
+            # default `Python-urllib/x.y` User-Agent; identify honestly instead.
+            "user-agent": "inamprotocol-python-sdk/0.1.0",
+            "inam-agent": self.keypair.did,
+            "inam-timestamp": timestamp,
+            "inam-signature": signature,
+        }
+        if idempotency_key:
+            headers["idempotency-key"] = idempotency_key
+
+        url = f"{self.base_url}{path}"
+        data = raw_body.encode("utf-8") if body is not None else None
+        req = urllib.request.Request(url, data=data, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req) as res:
+                return json.loads(res.read().decode("utf-8"))
+        except urllib.error.HTTPError as e:
+            payload_text = e.read().decode("utf-8")
+            try:
+                payload = json.loads(payload_text)
+            except json.JSONDecodeError:
+                payload = payload_text
+            raise InamApiError(method, path, e.code, payload) from None
+
+    def register_agent(self, capabilities: List[str], metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        # Omit the key entirely rather than sending it as JSON null: the
+        # server's zod schema treats `metadata` as optional-if-absent, not
+        # nullable, and Python's json.dumps (unlike JS's JSON.stringify,
+        # which drops `undefined`-valued keys) serializes None as null.
+        body: Dict[str, Any] = {"capabilities": capabilities}
+        if metadata is not None:
+            body["metadata"] = metadata
+        return self._request("POST", "/v1/agents", body, idempotency_key=f"register:{self.keypair.did}")
+
+    def get_agent(self, agent_id: str) -> Dict[str, Any]:
+        return self._request("GET", f"/v1/agents/{urllib.parse.quote(agent_id, safe='')}")
+
+    def link_identity(self, protocol: str, value: str) -> Dict[str, Any]:
+        return self._request(
+            "POST",
+            f"/v1/agents/{urllib.parse.quote(self.did, safe='')}/link",
+            {"protocol": protocol, "value": value},
+            idempotency_key=f"link:{protocol}:{value}",
+        )
+
+    def search_agents(
+        self,
+        capability: Optional[str] = None,
+        min_reputation: Optional[float] = None,
+        supports: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        params: Dict[str, str] = {}
+        if capability:
+            params["capability"] = capability
+        if min_reputation is not None:
+            params["min_reputation"] = str(min_reputation)
+        if supports:
+            params["supports"] = supports
+        return self._request("GET", f"/v1/agents/search?{urllib.parse.urlencode(params)}")
+
+    def get_reputation(self, agent_id: str) -> Dict[str, Any]:
+        return self._request("GET", f"/v1/agents/{urllib.parse.quote(agent_id, safe='')}/reputation")
+
+    def list_receipts(self, agent_id: str) -> Dict[str, Any]:
+        return self._request("GET", f"/v1/agents/{urllib.parse.quote(agent_id, safe='')}/receipts")
+
+    def submit_work(self, agent_a_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
+        """Called by the worker (agent_b) once a job is complete, off-network."""
+        content = build_signable_content(agent_a_id, self.did, input)
+        signing_bytes = canonicalize({**content, "dispute": None}).encode("utf-8")
+        signature = to_base64(sign(signing_bytes, self.keypair.private_key))
+        body = {**input, "agentAId": agent_a_id, "signature": signature}
+        return self._request("POST", "/v1/receipts", body, idempotency_key=f"receipt:{input['jobId']}")
+
+    def accept_work(self, receipt: Dict[str, Any]) -> Dict[str, Any]:
+        """Called by the requester (agent_a) to accept the worker's submitted result."""
+        content = {**receipt, "signatures": None, "status": None, "dispute": None}
+        signing_bytes = canonicalize(content).encode("utf-8")
+        signature = to_base64(sign(signing_bytes, self.keypair.private_key))
+        receipt_id = urllib.parse.quote(receipt["receiptId"], safe="")
+        return self._request(
+            "POST",
+            f"/v1/receipts/{receipt_id}/countersign",
+            {"signature": signature},
+            idempotency_key=f"countersign:{receipt['receiptId']}",
+        )
+
+    def dispute_receipt(self, receipt_id: str, reason: str) -> Dict[str, Any]:
+        encoded = urllib.parse.quote(receipt_id, safe="")
+        return self._request(
+            "POST",
+            f"/v1/receipts/{encoded}/dispute",
+            {"reason": reason},
+            idempotency_key=f"dispute:{receipt_id}",
+        )
+
+    # ---- Jobs (SPEC.md section 3) -- optional pre-work discovery/offer/accept ----
+
+    def post_job(
+        self,
+        capability: str,
+        spec_hash: str,
+        budget: Optional[Dict[str, Any]] = None,
+        expires_at: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        body: Dict[str, Any] = {"capability": capability, "specHash": spec_hash}
+        if budget is not None:
+            body["budget"] = budget
+        if expires_at is not None:
+            body["expiresAt"] = expires_at
+        return self._request("POST", "/v1/jobs", body, idempotency_key=f"job:{capability}:{spec_hash}:{time.time()}")
+
+    def get_job(self, job_id: str) -> Dict[str, Any]:
+        return self._request("GET", f"/v1/jobs/{urllib.parse.quote(job_id, safe='')}")
+
+    def search_jobs(self, capability: Optional[str] = None, status: Optional[str] = None) -> Dict[str, Any]:
+        params: Dict[str, str] = {}
+        if capability:
+            params["capability"] = capability
+        if status:
+            params["status"] = status
+        return self._request("GET", f"/v1/jobs/search?{urllib.parse.urlencode(params)}")
+
+    def submit_offer(self, job_id: str, message: Optional[str] = None) -> Dict[str, Any]:
+        encoded = urllib.parse.quote(job_id, safe="")
+        body: Dict[str, Any] = {}
+        if message is not None:
+            body["message"] = message
+        return self._request(
+            "POST",
+            f"/v1/jobs/{encoded}/offers",
+            body,
+            idempotency_key=f"offer:{job_id}:{self.did}",
+        )
+
+    def list_offers(self, job_id: str) -> Dict[str, Any]:
+        return self._request("GET", f"/v1/jobs/{urllib.parse.quote(job_id, safe='')}/offers")
+
+    def accept_offer(self, job_id: str, agent_id: str) -> Dict[str, Any]:
+        """Called by the job's poster to accept one offer."""
+        encoded = urllib.parse.quote(job_id, safe="")
+        return self._request(
+            "POST",
+            f"/v1/jobs/{encoded}/accept",
+            {"agentId": agent_id},
+            idempotency_key=f"accept:{job_id}:{agent_id}",
+        )
+
+    def cancel_job(self, job_id: str) -> Dict[str, Any]:
+        """Called by the job's poster to cancel a not-yet-completed job."""
+        encoded = urllib.parse.quote(job_id, safe="")
+        return self._request("POST", f"/v1/jobs/{encoded}/cancel", None, idempotency_key=f"cancel:{job_id}")

inamprotocol-0.2.0/inamprotocol/keys.py

@@ -0,0 +1,79 @@
+"""did:key (Ed25519) identity — must match src/crypto/keys.ts."""
+
+import base64
+import hashlib
+from dataclasses import dataclass
+from typing import Union
+
+import base58
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey, Ed25519PublicKey
+from cryptography.hazmat.primitives import serialization
+
+# multicodec value for ed25519-pub (0xed) as a varint: [0xed, 0x01].
+ED25519_MULTICODEC_PREFIX = bytes([0xED, 0x01])
+
+
+@dataclass
+class Keypair:
+    did: str
+    public_key: bytes
+    private_key: Ed25519PrivateKey
+
+
+def public_key_to_did(public_key: bytes) -> str:
+    prefixed = ED25519_MULTICODEC_PREFIX + public_key
+    return "did:key:z" + base58.b58encode(prefixed).decode("ascii")
+
+
+def did_to_public_key(did: str) -> bytes:
+    if not did.startswith("did:key:z"):
+        raise ValueError(f"Unsupported DID method: {did}")
+    decoded = base58.b58decode(did[len("did:key:z") :])
+    if decoded[0:2] != ED25519_MULTICODEC_PREFIX:
+        raise ValueError(f"Unsupported key type in DID: {did}")
+    return decoded[2:]
+
+
+def generate_keypair() -> Keypair:
+    private_key = Ed25519PrivateKey.generate()
+    return keypair_from_private_key(private_key)
+
+
+def keypair_from_raw_private_key(raw_private_key: bytes) -> Keypair:
+    private_key = Ed25519PrivateKey.from_private_bytes(raw_private_key)
+    return keypair_from_private_key(private_key)
+
+
+def keypair_from_private_key(private_key: Ed25519PrivateKey) -> Keypair:
+    public_bytes = private_key.public_key().public_bytes(
+        encoding=serialization.Encoding.Raw,
+        format=serialization.PublicFormat.Raw,
+    )
+    return Keypair(did=public_key_to_did(public_bytes), public_key=public_bytes, private_key=private_key)
+
+
+def sign(message: bytes, private_key: Ed25519PrivateKey) -> bytes:
+    return private_key.sign(message)
+
+
+def verify(signature: bytes, message: bytes, did: str) -> bool:
+    try:
+        public_key = Ed25519PublicKey.from_public_bytes(did_to_public_key(did))
+        public_key.verify(signature, message)
+        return True
+    except Exception:
+        return False
+
+
+def sha256_hex(data: Union[str, bytes]) -> str:
+    if isinstance(data, str):
+        data = data.encode("utf-8")
+    return hashlib.sha256(data).hexdigest()
+
+
+def to_base64(data: bytes) -> str:
+    return base64.b64encode(data).decode("ascii")
+
+
+def from_base64(s: str) -> bytes:
+    return base64.b64decode(s)

inamprotocol-0.2.0/inamprotocol/receipt.py

@@ -0,0 +1,35 @@
+"""Pure receipt-content logic — must match src/core/receiptContent.ts."""
+
+from typing import Any, Dict
+
+from .canonical import canonicalize
+from .keys import sha256_hex
+
+
+def compute_receipt_id(agent_a_id: str, agent_b_id: str, input: Dict[str, Any]) -> str:
+    base = {
+        "jobId": input["jobId"],
+        "agentA": {"id": agent_a_id, "role": "requester"},
+        "agentB": {"id": agent_b_id, "role": "worker"},
+        "task": input["task"],
+        "result": input["result"],
+        "settlement": input.get("settlement"),
+        "verification": input["verification"],
+    }
+    return f"sha256:{sha256_hex(canonicalize(base))}"
+
+
+def build_signable_content(agent_a_id: str, agent_b_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
+    receipt_id = compute_receipt_id(agent_a_id, agent_b_id, input)
+    return {
+        "receiptVersion": "1.0",
+        "receiptId": receipt_id,
+        "jobId": input["jobId"],
+        "agentA": {"id": agent_a_id, "role": "requester"},
+        "agentB": {"id": agent_b_id, "role": "worker"},
+        "task": input["task"],
+        "result": input["result"],
+        "settlement": input.get("settlement"),
+        "verification": input["verification"],
+        "dispute": {"status": "none", "windowClosesAt": ""},
+    }

inamprotocol-0.2.0/inamprotocol.egg-info/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: inamprotocol
+Version: 0.2.0
+Summary: Reference Python SDK for the INAM Protocol — agent identity, execution receipts, jobs, and reputation
+Author: INAM Protocol
+License: Apache-2.0
+Project-URL: Homepage, https://inamprotocol.org
+Project-URL: Documentation, https://docs.inamprotocol.org
+Project-URL: Repository, https://github.com/inamprotocol/inam-protocol
+Project-URL: Specification, https://docs.inamprotocol.org/spec/
+Project-URL: Changelog, https://github.com/inamprotocol/inam-protocol/blob/main/CHANGELOG.md
+Keywords: inam,agent,ai-agent,identity,reputation,did,protocol
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: base58>=2.1.0
+
+# inamprotocol (Python SDK)
+
+Reference Python client for the INAM Protocol — parity with the TypeScript `InamClient` in `../src/sdk/client.ts`. See [`../SPEC.md`](../SPEC.md) for the full protocol specification.
+
+## Install (development)
+
+```
+python -m venv .venv
+./.venv/Scripts/python.exe -m pip install -e . pytest   # Windows
+# ./.venv/bin/python -m pip install -e . pytest          # macOS/Linux
+```
+
+## Test
+
+```
+./.venv/Scripts/python.exe -m pytest -v
+```
+
+`tests/test_interop.py` is the important one: it checks this SDK's `did:key` encoding, canonical JSON, and Ed25519 signing against fixed values generated once by the TypeScript reference implementation (`../scripts/interop-vectors.ts`). If a change here ever breaks that test, a receipt signed by this SDK would stop verifying against a registry or another SDK written in a different language — that's the whole point of the test.
+
+## Usage
+
+```python
+from inamprotocol import InamClient, generate_keypair
+
+keypair = generate_keypair()
+client = InamClient("http://localhost:4021", keypair)
+
+profile = client.register_agent(["document-extraction"], {"name": "My Agent"})
+print(profile["id"])  # did:key:z...
+
+reputation = client.get_reputation(profile["id"])
+```
+
+See `examples/interop_worker.py` for a full worker-side flow (register, link an external identity, submit signed Execution Receipt drafts), and `../scripts/run-interop-demo.sh` for the end-to-end cross-language demo (a TypeScript requester and this Python worker doing real business through the same live registry).

inamprotocol-0.2.0/inamprotocol.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+inamprotocol/__init__.py
+inamprotocol/canonical.py
+inamprotocol/client.py
+inamprotocol/keys.py
+inamprotocol/receipt.py
+inamprotocol.egg-info/PKG-INFO
+inamprotocol.egg-info/SOURCES.txt
+inamprotocol.egg-info/dependency_links.txt
+inamprotocol.egg-info/requires.txt
+inamprotocol.egg-info/top_level.txt
+tests/test_canonical.py
+tests/test_interop.py
+tests/test_keys.py

inamprotocol-0.2.0/inamprotocol.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

inamprotocol-0.2.0/inamprotocol.egg-info/requires.txt

@@ -0,0 +1,2 @@
+cryptography>=42.0.0
+base58>=2.1.0

inamprotocol-0.2.0/inamprotocol.egg-info/top_level.txt

@@ -0,0 +1 @@
+inamprotocol

inamprotocol-0.2.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "inamprotocol"
+version = "0.2.0"
+description = "Reference Python SDK for the INAM Protocol — agent identity, execution receipts, jobs, and reputation"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "Apache-2.0" }
+authors = [{ name = "INAM Protocol" }]
+keywords = ["inam", "agent", "ai-agent", "identity", "reputation", "did", "protocol"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Internet :: WWW/HTTP",
+]
+dependencies = [
+    "cryptography>=42.0.0",
+    "base58>=2.1.0",
+]
+
+[project.urls]
+Homepage = "https://inamprotocol.org"
+Documentation = "https://docs.inamprotocol.org"
+Repository = "https://github.com/inamprotocol/inam-protocol"
+"Specification" = "https://docs.inamprotocol.org/spec/"
+Changelog = "https://github.com/inamprotocol/inam-protocol/blob/main/CHANGELOG.md"
+
+[tool.setuptools.packages.find]
+include = ["inamprotocol*"]

inamprotocol-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

inamprotocol-0.2.0/tests/test_canonical.py

@@ -0,0 +1,19 @@
+from inamprotocol.canonical import canonicalize
+
+
+def test_key_order_independence():
+    a = canonicalize({"b": 1, "a": 2, "c": {"z": 1, "y": 2}})
+    b = canonicalize({"c": {"y": 2, "z": 1}, "a": 2, "b": 1})
+    assert a == b
+
+
+def test_drops_none_valued_keys():
+    assert canonicalize({"a": 1, "b": None}) == '{"a":1}'
+
+
+def test_preserves_array_order():
+    assert canonicalize([3, 1, 2]) == "[3,1,2]"
+
+
+def test_sensitive_to_value_change():
+    assert canonicalize({"amount": "12.50"}) != canonicalize({"amount": "12.51"})

inamprotocol-0.2.0/tests/test_interop.py

@@ -0,0 +1,65 @@
+"""Cross-language correctness: these expected values were generated once by the
+TypeScript reference implementation (see ../../scripts/interop-vectors.ts) from
+a fixed test-only private key. If the Python SDK's did:key encoding,
+canonical-JSON serialization, or Ed25519 signing ever diverges from the
+TypeScript side, this test fails — that divergence is exactly what would make
+a receipt signed by one language's SDK fail to verify against a registry (or
+another SDK) written in the other language.
+"""
+
+from inamprotocol.canonical import canonicalize
+from inamprotocol.keys import keypair_from_raw_private_key, sign, to_base64, verify
+
+# --- Ground truth from `npx tsx scripts/interop-vectors.ts` ---
+PRIVATE_KEY_HEX = "01" * 32
+EXPECTED_PUBLIC_KEY_HEX = "8a88e3dd7409f195fd52db2d3cba5d72ca6709bf1d94121bf3748801b40f6f5c"
+EXPECTED_DID = "did:key:z6Mkon3Necd6NkkyfoGoHxid2znGc59LU3K7mubaRcFbLfLX"
+EXPECTED_CANONICAL = (
+    '{"agentA":{"id":"did:key:zExampleA","role":"requester"},'
+    '"agentB":{"id":"did:key:zExampleB","role":"worker"},'
+    '"jobId":"job_interop_1",'
+    '"result":{"completedAt":"2026-08-22T00:01:00.000Z","outputHash":"sha256:out"},'
+    '"settlement":{"amount":"12.50","currency":"USDC"},'
+    '"task":{"capability":"translation.tr-en","createdAt":"2026-08-22T00:00:00.000Z","specHash":"sha256:spec"},'
+    '"verification":{"method":"payer_confirmation","outcome":"success"}}'
+)
+MESSAGE = b"inam-interop-test-message"
+EXPECTED_SIGNATURE_B64 = "V3nIJGvwXXN+dNRM5gxyLeECY3fMVLu8baci/JrlArgeElTU3bEThOR7ipfJxGtHvWDIcrEzyIDq/vNkHVAJDA=="
+
+SAMPLE_OBJECT = {
+    "jobId": "job_interop_1",
+    "agentA": {"id": "did:key:zExampleA", "role": "requester"},
+    "agentB": {"id": "did:key:zExampleB", "role": "worker"},
+    "task": {"capability": "translation.tr-en", "specHash": "sha256:spec", "createdAt": "2026-08-22T00:00:00.000Z"},
+    "result": {"outputHash": "sha256:out", "completedAt": "2026-08-22T00:01:00.000Z"},
+    "settlement": {"amount": "12.50", "currency": "USDC"},
+    "verification": {"method": "payer_confirmation", "outcome": "success"},
+}
+
+
+def test_did_key_matches_typescript():
+    kp = keypair_from_raw_private_key(bytes.fromhex(PRIVATE_KEY_HEX))
+    assert kp.public_key.hex() == EXPECTED_PUBLIC_KEY_HEX
+    assert kp.did == EXPECTED_DID
+
+
+def test_canonical_json_matches_typescript():
+    assert canonicalize(SAMPLE_OBJECT) == EXPECTED_CANONICAL
+
+
+def test_signature_is_byte_identical_to_typescript():
+    # Ed25519 signatures are deterministic (RFC 8032) — the same key and
+    # message MUST produce the exact same signature in any correct
+    # implementation, not just a signature that happens to verify.
+    kp = keypair_from_raw_private_key(bytes.fromhex(PRIVATE_KEY_HEX))
+    signature = sign(MESSAGE, kp.private_key)
+    assert to_base64(signature) == EXPECTED_SIGNATURE_B64
+
+
+def test_python_verifies_a_typescript_produced_signature():
+    import base64
+
+    kp_did = EXPECTED_DID
+    signature = base64.b64decode(EXPECTED_SIGNATURE_B64)
+    assert verify(signature, MESSAGE, kp_did) is True
+    assert verify(signature, b"tampered message", kp_did) is False

inamprotocol-0.2.0/tests/test_keys.py

@@ -0,0 +1,28 @@
+from inamprotocol.keys import generate_keypair, did_to_public_key, sign, verify
+
+
+def test_did_key_round_trip():
+    kp = generate_keypair()
+    assert kp.did.startswith("did:key:z")
+    assert did_to_public_key(kp.did) == kp.public_key
+
+
+def test_sign_and_verify():
+    kp = generate_keypair()
+    message = b"hello inam"
+    signature = sign(message, kp.private_key)
+    assert verify(signature, message, kp.did) is True
+
+
+def test_rejects_tampered_message():
+    kp = generate_keypair()
+    signature = sign(b"original", kp.private_key)
+    assert verify(signature, b"tampered", kp.did) is False
+
+
+def test_rejects_wrong_signer():
+    signer = generate_keypair()
+    impostor = generate_keypair()
+    message = b"hello inam"
+    signature = sign(message, signer.private_key)
+    assert verify(signature, message, impostor.did) is False