davide
63df38d30b
Deposits were credited exclusively by scripthash-change notifications, with nothing re-verifying a user's balance against the chain if a subscription was ever silently lost. address_for_new_user's subscribe was fire-and-forget: the task wasn't retained, so it could be garbage-collected mid-flight, and any failure (including self.client turning None between the check and the task running) vanished into asyncio's default unretrieved-exception handler instead of being logged anywhere. On an otherwise healthy, long-lived connection there may be no reconnect for days to re-subscribe everyone, so a user in that state never saw their deposits. address_for_new_user now retains the task and logs its exception if it fails. New app/deposits/reconcile.py adds DepositReconciler, a periodic sweep (every 5 minutes, gated on the Electrum client being connected, same shape as tx/reconcile.py) that round-robins over every user and calls the listener's own refresh_user (renamed from _refresh_user since it's now called from outside the class) - so the notification-driven and periodic paths can never behave differently. Deliberately sweeps every user rather than only ones missing from the in-memory scripthash map, since that map can't tell "never subscribed" apart from "subscribed, but the server stopped delivering notifications for it". Wired into app/main.py's lifespan alongside the other three background reconcilers. Suite grows from 176 to 182 tests. BUGS.md moves B-30 to Previously fixed.
138 lines
5.2 KiB
Python
138 lines
5.2 KiB
Python
import asyncio
|
|
import logging
|
|
from contextlib import asynccontextmanager
|
|
|
|
from fastapi import FastAPI, Request, status
|
|
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.rounds import router as rounds_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.api.errors import ApiError
|
|
from app.config import settings, validate_runtime_secrets
|
|
from app.db.base import AsyncSessionLocal
|
|
from app.deposits.reconcile import DepositReconciler
|
|
from app.electrum.client import ElectrumClient, ElectrumEndpoint, parse_endpoints
|
|
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
|
|
from app.tx.reconcile import PendingTransactionReconciler
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def _make_electrum_client(endpoint: ElectrumEndpoint) -> ElectrumClient:
|
|
return ElectrumClient(endpoint.host, endpoint.port, endpoint.use_ssl)
|
|
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app: FastAPI):
|
|
# Refuses to serve rather than starting up half-configured — see B-15 in BUGS.md.
|
|
validate_runtime_secrets()
|
|
|
|
endpoints = parse_endpoints(
|
|
settings.electrum_host,
|
|
settings.electrum_port,
|
|
settings.electrum_use_ssl,
|
|
settings.electrum_fallback_servers,
|
|
)
|
|
logger.info("Electrum endpoints (in rotation order): %s", ", ".join(str(e) for e in endpoints))
|
|
|
|
listener = ElectrumListener(_make_electrum_client, AsyncSessionLocal, endpoints)
|
|
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)
|
|
# Resolves in-flight transactions against the chain — the piece that lets the
|
|
# system recover on its own from a broadcast that never confirmed (B-04/B-08).
|
|
reconciler = PendingTransactionReconciler(AsyncSessionLocal, lambda: listener.client)
|
|
# Periodic safety net for deposit crediting/external-spend detection,
|
|
# independent of scripthash-change notifications — catches a subscription
|
|
# silently lost on an otherwise healthy connection (B-30).
|
|
deposit_reconciler = DepositReconciler(AsyncSessionLocal, listener)
|
|
|
|
tasks = [
|
|
asyncio.create_task(listener.run()),
|
|
asyncio.create_task(scheduler.run()),
|
|
asyncio.create_task(poller.run()),
|
|
asyncio.create_task(bumper.run()),
|
|
asyncio.create_task(reconciler.run()),
|
|
asyncio.create_task(deposit_reconciler.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.include_router(rounds_router)
|
|
|
|
|
|
@app.exception_handler(Exception)
|
|
async def log_unhandled_exception(request: Request, exc: Exception) -> JSONResponse:
|
|
"""Answers with the same structured `detail` shape as every deliberate failure
|
|
(app/api/errors.py) so clients never have to special-case unexpected errors.
|
|
The exception itself stays in logs/app.log only — never in the response body."""
|
|
logger.exception("Unhandled error on %s %s", request.method, request.url.path)
|
|
return JSONResponse(
|
|
status_code=500,
|
|
content={"detail": ApiError("internal_error", "internal server error").as_detail()},
|
|
)
|
|
|
|
|
|
@app.get("/health")
|
|
async def health() -> dict[str, str]:
|
|
return {"status": "ok"}
|
|
|
|
|
|
_NO_STORE_HEADERS = {"Cache-Control": "no-store"}
|
|
|
|
|
|
@app.get("/", include_in_schema=False)
|
|
async def index_page() -> FileResponse:
|
|
return FileResponse("app/static/index.html", headers=_NO_STORE_HEADERS)
|
|
|
|
|
|
@app.get("/admin", include_in_schema=False)
|
|
async def admin_panel() -> FileResponse:
|
|
return FileResponse("app/static/admin.html", headers=_NO_STORE_HEADERS)
|
|
|
|
|
|
@app.get("/guida", include_in_schema=False)
|
|
async def user_guide() -> FileResponse:
|
|
return FileResponse("app/static/guida.html", headers=_NO_STORE_HEADERS)
|
|
|
|
|
|
@app.get("/report-bug", include_in_schema=False)
|
|
async def report_bug_page() -> FileResponse:
|
|
return FileResponse("app/static/report-bug.html", headers=_NO_STORE_HEADERS)
|
|
|
|
|
|
app.mount("/", StaticFiles(directory="app/static", html=True), name="static")
|