agentpayments-python 0.1.1__tar.gz → 0.2.0__tar.gz

{agentpayments_python-0.1.1 → agentpayments_python-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentpayments-python
-Version: 0.1.1
+Version: 0.2.0
 Summary: AgentPayments gate for Python web frameworks — charge AI agents USDC on Solana before they can access your API
 License: MIT
 Project-URL: Homepage, https://github.com/adambrzosko/AgentPayments
@@ -116,6 +116,10 @@ register_agentpayments(
 | `home_wallet_address` | Yes | `''` | Solana wallet address to receive USDC payments. |
 | `solana_rpc_url` | No | Auto (devnet/mainnet) | Custom Solana RPC endpoint. |
 | `usdc_mint` | No | Auto (devnet/mainnet) | Custom USDC mint address. |
+| `min_payment` | No | `0.01` | Minimum USDC payment required. Ignored when `pricing_tiers` is set (the lowest tier's `min_amount` becomes the floor). |
+| `access_duration` | No | `None` (forever) | Seconds a successful payment grants access for. Requires `grant_store` to actually persist. |
+| `pricing_tiers` | No | `None` | Payment-amount → access mapping: `[{"min_amount": ..., "duration_seconds": ..., "name": ...}]`. Overrides `min_payment`/`access_duration`. |
+| `routes` | No | `None` | Per-route overrides for a single middleware instance: `[{"path_prefix": ..., "min_payment": ..., "access_duration": ..., "pricing_tiers": ...}]`, matched by longest `path_prefix`. |
 | `debug` | No | `True` | `True` = devnet. `False` = mainnet + strict mode. |
 | `api_key` | No | `None` | AgentPayments hosted-platform API key (`ap_live_...`). When set, agent keys are issued and metered via the platform instead of self-signed locally. See **Hosted Platform Mode** below. |
 | `platform_url` | No | AgentPayments-hosted URL | Override for a self-hosted platform API. |
@@ -126,6 +130,40 @@ Django reads these from `settings.*` (e.g., `settings.CHALLENGE_SECRET`, `settin
 
 Setting `api_key` switches agent-key issuance from local (`ag_...`) to platform-issued (`agp_...`), and — when the platform account has an on-chain fee configured — every 402 response's `payment` dict gains a `platform_fee` field describing a second required USDC transfer, to be sent in the **same Solana transaction** as the vendor payment. Missing that second transfer is treated as an unpaid request, same as any other invalid payment. This is opt-in per vendor account and has no effect on self-hosted deployments (no `api_key`). The standards-compliant `accepts[]`/`X-PAYMENT-REQUIRED` x402 fields are untouched — they still describe only the vendor leg.
 
+## Pricing & Access Model
+
+By default one `min_payment` buys indefinite access. Three parameters layer on top, identical across Django/FastAPI/Flask (Django via `settings.AGENTPAYMENTS_*`, the others as constructor kwargs):
+
+```python
+# FastAPI / Flask
+register_agentpayments(  # or AgentPaymentsASGIMiddleware(...)
+    app, ...,
+    grant_store=FileGrantStore("./data/grants.json"),  # required for duration/tiers to persist
+    access_duration=86400,  # seconds; a paid key is only good for 24h, then re-verifies
+    pricing_tiers=[
+        {"min_amount": 0.01, "duration_seconds": 3600,  "name": "hourly"},
+        {"min_amount": 0.05, "duration_seconds": 86400, "name": "daily"},
+        {"min_amount": 0.50, "duration_seconds": None,  "name": "lifetime"},
+    ],
+    routes=[
+        {"path_prefix": "/api/premium", "min_payment": 0.05},
+        {"path_prefix": "/api/basic",   "min_payment": 0.01},
+    ],
+)
+```
+
+```python
+# Django settings.py
+AGENTPAYMENTS_GRANT_STORE = FileGrantStore("/var/data/agp_grants.json")
+AGENTPAYMENTS_ACCESS_DURATION = 86400
+AGENTPAYMENTS_PRICING_TIERS = [...]  # same shape as above
+AGENTPAYMENTS_ROUTES = [...]
+```
+
+`pricing_tiers` overrides `min_payment`/`access_duration` when set — the gate finds the highest tier the actual on-chain payment clears and grants that tier's duration; the lowest tier's `min_amount` becomes the floor price for any access at all. Every non-floor tier also appears as its own entry in the 402 response's x402 `accepts[]` array. `routes` is matched by longest `path_prefix` on a path-segment boundary; unmatched requests fall back to the top-level `min_payment`/`access_duration`/`pricing_tiers`.
+
+**Revocation**: `MemoryGrantStore`/`FileGrantStore` (`agentpayments_python.grant_store`) both gained a `revoke(agent_key)` method — call it from your own admin view to cut off a specific paid key early. The adapters need no changes to respect this: `has()` already returns `False` for a revoked (or expired) grant. A grants file written by an older SDK version (a plain JSON array of key strings) is still read correctly as a set of permanent grants.
+
 ## Security Features
 
 - **Timing-safe HMAC comparison** — uses `hmac.compare_digest()` for all signature checks
@@ -150,6 +188,8 @@ agentpayments_python/
   detection.py           Browser detection and public path checks
   solana.py              On-chain payment verification + caching
   ratelimit.py           Shared IP-based rate limiter
+  grant_store.py         Durable paid-key persistence (expiry, revocation)
+  pricing.py             Pricing-tier / access-duration / per-route resolution
 ```
 
 ## Notes

{agentpayments_python-0.1.1 → agentpayments_python-0.2.0}/README.md

@@ -79,6 +79,10 @@ register_agentpayments(
 | `home_wallet_address` | Yes | `''` | Solana wallet address to receive USDC payments. |
 | `solana_rpc_url` | No | Auto (devnet/mainnet) | Custom Solana RPC endpoint. |
 | `usdc_mint` | No | Auto (devnet/mainnet) | Custom USDC mint address. |
+| `min_payment` | No | `0.01` | Minimum USDC payment required. Ignored when `pricing_tiers` is set (the lowest tier's `min_amount` becomes the floor). |
+| `access_duration` | No | `None` (forever) | Seconds a successful payment grants access for. Requires `grant_store` to actually persist. |
+| `pricing_tiers` | No | `None` | Payment-amount → access mapping: `[{"min_amount": ..., "duration_seconds": ..., "name": ...}]`. Overrides `min_payment`/`access_duration`. |
+| `routes` | No | `None` | Per-route overrides for a single middleware instance: `[{"path_prefix": ..., "min_payment": ..., "access_duration": ..., "pricing_tiers": ...}]`, matched by longest `path_prefix`. |
 | `debug` | No | `True` | `True` = devnet. `False` = mainnet + strict mode. |
 | `api_key` | No | `None` | AgentPayments hosted-platform API key (`ap_live_...`). When set, agent keys are issued and metered via the platform instead of self-signed locally. See **Hosted Platform Mode** below. |
 | `platform_url` | No | AgentPayments-hosted URL | Override for a self-hosted platform API. |
@@ -89,6 +93,40 @@ Django reads these from `settings.*` (e.g., `settings.CHALLENGE_SECRET`, `settin
 
 Setting `api_key` switches agent-key issuance from local (`ag_...`) to platform-issued (`agp_...`), and — when the platform account has an on-chain fee configured — every 402 response's `payment` dict gains a `platform_fee` field describing a second required USDC transfer, to be sent in the **same Solana transaction** as the vendor payment. Missing that second transfer is treated as an unpaid request, same as any other invalid payment. This is opt-in per vendor account and has no effect on self-hosted deployments (no `api_key`). The standards-compliant `accepts[]`/`X-PAYMENT-REQUIRED` x402 fields are untouched — they still describe only the vendor leg.
 
+## Pricing & Access Model
+
+By default one `min_payment` buys indefinite access. Three parameters layer on top, identical across Django/FastAPI/Flask (Django via `settings.AGENTPAYMENTS_*`, the others as constructor kwargs):
+
+```python
+# FastAPI / Flask
+register_agentpayments(  # or AgentPaymentsASGIMiddleware(...)
+    app, ...,
+    grant_store=FileGrantStore("./data/grants.json"),  # required for duration/tiers to persist
+    access_duration=86400,  # seconds; a paid key is only good for 24h, then re-verifies
+    pricing_tiers=[
+        {"min_amount": 0.01, "duration_seconds": 3600,  "name": "hourly"},
+        {"min_amount": 0.05, "duration_seconds": 86400, "name": "daily"},
+        {"min_amount": 0.50, "duration_seconds": None,  "name": "lifetime"},
+    ],
+    routes=[
+        {"path_prefix": "/api/premium", "min_payment": 0.05},
+        {"path_prefix": "/api/basic",   "min_payment": 0.01},
+    ],
+)
+```
+
+```python
+# Django settings.py
+AGENTPAYMENTS_GRANT_STORE = FileGrantStore("/var/data/agp_grants.json")
+AGENTPAYMENTS_ACCESS_DURATION = 86400
+AGENTPAYMENTS_PRICING_TIERS = [...]  # same shape as above
+AGENTPAYMENTS_ROUTES = [...]
+```
+
+`pricing_tiers` overrides `min_payment`/`access_duration` when set — the gate finds the highest tier the actual on-chain payment clears and grants that tier's duration; the lowest tier's `min_amount` becomes the floor price for any access at all. Every non-floor tier also appears as its own entry in the 402 response's x402 `accepts[]` array. `routes` is matched by longest `path_prefix` on a path-segment boundary; unmatched requests fall back to the top-level `min_payment`/`access_duration`/`pricing_tiers`.
+
+**Revocation**: `MemoryGrantStore`/`FileGrantStore` (`agentpayments_python.grant_store`) both gained a `revoke(agent_key)` method — call it from your own admin view to cut off a specific paid key early. The adapters need no changes to respect this: `has()` already returns `False` for a revoked (or expired) grant. A grants file written by an older SDK version (a plain JSON array of key strings) is still read correctly as a set of permanent grants.
+
 ## Security Features
 
 - **Timing-safe HMAC comparison** — uses `hmac.compare_digest()` for all signature checks
@@ -113,6 +151,8 @@ agentpayments_python/
   detection.py           Browser detection and public path checks
   solana.py              On-chain payment verification + caching
   ratelimit.py           Shared IP-based rate limiter
+  grant_store.py         Durable paid-key persistence (expiry, revocation)
+  pricing.py             Pricing-tier / access-duration / per-route resolution
 ```
 
 ## Notes

{agentpayments_python-0.1.1 → agentpayments_python-0.2.0}/agentpayments_python/detection.py

@@ -18,10 +18,18 @@ _BOT_UA_RE = _re.compile(r"bot|crawl|spider|slurp|mediapartners|adsbot", _re.IGN
 
 
 def is_browser_from_headers(headers: dict) -> bool:
-    # Primary signal: Fetch metadata headers (Chrome 76+, Firefox 90+).
-    if headers.get("sec-fetch-mode") or headers.get("sec-fetch-dest"):
+    # Primary signal: Fetch metadata headers, but only the values set exclusively for
+    # top-level navigations. These values are not reachable through the fetch()/XHR
+    # APIs, so this doesn't just check for *presence* of the header: Node's built-in
+    # fetch() (undici) unconditionally sends `sec-fetch-mode: cors` on every outgoing
+    # request (not overridable, it's a forbidden header), which previously
+    # misclassified fetch()-based agents as browsers and served them the HTML
+    # challenge instead of the 402 JSON they need to read to pay.
+    if headers.get("sec-fetch-mode") == "navigate" or headers.get("sec-fetch-dest") == "document":
         return True
-    # Fallback: UA heuristic for older browsers that don't send Sec-Fetch-*.
+    # Fallback: UA heuristic for older browsers that don't send Sec-Fetch-*, and for
+    # real in-page browser fetch()/XHR calls (Sec-Fetch-Mode: cors) which still carry
+    # a genuine browser User-Agent.
     ua = headers.get("user-agent") or headers.get("User-Agent") or ""
     if ua and not _BOT_UA_RE.search(ua) and _BROWSER_UA_RE.search(ua):
         return True

{agentpayments_python-0.1.1 → agentpayments_python-0.2.0}/agentpayments_python/django_adapter.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 import logging
+import time as _time
 
 from django.conf import settings
 from django.http import HttpResponse, HttpResponseRedirect, JsonResponse
@@ -11,9 +14,10 @@ from .crypto import generate_agent_key, is_valid_agent_key
 from .detection import is_browser_from_headers, is_public_path
 from .ratelimit import _challenge_limiter, _agent_key_limiter, _challenge_issue_limiter
 from .crawler import is_verified_crawler
-from .solana import MIN_PAYMENT, RPC_DEVNET, RPC_MAINNET, USDC_MINT_DEVNET, USDC_MINT_MAINNET, is_valid_solana_address, verify_payment_on_chain
-from .x402 import build_payment_object, build_payment_requirements, enrich_402_body, payment_required_header
+from .solana import MIN_PAYMENT, RPC_DEVNET, RPC_MAINNET, USDC_MINT_DEVNET, USDC_MINT_MAINNET, is_valid_solana_address, _scan_for_payment
+from .x402 import build_payment_object, build_payment_requirements, enrich_402_body, payment_required_header, tier_x402_opts_list
 from .platform_client import HOSTED_KEY_PREFIX, PlatformClient, is_valid_hosted_key
+from .pricing import normalize_price_config, build_routes_table, resolve_route_config, resolve_tier
 
 import json as _json
 from pathlib import Path as _Path
@@ -26,10 +30,11 @@ MAX_POW_LENGTH = _constants["MAX_POW_LENGTH"]
 logger = logging.getLogger("agentpayments")
 
 
-def _payment_required_response(body: dict, *, wallet_address: str, mint: str, min_payment: float, debug: bool, agent_key: str = "", resource: str = "") -> JsonResponse:
+def _payment_required_response(body: dict, *, wallet_address: str, mint: str, min_payment: float, debug: bool, agent_key: str = "", resource: str = "", extra_tier_opts: list[dict] | None = None) -> JsonResponse:
     """Return a 402 JsonResponse enriched with x402-standard fields and header."""
     pay_req = build_payment_requirements(wallet_address=wallet_address, mint=mint, min_payment=min_payment, debug=debug, agent_key=agent_key, resource=resource)
-    resp = JsonResponse(enrich_402_body(body, pay_req), status=402, json_dumps_params={"indent": 2})
+    extra_reqs = [build_payment_requirements(**opts) for opts in (extra_tier_opts or [])]
+    resp = JsonResponse(enrich_402_body(body, pay_req, extra_reqs), status=402, json_dumps_params={"indent": 2})
     resp["X-PAYMENT-REQUIRED"] = payment_required_header(pay_req)
     return resp
 
@@ -69,6 +74,16 @@ class GateMiddleware:
         self.rpc_url = rpc_url
         self.usdc_mint = usdc_mint
         self.network = "devnet" if debug else "mainnet-beta"
+        # Price/duration/tier resolution is static for this server — precompute
+        # once rather than per-request. Configure via settings.py:
+        #   AGENTPAYMENTS_MIN_PAYMENT, AGENTPAYMENTS_ACCESS_DURATION,
+        #   AGENTPAYMENTS_PRICING_TIERS, AGENTPAYMENTS_ROUTES
+        min_payment = getattr(settings, "AGENTPAYMENTS_MIN_PAYMENT", MIN_PAYMENT)
+        access_duration = getattr(settings, "AGENTPAYMENTS_ACCESS_DURATION", None)
+        pricing_tiers = getattr(settings, "AGENTPAYMENTS_PRICING_TIERS", None)
+        routes = getattr(settings, "AGENTPAYMENTS_ROUTES", None)
+        self.base_price_config = normalize_price_config(min_payment, access_duration, pricing_tiers)
+        self.routes_table = build_routes_table(routes, min_payment, access_duration, pricing_tiers)
         self.pow_difficulty = getattr(settings, "POW_DIFFICULTY", POW_DIFFICULTY)
         self.verify_crawlers = getattr(settings, "AGENTPAYMENTS_VERIFY_CRAWLERS", True)
         # Optional grant store for durable paid-key persistence. Set
@@ -81,6 +96,7 @@ class GateMiddleware:
         network = self.network
 
         pathname = request.path
+        price_config = resolve_route_config(pathname, self.routes_table, self.base_price_config)
         if is_public_path(pathname):
             return self.get_response(request)
 
@@ -128,21 +144,22 @@ class GateMiddleware:
                     new_key = generate_agent_key(secret)
                 if fee_info:
                     no_key_instructions = (
-                        f'Send {MIN_PAYMENT} USDC on Solana {network} to {wallet_address} with memo "{new_key}", '
+                        f'Send {price_config["min_payment"]} USDC on Solana {network} to {wallet_address} with memo "{new_key}", '
                         f'AND in the SAME transaction send the platform fee (see platform_fee below) to {fee_info["wallet"]}. '
                         f'Then include the header X-Agent-Key: {new_key} on all subsequent requests.'
                     )
                 else:
-                    no_key_instructions = f'Send {MIN_PAYMENT} USDC on Solana {network} to {wallet_address} with memo "{new_key}". Then include the header X-Agent-Key: {new_key} on all subsequent requests.'
+                    no_key_instructions = f'Send {price_config["min_payment"]} USDC on Solana {network} to {wallet_address} with memo "{new_key}". Then include the header X-Agent-Key: {new_key} on all subsequent requests.'
                 return _payment_required_response(
                     {
                         "error": "payment_required",
                         "message": "Access requires a paid API key. A key has been generated for you below. Send a USDC payment on Solana with this key as the memo to activate it, then retry your request with the X-Agent-Key header.",
                         "your_key": new_key,
-                        "payment": build_payment_object(network=network, min_payment=MIN_PAYMENT, wallet_address=wallet_address, memo=new_key, fee_info=fee_info, instructions=no_key_instructions),
+                        "payment": build_payment_object(network=network, min_payment=price_config["min_payment"], wallet_address=wallet_address, memo=new_key, fee_info=fee_info, instructions=no_key_instructions),
                     },
-                    wallet_address=wallet_address, mint=self.usdc_mint, min_payment=MIN_PAYMENT,
+                    wallet_address=wallet_address, mint=self.usdc_mint, min_payment=price_config["min_payment"],
                     debug=self.debug, agent_key=new_key, resource=pathname,
+                    extra_tier_opts=tier_x402_opts_list(price_config["pricing_tiers"], {"wallet_address": wallet_address, "mint": self.usdc_mint, "debug": self.debug, "agent_key": new_key, "resource": pathname}),
                 )
 
             # Validate the key. Platform-issued (agp_) use verificationSecret;
@@ -170,19 +187,24 @@ class GateMiddleware:
             if self.grant_store and self.grant_store.has(agent_key):
                 return self.get_response(request)
 
-            paid = verify_payment_on_chain(agent_key, wallet_address, self.rpc_url, self.usdc_mint, fee_info=fee_info)
+            scan_result = _scan_for_payment(agent_key, wallet_address, self.rpc_url, self.usdc_mint, min_payment=price_config["min_payment"], fee_info=fee_info)
+            paid = scan_result["paid"]
             if paid and self.grant_store:
-                self.grant_store.add(agent_key)
+                tier = resolve_tier(scan_result["amount_paid"], price_config["pricing_tiers"])
+                duration_seconds = tier["duration_seconds"] if tier else price_config["access_duration"]
+                expires_at = (_time.time() + duration_seconds) if duration_seconds else None
+                self.grant_store.add(agent_key, expires_at=expires_at, tier=(tier["name"] if tier else None))
             if not paid:
                 return _payment_required_response(
                     {
                         "error": "payment_required",
                         "message": "Key is valid but payment has not been verified on-chain yet.",
                         "your_key": agent_key,
-                        "payment": build_payment_object(network=network, min_payment=MIN_PAYMENT, wallet_address=wallet_address, memo=agent_key, fee_info=fee_info),
+                        "payment": build_payment_object(network=network, min_payment=price_config["min_payment"], wallet_address=wallet_address, memo=agent_key, fee_info=fee_info),
                     },
-                    wallet_address=wallet_address, mint=self.usdc_mint, min_payment=MIN_PAYMENT,
+                    wallet_address=wallet_address, mint=self.usdc_mint, min_payment=price_config["min_payment"],
                     debug=self.debug, agent_key=agent_key, resource=pathname,
+                    extra_tier_opts=tier_x402_opts_list(price_config["pricing_tiers"], {"wallet_address": wallet_address, "mint": self.usdc_mint, "debug": self.debug, "agent_key": agent_key, "resource": pathname}),
                 )
 
             return self.get_response(request)

{agentpayments_python-0.1.1 → agentpayments_python-0.2.0}/agentpayments_python/fastapi_adapter.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 
 from starlette.middleware.base import BaseHTTPMiddleware
@@ -10,9 +12,11 @@ from .crypto import generate_agent_key, is_valid_agent_key
 from .detection import is_browser_from_headers, is_public_path
 from .ratelimit import _challenge_limiter, _agent_key_limiter, _challenge_issue_limiter
 from .crawler import is_verified_crawler
-from .solana import MIN_PAYMENT, RPC_DEVNET, RPC_MAINNET, USDC_MINT_DEVNET, USDC_MINT_MAINNET, is_valid_solana_address, verify_payment_on_chain
-from .x402 import build_payment_object, build_payment_requirements, enrich_402_body, payment_required_header
+from .solana import MIN_PAYMENT, RPC_DEVNET, RPC_MAINNET, USDC_MINT_DEVNET, USDC_MINT_MAINNET, is_valid_solana_address, _scan_for_payment
+from .x402 import build_payment_object, build_payment_requirements, enrich_402_body, payment_required_header, tier_x402_opts_list
 from .platform_client import HOSTED_KEY_PREFIX, PlatformClient, is_valid_hosted_key
+from .pricing import normalize_price_config, build_routes_table, resolve_route_config, resolve_tier
+import time as _time
 
 import json as _json
 from pathlib import Path as _Path
@@ -23,11 +27,12 @@ MAX_FP_LENGTH = _constants["MAX_FP_LENGTH"]
 MAX_POW_LENGTH = _constants["MAX_POW_LENGTH"]
 
 
-def _payment_required_response(body: dict, *, wallet_address: str, mint: str, min_payment: float, debug: bool, agent_key: str = "", resource: str = "") -> JSONResponse:
+def _payment_required_response(body: dict, *, wallet_address: str, mint: str, min_payment: float, debug: bool, agent_key: str = "", resource: str = "", extra_tier_opts: list[dict] | None = None) -> JSONResponse:
     """Return a Starlette JSONResponse (402) enriched with x402-standard fields and header."""
     pay_req = build_payment_requirements(wallet_address=wallet_address, mint=mint, min_payment=min_payment, debug=debug, agent_key=agent_key, resource=resource)
+    extra_reqs = [build_payment_requirements(**opts) for opts in (extra_tier_opts or [])]
     return JSONResponse(
-        content=enrich_402_body(body, pay_req),
+        content=enrich_402_body(body, pay_req, extra_reqs),
         status_code=402,
         headers={"X-PAYMENT-REQUIRED": payment_required_header(pay_req)},
     )
@@ -41,7 +46,7 @@ def _client_ip(request: Request) -> str:
 
 
 class AgentPaymentsASGIMiddleware(BaseHTTPMiddleware):
-    def __init__(self, app, *, challenge_secret: str, home_wallet_address: str, debug: bool = True, solana_rpc_url=None, usdc_mint: str = "", pow_difficulty: int = POW_DIFFICULTY, verify_crawlers: bool = True, grant_store=None, require_https: bool = None, api_key: str = None, platform_url: str = None):
+    def __init__(self, app, *, challenge_secret: str, home_wallet_address: str, debug: bool = True, solana_rpc_url=None, usdc_mint: str = "", min_payment: float = MIN_PAYMENT, access_duration: float | None = None, pricing_tiers: list[dict] | None = None, routes: list[dict] | None = None, pow_difficulty: int = POW_DIFFICULTY, verify_crawlers: bool = True, grant_store=None, require_https: bool = None, api_key: str = None, platform_url: str = None):
         super().__init__(app)
         if challenge_secret == "default-secret-change-me":
             import logging
@@ -58,6 +63,10 @@ class AgentPaymentsASGIMiddleware(BaseHTTPMiddleware):
         raw_rpc = solana_rpc_url or (RPC_DEVNET if debug else RPC_MAINNET)
         self.solana_rpc_url = raw_rpc if isinstance(raw_rpc, list) else [raw_rpc]
         self.usdc_mint = usdc_mint or (USDC_MINT_DEVNET if debug else USDC_MINT_MAINNET)
+        # Price/duration/tier resolution is static for this middleware instance —
+        # precompute once rather than per-request.
+        self.base_price_config = normalize_price_config(min_payment, access_duration, pricing_tiers)
+        self.routes_table = build_routes_table(routes, min_payment, access_duration, pricing_tiers)
         self.pow_difficulty = pow_difficulty
         self.verify_crawlers = verify_crawlers
         self.grant_store = grant_store
@@ -66,6 +75,7 @@ class AgentPaymentsASGIMiddleware(BaseHTTPMiddleware):
 
     async def dispatch(self, request: Request, call_next):
         path = request.url.path
+        price_config = resolve_route_config(path, self.routes_table, self.base_price_config)
         if is_public_path(path):
             return await call_next(request)
 
@@ -112,21 +122,22 @@ class AgentPaymentsASGIMiddleware(BaseHTTPMiddleware):
                     new_key = generate_agent_key(self.challenge_secret)
                 if fee_info:
                     no_key_instructions = (
-                        f'Send {MIN_PAYMENT} USDC on Solana {network} to {self.home_wallet_address} with memo "{new_key}", '
+                        f'Send {price_config["min_payment"]} USDC on Solana {network} to {self.home_wallet_address} with memo "{new_key}", '
                         f'AND in the SAME transaction send the platform fee (see platform_fee below) to {fee_info["wallet"]}. '
                         f'Then include the header X-Agent-Key: {new_key} on all subsequent requests.'
                     )
                 else:
-                    no_key_instructions = f'Send {MIN_PAYMENT} USDC on Solana {network} to {self.home_wallet_address} with memo "{new_key}". Then include the header X-Agent-Key: {new_key} on all subsequent requests.'
+                    no_key_instructions = f'Send {price_config["min_payment"]} USDC on Solana {network} to {self.home_wallet_address} with memo "{new_key}". Then include the header X-Agent-Key: {new_key} on all subsequent requests.'
                 return _payment_required_response(
                     {
                         "error": "payment_required",
                         "message": "Access requires a paid API key. A key has been generated for you below. Send a USDC payment on Solana with this key as the memo to activate it, then retry your request with the X-Agent-Key header.",
                         "your_key": new_key,
-                        "payment": build_payment_object(network=network, min_payment=MIN_PAYMENT, wallet_address=self.home_wallet_address, memo=new_key, fee_info=fee_info, instructions=no_key_instructions),
+                        "payment": build_payment_object(network=network, min_payment=price_config["min_payment"], wallet_address=self.home_wallet_address, memo=new_key, fee_info=fee_info, instructions=no_key_instructions),
                     },
-                    wallet_address=self.home_wallet_address, mint=self.usdc_mint, min_payment=MIN_PAYMENT,
+                    wallet_address=self.home_wallet_address, mint=self.usdc_mint, min_payment=price_config["min_payment"],
                     debug=self.debug, agent_key=new_key, resource=path,
+                    extra_tier_opts=tier_x402_opts_list(price_config["pricing_tiers"], {"wallet_address": self.home_wallet_address, "mint": self.usdc_mint, "debug": self.debug, "agent_key": new_key, "resource": path}),
                 )
 
             if agent_key.startswith(HOSTED_KEY_PREFIX):
@@ -153,23 +164,28 @@ class AgentPaymentsASGIMiddleware(BaseHTTPMiddleware):
             if self.grant_store and self.grant_store.has(agent_key):
                 return await call_next(request)
 
-            # verify_payment_on_chain is synchronous (uses requests). Run it in a
+            # _scan_for_payment is synchronous (uses requests). Run it in a
             # thread-pool executor so it doesn't block the async event loop.
-            paid = await loop.run_in_executor(
-                None, lambda: verify_payment_on_chain(agent_key, self.home_wallet_address, self.solana_rpc_url, self.usdc_mint, fee_info=fee_info)
+            scan_result = await loop.run_in_executor(
+                None, lambda: _scan_for_payment(agent_key, self.home_wallet_address, self.solana_rpc_url, self.usdc_mint, min_payment=price_config["min_payment"], fee_info=fee_info)
             )
+            paid = scan_result["paid"]
             if paid and self.grant_store:
-                self.grant_store.add(agent_key)
+                tier = resolve_tier(scan_result["amount_paid"], price_config["pricing_tiers"])
+                duration_seconds = tier["duration_seconds"] if tier else price_config["access_duration"]
+                expires_at = (_time.time() + duration_seconds) if duration_seconds else None
+                self.grant_store.add(agent_key, expires_at=expires_at, tier=(tier["name"] if tier else None))
             if not paid:
                 return _payment_required_response(
                     {
                         "error": "payment_required",
                         "message": "Key is valid but payment has not been verified on-chain yet.",
                         "your_key": agent_key,
-                        "payment": build_payment_object(network=network, min_payment=MIN_PAYMENT, wallet_address=self.home_wallet_address, memo=agent_key, fee_info=fee_info),
+                        "payment": build_payment_object(network=network, min_payment=price_config["min_payment"], wallet_address=self.home_wallet_address, memo=agent_key, fee_info=fee_info),
                     },
-                    wallet_address=self.home_wallet_address, mint=self.usdc_mint, min_payment=MIN_PAYMENT,
+                    wallet_address=self.home_wallet_address, mint=self.usdc_mint, min_payment=price_config["min_payment"],
                     debug=self.debug, agent_key=agent_key, resource=path,
+                    extra_tier_opts=tier_x402_opts_list(price_config["pricing_tiers"], {"wallet_address": self.home_wallet_address, "mint": self.usdc_mint, "debug": self.debug, "agent_key": agent_key, "resource": path}),
                 )
 
             return await call_next(request)

{agentpayments_python-0.1.1 → agentpayments_python-0.2.0}/agentpayments_python/flask_adapter.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 from flask import jsonify, make_response, redirect, request, Response as FlaskResponse
 import json as _flask_json
+import time as _time
 
 from .challenge import POW_DIFFICULTY, challenge_html, make_nonce, validate_challenge_submission
 from .cookies import COOKIE_MAX_AGE, COOKIE_NAME, is_valid_cookie_value, make_cookie
@@ -7,9 +10,10 @@ from .crypto import generate_agent_key, is_valid_agent_key
 from .detection import is_browser_from_headers, is_public_path
 from .ratelimit import _challenge_limiter, _agent_key_limiter, _challenge_issue_limiter
 from .crawler import is_verified_crawler
-from .solana import MIN_PAYMENT, RPC_DEVNET, RPC_MAINNET, USDC_MINT_DEVNET, USDC_MINT_MAINNET, is_valid_solana_address, verify_payment_on_chain
-from .x402 import build_payment_object, build_payment_requirements, enrich_402_body, payment_required_header
+from .solana import MIN_PAYMENT, RPC_DEVNET, RPC_MAINNET, USDC_MINT_DEVNET, USDC_MINT_MAINNET, is_valid_solana_address, _scan_for_payment
+from .x402 import build_payment_object, build_payment_requirements, enrich_402_body, payment_required_header, tier_x402_opts_list
 from .platform_client import HOSTED_KEY_PREFIX, PlatformClient, is_valid_hosted_key
+from .pricing import normalize_price_config, build_routes_table, resolve_route_config, resolve_tier
 
 import json as _json
 from pathlib import Path as _Path
@@ -20,10 +24,11 @@ MAX_FP_LENGTH = _constants["MAX_FP_LENGTH"]
 MAX_POW_LENGTH = _constants["MAX_POW_LENGTH"]
 
 
-def _payment_required_flask(body: dict, *, wallet_address: str, mint: str, min_payment: float, debug: bool, agent_key: str = "", resource: str = ""):
+def _payment_required_flask(body: dict, *, wallet_address: str, mint: str, min_payment: float, debug: bool, agent_key: str = "", resource: str = "", extra_tier_opts: list[dict] | None = None):
     """Return a Flask 402 response enriched with x402-standard fields and header."""
     pay_req = build_payment_requirements(wallet_address=wallet_address, mint=mint, min_payment=min_payment, debug=debug, agent_key=agent_key, resource=resource)
-    enriched = enrich_402_body(body, pay_req)
+    extra_reqs = [build_payment_requirements(**opts) for opts in (extra_tier_opts or [])]
+    enriched = enrich_402_body(body, pay_req, extra_reqs)
     resp = make_response(_flask_json.dumps(enriched, indent=2), 402)
     resp.headers["Content-Type"] = "application/json"
     resp.headers["X-PAYMENT-REQUIRED"] = payment_required_header(pay_req)
@@ -34,7 +39,7 @@ def _client_ip() -> str:
     return request.headers.get("X-Forwarded-For", "").split(",")[0].strip() or request.remote_addr or "unknown"
 
 
-def register_agentpayments(app, *, challenge_secret: str, home_wallet_address: str, debug: bool = True, solana_rpc_url=None, usdc_mint: str = "", pow_difficulty: int = POW_DIFFICULTY, verify_crawlers: bool = True, grant_store=None, require_https: bool = None, api_key: str = None, platform_url: str = None):
+def register_agentpayments(app, *, challenge_secret: str, home_wallet_address: str, debug: bool = True, solana_rpc_url=None, usdc_mint: str = "", min_payment: float = MIN_PAYMENT, access_duration: float | None = None, pricing_tiers: list[dict] | None = None, routes: list[dict] | None = None, pow_difficulty: int = POW_DIFFICULTY, verify_crawlers: bool = True, grant_store=None, require_https: bool = None, api_key: str = None, platform_url: str = None):
     if challenge_secret == "default-secret-change-me":
         import logging
         logger = logging.getLogger("agentpayments")
@@ -49,10 +54,14 @@ def register_agentpayments(app, *, challenge_secret: str, home_wallet_address: s
     mint = usdc_mint or (USDC_MINT_DEVNET if debug else USDC_MINT_MAINNET)
     _require_https = (not debug) if require_https is None else require_https
     _platform_client = PlatformClient(api_key, platform_url) if api_key else None
+    # Price/duration/tier resolution is static for this app — precompute once.
+    base_price_config = normalize_price_config(min_payment, access_duration, pricing_tiers)
+    routes_table = build_routes_table(routes, min_payment, access_duration, pricing_tiers)
 
     @app.before_request
     def _gate():
         path = request.path
+        price_config = resolve_route_config(path, routes_table, base_price_config)
         if is_public_path(path):
             return None
         if path == "/__challenge/verify" and request.method == "POST":
@@ -94,21 +103,22 @@ def register_agentpayments(app, *, challenge_secret: str, home_wallet_address: s
                     new_key = generate_agent_key(challenge_secret)
                 if fee_info:
                     no_key_instructions = (
-                        f'Send {MIN_PAYMENT} USDC on Solana {network} to {home_wallet_address} with memo "{new_key}", '
+                        f'Send {price_config["min_payment"]} USDC on Solana {network} to {home_wallet_address} with memo "{new_key}", '
                         f'AND in the SAME transaction send the platform fee (see platform_fee below) to {fee_info["wallet"]}. '
                         f'Then include the header X-Agent-Key: {new_key} on all subsequent requests.'
                     )
                 else:
-                    no_key_instructions = f'Send {MIN_PAYMENT} USDC on Solana {network} to {home_wallet_address} with memo "{new_key}". Then include the header X-Agent-Key: {new_key} on all subsequent requests.'
+                    no_key_instructions = f'Send {price_config["min_payment"]} USDC on Solana {network} to {home_wallet_address} with memo "{new_key}". Then include the header X-Agent-Key: {new_key} on all subsequent requests.'
                 return _payment_required_flask(
                     {
                         "error": "payment_required",
                         "message": "Access requires a paid API key. A key has been generated for you below. Send a USDC payment on Solana with this key as the memo to activate it, then retry your request with the X-Agent-Key header.",
                         "your_key": new_key,
-                        "payment": build_payment_object(network=network, min_payment=MIN_PAYMENT, wallet_address=home_wallet_address, memo=new_key, fee_info=fee_info, instructions=no_key_instructions),
+                        "payment": build_payment_object(network=network, min_payment=price_config["min_payment"], wallet_address=home_wallet_address, memo=new_key, fee_info=fee_info, instructions=no_key_instructions),
                     },
-                    wallet_address=home_wallet_address, mint=mint, min_payment=MIN_PAYMENT,
+                    wallet_address=home_wallet_address, mint=mint, min_payment=price_config["min_payment"],
                     debug=debug, agent_key=new_key, resource=path,
+                    extra_tier_opts=tier_x402_opts_list(price_config["pricing_tiers"], {"wallet_address": home_wallet_address, "mint": mint, "debug": debug, "agent_key": new_key, "resource": path}),
                 )
             if key.startswith(HOSTED_KEY_PREFIX):
                 if not _platform_client:
@@ -129,19 +139,24 @@ def register_agentpayments(app, *, challenge_secret: str, home_wallet_address: s
                 return jsonify({"error": "server_error", "message": "Payment verification unavailable."}), 500
             if grant_store and grant_store.has(key):
                 return None
-            paid = verify_payment_on_chain(key, home_wallet_address, rpc_url, mint, fee_info=fee_info)
+            scan_result = _scan_for_payment(key, home_wallet_address, rpc_url, mint, min_payment=price_config["min_payment"], fee_info=fee_info)
+            paid = scan_result["paid"]
             if paid and grant_store:
-                grant_store.add(key)
+                tier = resolve_tier(scan_result["amount_paid"], price_config["pricing_tiers"])
+                duration_seconds = tier["duration_seconds"] if tier else price_config["access_duration"]
+                expires_at = (_time.time() + duration_seconds) if duration_seconds else None
+                grant_store.add(key, expires_at=expires_at, tier=(tier["name"] if tier else None))
             if not paid:
                 return _payment_required_flask(
                     {
                         "error": "payment_required",
                         "message": "Key is valid but payment has not been verified on-chain yet.",
                         "your_key": key,
-                        "payment": build_payment_object(network=network, min_payment=MIN_PAYMENT, wallet_address=home_wallet_address, memo=key, fee_info=fee_info),
+                        "payment": build_payment_object(network=network, min_payment=price_config["min_payment"], wallet_address=home_wallet_address, memo=key, fee_info=fee_info),
                     },
-                    wallet_address=home_wallet_address, mint=mint, min_payment=MIN_PAYMENT,
+                    wallet_address=home_wallet_address, mint=mint, min_payment=price_config["min_payment"],
                     debug=debug, agent_key=key, resource=path,
+                    extra_tier_opts=tier_x402_opts_list(price_config["pricing_tiers"], {"wallet_address": home_wallet_address, "mint": mint, "debug": debug, "agent_key": key, "resource": path}),
                 )
             return None