aotrust-protocol 2.3.7__tar.gz → 2.4.0__tar.gz

{aotrust_protocol-2.3.7 → aotrust_protocol-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aotrust-protocol
-Version: 2.3.7
+Version: 2.4.0
 Summary: Asyncio-native SDK for A&O Trust Layer — Agent Notary Service
 Author: A&O Trust Layer
 License: MIT
@@ -31,6 +31,9 @@ Dynamic: license-file
 
 Asyncio-native Python SDK for the AOTrust Notary API — cryptographic proof-of-existence for AI agent outputs.
 
+> **Why protocol-level proofs?** An ERC-8004 empirical study (2026) measured that **>98% of agent feedback records carry no proof of an underlying interaction** (no payment proof, no task linkage); 59–91% of reviewers on three chains participated in coordinated Sybil campaigns, and manipulating a reputation score past a trust threshold costs as little as **$0.0027**. The agentic economy is moving from *statements* to *verifiable claims*: a PDR (239 bytes, Ed25519-signed, hash-chained, NEAR-anchored) turns any output or payment into independent evidence — verifiable by anyone, without trusting the provider's database.
+> *(Refs: arXiv:2610.12948 [cs.CR], 2026; ERC-8004 Sybil measurements, Xiong et al. 2026.)*
+
 ## Install
 
 ```bash
@@ -166,3 +169,31 @@ except NotaryError as e:
 pip install -e ".[dev]"
 pytest tests/ -v
 ```
+
+## Payment binding (NEAR rail)
+
+NEAR payments must be provably linked to the account that sent them. Pass
+`payer_account` (the NEAR account that paid) together with `bind_sig` — a
+base64 Ed25519 **NEP-413 raw-buffer** signature (no SHA-256 pre-hash) over:
+
+```
+AOTrust AITP-BIND v1
+work_hash:<64 hex>
+tx_hash:<tx hash exactly as submitted>
+```
+
+The server resolves the account's public key via RPC and checks
+`transaction.signer_id == payer_account`; a mismatch is rejected with
+`403 PAYMENT_BIND_SIGNER_MISMATCH`, a bad signature with
+`403 PAYMENT_BIND_INVALID`.
+
+If `NEAR_PRIVATE_KEY` is set in the environment (or `near_private_key=` is
+passed), the SDK signs the canonical message itself and fills `bind_sig`:
+
+```python
+req = NotarizeRequest(tx_hash=tx, work_hash=wh)
+await client.notarize(req, payer_account="alice.near")
+```
+
+Server mode `AITP_BIND_MODE=warn` (default) accepts unbound requests with a
+`PAYMENT_UNBOUND` log line; `enforce` requires the fields.

{aotrust_protocol-2.3.7 → aotrust_protocol-2.4.0}/README.md

@@ -4,6 +4,9 @@
 
 Asyncio-native Python SDK for the AOTrust Notary API — cryptographic proof-of-existence for AI agent outputs.
 
+> **Why protocol-level proofs?** An ERC-8004 empirical study (2026) measured that **>98% of agent feedback records carry no proof of an underlying interaction** (no payment proof, no task linkage); 59–91% of reviewers on three chains participated in coordinated Sybil campaigns, and manipulating a reputation score past a trust threshold costs as little as **$0.0027**. The agentic economy is moving from *statements* to *verifiable claims*: a PDR (239 bytes, Ed25519-signed, hash-chained, NEAR-anchored) turns any output or payment into independent evidence — verifiable by anyone, without trusting the provider's database.
+> *(Refs: arXiv:2610.12948 [cs.CR], 2026; ERC-8004 Sybil measurements, Xiong et al. 2026.)*
+
 ## Install
 
 ```bash
@@ -138,4 +141,32 @@ except NotaryError as e:
 ```bash
 pip install -e ".[dev]"
 pytest tests/ -v
-```
+```
+
+## Payment binding (NEAR rail)
+
+NEAR payments must be provably linked to the account that sent them. Pass
+`payer_account` (the NEAR account that paid) together with `bind_sig` — a
+base64 Ed25519 **NEP-413 raw-buffer** signature (no SHA-256 pre-hash) over:
+
+```
+AOTrust AITP-BIND v1
+work_hash:<64 hex>
+tx_hash:<tx hash exactly as submitted>
+```
+
+The server resolves the account's public key via RPC and checks
+`transaction.signer_id == payer_account`; a mismatch is rejected with
+`403 PAYMENT_BIND_SIGNER_MISMATCH`, a bad signature with
+`403 PAYMENT_BIND_INVALID`.
+
+If `NEAR_PRIVATE_KEY` is set in the environment (or `near_private_key=` is
+passed), the SDK signs the canonical message itself and fills `bind_sig`:
+
+```python
+req = NotarizeRequest(tx_hash=tx, work_hash=wh)
+await client.notarize(req, payer_account="alice.near")
+```
+
+Server mode `AITP_BIND_MODE=warn` (default) accepts unbound requests with a
+`PAYMENT_UNBOUND` log line; `enforce` requires the fields.

{aotrust_protocol-2.3.7 → aotrust_protocol-2.4.0}/agent_notary/client.py

@@ -9,6 +9,40 @@ from typing import Optional
 import aiohttp
 
 from .models import NotarizeRequest, NotarizeResult, StatusResult, PdrResult
+NEP413_TAG = 2147484061
+
+
+def canonical_bind_message(work_hash: str, tx_hash: str) -> bytes:
+    """Canonical AOTrust AITP-BIND v1 message — identical to the server module."""
+    return f"AOTrust AITP-BIND v1\nwork_hash:{work_hash}\ntx_hash:{tx_hash}".encode("utf-8")
+
+
+def _decode_ed25519_key(raw: str) -> bytes:
+    """Accepts hex, base58, or NEAR's 'ed25519:<base58>' key format."""
+    import base58
+    key = raw.strip()
+    if key.startswith("ed25519:"):
+        key = key.split(":", 1)[1]
+    try:
+        if len(key) == 64 and all(c in "0123456789abcdefABCDEF" for c in key):
+            return bytes.fromhex(key)
+    except Exception:
+        pass
+    return base58.b58decode(key)
+
+
+def _sign_bind_message(private_key: str, work_hash: str, tx_hash: str) -> str:
+    """NEP-413 RAW buffer signature (no SHA-256 pre-hash) over the bind message."""
+    import base64
+    import struct
+    from nacl.signing import SigningKey
+
+    msg = canonical_bind_message(work_hash, tx_hash)
+    buf = struct.pack("<II", NEP413_TAG, len(msg)) + msg
+    sk = SigningKey(_decode_ed25519_key(private_key))
+    return base64.b64encode(sk.sign(buf).signature).decode()
+
+
 from .exceptions import (
     NotaryError,
     NotaryAuthError,
@@ -129,19 +163,42 @@ class NotaryClient:
         if status >= 500:
             raise NotaryServerError(body.get("error", f"Server error {status}"), status_code=status)
 
-    async def notarize(self, request: NotarizeRequest) -> NotarizeResult:
+    async def notarize(
+        self,
+        request: NotarizeRequest,
+        payer_account: Optional[str] = None,
+        bind_sig: Optional[str] = None,
+        near_private_key: Optional[str] = None,
+    ) -> NotarizeResult:
         """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).
+
+        Payment binding (V5-A', NEAR rail): pass payer_account + bind_sig, or
+        let the SDK build them. If `near_private_key` (or env NEAR_PRIVATE_KEY)
+        is set and payer_account is provided, the SDK signs the canonical
+        AOTrust AITP-BIND v1 message with the NEP-413 raw buffer and fills
+        bind_sig. Without a key, fields are simply not added (server warn mode
+        passes unbound requests).
         """
+        payer = payer_account or request.payer_account
+        sig = bind_sig or request.bind_sig
+        key = near_private_key or os.environ.get("NEAR_PRIVATE_KEY")
+        if not sig and key and payer and request.work_hash and request.tx_hash:
+            sig = _sign_bind_message(key, request.work_hash, request.tx_hash)
+
         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
+        if payer:
+            payload["payer_account"] = payer
+        if sig:
+            payload["bind_sig"] = sig
         status, body = await self._request("POST", "/notarize", json_data=payload)
         self._check_status(status, body)
         if status not in (200, 202):

{aotrust_protocol-2.3.7 → aotrust_protocol-2.4.0}/agent_notary/models.py

@@ -33,6 +33,13 @@ class NotarizeRequest(BaseModel):
     work_hash: Optional[str] = Field(None, description="SHA-256 hex digest (64 chars)")
     agent_sig: Optional[str] = Field(None, description="Base64 Ed25519 signature (sig_A)")
     agent_pubkey: Optional[str] = Field(None, description="Hex Ed25519 public key")
+    payer_account: Optional[str] = Field(
+        None, description="NEAR account that paid/signed the tx (payment binding)"
+    )
+    bind_sig: Optional[str] = Field(
+        None,
+        description="Base64 Ed25519 NEP-413 signature over the AOTrust AITP-BIND v1 message",
+    )
 
     def to_api_payload(self) -> dict:
         payload: dict = {"tx_hash": self.tx_hash}
@@ -42,6 +49,10 @@ class NotarizeRequest(BaseModel):
             payload["agent_sig"] = self.agent_sig
         if self.agent_pubkey:
             payload["agent_pubkey"] = self.agent_pubkey
+        if self.payer_account:
+            payload["payer_account"] = self.payer_account
+        if self.bind_sig:
+            payload["bind_sig"] = self.bind_sig
         return payload
 
 

{aotrust_protocol-2.3.7 → aotrust_protocol-2.4.0}/aotrust_protocol.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aotrust-protocol
-Version: 2.3.7
+Version: 2.4.0
 Summary: Asyncio-native SDK for A&O Trust Layer — Agent Notary Service
 Author: A&O Trust Layer
 License: MIT
@@ -31,6 +31,9 @@ Dynamic: license-file
 
 Asyncio-native Python SDK for the AOTrust Notary API — cryptographic proof-of-existence for AI agent outputs.
 
+> **Why protocol-level proofs?** An ERC-8004 empirical study (2026) measured that **>98% of agent feedback records carry no proof of an underlying interaction** (no payment proof, no task linkage); 59–91% of reviewers on three chains participated in coordinated Sybil campaigns, and manipulating a reputation score past a trust threshold costs as little as **$0.0027**. The agentic economy is moving from *statements* to *verifiable claims*: a PDR (239 bytes, Ed25519-signed, hash-chained, NEAR-anchored) turns any output or payment into independent evidence — verifiable by anyone, without trusting the provider's database.
+> *(Refs: arXiv:2610.12948 [cs.CR], 2026; ERC-8004 Sybil measurements, Xiong et al. 2026.)*
+
 ## Install
 
 ```bash
@@ -166,3 +169,31 @@ except NotaryError as e:
 pip install -e ".[dev]"
 pytest tests/ -v
 ```
+
+## Payment binding (NEAR rail)
+
+NEAR payments must be provably linked to the account that sent them. Pass
+`payer_account` (the NEAR account that paid) together with `bind_sig` — a
+base64 Ed25519 **NEP-413 raw-buffer** signature (no SHA-256 pre-hash) over:
+
+```
+AOTrust AITP-BIND v1
+work_hash:<64 hex>
+tx_hash:<tx hash exactly as submitted>
+```
+
+The server resolves the account's public key via RPC and checks
+`transaction.signer_id == payer_account`; a mismatch is rejected with
+`403 PAYMENT_BIND_SIGNER_MISMATCH`, a bad signature with
+`403 PAYMENT_BIND_INVALID`.
+
+If `NEAR_PRIVATE_KEY` is set in the environment (or `near_private_key=` is
+passed), the SDK signs the canonical message itself and fills `bind_sig`:
+
+```python
+req = NotarizeRequest(tx_hash=tx, work_hash=wh)
+await client.notarize(req, payer_account="alice.near")
+```
+
+Server mode `AITP_BIND_MODE=warn` (default) accepts unbound requests with a
+`PAYMENT_UNBOUND` log line; `enforce` requires the fields.

{aotrust_protocol-2.3.7 → aotrust_protocol-2.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aotrust-protocol"
-version = "2.3.7"
+version = "2.4.0"
 description = "Asyncio-native SDK for A&O Trust Layer — Agent Notary Service"
 readme = "README.md"
 requires-python = ">=3.10"