fizzl 0.1.0__tar.gz

fizzl-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+dist/
+build/
+*.egg-info/
+__pycache__/
+.pytest_cache/

fizzl-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Frits Zwager
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fizzl-0.1.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.5
+Name: fizzl
+Version: 0.1.0
+Summary: Safety checks for AI agents that pay: check a transaction or signature before signing, a token before buying, a wallet's approvals, and an x402 endpoint before paying it (presign-guard, x402 Doctor).
+Project-URL: Homepage, https://github.com/Fizzl13/x402-examples/tree/main/fizzl-py
+Project-URL: Repository, https://github.com/Fizzl13/x402-examples
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,ai-agents,approvals,base,honeypot,langchain,mcp,presign,security,solana,token-check,usdc,wallet,x402
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Requires-Python: >=3.9
+Requires-Dist: requests>=2.28
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.3; extra == 'langchain'
+Requires-Dist: pydantic>=2; extra == 'langchain'
+Provides-Extra: x402
+Requires-Dist: x402[requests]>=2.0; extra == 'x402'
+Description-Content-Type: text/markdown
+
+# fizzl
+
+Safety checks for Python AI agents that pay: LangChain, LangGraph, CrewAI or your own loop.
+
+| Check | What the agent checks | Service | Price |
+|---|---|---|---|
+| `check_before_signing` | a transaction, token approval or signature **before signing it**: green / orange / red with reason codes (drainers, unlimited approvals to unknown spenders, look-alike tokens, Permit/Permit2/Seaport signatures that hand over tokens) | [presign-guard](https://presign-guard.fizzl.eu) | $0.01 |
+| `check_token` | a token **before buying or accepting it**: honeypot, rug-pull signs, look-alikes (Solana and EVM) | presign-guard | $0.01 |
+| `check_wallet_approvals` | every open approval of a wallet and which to revoke | presign-guard | $0.02 |
+| `check_endpoint_before_paying` | an x402 or MPP paid API **before paying it**: go / caution / no_go, the cheapest option that settles, budget, track record, bait signs (fake brands, airdrop lures, output that doesn't match) | [x402 Doctor](https://x402-doctor.fizzl.eu) | $0.001 |
+
+The checks only check. They never sign, pay or move anything themselves. A failed check comes back as
+`{"error": ..., "message": ...}` instead of raising, so the agent can tell its user.
+
+## Install
+
+```sh
+pip install "fizzl[x402]"              # with the x402 client, to pay per check
+pip install "fizzl[langchain,x402]"    # plus LangChain tools
+```
+
+## Use
+
+```python
+import requests
+from eth_account import Account
+from x402 import x402ClientSync
+from x402.http.clients import wrapRequestsWithPayment
+from x402.mechanisms.evm.exact import ExactEvmScheme
+from fizzl import Fizzl
+
+payer = x402ClientSync().register("eip155:8453", ExactEvmScheme(Account.from_key(AGENT_KEY)))  # USDC on Base
+session = wrapRequestsWithPayment(requests.Session(), payer)
+
+fizzl = Fizzl(session=session)
+fizzl.check_endpoint_before_paying("https://api.example.com/funding", max_usd=0.05)
+# {'verdict': 'go', 'summary': 'OK to pay: $0.02 on Base.', 'options': [...], 'reasons': [], ...}
+fizzl.check_token("base", "0x...")
+fizzl.check_before_signing(type="approval", chainId=8453, token="0x...", spender="0x...", amount="115792089237316195423570985008687907853269984665640564039457584007913129639935")
+```
+
+**Prepaid credits instead of a payment per check:** buy a pack once ([presign-guard](https://presign-guard.fizzl.eu/v1/credits): 100 checks for $0.80; [x402 Doctor](https://x402-doctor.fizzl.eu/api/v1/credits): 1000 preflights for $0.80), then use a plain session:
+
+```python
+fizzl = Fizzl(credit_keys={"presign": PRESIGN_CREDIT_KEY, "doctor": DOCTOR_CREDIT_KEY})
+```
+
+## LangChain / LangGraph
+
+```python
+from langgraph.prebuilt import create_react_agent
+from fizzl.langchain import fizzl_tools
+
+tools = fizzl_tools(session=session)          # or credit_keys={...}; only=[...] for some of them
+agent = create_react_agent(model, tools + your_tools,
+    prompt="Before you pay any API, call check_endpoint_before_paying. Before you sign anything, call check_before_signing. Never continue on red or no_go.")
+```
+
+The tools are plain `StructuredTool`s with typed arguments, so CrewAI and other frameworks that take LangChain tools can use them too.
+
+## Want the wallet to enforce it, not just inform the model?
+
+Tools inform the model; a model can still ignore them. To make red and over-budget payments impossible, guard the
+wallet itself: [presign-guard-wallet](https://www.npmjs.com/package/presign-guard-wallet) (Node) checks every
+signature with presign-guard and your spending limits, with Telegram approval above them.
+
+## License
+
+MIT

fizzl-0.1.0/README.md

@@ -0,0 +1,69 @@
+# fizzl
+
+Safety checks for Python AI agents that pay: LangChain, LangGraph, CrewAI or your own loop.
+
+| Check | What the agent checks | Service | Price |
+|---|---|---|---|
+| `check_before_signing` | a transaction, token approval or signature **before signing it**: green / orange / red with reason codes (drainers, unlimited approvals to unknown spenders, look-alike tokens, Permit/Permit2/Seaport signatures that hand over tokens) | [presign-guard](https://presign-guard.fizzl.eu) | $0.01 |
+| `check_token` | a token **before buying or accepting it**: honeypot, rug-pull signs, look-alikes (Solana and EVM) | presign-guard | $0.01 |
+| `check_wallet_approvals` | every open approval of a wallet and which to revoke | presign-guard | $0.02 |
+| `check_endpoint_before_paying` | an x402 or MPP paid API **before paying it**: go / caution / no_go, the cheapest option that settles, budget, track record, bait signs (fake brands, airdrop lures, output that doesn't match) | [x402 Doctor](https://x402-doctor.fizzl.eu) | $0.001 |
+
+The checks only check. They never sign, pay or move anything themselves. A failed check comes back as
+`{"error": ..., "message": ...}` instead of raising, so the agent can tell its user.
+
+## Install
+
+```sh
+pip install "fizzl[x402]"              # with the x402 client, to pay per check
+pip install "fizzl[langchain,x402]"    # plus LangChain tools
+```
+
+## Use
+
+```python
+import requests
+from eth_account import Account
+from x402 import x402ClientSync
+from x402.http.clients import wrapRequestsWithPayment
+from x402.mechanisms.evm.exact import ExactEvmScheme
+from fizzl import Fizzl
+
+payer = x402ClientSync().register("eip155:8453", ExactEvmScheme(Account.from_key(AGENT_KEY)))  # USDC on Base
+session = wrapRequestsWithPayment(requests.Session(), payer)
+
+fizzl = Fizzl(session=session)
+fizzl.check_endpoint_before_paying("https://api.example.com/funding", max_usd=0.05)
+# {'verdict': 'go', 'summary': 'OK to pay: $0.02 on Base.', 'options': [...], 'reasons': [], ...}
+fizzl.check_token("base", "0x...")
+fizzl.check_before_signing(type="approval", chainId=8453, token="0x...", spender="0x...", amount="115792089237316195423570985008687907853269984665640564039457584007913129639935")
+```
+
+**Prepaid credits instead of a payment per check:** buy a pack once ([presign-guard](https://presign-guard.fizzl.eu/v1/credits): 100 checks for $0.80; [x402 Doctor](https://x402-doctor.fizzl.eu/api/v1/credits): 1000 preflights for $0.80), then use a plain session:
+
+```python
+fizzl = Fizzl(credit_keys={"presign": PRESIGN_CREDIT_KEY, "doctor": DOCTOR_CREDIT_KEY})
+```
+
+## LangChain / LangGraph
+
+```python
+from langgraph.prebuilt import create_react_agent
+from fizzl.langchain import fizzl_tools
+
+tools = fizzl_tools(session=session)          # or credit_keys={...}; only=[...] for some of them
+agent = create_react_agent(model, tools + your_tools,
+    prompt="Before you pay any API, call check_endpoint_before_paying. Before you sign anything, call check_before_signing. Never continue on red or no_go.")
+```
+
+The tools are plain `StructuredTool`s with typed arguments, so CrewAI and other frameworks that take LangChain tools can use them too.
+
+## Want the wallet to enforce it, not just inform the model?
+
+Tools inform the model; a model can still ignore them. To make red and over-budget payments impossible, guard the
+wallet itself: [presign-guard-wallet](https://www.npmjs.com/package/presign-guard-wallet) (Node) checks every
+signature with presign-guard and your spending limits, with Telegram approval above them.
+
+## License
+
+MIT

fizzl-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fizzl"
+version = "0.1.0"
+description = "Safety checks for AI agents that pay: check a transaction or signature before signing, a token before buying, a wallet's approvals, and an x402 endpoint before paying it (presign-guard, x402 Doctor)."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.9"
+dependencies = ["requests>=2.28"]
+keywords = ["x402", "ai-agents", "agents", "langchain", "wallet", "security", "presign", "token-check", "honeypot", "approvals", "usdc", "base", "solana", "mcp"]
+classifiers = ["Programming Language :: Python :: 3", "Intended Audience :: Developers", "Topic :: Security"]
+
+[project.optional-dependencies]
+langchain = ["langchain-core>=0.3", "pydantic>=2"]
+x402 = ["x402[requests]>=2.0"]
+
+[project.urls]
+Homepage = "https://github.com/Fizzl13/x402-examples/tree/main/fizzl-py"
+Repository = "https://github.com/Fizzl13/x402-examples"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/fizzl"]

fizzl-0.1.0/src/fizzl/__init__.py

@@ -0,0 +1,122 @@
+"""Fizzl safety checks for AI agents that pay.
+
+Check a transaction or signature before signing, a token before buying, a wallet's open approvals, and an
+x402 endpoint before paying it (presign-guard and x402 Doctor, paid per call over x402 or with prepaid
+credits). The checks never sign, pay or move anything themselves, and a failed check comes back as
+``{"error": ..., "message": ...}`` instead of an exception, so an agent can tell its user.
+
+    import requests
+    from x402 import x402ClientSync
+    from x402.http.clients import wrapRequestsWithPayment
+    from fizzl import Fizzl
+
+    payer = x402ClientSync()            # register an EVM scheme with your agent's key
+    session = wrapRequestsWithPayment(requests.Session(), payer)
+    fizzl = Fizzl(session=session)
+    fizzl.check_endpoint_before_paying("https://api.example.com/data", max_usd=0.05)
+"""
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional
+from urllib.parse import urlencode
+
+__version__ = "0.1.0"
+__all__ = ["Fizzl", "PRICES", "PRESIGN_URL", "DOCTOR_URL", "__version__"]
+
+PRESIGN_URL = "https://presign-guard.fizzl.eu"
+DOCTOR_URL = "https://x402-doctor.fizzl.eu"
+PRICES = {
+    "check_before_signing": "$0.01",
+    "check_token": "$0.01",
+    "check_wallet_approvals": "$0.02",
+    "check_endpoint_before_paying": "$0.001",
+}
+EVM_CHAIN_IDS = (1, 10, 56, 137, 8453, 42161)
+TOKEN_CHAINS = ("solana", "base", "ethereum", "arbitrum", "optimism", "polygon", "bsc")
+APPROVAL_CHAINS = ("base", "ethereum", "arbitrum", "optimism", "polygon", "bsc")
+
+
+def _error(code: str, message: str) -> dict:
+    return {"error": code, "message": message}
+
+
+class Fizzl:
+    """The four checks. ``session`` is anything with ``request(method, url, **kwargs)`` like a
+    ``requests.Session``; wrap it with x402's ``wrapRequestsWithPayment`` to pay per check, or pass
+    ``credit_keys={"presign": ..., "doctor": ...}`` to pay from prepaid credits with a plain session."""
+
+    def __init__(self, session: Any = None, credit_keys: Optional[Mapping[str, str]] = None, timeout: float = 30,
+                 presign_url: str = PRESIGN_URL, doctor_url: str = DOCTOR_URL):
+        if session is None:
+            import requests  # only needed when no session is given
+            session = requests.Session()
+        self.session = session
+        self.credit_keys = dict(credit_keys or {})
+        self.timeout = timeout
+        self.presign_url = presign_url.rstrip("/")
+        self.doctor_url = doctor_url.rstrip("/")
+
+    def _call(self, service: str, method: str, url: str, body: Optional[dict] = None) -> dict:
+        headers = {"accept": "application/json", "user-agent": f"fizzl-py/{__version__}"}
+        key = self.credit_keys.get(service)
+        if key:
+            headers["x-credit-key"] = key
+        try:
+            res = self.session.request(method, url, headers=headers, timeout=self.timeout, **({"json": body} if body is not None else {}))
+        except Exception as err:  # network, timeout, payment client errors
+            return _error("check_failed", f"{type(err).__name__}: {err}")
+        try:
+            data = res.json()
+        except Exception:
+            data = None
+        if res.status_code == 402:
+            why = data.get("error") if isinstance(data, dict) and isinstance(data.get("error"), str) else None
+            return _error("payment_required", "This check is paid (x402) and no payment went through"
+                          + (f" ({why})" if why else "")
+                          + ". Pass a session wrapped with x402's wrapRequestsWithPayment whose wallet holds USDC on Base, or a prepaid credit key.")
+        if res.status_code >= 400:
+            msg = (data or {}).get("error") or (data or {}).get("message") if isinstance(data, dict) else None
+            return _error(f"http_{res.status_code}", str(msg or getattr(res, "text", ""))[:300])
+        if not isinstance(data, dict):
+            return _error("bad_response", "The check did not answer JSON.")
+        data.pop("receipt", None)  # the signed receipt is for audits, not for the model
+        return data
+
+    def check_before_signing(self, type: str, chainId: int, token: Optional[str] = None, spender: Optional[str] = None,
+                             amount: Optional[str] = None, to: Optional[str] = None, data: Optional[str] = None,
+                             value: Optional[str] = None, typedData: Any = None, origin: Optional[str] = None) -> dict:
+        """Check a transaction, token approval or signature BEFORE signing it (presign-guard, $0.01).
+        Returns verdict green / orange / red with reason codes. Never sign on red; ask the user on orange."""
+        if type not in ("approval", "transaction", "signature"):
+            return _error("bad_input", 'type must be "approval", "transaction" or "signature"')
+        if chainId not in EVM_CHAIN_IDS:
+            return _error("bad_input", f"chainId must be one of {EVM_CHAIN_IDS}")
+        body = {k: v for k, v in dict(type=type, chainId=chainId, token=token, spender=spender, amount=amount, to=to,
+                                      data=data, value=value, typedData=typedData, origin=origin).items() if v is not None}
+        return self._call("presign", "POST", f"{self.presign_url}/v1/check", body)
+
+    def check_token(self, chain: str, address: str) -> dict:
+        """Check a token BEFORE buying, holding or accepting it (presign-guard, $0.01): honeypot, rug-pull
+        signs, look-alikes of known tokens. Solana and EVM chains."""
+        if chain not in TOKEN_CHAINS:
+            return _error("bad_input", f"chain must be one of {TOKEN_CHAINS}")
+        return self._call("presign", "GET", f"{self.presign_url}/v1/token?{urlencode({'chain': chain, 'address': address})}")
+
+    def check_wallet_approvals(self, chain: str, address: str) -> dict:
+        """List every open token approval of an EVM wallet and which ones to revoke (presign-guard, $0.02)."""
+        if chain not in APPROVAL_CHAINS:
+            return _error("bad_input", f"chain must be one of {APPROVAL_CHAINS}")
+        return self._call("presign", "GET", f"{self.presign_url}/v1/approvals?{urlencode({'chain': chain, 'address': address})}")
+
+    def check_endpoint_before_paying(self, url: str, max_usd: Optional[float] = None, network: Optional[str] = None,
+                                     method: Optional[str] = None) -> dict:
+        """Check an x402 or MPP paid API BEFORE paying it (x402 Doctor, $0.001): go / caution / no_go, the
+        cheapest option that settles, budget, track record and bait signs. Don't pay on no_go."""
+        q = {"url": url}
+        if max_usd is not None:
+            q["max_usd"] = str(max_usd)
+        if network:
+            q["network"] = network
+        if method:
+            q["method"] = method
+        return self._call("doctor", "GET", f"{self.doctor_url}/api/v1/preflight?{urlencode(q)}")

fizzl-0.1.0/src/fizzl/langchain.py

@@ -0,0 +1,62 @@
+"""The Fizzl checks as LangChain tools (``langchain-core``), for LangChain and LangGraph agents.
+
+    from fizzl.langchain import fizzl_tools
+    tools = fizzl_tools(session=paying_session)   # or credit_keys={...}
+    agent = create_react_agent(model, tools)
+"""
+from __future__ import annotations
+
+from typing import Any, List, Literal, Optional, Union
+
+from . import Fizzl
+
+TOOL_NAMES = ("check_before_signing", "check_token", "check_wallet_approvals", "check_endpoint_before_paying")
+
+
+def fizzl_tools(session: Any = None, credit_keys: Optional[dict] = None, only: Optional[List[str]] = None, **kwargs) -> list:
+    """LangChain StructuredTools for the four checks (all of them, or the names in ``only``)."""
+    try:
+        from langchain_core.tools import StructuredTool
+        from pydantic import BaseModel, Field
+    except ImportError as err:  # pragma: no cover
+        raise ImportError("fizzl.langchain needs langchain-core: pip install 'fizzl[langchain]'") from err
+
+    f = Fizzl(session=session, credit_keys=credit_keys, **kwargs)
+
+    class SignArgs(BaseModel):
+        type: Literal["approval", "transaction", "signature"] = Field(description="What is about to be signed")
+        chainId: int = Field(description="EVM chain id: 1, 10, 56, 137, 8453 (Base) or 42161")
+        token: Optional[str] = Field(None, description="approval: token contract")
+        spender: Optional[str] = Field(None, description="approval: who gets the allowance")
+        amount: Optional[str] = Field(None, description="approval: amount in base units (0 = revoke)")
+        to: Optional[str] = Field(None, description="transaction: target contract or recipient")
+        data: Optional[str] = Field(None, description="transaction: 0x-prefixed calldata")
+        value: Optional[str] = Field(None, description="transaction: native value in wei")
+        typedData: Optional[Union[dict, str]] = Field(None, description="signature: the eth_signTypedData_v4 payload")
+        origin: Optional[str] = Field(None, description="the site asking for the signature or transaction, if any")
+
+    class TokenArgs(BaseModel):
+        chain: Literal["solana", "base", "ethereum", "arbitrum", "optimism", "polygon", "bsc"]
+        address: str = Field(description="Solana mint (base58) or EVM token contract (0x…)")
+
+    class ApprovalArgs(BaseModel):
+        chain: Literal["base", "ethereum", "arbitrum", "optimism", "polygon", "bsc"]
+        address: str = Field(description="Wallet address (0x…)")
+
+    class EndpointArgs(BaseModel):
+        url: str = Field(description="The paid endpoint you are about to pay")
+        max_usd: Optional[float] = Field(None, description="Your budget for this call in USD")
+        network: Optional[str] = Field(None, description="CAIP-2 network to pay on, e.g. eip155:8453")
+        method: Optional[Literal["GET", "POST"]] = None
+
+    specs = {
+        "check_before_signing": (f.check_before_signing, SignArgs),
+        "check_token": (f.check_token, TokenArgs),
+        "check_wallet_approvals": (f.check_wallet_approvals, ApprovalArgs),
+        "check_endpoint_before_paying": (f.check_endpoint_before_paying, EndpointArgs),
+    }
+    names = list(only) if only else list(TOOL_NAMES)
+    unknown = [n for n in names if n not in specs]
+    if unknown:
+        raise ValueError(f"unknown Fizzl tool(s): {', '.join(unknown)}")
+    return [StructuredTool.from_function(func=specs[n][0], name=n, description=(specs[n][0].__doc__ or "").strip(), args_schema=specs[n][1]) for n in names]

fizzl-0.1.0/tests/test_fizzl.py

@@ -0,0 +1,74 @@
+"""The checks against a stand-in session (no network, no money), and as LangChain tools."""
+import json
+
+import pytest
+
+from fizzl import PRICES, Fizzl
+
+
+class Resp:
+    def __init__(self, status, body):
+        self.status_code = status
+        self.text = body if isinstance(body, str) else json.dumps(body)
+
+    def json(self):
+        return json.loads(self.text)
+
+
+class StandIn:
+    def __init__(self, answers):
+        self.answers, self.calls = answers, []
+
+    def request(self, method, url, **kw):
+        self.calls.append({"method": method, "url": url, **kw})
+        if isinstance(self.answers, Exception):
+            raise self.answers
+        path = url.split("://", 1)[1].split("/", 1)[1].split("?")[0]
+        status, body = self.answers.get("/" + path, (404, {"error": "not found"}))
+        return Resp(status, body)
+
+
+def test_calls_the_right_api_sends_credit_keys_and_leaves_the_receipt_out():
+    s = StandIn({"/v1/check": (200, {"verdict": "red", "reasons": [{"code": "known_drainer"}], "receipt": {"sig": "0x"}}),
+                 "/v1/token": (200, {"verdict": "green"}), "/v1/approvals": (200, {"summary": {"toRevoke": 1}}),
+                 "/api/v1/preflight": (200, {"verdict": "caution"})})
+    f = Fizzl(session=s, credit_keys={"presign": "pk", "doctor": "dk"})
+    assert f.check_before_signing(type="approval", chainId=8453, token="0xa", spender="0xb", amount="1") == {"verdict": "red", "reasons": [{"code": "known_drainer"}]}
+    assert s.calls[0]["method"] == "POST" and s.calls[0]["url"] == "https://presign-guard.fizzl.eu/v1/check"
+    assert s.calls[0]["headers"]["x-credit-key"] == "pk" and s.calls[0]["json"]["spender"] == "0xb" and "data" not in s.calls[0]["json"]
+    f.check_token("solana", "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263")
+    assert "/v1/token?chain=solana&address=Dez" in s.calls[1]["url"]
+    f.check_wallet_approvals("base", "0x6B0F4651eD42893ab58139938175E4a69f175F25")
+    assert "/v1/approvals?chain=base&address=0x6B0F" in s.calls[2]["url"]
+    assert f.check_endpoint_before_paying("https://api.example.com/x", max_usd=0.05, network="eip155:8453")["verdict"] == "caution"
+    assert s.calls[3]["url"] == "https://x402-doctor.fizzl.eu/api/v1/preflight?url=https%3A%2F%2Fapi.example.com%2Fx&max_usd=0.05&network=eip155%3A8453"
+    assert s.calls[3]["headers"]["x-credit-key"] == "dk"
+
+
+def test_failures_come_back_as_error_dicts():
+    f = Fizzl(session=StandIn({"/v1/token": (402, {}), "/v1/check": (500, {"error": "boom"}), "/v1/approvals": (200, "not json")}))
+    assert f.check_token("base", "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913")["error"] == "payment_required"
+    assert f.check_before_signing(type="transaction", chainId=1, to="0x1") == {"error": "http_500", "message": "boom"}
+    assert f.check_wallet_approvals("base", "0x6B0F4651eD42893ab58139938175E4a69f175F25")["error"] == "bad_response"
+    assert Fizzl(session=StandIn(ConnectionError("down"))).check_endpoint_before_paying("https://a.example") == {"error": "check_failed", "message": "ConnectionError: down"}
+    assert f.check_before_signing(type="approval", chainId=999)["error"] == "bad_input"
+    assert f.check_token("dogechain", "x")["error"] == "bad_input"
+
+
+def test_prices_cover_every_check():
+    assert sorted(PRICES) == ["check_before_signing", "check_endpoint_before_paying", "check_token", "check_wallet_approvals"]
+
+
+def test_langchain_tools_call_the_checks():
+    pytest.importorskip("langchain_core")
+    from fizzl.langchain import fizzl_tools
+    s = StandIn({"/api/v1/preflight": (200, {"verdict": "no_go", "summary": "Do not pay: over budget."})})
+    tools = fizzl_tools(session=s)
+    assert [t.name for t in tools] == ["check_before_signing", "check_token", "check_wallet_approvals", "check_endpoint_before_paying"]
+    pre = next(t for t in tools if t.name == "check_endpoint_before_paying")
+    assert "BEFORE paying" in pre.description
+    assert pre.invoke({"url": "https://api.example.com/x", "max_usd": 0.01})["verdict"] == "no_go"
+    assert "max_usd=0.01" in s.calls[0]["url"]
+    assert [t.name for t in fizzl_tools(session=s, only=["check_token"])] == ["check_token"]
+    with pytest.raises(ValueError):
+        fizzl_tools(session=s, only=["nope"])