davideandClaude Sonnet 5
dd45ec75c6
GET /qr/{address} renders the address as a PNG QR code (qrcode[pil]),
gated by a bech32-shaped regex since it's otherwise unauthenticated —
the address itself isn't sensitive, but this keeps it from being used
as an arbitrary text-to-QR service.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
89 lines
3.0 KiB
Python
89 lines
3.0 KiB
Python
import asyncio
|
|
import logging
|
|
from contextlib import asynccontextmanager
|
|
|
|
from fastapi import FastAPI, Request
|
|
from fastapi.responses import FileResponse, JSONResponse
|
|
from fastapi.staticfiles import StaticFiles
|
|
|
|
from app.logging_config import setup_logging
|
|
|
|
setup_logging()
|
|
|
|
import app.bets.confirmation # noqa: F401 (registers the "bet" confirmation handler)
|
|
import app.rounds.confirmation # noqa: F401 (registers the "payout" confirmation handler)
|
|
import app.withdrawals.confirmation # noqa: F401 (registers the "withdrawal" confirmation handler)
|
|
from app.api.routes.admin import router as admin_router
|
|
from app.api.routes.bets import router as bets_router
|
|
from app.api.routes.qr import router as qr_router
|
|
from app.api.routes.users import router as users_router
|
|
from app.api.routes.withdrawals import router as withdrawals_router
|
|
from app.auth.routes import router as auth_router
|
|
from app.config import settings
|
|
from app.db.base import AsyncSessionLocal
|
|
from app.electrum.client import ElectrumClient
|
|
from app.electrum.listener import ElectrumListener
|
|
from app.rounds.scheduler import RoundScheduler
|
|
from app.tx.broadcast import RbfBumper
|
|
from app.tx.confirmation import ConfirmationPoller
|
|
from app.tx.locks import UserLocks
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def _make_electrum_client() -> ElectrumClient:
|
|
return ElectrumClient(settings.electrum_host, settings.electrum_port, settings.electrum_use_ssl)
|
|
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app: FastAPI):
|
|
listener = ElectrumListener(_make_electrum_client, AsyncSessionLocal)
|
|
app.state.electrum_listener = listener
|
|
app.state.user_locks = UserLocks()
|
|
|
|
scheduler = RoundScheduler(AsyncSessionLocal, listener)
|
|
poller = ConfirmationPoller(AsyncSessionLocal, lambda: listener.client)
|
|
bumper = RbfBumper(AsyncSessionLocal, lambda: listener.client)
|
|
|
|
tasks = [
|
|
asyncio.create_task(listener.run()),
|
|
asyncio.create_task(scheduler.run()),
|
|
asyncio.create_task(poller.run()),
|
|
asyncio.create_task(bumper.run()),
|
|
]
|
|
try:
|
|
yield
|
|
finally:
|
|
for task in tasks:
|
|
task.cancel()
|
|
if listener.client is not None:
|
|
await listener.client.close()
|
|
|
|
|
|
app = FastAPI(title="PLM Lottery", lifespan=lifespan)
|
|
app.include_router(auth_router)
|
|
app.include_router(users_router)
|
|
app.include_router(bets_router)
|
|
app.include_router(withdrawals_router)
|
|
app.include_router(admin_router)
|
|
app.include_router(qr_router)
|
|
|
|
|
|
@app.exception_handler(Exception)
|
|
async def log_unhandled_exception(request: Request, exc: Exception) -> JSONResponse:
|
|
logger.exception("Unhandled error on %s %s", request.method, request.url.path)
|
|
return JSONResponse(status_code=500, content={"detail": "internal server error"})
|
|
|
|
|
|
@app.get("/health")
|
|
async def health() -> dict[str, str]:
|
|
return {"status": "ok"}
|
|
|
|
|
|
@app.get("/admin", include_in_schema=False)
|
|
async def admin_panel() -> FileResponse:
|
|
return FileResponse("app/static/admin.html")
|
|
|
|
|
|
app.mount("/", StaticFiles(directory="app/static", html=True), name="static")
|