billmyagent 2.1.0__tar.gz

billmyagent-2.1.0/.gitignore

@@ -0,0 +1,8 @@
+.venv/
+dist/
+build/
+*.egg-info/
+__pycache__/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/

billmyagent-2.1.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: billmyagent
+Version: 2.1.0
+Summary: x402 payment SDK for billmyagent — auto-pays HTTP 402 challenges with an eth-account signer and gates your own endpoints (FastAPI/Flask)
+Project-URL: Homepage, https://billmyagent.ai
+Project-URL: Source, https://github.com/RealMaxPower/payment-processor
+Author: billmyagent
+License-Expression: Apache-2.0
+Keywords: ai-agents,eip-3009,ethereum,payments,usdc,x402
+Requires-Python: >=3.10
+Requires-Dist: eth-account>=0.13
+Requires-Dist: requests>=2.31
+Requires-Dist: x402[evm]<3,>=2.13
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: responses>=0.25; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: types-requests; extra == 'dev'
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.110; extra == 'fastapi'
+Requires-Dist: httpx>=0.27; extra == 'fastapi'
+Provides-Extra: flask
+Requires-Dist: flask>=3.0; extra == 'flask'
+Description-Content-Type: text/markdown
+
+# billmyagent (Python)
+
+x402 payment SDK for Python. Pay x402-gated APIs as a **server/agent** and gate
+your **own endpoints** with a paywall. The Python counterpart of
+[`@billmyagent/payments-core`](../core), built on the official
+[`x402`](https://pypi.org/project/x402/) library + `eth-account`.
+
+Unlike the browser-oriented JS SDK, the agent here holds its private key
+directly — which is why this SDK matters for autonomous Python agents
+(LangChain, CrewAI, FastAPI services).
+
+## Install
+
+```bash
+pip install billmyagent              # buyer client
+pip install 'billmyagent[fastapi]'   # + FastAPI seller middleware
+pip install 'billmyagent[flask]'     # + Flask seller middleware
+```
+
+## Pay an x402-gated API (buyer / agent)
+
+```python
+import os
+from billmyagent import PaymentClient, create_signer
+
+# The private key is held in-process and never leaves it.
+signer = create_signer("base", os.environ["PRIVATE_KEY"])
+client = PaymentClient(signer=signer)
+
+# client.http is a requests.Session; any HTTP 402 it hits is paid and retried.
+res = client.http.get("https://api.example.com/paid-resource")
+print(res.json(), "paid:", bool(res.headers.get("x-payment-response")))
+```
+
+## Manage your merchant account (REST)
+
+```python
+client = PaymentClient(api_key=os.environ["BMA_API_KEY"], auth_token=jwt)
+
+client.get_payout_settings()
+client.update_payout_settings({"base_address": "0x…"})
+client.list_payments()
+```
+
+## Charge for your endpoints (seller)
+
+FastAPI:
+
+```python
+from fastapi import FastAPI
+from billmyagent.middleware.fastapi import add_payment_middleware
+
+app = FastAPI()
+add_payment_middleware(
+    app,
+    pay_to="0xYourPayoutAddress",
+    routes={"GET /premium": "$0.01"},
+    network="base-sepolia",   # base | base-sepolia | polygon
+)
+
+@app.get("/premium")
+def premium():
+    return {"unlocked": True}
+```
+
+Flask is identical via `billmyagent.middleware.flask.add_payment_middleware`.
+
+> Mainnet (base/polygon) settlement needs a facilitator with CDP credentials —
+> pass `facilitator_url=...`. Omit it to use the public x402.org testnet facilitator.
+
+## Supported networks
+
+EVM only, `exact` scheme: **base**, **base-sepolia** (testing), **polygon**.
+
+## Development
+
+```bash
+pip install -e '.[dev,fastapi,flask]'
+pytest && ruff check . && mypy billmyagent
+```
+
+## License
+
+Apache 2.0.

billmyagent-2.1.0/README.md

@@ -0,0 +1,84 @@
+# billmyagent (Python)
+
+x402 payment SDK for Python. Pay x402-gated APIs as a **server/agent** and gate
+your **own endpoints** with a paywall. The Python counterpart of
+[`@billmyagent/payments-core`](../core), built on the official
+[`x402`](https://pypi.org/project/x402/) library + `eth-account`.
+
+Unlike the browser-oriented JS SDK, the agent here holds its private key
+directly — which is why this SDK matters for autonomous Python agents
+(LangChain, CrewAI, FastAPI services).
+
+## Install
+
+```bash
+pip install billmyagent              # buyer client
+pip install 'billmyagent[fastapi]'   # + FastAPI seller middleware
+pip install 'billmyagent[flask]'     # + Flask seller middleware
+```
+
+## Pay an x402-gated API (buyer / agent)
+
+```python
+import os
+from billmyagent import PaymentClient, create_signer
+
+# The private key is held in-process and never leaves it.
+signer = create_signer("base", os.environ["PRIVATE_KEY"])
+client = PaymentClient(signer=signer)
+
+# client.http is a requests.Session; any HTTP 402 it hits is paid and retried.
+res = client.http.get("https://api.example.com/paid-resource")
+print(res.json(), "paid:", bool(res.headers.get("x-payment-response")))
+```
+
+## Manage your merchant account (REST)
+
+```python
+client = PaymentClient(api_key=os.environ["BMA_API_KEY"], auth_token=jwt)
+
+client.get_payout_settings()
+client.update_payout_settings({"base_address": "0x…"})
+client.list_payments()
+```
+
+## Charge for your endpoints (seller)
+
+FastAPI:
+
+```python
+from fastapi import FastAPI
+from billmyagent.middleware.fastapi import add_payment_middleware
+
+app = FastAPI()
+add_payment_middleware(
+    app,
+    pay_to="0xYourPayoutAddress",
+    routes={"GET /premium": "$0.01"},
+    network="base-sepolia",   # base | base-sepolia | polygon
+)
+
+@app.get("/premium")
+def premium():
+    return {"unlocked": True}
+```
+
+Flask is identical via `billmyagent.middleware.flask.add_payment_middleware`.
+
+> Mainnet (base/polygon) settlement needs a facilitator with CDP credentials —
+> pass `facilitator_url=...`. Omit it to use the public x402.org testnet facilitator.
+
+## Supported networks
+
+EVM only, `exact` scheme: **base**, **base-sepolia** (testing), **polygon**.
+
+## Development
+
+```bash
+pip install -e '.[dev,fastapi,flask]'
+pytest && ruff check . && mypy billmyagent
+```
+
+## License
+
+Apache 2.0.

billmyagent-2.1.0/billmyagent/__init__.py

@@ -0,0 +1,17 @@
+"""billmyagent — x402 payment SDK for Python.
+
+Pay x402-gated APIs as a server/agent, and gate your own endpoints.
+
+    from billmyagent import PaymentClient, create_signer
+
+    signer = create_signer("base", PRIVATE_KEY)
+    client = PaymentClient(signer=signer)
+    res = client.http.get("https://api.example.com/paid")  # auto-pays any 402
+"""
+
+from .client import PaymentClient, DEFAULT_BASE_URL
+from .signer import create_signer, SUPPORTED_NETWORKS
+
+__all__ = ["PaymentClient", "create_signer", "SUPPORTED_NETWORKS", "DEFAULT_BASE_URL", "__version__"]
+
+__version__ = "2.1.0"

billmyagent-2.1.0/billmyagent/client.py

@@ -0,0 +1,131 @@
+"""billmyagent payment client (Python).
+
+Mirrors ``@billmyagent/payments-core`` for the Python AI-agent audience. Two
+independent, optional roles:
+
+* **Pay x402-gated APIs** (buyer/agent): pass a ``signer``. Then ``client.http``
+  auto-pays any HTTP 402 it hits — ``client.http.get("https://api.example.com/paid")``.
+* **Manage your merchant account / payments** (REST): pass ``api_key`` (and
+  ``auth_token`` for ``/merchant/*``) and call the methods below.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import requests
+from eth_account.signers.local import LocalAccount
+
+from x402 import x402ClientSync
+from x402.mechanisms.evm.exact import register_exact_evm_client
+from x402.http.clients.requests import x402_requests
+
+DEFAULT_BASE_URL = "https://api.billmyagent.ai/api/v1"
+
+
+class PaymentClient:
+    """Client for the billmyagent x402 payment processor."""
+
+    def __init__(
+        self,
+        *,
+        signer: LocalAccount | None = None,
+        api_key: str | None = None,
+        base_url: str = DEFAULT_BASE_URL,
+        auth_token: str | None = None,
+    ) -> None:
+        """Create a client.
+
+        Args:
+            signer: eth_account signer (see :func:`billmyagent.create_signer`).
+                When provided, ``http`` auto-pays HTTP 402 challenges.
+            api_key: billmyagent API key, sent as ``X-API-Key`` on REST calls.
+            base_url: billmyagent API base URL.
+            auth_token: merchant JWT, required only for ``/merchant/*`` methods.
+        """
+        self.base_url = base_url.rstrip("/")
+        self._auth_token = auth_token
+
+        if signer is not None:
+            x402_client = x402ClientSync()
+            # Registers the exact-EVM scheme for all EVM networks (eip155:*),
+            # wrapping the LocalAccount so it can sign EIP-3009 authorizations.
+            # register_exact_evm_client wraps a LocalAccount internally
+            # (_wrap_if_local_account); the static type is the wrapped interface.
+            register_exact_evm_client(x402_client, signer)  # type: ignore[arg-type]
+            #: requests.Session that automatically pays HTTP 402 challenges.
+            self.http: requests.Session = x402_requests(x402_client)
+        else:
+            self.http = requests.Session()
+
+        if api_key:
+            self.http.headers["X-API-Key"] = api_key
+        self.http.headers["Content-Type"] = "application/json"
+
+    # ── Payments (REST; X-API-Key) ──────────────────────────────────────────
+
+    def create_payment(self, request: dict[str, Any]) -> dict[str, Any]:
+        """Record a payment with a pre-built x402 payload/requirements pair."""
+        return self._json(self.http.post(f"{self.base_url}/payments", json=request))
+
+    def get_payment(self, payment_id: str) -> dict[str, Any]:
+        return self._json(self.http.get(f"{self.base_url}/payments/{payment_id}"))
+
+    def verify_payment(self, payment_id: str) -> dict[str, Any]:
+        return self._json(self.http.post(f"{self.base_url}/payments/{payment_id}/verify"))
+
+    def settle_payment(self, payment_id: str) -> dict[str, Any]:
+        return self._json(self.http.post(f"{self.base_url}/payments/{payment_id}/settle"))
+
+    def list_payments(self, limit: int = 20, offset: int = 0) -> dict[str, Any]:
+        return self._json(
+            self.http.get(f"{self.base_url}/payments", params={"limit": limit, "offset": offset})
+        )
+
+    # ── Merchant account management (JWT) ───────────────────────────────────
+
+    def get_payout_settings(self) -> dict[str, Any]:
+        """Get your payout addresses (per network) and current fee rate."""
+        return self._json(
+            self.http.get(f"{self.base_url}/merchant/payout-settings", headers=self._bearer())
+        )["settings"]
+
+    def update_payout_settings(self, addresses: dict[str, str]) -> dict[str, Any]:
+        """Set one or more payout wallet addresses. Only provided fields change."""
+        return self._json(
+            self.http.put(
+                f"{self.base_url}/merchant/payout-settings", json=addresses, headers=self._bearer()
+            )
+        )["settings"]
+
+    def get_fees(self) -> dict[str, Any]:
+        """Get your accrued platform-fee ledger plus a per-currency/status summary."""
+        body = self._json(self.http.get(f"{self.base_url}/merchant/fees", headers=self._bearer()))
+        return {"summary": body.get("summary"), "fees": body.get("fees")}
+
+    def list_invoices(self) -> list[dict[str, Any]]:
+        """List your fee invoices."""
+        return self._json(
+            self.http.get(f"{self.base_url}/merchant/invoices", headers=self._bearer())
+        )["invoices"]
+
+    def get_invoice(self, invoice_id: str) -> dict[str, Any]:
+        """Get an invoice plus, for open/overdue invoices, the x402 payment instruction."""
+        return self._json(
+            self.http.get(f"{self.base_url}/merchant/invoices/{invoice_id}", headers=self._bearer())
+        )
+
+    # ── internals ───────────────────────────────────────────────────────────
+
+    def _bearer(self) -> dict[str, str]:
+        if not self._auth_token:
+            raise ValueError(
+                "auth_token (JWT) is required for merchant account methods. "
+                "Set it in PaymentClient(...)."
+            )
+        return {"Authorization": f"Bearer {self._auth_token}"}
+
+    @staticmethod
+    def _json(response: requests.Response) -> Any:
+        response.raise_for_status()
+        return response.json()

billmyagent-2.1.0/billmyagent/middleware/__init__.py

@@ -0,0 +1,56 @@
+"""Seller-side x402 middleware for Python web frameworks.
+
+Gate your own endpoints behind an x402 paywall. A request gets HTTP 402 with the
+official payment requirements until a valid payment is presented; the facilitator
+verifies + settles it and your payout address receives the funds directly.
+
+These are thin wrappers over the official ``x402`` server middleware, pre-wired
+to billmyagent conventions (simple network names, USD/USDC pricing). Import the
+framework you use:
+
+    from billmyagent.middleware.fastapi import add_payment_middleware   # FastAPI
+    from billmyagent.middleware.flask import add_payment_middleware     # Flask
+"""
+
+# Networks the x402 facilitator can settle, mapped to CAIP-2 chain ids.
+NETWORK_TO_CAIP2 = {
+    "base": "eip155:8453",
+    "base-sepolia": "eip155:84532",
+    "polygon": "eip155:137",
+}
+
+
+def to_caip2(network: str) -> str:
+    """Translate a simple network name to its CAIP-2 id (raises on unknown)."""
+    try:
+        return NETWORK_TO_CAIP2[network]
+    except KeyError as exc:
+        raise ValueError(
+            f"Unsupported network {network!r}. Supported: {', '.join(NETWORK_TO_CAIP2)}"
+        ) from exc
+
+
+def build_routes(pay_to: str, routes: dict[str, object], default_network: str) -> dict[str, object]:
+    """Build an x402 RoutesConfig from a simple ``{"GET /premium": "$0.01"}`` spec.
+
+    Each value may be a price string (uses ``default_network``) or a dict with
+    ``price`` and optional ``network`` keys.
+    """
+    config: dict[str, object] = {}
+    for route, spec in routes.items():
+        if isinstance(spec, str):
+            price, network = spec, default_network
+        elif isinstance(spec, dict):
+            price = str(spec.get("price"))
+            network = str(spec.get("network", default_network))
+        else:
+            raise TypeError(f"route spec for {route!r} must be a price string or dict")
+        config[route] = {
+            "accepts": {
+                "scheme": "exact",
+                "payTo": pay_to,
+                "price": price,
+                "network": to_caip2(network),
+            }
+        }
+    return config

billmyagent-2.1.0/billmyagent/middleware/fastapi.py

@@ -0,0 +1,62 @@
+"""FastAPI x402 paywall middleware.
+
+Example:
+    from fastapi import FastAPI
+    from billmyagent.middleware.fastapi import add_payment_middleware
+
+    app = FastAPI()
+    add_payment_middleware(
+        app,
+        pay_to="0xYourPayoutAddress",
+        routes={"GET /premium": "$0.01"},
+        network="base-sepolia",
+    )
+
+    @app.get("/premium")
+    def premium():
+        return {"unlocked": True}
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from x402 import x402ResourceServer
+from x402.http import HTTPFacilitatorClient
+from x402.mechanisms.evm.exact import register_exact_evm_server
+from x402.http.middleware.fastapi import payment_middleware as _payment_middleware
+
+from . import build_routes
+
+
+def _build_server(facilitator_url: str | None) -> x402ResourceServer:
+    facilitator = HTTPFacilitatorClient({"url": facilitator_url}) if facilitator_url else HTTPFacilitatorClient()
+    server = x402ResourceServer(facilitator)
+    register_exact_evm_server(server)
+    return server
+
+
+def add_payment_middleware(
+    app: Any,
+    *,
+    pay_to: str,
+    routes: dict[str, object],
+    network: str = "base-sepolia",
+    facilitator_url: str | None = None,
+) -> None:
+    """Register an x402 paywall on a FastAPI app.
+
+    Args:
+        app: the FastAPI application.
+        pay_to: payout address that receives payments.
+        routes: ``{"GET /premium": "$0.01"}`` (or per-route ``{"price","network"}`` dicts).
+        network: default network for routes without one (base / base-sepolia / polygon).
+        facilitator_url: a facilitator you control; omit for the public x402.org
+            testnet facilitator. Mainnet settlement needs CDP credentials.
+    """
+    server = _build_server(facilitator_url)
+    middleware = _payment_middleware(build_routes(pay_to, routes, network), server)  # type: ignore[arg-type]
+
+    @app.middleware("http")
+    async def _x402(request: Any, call_next: Any) -> Any:  # noqa: ANN401
+        return await middleware(request, call_next)

billmyagent-2.1.0/billmyagent/middleware/flask.py

@@ -0,0 +1,56 @@
+"""Flask x402 paywall middleware.
+
+Example:
+    from flask import Flask
+    from billmyagent.middleware.flask import add_payment_middleware
+
+    app = Flask(__name__)
+    add_payment_middleware(
+        app,
+        pay_to="0xYourPayoutAddress",
+        routes={"GET /premium": "$0.01"},
+        network="base-sepolia",
+    )
+
+    @app.get("/premium")
+    def premium():
+        return {"unlocked": True}
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from x402 import x402ResourceServerSync
+from x402.http import HTTPFacilitatorClientSync
+from x402.mechanisms.evm.exact import register_exact_evm_server
+from x402.http.middleware.flask import payment_middleware as _payment_middleware
+
+from . import build_routes
+
+
+def _build_server(facilitator_url: str | None) -> x402ResourceServerSync:
+    facilitator = (
+        HTTPFacilitatorClientSync({"url": facilitator_url})
+        if facilitator_url
+        else HTTPFacilitatorClientSync()
+    )
+    server = x402ResourceServerSync(facilitator)
+    register_exact_evm_server(server)
+    return server
+
+
+def add_payment_middleware(
+    app: Any,
+    *,
+    pay_to: str,
+    routes: dict[str, object],
+    network: str = "base-sepolia",
+    facilitator_url: str | None = None,
+) -> Any:
+    """Register an x402 paywall on a Flask app. Returns the PaymentMiddleware.
+
+    Args mirror the FastAPI variant. Uses the sync x402 server + facilitator.
+    """
+    server = _build_server(facilitator_url)
+    return _payment_middleware(app, build_routes(pay_to, routes, network), server)  # type: ignore[arg-type]

billmyagent-2.1.0/billmyagent/signer.py

@@ -0,0 +1,36 @@
+"""Signer helpers for the billmyagent x402 client.
+
+A "signer" is an ``eth_account`` ``LocalAccount``. The x402 exact-EVM scheme
+signs an EIP-3009 ``transferWithAuthorization`` with it; the facilitator settles
+on-chain. On a server/agent the private key is held directly and never leaves
+your process — which is the main reason this SDK exists (browsers use the JS SDK
+with an injected wallet instead).
+"""
+
+from __future__ import annotations
+
+from eth_account import Account
+from eth_account.signers.local import LocalAccount
+
+# EVM networks the x402 facilitator can settle. Solana is intentionally
+# unsupported; Ethereum L1 is not offered by the facilitator.
+SUPPORTED_NETWORKS = ("base", "base-sepolia", "polygon")
+
+
+def create_signer(network: str, private_key: str) -> LocalAccount:
+    """Build a signer (eth_account LocalAccount) from a private key.
+
+    Args:
+        network: Target network — one of ``base``, ``base-sepolia``, ``polygon``.
+            Advisory: the exact-EVM scheme pays whatever network the 402 challenge
+            asks for, but this guards against typos / unsupported chains.
+        private_key: 0x-prefixed private key. Use a dedicated, funded key.
+
+    Returns:
+        An ``eth_account`` ``LocalAccount`` usable as the client's ``signer``.
+    """
+    if network not in SUPPORTED_NETWORKS:
+        raise ValueError(
+            f"Unsupported network {network!r}. Supported: {', '.join(SUPPORTED_NETWORKS)}"
+        )
+    return Account.from_key(private_key)

billmyagent-2.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "billmyagent"
+version = "2.1.0"
+description = "x402 payment SDK for billmyagent — auto-pays HTTP 402 challenges with an eth-account signer and gates your own endpoints (FastAPI/Flask)"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+authors = [{ name = "billmyagent" }]
+keywords = ["x402", "payments", "ai-agents", "ethereum", "usdc", "eip-3009"]
+dependencies = [
+    "x402[evm]>=2.13,<3",
+    "eth-account>=0.13",
+    "requests>=2.31",
+]
+
+[project.urls]
+Homepage = "https://billmyagent.ai"
+Source = "https://github.com/RealMaxPower/payment-processor"
+
+[project.optional-dependencies]
+fastapi = ["fastapi>=0.110", "httpx>=0.27"]
+flask = ["flask>=3.0"]
+dev = [
+    "pytest>=8.0",
+    "ruff>=0.6",
+    "mypy>=1.11",
+    "types-requests",
+    "responses>=0.25",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["billmyagent"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.mypy]
+python_version = "3.10"
+ignore_missing_imports = true

billmyagent-2.1.0/tests/test_client.py

@@ -0,0 +1,41 @@
+import pytest
+import responses
+
+from billmyagent import PaymentClient
+
+BASE = "https://api.test/api/v1"
+
+
+@responses.activate
+def test_create_payment_sends_api_key() -> None:
+    responses.add(responses.POST, f"{BASE}/payments", json={"id": "p1", "status": "pending"})
+    client = PaymentClient(api_key="sk_test", base_url=BASE)
+    out = client.create_payment({"amount": "1", "currency": "USDC"})
+    assert out["id"] == "p1"
+    assert responses.calls[0].request.headers["X-API-Key"] == "sk_test"
+
+
+@responses.activate
+def test_list_payments() -> None:
+    responses.add(responses.GET, f"{BASE}/payments", json={"data": [], "limit": 20, "offset": 0})
+    client = PaymentClient(api_key="sk_test", base_url=BASE)
+    assert client.list_payments()["limit"] == 20
+
+
+def test_merchant_methods_require_auth_token() -> None:
+    client = PaymentClient(api_key="sk_test", base_url=BASE)
+    with pytest.raises(ValueError):
+        client.get_payout_settings()
+
+
+@responses.activate
+def test_get_payout_settings_sends_bearer() -> None:
+    responses.add(
+        responses.GET,
+        f"{BASE}/merchant/payout-settings",
+        json={"settings": {"base_address": "0xabc", "fee_bps": 100}},
+    )
+    client = PaymentClient(api_key="sk_test", base_url=BASE, auth_token="jwt123")
+    settings = client.get_payout_settings()
+    assert settings["base_address"] == "0xabc"
+    assert responses.calls[0].request.headers["Authorization"] == "Bearer jwt123"

billmyagent-2.1.0/tests/test_middleware.py

@@ -0,0 +1,30 @@
+import pytest
+
+from billmyagent.middleware import build_routes, to_caip2
+
+
+def test_to_caip2_maps_supported_networks() -> None:
+    assert to_caip2("base") == "eip155:8453"
+    assert to_caip2("base-sepolia") == "eip155:84532"
+    assert to_caip2("polygon") == "eip155:137"
+
+
+def test_to_caip2_rejects_unsupported() -> None:
+    with pytest.raises(ValueError):
+        to_caip2("ethereum")
+
+
+def test_build_routes_string_and_dict_specs() -> None:
+    routes = build_routes(
+        "0xPayout",
+        {"GET /a": "$0.01", "GET /b": {"price": "$1.00", "network": "polygon"}},
+        default_network="base",
+    )
+    a = routes["GET /a"]["accepts"]  # type: ignore[index]
+    assert a["payTo"] == "0xPayout"
+    assert a["price"] == "$0.01"
+    assert a["network"] == "eip155:8453"  # default network
+    assert a["scheme"] == "exact"
+
+    b = routes["GET /b"]["accepts"]  # type: ignore[index]
+    assert b["network"] == "eip155:137"  # per-route override

billmyagent-2.1.0/tests/test_signer.py

@@ -0,0 +1,17 @@
+import pytest
+
+from billmyagent import create_signer
+
+# Well-known throwaway test key (never use a real key in tests).
+TEST_KEY = "0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318"
+
+
+def test_create_signer_returns_account() -> None:
+    account = create_signer("base", TEST_KEY)
+    assert account.address.startswith("0x")
+    assert len(account.address) == 42
+
+
+def test_create_signer_rejects_unknown_network() -> None:
+    with pytest.raises(ValueError):
+        create_signer("ethereum", TEST_KEY)