aotrust-protocol 2.3.2__tar.gz → 2.3.4__tar.gz

{aotrust_protocol-2.3.2/aotrust_protocol.egg-info → aotrust_protocol-2.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aotrust-protocol
-Version: 2.3.2
+Version: 2.3.4
 Summary: Asyncio-native SDK for A&O Trust Layer — Agent Notary Service
 Author: A&O Trust Layer
 License: MIT

{aotrust_protocol-2.3.2 → aotrust_protocol-2.3.4}/agent_notary/__init__.py

@@ -1,5 +1,7 @@
 """A&O Trust Layer — Agent Notary SDK (asyncio-native)."""
 
+__version__ = "2.3.4"
+
 from .client import NotaryClient
 from .models import NotarizeRequest, NotarizeResult, PdrResult, StatusResult
 from .exceptions import (

{aotrust_protocol-2.3.2 → aotrust_protocol-2.3.4}/agent_notary/client.py

@@ -1,4 +1,4 @@
-"""Asyncio-native NotaryClient for A&O Trust Layer."""
+"""Asyncio-native NotaryClient for AOTrust."""
 
 from __future__ import annotations
 
@@ -23,9 +23,19 @@ DEFAULT_POLL_TIMEOUT = 120.0
 MAX_RETRIES = 3
 RETRY_DELAYS = (1.0, 2.0, 4.0)
 
+VERIFY_WEB_BASE = "https://verify.aotrust.link"
+
 
 class NotaryClient:
-    """Async client for the A&O Trust Layer Notary API."""
+    """Async client for the AOTrust Notary API.
+
+    URL map matches the live API (openapi.yaml v2.3.4+):
+      - notarize()   -> POST /notarize          (anonymous x402 payment path)
+      - quote()      -> POST /v1/notarize/quote (authenticated CI channel; api_key required)
+      - get_status() -> GET  /v1/status/{job_id}
+      - shield_free()-> POST /v1/shield/free    (free tier, rate limited)
+      - pubkey lazy-fetch: GET /v1/notary/pubkey (cached)
+    """
 
     def __init__(
         self,
@@ -34,15 +44,44 @@ class NotaryClient:
         notary_pubkey: Optional[str] = None,
     ):
         self.api_key = api_key or os.environ.get("NOTARY_API_KEY", "")
-        self.base_url = (base_url or os.environ.get("NOTARY_API_URL", "https://api.aotrust.link/v1")).rstrip("/")
-        self.notary_pubkey = notary_pubkey or os.environ.get("NOTARY_PUBKEY", "9c7d64bbabe90ead8f18982497a47acbd95677cef0d9285caec95377e4ccf6b0")
+        self.base_url = (base_url or os.environ.get("NOTARY_API_URL", "https://api.aotrust.link")).rstrip("/")
+        # No hardcoded fallback: if not provided, fetched lazily from the server (cached).
+        self._pubkey_provided = notary_pubkey or os.environ.get("NOTARY_PUBKEY", "") or ""
+        self._pubkey_fetched: Optional[str] = None
 
     def _headers(self) -> dict:
-        h = {"Content-Type": "application/json"}
+        from . import __version__
+        h = {
+            "Content-Type": "application/json",
+            "User-Agent": f"aotrust-protocol/{__version__}",
+        }
         if self.api_key:
             h["X-API-Key"] = self.api_key
         return h
 
+    async def get_notary_pubkey(self) -> str:
+        """Notary Ed25519 public key (hex, 64 chars).
+
+        Resolution order:
+        1. explicitly provided (constructor / NOTARY_PUBKEY env)
+        2. lazy fetch GET /v1/notary/pubkey — fetched once, cached
+        Raises NotaryError when neither is available.
+        """
+        if self._pubkey_provided:
+            return self._pubkey_provided
+        if self._pubkey_fetched:
+            return self._pubkey_fetched
+        status, body = await self._request("GET", "/v1/notary/pubkey")
+        self._check_status(status, body)
+        pubkey = body.get("pubkey_hex", body.get("pubkey", body.get("notary_pubkey", "")))
+        if not pubkey:
+            raise NotaryError(
+                "notary_pubkey not provided and not available from server "
+                f"(GET /v1/notary/pubkey returned: {body})"
+            )
+        self._pubkey_fetched = pubkey
+        return pubkey
+
     async def _request(
         self,
         method: str,
@@ -70,6 +109,9 @@ class NotaryClient:
     def _check_status(self, status: int, body: dict) -> None:
         if status == 401:
             raise NotaryAuthError(body.get("error", "Unauthorized"))
+        if status == 402:
+            # x402 challenge: surface the full payment requirement to the caller
+            raise NotaryPaymentError(f"Payment required: {body}")
         if status == 403:
             detail = body.get("detail", body.get("error", "Forbidden"))
             raise NotaryPaymentError(detail)
@@ -81,14 +123,26 @@ class NotaryClient:
             raise NotaryServerError(body.get("error", f"Server error {status}"), status_code=status)
 
     async def notarize(self, request: NotarizeRequest) -> NotarizeResult:
-        status, body = await self._request("POST", "/notarize", json_data=request.to_api_payload())
+        """POST /notarize — anonymous x402 path.
+
+        Without payment the server answers 402 with the x402 challenge
+        (x402Version/accepts[0].resource=...); NotaryPaymentError carries it.
+        Payload built for the live x402 contract: work_hash at top level
+        (the CI-channel envelope with tx_hash/payload.work_hash is NOT used here).
+        """
+        payload: dict = {"work_hash": request.work_hash or ""}
+        if request.agent_sig:
+            payload["agent_sig"] = request.agent_sig
+        if request.agent_pubkey:
+            payload["agent_pubkey"] = request.agent_pubkey
+        status, body = await self._request("POST", "/notarize", json_data=payload)
         self._check_status(status, body)
         if status not in (200, 202):
             raise NotaryError(f"Unexpected status {status}: {body}")
         return NotarizeResult(job_id=body.get("job_id", ""))
 
     async def get_status(self, job_id: str) -> StatusResult:
-        status, body = await self._request("GET", f"/status/{job_id}")
+        status, body = await self._request("GET", f"/v1/status/{job_id}")
         self._check_status(status, body)
         result = body.get("result", {})
         return StatusResult(
@@ -98,15 +152,28 @@ class NotaryClient:
         )
 
     async def get_pdr(self, job_id: str) -> PdrResult:
-        status, body = await self._request("GET", f"/pdr/{job_id}")
-        self._check_status(status, body)
-        verify_url = f"{self.base_url}/verify/{job_id}" if "verify_url" not in body else body.get("verify_url")
+        """Fetch PDR via status endpoint and build the public verify URL."""
+        status_result = await self.get_status(job_id)
+        pdr_b64 = status_result.pdr_b64 or ""
         return PdrResult(
-            pdr_b64=body.get("pdr", body.get("pdr_b64", "")),
-            payment_hash=body.get("near_tx_hash") or body.get("payment_hash"),
-            verify_url=verify_url,
+            pdr_b64=pdr_b64,
+            payment_hash=status_result.payment_hash,
+            verify_url=self._verify_url(pdr_b64),
         )
 
+    async def verify_pdr(self, pdr_b64: str) -> dict:
+        """GET /v1/pdr/verify/{pdr_b64} — server-side PDR verification."""
+        from urllib.parse import quote as _urlquote
+        status, body = await self._request("GET", f"/v1/pdr/verify/{_urlquote(pdr_b64, safe='')}")
+        self._check_status(status, body)
+        return body
+
+    @staticmethod
+    def _verify_url(pdr_b64: str) -> str:
+        """Public web verifier URL (the /v1/verify/{job_id} path does not exist)."""
+        b64url = pdr_b64.replace("+", "-").replace("/", "_").rstrip("=")
+        return f"{VERIFY_WEB_BASE}/?pdr={b64url}"
+
     async def wait_for_pdr(
         self,
         job_id: str,
@@ -125,7 +192,17 @@ class NotaryClient:
         raise NotaryServerError(f"Timed out waiting for PDR ({timeout}s)")
 
     async def quote(self) -> dict:
-        status, body = await self._request("POST", "/notarize/quote")
+        """POST /v1/notarize/quote — authenticated CI channel.
+
+        Requires api_key; the public x402 flow does not need a quote
+        (price is always $0.01, see the 402 challenge from notarize()).
+        """
+        if not self.api_key:
+            raise NotaryAuthError(
+                "quote() requires an API key (authenticated CI channel, POST /v1/notarize/quote). "
+                "The public x402 flow needs no quote: price is flat $0.01 per PDR."
+            )
+        status, body = await self._request("POST", "/v1/notarize/quote")
         self._check_status(status, body)
         return body
 
@@ -148,6 +225,6 @@ class NotaryClient:
             payload["agent_sig"] = agent_sig
         if agent_pubkey:
             payload["agent_pubkey"] = agent_pubkey
-        status, body = await self._request("POST", "/shield/free", json_data=payload)
+        status, body = await self._request("POST", "/v1/shield/free", json_data=payload)
         self._check_status(status, body)
         return body

{aotrust_protocol-2.3.2 → aotrust_protocol-2.3.4/aotrust_protocol.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aotrust-protocol
-Version: 2.3.2
+Version: 2.3.4
 Summary: Asyncio-native SDK for A&O Trust Layer — Agent Notary Service
 Author: A&O Trust Layer
 License: MIT

{aotrust_protocol-2.3.2 → aotrust_protocol-2.3.4}/aotrust_protocol.egg-info/SOURCES.txt

@@ -11,4 +11,5 @@ aotrust_protocol.egg-info/SOURCES.txt
 aotrust_protocol.egg-info/dependency_links.txt
 aotrust_protocol.egg-info/requires.txt
 aotrust_protocol.egg-info/top_level.txt
-tests/test_client.py
+tests/test_client.py
+tests/test_live_smoke.py

{aotrust_protocol-2.3.2 → aotrust_protocol-2.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aotrust-protocol"
-version = "2.3.2"
+version = "2.3.4"
 description = "Asyncio-native SDK for A&O Trust Layer — Agent Notary Service"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -40,4 +40,8 @@ include = ["agent_notary*"]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
+markers = [
+    "live: live smoke tests against production (run explicitly with -m live)",
+]
+addopts = "-m 'not live'"
 testpaths = ["tests"]

{aotrust_protocol-2.3.2 → aotrust_protocol-2.3.4}/tests/test_client.py

@@ -116,7 +116,7 @@ class TestNotaryClientErrors:
 class TestNotaryClientConstruction:
     def test_default_base_url(self):
         client = NotaryClient(api_key="k")
-        assert "aotrust.link/v1" in client.base_url
+        assert client.base_url == "https://api.aotrust.link"
 
     def test_custom_base_url(self):
         client = NotaryClient(api_key="k", base_url="http://localhost:9999/v1")

aotrust_protocol-2.3.4/tests/test_live_smoke.py

@@ -0,0 +1,92 @@
+"""
+test_live_smoke.py — живой smoke-тест SDK против прода (новый протокол).
+
+Запуск ТОЛЬКО явно: `pytest -m live`. По умолчанию скипается.
+НЕ платит: 402-челлендж — граница теста (кошелёк/ключи не трогаются).
+
+Путь (ровно тот, что прошёл node-агент):
+  1. Чистый клиент без ключей, дефолтный base_url (без /v1)
+  2. notarize() → 402-челлендж x402 (x402Version/accepts[0].resource — полный URL)
+  3. get_status() на свежем (несуществующем) job → 404 NotaryNotFoundError (эндпоинт жив)
+  4. get_notary_pubkey() → pubkey подтянут с сервера (lazy-fetch работает)
+
+Асинхронные вызовы обёрнуты asyncio.run — тест не зависит от pytest_asyncio.
+"""
+
+import os
+import sys
+import asyncio
+import uuid
+from pathlib import Path
+
+PROJECT_ROOT = str(Path(__file__).resolve().parent.parent)
+sys.path.insert(0, PROJECT_ROOT)
+
+import pytest
+
+pytestmark = [pytest.mark.live]
+
+
+def _live_guard():
+    """Пропускать, если live-тесты выключены (CI/offline)."""
+    if os.environ.get("ANS_LIVE_TESTS") == "0":
+        pytest.skip("ANS_LIVE_TESTS=0")
+
+
+def test_live_notarize_402_challenge():
+    _live_guard()
+    from agent_notary import NotaryClient, NotarizeRequest
+    from agent_notary.exceptions import NotaryPaymentError
+
+    client = NotaryClient()  # чистый: без api_key, без pubkey
+    assert client.base_url == "https://api.aotrust.link"
+    req = NotarizeRequest(tx_hash="0x" + "a" * 64, work_hash="b" * 64)
+
+    async def run():
+        try:
+            await client.notarize(req)
+            return None
+        except NotaryPaymentError as e:
+            return str(e)
+
+    msg = asyncio.run(run())
+    assert msg is not None, "notarize() без оплаты должен дать NotaryPaymentError (402)"
+    # 402-челлендж: тело содержит x402-структуру с полным resource URL
+    assert "402" in msg, f"expected 402 in error body: {msg[:200]}"
+    assert "accepts" in msg, f"expected x402 accepts[] in error body: {msg[:200]}"
+    assert "resource" in msg, f"expected resource in error body: {msg[:200]}"
+
+
+def test_live_get_status_404_on_unknown_job():
+    _live_guard()
+    from agent_notary import NotaryClient
+    from agent_notary.exceptions import NotaryNotFoundError
+
+    client = NotaryClient()
+    fresh_job = str(uuid.uuid4())
+
+    async def run():
+        try:
+            await client.get_status(fresh_job)
+            return None
+        except NotaryNotFoundError as e:
+            return str(e)
+
+    msg = asyncio.run(run())
+    assert msg is not None, "get_status() на несуществующем job должен дать 404"
+
+
+def test_live_pubkey_lazy_fetch():
+    _live_guard()
+    from agent_notary import NotaryClient
+
+    client = NotaryClient()
+
+    async def run():
+        return await client.get_notary_pubkey()
+
+    pubkey = asyncio.run(run())
+    assert isinstance(pubkey, str) and len(pubkey) == 64, f"pubkey hex 64 chars, got: {pubkey!r}"
+    assert all(c in "0123456789abcdef" for c in pubkey.lower())
+    # Кеш: второй вызов не ходит в сеть (тот же атрибут)
+    assert client._pubkey_fetched == pubkey