merge: chore/cleanup-remove-bloat-and-secrets into main

app/api/v1/public/__init__.py

@@ -0,0 +1,4 @@
+"""Public routes — no authentication required.
+
+Target: scanner, wallet lookup, token info, pricing, health.
+"""

app/api/v1/public/scanner.py

@@ -0,0 +1,62 @@
+"""Public scanner endpoints — /api/v1/scanner/*.
+
+Stub for unauthenticated token scans. Real implementation will
+trigger the scanner pipeline (honeypot detection, flash loan checks,
+oracle manipulation analysis).
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/scanner", tags=["scanner"])
+
+
+class ScanRequest(BaseModel):
+    """Request to scan a token or wallet."""
+
+    chain: str = "ethereum"
+    address: str
+    depth: str = "standard"  # "quick" | "standard" | "deep"
+
+
+class ScanResult(BaseModel):
+    """Result of a scan."""
+
+    scan_id: str
+    status: str  # "queued" | "running" | "completed" | "failed"
+    risk_score: int | None = None
+    risk_tier: str | None = None
+    findings: list[str] = []
+
+
+@router.post("/scan", response_model=ScanResult)
+async def scan(req: ScanRequest) -> ScanResult:
+    """Queue a token/wallet scan."""
+    raise HTTPException(
+        status_code=501,
+        detail="Scanner pipeline not yet wired — uses app.domain.scanner (T06+)",
+    )
+
+
+@router.get("/result/{scan_id}", response_model=ScanResult)
+async def get_scan_result(scan_id: str) -> ScanResult:
+    """Get the result of a previously queued scan."""
+    raise HTTPException(
+        status_code=501,
+        detail="Scan result retrieval not yet implemented",
+    )
+
+
+@router.get("/quick")
+async def quick_scan(
+    chain: str = Query("ethereum"),
+    address: str = Query(...),
+) -> dict[str, Any]:
+    """Quick scan (free tier, no persistence)."""
+    raise HTTPException(
+        status_code=501,
+        detail="Quick scan uses cached shield — see caching_shield module",
+    )

app/api/v1/public/token.py

@@ -0,0 +1,65 @@
+"""Public token endpoints — /api/v1/token/*.
+
+Stub for unauthenticated token queries. Real implementation will
+fetch token metadata, holders, liquidity, and risk score.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/token", tags=["token"])
+
+
+class TokenSummary(BaseModel):
+    """Basic token metadata."""
+
+    chain: str
+    address: str
+    name: str | None = None
+    symbol: str | None = None
+    decimals: int | None = None
+    deployed_at: str | None = None
+    deployer: str | None = None
+
+
+class TokenRisk(BaseModel):
+    """Token risk assessment."""
+
+    address: str
+    chain: str
+    risk_score: int
+    risk_tier: str
+    factors: list[str] = []
+
+
+@router.get("/{address}", response_model=TokenSummary)
+async def get_token(
+    address: str,
+    chain: str = Query("ethereum"),
+) -> TokenSummary:
+    """Fetch basic token metadata."""
+    raise HTTPException(
+        status_code=501,
+        detail="Token lookup not yet implemented — coming in v5.1",
+    )
+
+
+@router.get("/{address}/risk", response_model=TokenRisk)
+async def get_token_risk(address: str, chain: str = "ethereum") -> TokenRisk:
+    """Compute the risk score for a token (uses Bayesian reputation + on-chain checks)."""
+    raise HTTPException(
+        status_code=501,
+        detail="Token risk uses T01 Bayesian + T02 scanner pipeline — pending wiring",
+    )
+
+
+@router.get("/{address}/holders")
+async def get_token_holders(address: str, chain: str = "ethereum", top: int = 50) -> dict[str, Any]:
+    """Return top holders distribution for a token."""
+    raise HTTPException(
+        status_code=501,
+        detail="Holder distribution not yet implemented — uses Postgres + Neo4j",
+    )

app/api/v1/public/wallet.py

@@ -0,0 +1,57 @@
+"""Public wallet endpoints — /api/v1/wallet/*.
+
+Stub for unauthenticated wallet queries. Real implementation will
+resolve wallets, fetch labels, and return balance/history data.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/wallet", tags=["wallet"])
+
+
+class WalletResolveResponse(BaseModel):
+    """Response for wallet resolution."""
+
+    chain: str
+    address: str
+    labels: list[str] = []
+    entity: str | None = None
+    balance_usd: float | None = None
+    tx_count: int | None = None
+
+
+@router.get("/{address}", response_model=WalletResolveResponse)
+async def resolve_wallet(
+    address: str,
+    chain: str = Query("ethereum", description="Blockchain (ethereum, solana, base, etc.)"),
+) -> WalletResolveResponse:
+    """Resolve a wallet address to its labels + summary.
+
+    Returns 501 stub until label resolution is wired up.
+    """
+    raise HTTPException(
+        status_code=501,
+        detail="Wallet resolution not yet implemented — coming in v5.1",
+    )
+
+
+@router.get("/{address}/labels", response_model=list[dict[str, Any]])
+async def get_wallet_labels(address: str, chain: str = "ethereum") -> list[dict[str, Any]]:
+    """Return labels for a wallet from all federated sources."""
+    raise HTTPException(
+        status_code=501,
+        detail="Federated labels API pending — see T11",
+    )
+
+
+@router.get("/{address}/history")
+async def get_wallet_history(address: str, chain: str = "ethereum") -> dict[str, Any]:
+    """Return transaction history summary for a wallet."""
+    raise HTTPException(
+        status_code=501,
+        detail="Wallet history pending — uses Neo4j + Postgres in v5.1",
+    )