oneshot-python 0.8.0__tar.gz → 0.8.2__tar.gz

{oneshot_python-0.8.0 → oneshot_python-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oneshot-python
-Version: 0.8.0
+Version: 0.8.2
 Summary: Core Python SDK for the OneShot API — HTTP client with x402 payment handling
 License-Expression: MIT
 Requires-Python: >=3.10

{oneshot_python-0.8.0 → oneshot_python-0.8.2}/oneshot/client.py

@@ -23,9 +23,14 @@ from oneshot._errors import (
     ToolError,
     ValidationError,
 )
-from oneshot.x402 import sign_payment_authorization, encode_payment_header, parse_payment_required
+from oneshot.x402 import (
+    build_zero_cost_authorization,
+    encode_payment_header,
+    parse_payment_required,
+    sign_payment_authorization,
+)
 
-SDK_VERSION = "0.8.0"
+SDK_VERSION = "0.8.2"
 
 # ---------------------------------------------------------------------------
 # Environment configuration
@@ -157,29 +162,47 @@ class OneShotClient:
 
             self._log(f"Payment required: {payment_request['amount']} USDC")
 
-            # Step 3 — Sign x402 payment (v2 format with accepted requirements + Bazaar metadata)
-            auth = sign_payment_authorization(
-                private_key=self._private_key,
-                from_address=self.address,
-                to_address=payment_request["recipient"],
-                amount=payment_request["amount"],
-                token_address=payment_request["token_address"],
-                chain_id=payment_request["chain_id"],
-                network=f"eip155:{payment_request['chain_id']}",
-                accepted=accepted,
-                resource=parsed_req.get("resource"),
-                extensions=parsed_req.get("extensions"),
-            )
+            # Step 3 — Sign x402 payment (zero-cost auth if credits cover full cost)
+            amount = float(payment_request["amount"])
+            if amount == 0:
+                self._log("Credits cover full cost — sending zero-cost authorization")
+                auth = build_zero_cost_authorization(
+                    from_address=self.address,
+                    to_address=payment_request["recipient"],
+                    accepted=accepted,
+                    resource=parsed_req.get("resource"),
+                    extensions=parsed_req.get("extensions"),
+                )
+                headers = {
+                    **self._headers(),
+                    "payment-signature": encode_payment_header(auth),
+                }
+                if quote_id:
+                    headers["x-quote-id"] = quote_id
+                resp2 = await client.post(url, headers=headers, json=payload)
+            else:
+                auth = sign_payment_authorization(
+                    private_key=self._private_key,
+                    from_address=self.address,
+                    to_address=payment_request["recipient"],
+                    amount=payment_request["amount"],
+                    token_address=payment_request["token_address"],
+                    chain_id=payment_request["chain_id"],
+                    network=f"eip155:{payment_request['chain_id']}",
+                    accepted=accepted,
+                    resource=parsed_req.get("resource"),
+                    extensions=parsed_req.get("extensions"),
+                )
 
-            # Step 4 — Re-POST with payment headers (x402 format)
-            headers = {
-                **self._headers(),
-                "payment-signature": encode_payment_header(auth),
-            }
-            if quote_id:
-                headers["x-quote-id"] = quote_id
+                # Step 4 — Re-POST with payment headers (x402 format)
+                headers = {
+                    **self._headers(),
+                    "payment-signature": encode_payment_header(auth),
+                }
+                if quote_id:
+                    headers["x-quote-id"] = quote_id
 
-            resp2 = await client.post(url, headers=headers, json=payload)
+                resp2 = await client.post(url, headers=headers, json=payload)
 
             if resp2.status_code not in (200, 201, 202):
                 raise ToolError(

{oneshot_python-0.8.0 → oneshot_python-0.8.2}/oneshot/x402.py

@@ -192,6 +192,42 @@ def sign_payment_authorization(
     return result
 
 
+def build_zero_cost_authorization(
+    *,
+    from_address: str,
+    to_address: str,
+    accepted: PaymentRequirements | dict[str, Any] | None = None,
+    resource: dict[str, Any] | None = None,
+    extensions: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Build a zero-cost x402 PaymentPayload for credit-covered requests.
+
+    Instead of skipping the payment header entirely (which causes the server's
+    x402 SDK to return a 402 error), we send a stub authorization with value=0
+    and signature=0x so the server can recognise the zero-cost intent.
+    """
+    result: dict[str, Any] = {
+        "x402Version": 2,
+        "accepted": dict(accepted) if accepted else {},
+        "payload": {
+            "signature": "0x",
+            "authorization": {
+                "from": from_address,
+                "to": to_address,
+                "value": "0",
+                "validAfter": "0",
+                "validBefore": "0",
+                "nonce": "0x" + "00" * 32,
+            },
+        },
+    }
+    if resource:
+        result["resource"] = resource
+    if extensions:
+        result["extensions"] = extensions
+    return result
+
+
 def encode_payment_header(auth: dict[str, Any]) -> str:
     """Base64-encode a PaymentPayload dict for the payment-signature header."""
     return base64.b64encode(json.dumps(auth).encode()).decode()

{oneshot_python-0.8.0 → oneshot_python-0.8.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "oneshot-python"
-version = "0.8.0"
+version = "0.8.2"
 description = "Core Python SDK for the OneShot API — HTTP client with x402 payment handling"
 readme = {text = "Core Python SDK for the OneShot API", content-type = "text/plain"}
 license = "MIT"

{oneshot_python-0.8.0 → oneshot_python-0.8.2}/tests/test_x402.py

@@ -15,6 +15,7 @@ from eth_account import Account
 
 from oneshot.x402 import (
     _parse_usdc_amount,
+    build_zero_cost_authorization,
     encode_payment_header,
     parse_payment_required,
     sign_payment_authorization,
@@ -158,6 +159,101 @@ class TestSignPaymentAuthorization:
         assert auth1["payload"]["authorization"]["nonce"] != auth2["payload"]["authorization"]["nonce"]
 
 
+class TestBuildZeroCostAuthorization:
+    def test_returns_valid_payload(self) -> None:
+        auth = build_zero_cost_authorization(
+            from_address=TEST_ADDRESS,
+            to_address=TO_ADDRESS,
+            accepted=MOCK_ACCEPTED,
+        )
+        assert auth["x402Version"] == 2
+        assert auth["payload"]["signature"] == "0x"
+        assert auth["payload"]["authorization"]["value"] == "0"
+
+    def test_authorization_addresses(self) -> None:
+        auth = build_zero_cost_authorization(
+            from_address=TEST_ADDRESS,
+            to_address=TO_ADDRESS,
+            accepted=MOCK_ACCEPTED,
+        )
+        assert auth["payload"]["authorization"]["from"] == TEST_ADDRESS
+        assert auth["payload"]["authorization"]["to"] == TO_ADDRESS
+
+    def test_nonce_is_32_zero_bytes(self) -> None:
+        auth = build_zero_cost_authorization(
+            from_address=TEST_ADDRESS,
+            to_address=TO_ADDRESS,
+        )
+        nonce = auth["payload"]["authorization"]["nonce"]
+        assert nonce == "0x" + "00" * 32
+        assert len(nonce) == 66
+
+    def test_includes_resource_when_provided(self) -> None:
+        resource = {"url": "https://api.example.com/v1/tools/research", "mimeType": "application/json"}
+        auth = build_zero_cost_authorization(
+            from_address=TEST_ADDRESS,
+            to_address=TO_ADDRESS,
+            resource=resource,
+        )
+        assert auth["resource"] == resource
+
+    def test_omits_resource_when_not_provided(self) -> None:
+        auth = build_zero_cost_authorization(
+            from_address=TEST_ADDRESS,
+            to_address=TO_ADDRESS,
+        )
+        assert "resource" not in auth
+
+    def test_includes_extensions_when_provided(self) -> None:
+        extensions = {"discovery": {"bodyType": "json", "input": {"topic": "AI"}}}
+        auth = build_zero_cost_authorization(
+            from_address=TEST_ADDRESS,
+            to_address=TO_ADDRESS,
+            extensions=extensions,
+        )
+        assert auth["extensions"] == extensions
+
+    def test_omits_extensions_when_not_provided(self) -> None:
+        auth = build_zero_cost_authorization(
+            from_address=TEST_ADDRESS,
+            to_address=TO_ADDRESS,
+        )
+        assert "extensions" not in auth
+
+    def test_echoes_accepted_requirements(self) -> None:
+        auth = build_zero_cost_authorization(
+            from_address=TEST_ADDRESS,
+            to_address=TO_ADDRESS,
+            accepted=MOCK_ACCEPTED,
+        )
+        assert auth["accepted"]["scheme"] == "exact"
+        assert auth["accepted"]["payTo"] == TO_ADDRESS
+
+    def test_base64_roundtrip(self) -> None:
+        """Encoded zero-cost auth should be decodable by the server."""
+        auth = build_zero_cost_authorization(
+            from_address=TEST_ADDRESS,
+            to_address=TO_ADDRESS,
+            accepted=MOCK_ACCEPTED,
+        )
+        encoded = encode_payment_header(auth)
+        decoded = json.loads(base64.b64decode(encoded))
+        assert decoded["payload"]["authorization"]["value"] == "0"
+        assert decoded["payload"]["signature"] == "0x"
+
+    def test_server_detects_zero_value(self) -> None:
+        """Server step 5c: checks decoded.payload.authorization.value === '0'."""
+        auth = build_zero_cost_authorization(
+            from_address=TEST_ADDRESS,
+            to_address=TO_ADDRESS,
+            accepted=MOCK_ACCEPTED,
+        )
+        encoded = encode_payment_header(auth)
+        decoded = json.loads(base64.b64decode(encoded))
+        # This is the exact check the server does in step 5c
+        assert decoded.get("payload", {}).get("authorization", {}).get("value") == "0"
+
+
 class TestEncodePaymentHeader:
     def test_base64_roundtrip(self) -> None:
         auth = sign_payment_authorization(