857 lines
31 KiB
Python
857 lines
31 KiB
Python
"""
|
|
RMI x402 Payment Middleware — Proper x402 Protocol Integration
|
|
================================================================
|
|
Uses the official x402 SDK for payment verification, receipt validation,
|
|
and public transparency. Replaces the hacky direct facilitator POST.
|
|
|
|
Components:
|
|
1. x402_middleware.py — FastAPI middleware for payment verification
|
|
2. /api/v1/x402/receipt/{id}/verify — Public receipt verification
|
|
3. /api/v1/x402/ledger — Public payment ledger (anonymized)
|
|
4. /api/v1/x402/transparency — System trust metrics
|
|
|
|
Author: RMI Development
|
|
Date: 2026-05-03
|
|
"""
|
|
|
|
import contextlib
|
|
import hashlib
|
|
import json
|
|
import logging
|
|
import time
|
|
from datetime import UTC, datetime
|
|
from typing import Any
|
|
|
|
from fastapi import APIRouter, HTTPException, Request
|
|
|
|
logger = logging.getLogger("x402_middleware")
|
|
|
|
router = APIRouter(prefix="/api/v1/x402", tags=["x402-payment-middleware"])
|
|
|
|
|
|
# ── x402 SDK Integration ──────────────────────────────────────
|
|
|
|
# Import x402 SDK components
|
|
try:
|
|
from x402 import (
|
|
X402_VERSION,
|
|
Network,
|
|
PaymentPayload,
|
|
PaymentRequirements,
|
|
parse_payment_payload,
|
|
parse_payment_required,
|
|
x402Facilitator,
|
|
)
|
|
|
|
X402_SDK_AVAILABLE = True
|
|
logger.info(f"x402 SDK v{X402_VERSION} loaded")
|
|
except ImportError as e:
|
|
X402_SDK_AVAILABLE = False
|
|
logger.warning(f"x402 SDK not available: {e}")
|
|
|
|
|
|
# ── Payment Verification Engine ────────────────────────────────
|
|
|
|
# ERC-20 token metadata for EIP-712 domain verification
|
|
# Maps (chain_id, token_address) -> (name, version)
|
|
TOKEN_METADATA = {
|
|
# USDC on Base mainnet
|
|
(8453, "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913"): ("USD Coin", "2"),
|
|
# USDC on Base Sepolia
|
|
(84532, "0x036cbd53842c5426634e7929541ec2318f3dcf7e"): ("USD Coin", "2"),
|
|
}
|
|
|
|
# Network configs with correct facilitator URLs
|
|
FACILITATOR_CONFIGS = {
|
|
"base": {
|
|
"network": "eip155:8453",
|
|
"chain_id": 8453,
|
|
# x402.org doesn't support Base mainnet, use PayAI
|
|
"url": "https://facilitator.payai.network",
|
|
},
|
|
"base-sepolia": {
|
|
"network": "eip155:84532",
|
|
"chain_id": 84532,
|
|
"url": "https://x402.org/facilitator",
|
|
},
|
|
"solana": {
|
|
"network": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
|
|
"url": "https://facilitator.payai.network",
|
|
},
|
|
"solana-devnet": {
|
|
"network": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
|
|
"url": "https://facilitator.payai.network",
|
|
},
|
|
}
|
|
|
|
|
|
class PaymentVerifier:
|
|
"""
|
|
x402 payment verification with local EIP-712 verification for Base
|
|
and facilitator fallback for other networks.
|
|
|
|
Primary: Local EIP-712 signature verification (no external dependency)
|
|
Fallback: PayAI facilitator via HTTP
|
|
"""
|
|
|
|
def __init__(self):
|
|
self._facilitators: dict[str, Any] = {}
|
|
|
|
def _verify_eip712_local(self, payload_data: dict) -> dict[str, Any]:
|
|
"""
|
|
Verify EIP-712 signed EIP-3009 authorization locally.
|
|
No external facilitator needed — pure cryptographic verification.
|
|
Uses the name/version from the payment's extra field (matches what SDK signed with).
|
|
"""
|
|
try:
|
|
from eth_account import Account
|
|
from eth_account.messages import encode_typed_data
|
|
from x402.mechanisms.evm.eip712 import build_typed_data_for_signing
|
|
from x402.mechanisms.evm.types import DOMAIN_TYPES, ExactEIP3009Authorization
|
|
from x402.mechanisms.evm.utils import get_evm_chain_id
|
|
|
|
accepted = payload_data.get("accepted", {})
|
|
inner = payload_data.get("payload", {})
|
|
auth = inner.get("authorization", {})
|
|
signature = inner.get("signature", "")
|
|
|
|
if not all([auth, signature, accepted]):
|
|
return {"verified": False, "reason": "Missing authorization or signature"}
|
|
|
|
# Build typed data exactly as the SDK client did
|
|
chain_id = get_evm_chain_id(accepted["network"])
|
|
|
|
authorization = ExactEIP3009Authorization(
|
|
from_address=auth["from"],
|
|
to=auth["to"],
|
|
value=auth["value"],
|
|
valid_after=auth["validAfter"],
|
|
valid_before=auth["validBefore"],
|
|
nonce=auth["nonce"],
|
|
)
|
|
|
|
# Get name/version from extra (this is what the SDK used to sign)
|
|
extra = accepted.get("extra", {})
|
|
token_name = extra.get("name", "USD Coin")
|
|
token_version = extra.get("version", "2")
|
|
|
|
domain, types, primary_type, message = build_typed_data_for_signing(
|
|
authorization, chain_id, accepted["asset"], token_name, token_version
|
|
)
|
|
|
|
# Verify time validity
|
|
now = int(time.time())
|
|
valid_before = int(auth["validBefore"])
|
|
valid_after = int(auth["validAfter"])
|
|
if valid_before < now + 6:
|
|
return {"verified": False, "reason": "Authorization expired (validBefore passed)"}
|
|
if valid_after > now:
|
|
return {
|
|
"verified": False,
|
|
"reason": "Authorization not yet valid (validAfter in future)",
|
|
}
|
|
|
|
# Build typed data for eth_account verification
|
|
all_types = {**DOMAIN_TYPES, **types}
|
|
typed_data = {
|
|
"types": {k: [{"name": f["name"], "type": f["type"]} for f in v] for k, v in all_types.items()},
|
|
"primaryType": primary_type,
|
|
"domain": {
|
|
"name": domain.name,
|
|
"version": domain.version,
|
|
"chainId": domain.chain_id,
|
|
"verifyingContract": domain.verifying_contract,
|
|
},
|
|
"message": {k: ("0x" + v.hex() if isinstance(v, bytes) else str(v)) for k, v in message.items()},
|
|
}
|
|
|
|
# Recover signer from signature
|
|
signable = encode_typed_data(full_message=typed_data)
|
|
recovered = Account.recover_message(signable, signature=signature)
|
|
|
|
if recovered.lower() != auth["from"].lower():
|
|
return {
|
|
"verified": False,
|
|
"reason": f"Signature mismatch: recovered {recovered}, expected {auth['from']}",
|
|
}
|
|
|
|
# Verify recipient matches payTo
|
|
if auth["to"].lower() != accepted.get("payTo", "").lower():
|
|
return {"verified": False, "reason": "Recipient address mismatch"}
|
|
|
|
# Verify amount matches
|
|
if str(auth["value"]) != str(accepted.get("amount", "")):
|
|
return {"verified": False, "reason": "Amount mismatch"}
|
|
|
|
return {
|
|
"verified": True,
|
|
"reason": "EIP-712 signature verified locally",
|
|
"payer": auth["from"],
|
|
"tx_hash": None,
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Local EIP-712 verification error: {e}")
|
|
return {"verified": False, "reason": f"Local verification error: {e!s}"}
|
|
|
|
async def _verify_via_payai(
|
|
self,
|
|
payload_data: dict,
|
|
requirements_data: dict | None,
|
|
) -> dict[str, Any]:
|
|
"""Fallback: verify via PayAI facilitator HTTP."""
|
|
import aiohttp
|
|
|
|
# Build flattened requirements format PayAI expects
|
|
accepted = payload_data.get("accepted", {})
|
|
flat_req = {
|
|
"x402Version": 2,
|
|
"scheme": accepted.get("scheme", "exact"),
|
|
"network": accepted.get("network", "eip155:8453"),
|
|
"asset": accepted.get("asset", ""),
|
|
"amount": accepted.get("amount", ""),
|
|
"payTo": accepted.get("payTo", ""),
|
|
"maxTimeoutSeconds": accepted.get("maxTimeoutSeconds", 60),
|
|
"extra": accepted.get("extra", {}),
|
|
"resource": {},
|
|
}
|
|
if requirements_data:
|
|
flat_req["resource"] = requirements_data.get("resource", {})
|
|
|
|
body = {
|
|
"x402Version": 2,
|
|
"paymentPayload": payload_data,
|
|
"paymentRequirements": flat_req,
|
|
}
|
|
|
|
try:
|
|
async with aiohttp.ClientSession() as session, session.post(
|
|
"https://facilitator.payai.network/verify",
|
|
json=body,
|
|
headers={"Content-Type": "application/json"},
|
|
timeout=aiohttp.ClientTimeout(total=15),
|
|
) as resp:
|
|
data = await resp.json()
|
|
if data.get("isValid"):
|
|
return {
|
|
"verified": True,
|
|
"reason": "Verified via PayAI",
|
|
"payer": data.get("payer"),
|
|
"tx_hash": None,
|
|
}
|
|
return {
|
|
"verified": False,
|
|
"reason": f"PayAI: {data.get('invalidReason', 'unknown')} - {data.get('invalidMessage', '')}",
|
|
"payer": data.get("payer"),
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"PayAI verification error: {e}")
|
|
return {"verified": False, "reason": f"PayAI connection error: {e!s}"}
|
|
|
|
async def verify_payment(
|
|
self,
|
|
x402_payload: str,
|
|
network_key: str = "base",
|
|
expected_amount: str | None = None,
|
|
expected_tool: str | None = None,
|
|
) -> dict[str, Any]:
|
|
"""
|
|
Verify an x402 payment payload with layered verification.
|
|
|
|
Priority:
|
|
1. Local EIP-712 verification (Base/EVM, instant, no external deps)
|
|
2. PayAI facilitator fallback
|
|
"""
|
|
# Step 1: Parse the payment payload
|
|
try:
|
|
payload_data = json.loads(x402_payload)
|
|
except json.JSONDecodeError:
|
|
return {
|
|
"verified": False,
|
|
"reason": "Invalid JSON in x402 payload",
|
|
"tx_hash": None,
|
|
"amount": None,
|
|
"network": network_key,
|
|
"settlement_id": None,
|
|
}
|
|
|
|
# Step 2: Local EIP-712 verification (primary for Base/EVM)
|
|
if network_key.startswith("base"):
|
|
local_result = self._verify_eip712_local(payload_data)
|
|
if local_result["verified"]:
|
|
return {
|
|
"verified": True,
|
|
"reason": local_result["reason"],
|
|
"tx_hash": local_result.get("tx_hash"),
|
|
"amount": expected_amount,
|
|
"network": network_key,
|
|
"settlement_id": None,
|
|
"payer": local_result.get("payer"),
|
|
}
|
|
logger.warning(f"Local verification failed: {local_result['reason']}")
|
|
# Fall through to facilitator
|
|
|
|
# Step 3: Facilitator fallback
|
|
config = FACILITATOR_CONFIGS.get(network_key, FACILITATOR_CONFIGS.get("base"))
|
|
config["url"]
|
|
|
|
# Build requirements from payload data for facilitator
|
|
requirements_data = None
|
|
try:
|
|
accepted = payload_data.get("accepted", {})
|
|
resource = payload_data.get("resource", {})
|
|
requirements_data = {
|
|
"x402Version": payload_data.get("x402Version", 2),
|
|
"resource": resource,
|
|
"accepts": [
|
|
{
|
|
"scheme": accepted.get("scheme", "exact"),
|
|
"network": accepted.get("network", config["network"]),
|
|
"asset": accepted.get("asset", ""),
|
|
"amount": accepted.get("amount", ""),
|
|
"payTo": accepted.get("payTo", ""),
|
|
"maxTimeoutSeconds": accepted.get("maxTimeoutSeconds", 60),
|
|
"extra": accepted.get("extra", {}),
|
|
}
|
|
],
|
|
}
|
|
except Exception:
|
|
pass
|
|
|
|
return await self._verify_via_payai(payload_data, requirements_data)
|
|
|
|
|
|
# Global verifier instance
|
|
_verifier = PaymentVerifier()
|
|
|
|
|
|
# ── Public Receipt Verification ───────────────────────────────
|
|
|
|
|
|
@router.get("/receipt/{receipt_id}/verify")
|
|
async def verify_receipt_public(receipt_id: str):
|
|
"""
|
|
Public endpoint to verify any x402 receipt.
|
|
Anyone can check if a payment was fulfilled — no auth needed.
|
|
Returns: receipt data + on-chain proof + verification status.
|
|
"""
|
|
try:
|
|
from app.auth import get_redis
|
|
|
|
r = await get_redis()
|
|
|
|
receipt_data = await r.get(f"x402:receipt:{receipt_id}")
|
|
if not receipt_data:
|
|
raise HTTPException(status_code=404, detail="Receipt not found")
|
|
|
|
receipt = json.loads(receipt_data)
|
|
|
|
# Compute integrity hash for transparency
|
|
integrity_data = f"{receipt_id}:{receipt.get('amount')}:{receipt.get('status')}:{receipt.get('timestamp')}"
|
|
integrity_hash = hashlib.sha256(integrity_data.encode()).hexdigest()[:16]
|
|
|
|
# Determine verification status
|
|
verification_status = "unverified"
|
|
if receipt.get("status") == "fulfilled":
|
|
verification_status = "verified"
|
|
if receipt.get("payment_tx"):
|
|
verification_status = "on_chain_confirmed"
|
|
elif receipt.get("status") == "refunded":
|
|
verification_status = "refunded"
|
|
|
|
return {
|
|
"receipt_id": receipt_id,
|
|
"status": receipt.get("status"),
|
|
"verification": verification_status,
|
|
"amount": receipt.get("amount"),
|
|
"asset": receipt.get("asset"),
|
|
"network": receipt.get("network"),
|
|
"tool": receipt.get("tool"),
|
|
"customer": receipt.get("customer_address", "")[:8] + "..." if receipt.get("customer_address") else None,
|
|
"timestamp": receipt.get("timestamp"),
|
|
"payment_tx": receipt.get("payment_tx"),
|
|
"delivery_status": receipt.get("delivery_status"),
|
|
"integrity_hash": integrity_hash,
|
|
"chain_of_custody": {
|
|
"stored": receipt.get("updated_at") is not None,
|
|
"fulfilled": receipt.get("status") == "fulfilled",
|
|
"on_chain": receipt.get("payment_tx") is not None and receipt.get("payment_tx") != "",
|
|
},
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
|
|
# ── Public Payment Ledger ─────────────────────────────────────
|
|
|
|
|
|
@router.get("/ledger")
|
|
async def payment_ledger(
|
|
limit: int = 50,
|
|
offset: int = 0,
|
|
tool: str | None = None,
|
|
network: str | None = None,
|
|
status: str | None = None,
|
|
):
|
|
"""
|
|
Public anonymized payment ledger for transparency.
|
|
Shows: tool used, amount, network, timestamp, status.
|
|
No wallet addresses, no PII.
|
|
"""
|
|
try:
|
|
from app.auth import get_redis
|
|
|
|
r = await get_redis()
|
|
|
|
# Get recent receipt IDs
|
|
all_ids = await r.zrevrange("x402:receipts_by_time", offset, offset + limit - 1)
|
|
|
|
ledger = []
|
|
for rid in all_ids:
|
|
rid_str = rid.decode() if isinstance(rid, bytes) else rid
|
|
data = await r.get(f"x402:receipt:{rid_str}")
|
|
if not data:
|
|
continue
|
|
|
|
receipt = json.loads(data)
|
|
|
|
# Filter by tool/network/status if specified
|
|
if tool and receipt.get("tool") != tool:
|
|
continue
|
|
if network and receipt.get("network") != network:
|
|
continue
|
|
if status and receipt.get("status") != status:
|
|
continue
|
|
|
|
# Anonymize customer
|
|
customer = receipt.get("customer_address", "")
|
|
anon_customer = customer[:6] + "..." + customer[-4:] if len(customer) > 10 else None
|
|
|
|
ledger.append(
|
|
{
|
|
"receipt_id": rid_str,
|
|
"tool": receipt.get("tool"),
|
|
"amount": receipt.get("amount"),
|
|
"asset": receipt.get("asset"),
|
|
"network": receipt.get("network"),
|
|
"status": receipt.get("status"),
|
|
"delivery": receipt.get("delivery_status"),
|
|
"timestamp": receipt.get("timestamp"),
|
|
"customer": anon_customer,
|
|
}
|
|
)
|
|
|
|
# Get total count
|
|
total = await r.zcard("x402:receipts_by_time")
|
|
|
|
return {
|
|
"ledger": ledger,
|
|
"count": len(ledger),
|
|
"total": total,
|
|
"offset": offset,
|
|
"limit": limit,
|
|
}
|
|
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
|
|
# ── Transparency Dashboard ────────────────────────────────────
|
|
|
|
|
|
@router.get("/transparency")
|
|
async def transparency_dashboard(hours: int = 24):
|
|
"""
|
|
Public transparency dashboard showing system trust metrics.
|
|
No sensitive data — all aggregated and anonymized.
|
|
"""
|
|
try:
|
|
from app.auth import get_redis
|
|
|
|
r = await get_redis()
|
|
|
|
cutoff = time.time() - (hours * 3600)
|
|
recent_ids = await r.zrangebyscore("x402:receipts_by_time", cutoff, "+inf")
|
|
|
|
total = fulfilled = refunded = failed = 0
|
|
total_revenue = 0.0
|
|
tool_counts: dict[str, int] = {}
|
|
network_counts: dict[str, int] = {}
|
|
# hourly array intentionally skipped — data is fetched on-demand
|
|
for rid in recent_ids:
|
|
rid_str = rid.decode() if isinstance(rid, bytes) else rid
|
|
data = await r.get(f"x402:receipt:{rid_str}")
|
|
if not data:
|
|
continue
|
|
|
|
receipt = json.loads(data)
|
|
total += 1
|
|
|
|
status = receipt.get("status", "unknown")
|
|
if status == "fulfilled":
|
|
fulfilled += 1
|
|
elif status == "refunded":
|
|
refunded += 1
|
|
elif status in ("failed", "error"):
|
|
failed += 1
|
|
|
|
# Revenue tracking (amounts stored in atomic units, convert to USDC)
|
|
try:
|
|
amount = float(receipt.get("amount", 0))
|
|
total_revenue += amount / 1e6
|
|
except (ValueError, TypeError):
|
|
pass
|
|
|
|
# Tool breakdown
|
|
tool_name = receipt.get("tool", "unknown")
|
|
tool_counts[tool_name] = tool_counts.get(tool_name, 0) + 1
|
|
|
|
# Network breakdown
|
|
net = receipt.get("network", "unknown")
|
|
network_counts[net] = network_counts.get(net, 0) + 1
|
|
|
|
# Get trial stats using SCAN (KEYS is disabled)
|
|
total_trials_used = 0
|
|
cursor = 0
|
|
while True:
|
|
cursor, keys = await r.scan(cursor, match="x402:trial:*", count=100)
|
|
for k in keys:
|
|
val = await r.get(k)
|
|
if val:
|
|
with contextlib.suppress(ValueError, TypeError):
|
|
total_trials_used += int(val)
|
|
if cursor == 0:
|
|
break
|
|
|
|
# Get ban stats
|
|
ip_bans = wallet_bans = 0
|
|
async for key in r.scan_iter(match="x402:ban:ip:*"):
|
|
k = key.decode() if isinstance(key, bytes) else key
|
|
if ":reason:" not in k:
|
|
ip_bans += 1
|
|
async for key in r.scan_iter(match="x402:ban:wallet:*"):
|
|
wallet_bans += 1
|
|
|
|
fulfillment_rate = fulfilled / max(1, total)
|
|
refund_rate = refunded / max(1, total)
|
|
|
|
return {
|
|
"period_hours": hours,
|
|
"payments": {
|
|
"total": total,
|
|
"fulfilled": fulfilled,
|
|
"refunded": refunded,
|
|
"failed": failed,
|
|
"fulfillment_rate": round(fulfillment_rate, 4),
|
|
"refund_rate": round(refund_rate, 4),
|
|
"total_revenue_usdc": round(total_revenue, 4),
|
|
},
|
|
"tools": dict(sorted(tool_counts.items(), key=lambda x: -x[1])[:10]),
|
|
"networks": network_counts,
|
|
"trials": {
|
|
"total_used": total_trials_used,
|
|
},
|
|
"security": {
|
|
"ip_bans_active": ip_bans,
|
|
"wallet_bans_active": wallet_bans,
|
|
"ban_duration_hours": 24,
|
|
},
|
|
"trust_score": round(
|
|
(fulfillment_rate * 0.6 + (1 - refund_rate) * 0.3 + (1 - failed / max(1, total)) * 0.1) * 100,
|
|
1,
|
|
),
|
|
"timestamp": datetime.now(UTC).isoformat(),
|
|
}
|
|
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
|
|
# ── Payment Verification Endpoint (for gateway use) ────────────
|
|
|
|
|
|
@router.post("/verify")
|
|
async def verify_payment_endpoint(
|
|
request: Request,
|
|
):
|
|
"""
|
|
Verify an x402 payment payload.
|
|
Used by the gateway worker to verify payments before executing tools.
|
|
Exempt from rate limiting — gateway workers call this for every paid request.
|
|
|
|
POST body: {
|
|
"payload": "<x402 payment payload JSON string>",
|
|
"network": "base" | "solana",
|
|
"tool": "audit" | "rugshield" | ...,
|
|
"amount": "$0.02" | ...,
|
|
"amount_atomic": "20000" | ...
|
|
}
|
|
|
|
Returns: {
|
|
"verified": true/false,
|
|
"reason": "...",
|
|
"tx_hash": "...",
|
|
"settlement_id": "...",
|
|
}
|
|
"""
|
|
try:
|
|
body = await request.json()
|
|
x402_payload = body.get("payload", "")
|
|
network = body.get("network", "base")
|
|
tool = body.get("tool")
|
|
amount = body.get("amount")
|
|
|
|
if not x402_payload:
|
|
raise HTTPException(status_code=400, detail="Missing x402 payload")
|
|
|
|
result = await _verifier.verify_payment(
|
|
x402_payload,
|
|
network_key=network,
|
|
expected_amount=amount,
|
|
expected_tool=tool,
|
|
)
|
|
|
|
# Store verification result for audit trail
|
|
if result["verified"]:
|
|
try:
|
|
from app.auth import get_redis
|
|
|
|
r = await get_redis()
|
|
verify_key = f"x402:verify:{result.get('settlement_id') or str(time.time())}"
|
|
await r.set(
|
|
verify_key,
|
|
json.dumps(
|
|
{
|
|
"verified_at": datetime.now(UTC).isoformat(),
|
|
"network": network,
|
|
"tool": tool,
|
|
"amount": amount,
|
|
"tx_hash": result.get("tx_hash"),
|
|
"result": result["reason"],
|
|
}
|
|
),
|
|
ex=7 * 86400,
|
|
) # Keep for 7 days
|
|
except Exception as e:
|
|
logger.debug(f"Audit store failed: {e}")
|
|
|
|
return result
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Payment verification error: {e}")
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
|
|
# ── Receipt Storage Endpoint (called by x402 Workers after payment) ────
|
|
|
|
|
|
@router.post("/receipt")
|
|
async def store_receipt(request: Request):
|
|
"""
|
|
Store a payment receipt from an x402 Worker after successful payment verification.
|
|
|
|
AUTH: Requires X-API-Key header matching ADMIN_API_KEY env var.
|
|
Called by x402-base and x402-sol Workers after verifyPayment succeeds.
|
|
Stores receipt in Redis for revenue tracking, audit trail, and transparency dashboard.
|
|
|
|
POST body: {
|
|
"receipt_id": "rmi-<timestamp>-<rand>",
|
|
"payment_tx": "0x...|<sol-sig>",
|
|
"amount": "$0.01"|0.01|10000,
|
|
"asset": "USDC",
|
|
"network": "base"|"solana"|<chain>,
|
|
"customer_address": "0x...|<sol-addr>",
|
|
"scan_request": {},
|
|
"status": "fulfilled",
|
|
"tool": "urlcheck"|"audit"|...,
|
|
"delivery_status": "fulfilled",
|
|
"fallback_chain": []
|
|
}
|
|
"""
|
|
# Auth: require admin API key
|
|
admin_key = os.getenv("ADMIN_API_KEY", os.getenv("WP_ADMIN_KEY", ""))
|
|
if admin_key:
|
|
auth = request.headers.get("X-API-Key", "") or request.headers.get("Authorization", "").replace("Bearer ", "")
|
|
if auth != admin_key:
|
|
return JSONResponse(status_code=403, content={"error": "Admin API key required"})
|
|
|
|
try:
|
|
body = await request.json()
|
|
receipt_id = body.get("receipt_id", f"rmi-{int(time.time())}-unknown")
|
|
payment_tx = body.get("payment_tx", "")
|
|
amount = body.get("amount", "")
|
|
asset = body.get("asset", "USDC")
|
|
network = body.get("network", "unknown")
|
|
customer_address = body.get("customer_address", "")
|
|
tool = body.get("tool", "unknown")
|
|
status = body.get("status", "fulfilled")
|
|
delivery_status = body.get("delivery_status", "fulfilled")
|
|
fallback_chain = body.get("fallback_chain", [])
|
|
scan_request = body.get("scan_request", {})
|
|
|
|
# Normalize amount
|
|
if isinstance(amount, str):
|
|
amount_val = amount.replace("$", "")
|
|
try:
|
|
amount_float = float(amount_val)
|
|
except (ValueError, TypeError):
|
|
amount_float = 0.0
|
|
elif isinstance(amount, (int, float)):
|
|
amount_float = float(amount)
|
|
else:
|
|
amount_float = 0.0
|
|
|
|
# Store in Redis (sync — app.auth.get_redis returns a sync client)
|
|
from app.auth import get_redis as _get_redis
|
|
|
|
r = _get_redis()
|
|
|
|
if r:
|
|
receipt_data = {
|
|
"receipt_id": receipt_id,
|
|
"payment_tx": payment_tx,
|
|
"amount": str(amount_float) if amount_float else str(amount),
|
|
"asset": asset,
|
|
"network": network,
|
|
"customer_address": customer_address,
|
|
"tool": tool,
|
|
"status": status,
|
|
"delivery_status": delivery_status,
|
|
"timestamp": str(time.time()),
|
|
"created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
|
|
"fallback_chain": fallback_chain,
|
|
"scan_request": scan_request,
|
|
"amount_usd": amount_float,
|
|
}
|
|
|
|
# Store receipt with 30-day TTL
|
|
r.set(f"x402:receipt:{receipt_id}", json.dumps(receipt_data), ex=30 * 86400)
|
|
|
|
# Also store by transaction hash for lookup
|
|
if payment_tx and payment_tx != "local-verified":
|
|
r.set(
|
|
f"x402:spent_tx:{payment_tx}",
|
|
json.dumps(
|
|
{
|
|
"chain": network,
|
|
"payer": customer_address,
|
|
"amount": str(amount_float),
|
|
"tool": tool,
|
|
"timestamp": str(time.time()),
|
|
"receipt_id": receipt_id,
|
|
}
|
|
),
|
|
ex=30 * 86400,
|
|
)
|
|
|
|
# Add to time-ordered index for ledger queries
|
|
r.zadd("x402:receipts_by_time", {receipt_id: time.time()})
|
|
|
|
# Increment revenue counter
|
|
today = time.strftime("%Y-%m-%d")
|
|
r.incrbyfloat(f"x402:revenue:daily:{today}", amount_float or 0)
|
|
r.incrbyfloat("x402:revenue:total", amount_float or 0)
|
|
r.incrby(f"x402:calls:daily:{today}", 1)
|
|
r.incrby("x402:calls:total", 1)
|
|
|
|
# Tool-level stats
|
|
r.incrby(f"x402:tool_calls:{tool}", 1)
|
|
r.incrbyfloat(f"x402:tool_revenue:{tool}", amount_float or 0)
|
|
|
|
logger.info(f"Receipt stored: {receipt_id} tx={payment_tx[:16]}... tool={tool} amount=${amount_float}")
|
|
|
|
return {
|
|
"ok": True,
|
|
"receipt_id": receipt_id,
|
|
"stored": True,
|
|
"message": "Receipt stored successfully",
|
|
}
|
|
else:
|
|
# Redis unavailable — still return success so Worker doesn't retry endlessly
|
|
logger.warning(f"Redis unavailable, receipt not stored: {receipt_id}")
|
|
return {
|
|
"ok": True,
|
|
"receipt_id": receipt_id,
|
|
"stored": False,
|
|
"message": "Receipt received but Redis unavailable",
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Receipt store error: {e}")
|
|
# Return 200 so Worker doesn't retry — receipt storage is best-effort
|
|
return {
|
|
"ok": True,
|
|
"stored": False,
|
|
"error": str(e)[:200],
|
|
"message": "Receipt received but storage failed",
|
|
}
|
|
|
|
|
|
# ── Fallback System Status ────────────────────────────────────
|
|
|
|
|
|
@router.get("/fallback/status")
|
|
async def fallback_status():
|
|
"""
|
|
Check fallback system health, cache stats, and fallback success rate.
|
|
Shows which fallback layers are working and which are failing.
|
|
"""
|
|
try:
|
|
from app.auth import get_redis
|
|
|
|
r = await get_redis()
|
|
|
|
# Count cache entries
|
|
cache_count = 0
|
|
async for _key in r.scan_iter(match="x402:cache:*", count=100):
|
|
cache_count += 1
|
|
|
|
# Get fallback usage stats
|
|
fallback_uses = 0
|
|
async for _key in r.scan_iter(match="x402:fallback:*", count=100):
|
|
fallback_uses += 1
|
|
|
|
return {
|
|
"fallback_system": "active",
|
|
"cache_entries": cache_count,
|
|
"fallback_uses": fallback_uses,
|
|
"layers_available": [
|
|
"cache",
|
|
"geckoterminal",
|
|
"dexlab",
|
|
"step_finance",
|
|
"moonrank",
|
|
"web_scrape",
|
|
"dexscreener_web",
|
|
"raydium",
|
|
"orca",
|
|
"jito",
|
|
"twitter",
|
|
"reddit",
|
|
"news",
|
|
"web_search",
|
|
"bigquery",
|
|
],
|
|
"priority_order": [
|
|
"1. Primary APIs (DexScreener, RPCs, etc.)",
|
|
"2. Secondary APIs (Birdeye, Jupiter, Coingecko)",
|
|
"3. Tertiary APIs (DeFiLlama, GeckoTerminal, DexLab)",
|
|
"4. Web scraping (Solscan, Etherscan, Basescan HTML)",
|
|
"5. Browser automation (JS-heavy sites)",
|
|
"6. AI web search (DuckDuckGo, Google)",
|
|
"7. Public data archives (BigQuery public datasets)",
|
|
"8. Community APIs (Jito, Orca, Raydium)",
|
|
"9. RSS/feeds (crypto news, launch trackers)",
|
|
"10. Social media (Twitter/X, Reddit public)",
|
|
"11. Cache layer (previous successful results)",
|
|
],
|
|
"refund_policy": "Refund only if ALL fallback layers fail",
|
|
}
|
|
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|