davideandClaude Sonnet 5.5
7ba8e22bb4
pysqlite's legacy mode emitted BEGIN only at the first DML, so every read before it ran outside any transaction and a lock wait surfaced as "database is locked" at an arbitrary later statement; place_bet also mistook that error for a write-snapshot conflict, which SQLite cannot produce. - _register_sqlite_pragmas: synchronous=FULL, isolation_level=None and a `begin` event that emits BEGIN / BEGIN IMMEDIATE. - begin_immediate(session): takes the write lock before the first read; called first thing in place_bet, request_withdrawal, the scheduler transitions, _trigger_payout, the confirmation poller, the reconciler, bump_fee's persist phase, deposit crediting / external-spend marking / reinstating, and the derivation-index allocation at registration. - A lock not granted before a broadcast answers service_busy (503, all seven languages), nothing built or sent; after a broadcast nothing is undone, the rows stay `building` for the reconciler. - Spec, storico, BUGS.md and CLAUDE.md updated; 37 new tests on a real file DB. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
115 lines
4.9 KiB
Python
115 lines
4.9 KiB
Python
import asyncio
|
|
import logging
|
|
from collections.abc import Awaitable, Callable
|
|
|
|
from sqlalchemy import select
|
|
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
|
|
|
|
from app.db.base import begin_immediate
|
|
from app.db.models import PendingTransaction
|
|
from app.electrum.client import ElectrumClient
|
|
from app.electrum.scripthash import address_to_scripthash
|
|
from app.rounds.events import broadcaster
|
|
from app.tx.pending_address import own_address_for
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
_POLL_INTERVAL_SECONDS = 10
|
|
|
|
ConfirmationHandler = Callable[[AsyncSession, PendingTransaction], Awaitable[None]]
|
|
_handlers: dict[str, ConfirmationHandler] = {}
|
|
|
|
|
|
def register_handler(kind: str, handler: ConfirmationHandler) -> None:
|
|
"""Domain modules (bets, rounds, withdrawals) register here so this generic
|
|
poller can notify them when one of their outgoing txs gets its 1st
|
|
confirmation, without this module importing them directly."""
|
|
_handlers[kind] = handler
|
|
|
|
|
|
async def poll_once(session_factory: async_sessionmaker, client: ElectrumClient) -> int:
|
|
async with session_factory() as session:
|
|
# Plain columns, not entities: nothing then outlives the session, so this
|
|
# can't break if expire_on_commit is ever turned on (B-21).
|
|
candidates = (
|
|
await session.execute(
|
|
select(
|
|
PendingTransaction.id,
|
|
PendingTransaction.current_txid,
|
|
PendingTransaction.kind,
|
|
PendingTransaction.user_id,
|
|
).where(PendingTransaction.status == "pending")
|
|
)
|
|
).all()
|
|
|
|
# Resolved once per candidate while the session is still open, and cached
|
|
# by scripthash below — every "payout" row shares the same pool address,
|
|
# so this also avoids asking the server the same history twice per tick.
|
|
scripthash_by_id: dict[int, str] = {}
|
|
for pending_id, _txid, kind, user_id in candidates:
|
|
try:
|
|
address = await own_address_for(session, kind, user_id)
|
|
scripthash_by_id[pending_id] = address_to_scripthash(address)
|
|
except Exception:
|
|
logger.exception("could not derive the address for pending_transaction %s", pending_id)
|
|
|
|
confirmed = 0
|
|
history_cache: dict[str, list[dict]] = {}
|
|
for pending_id, txid, kind, _user_id in candidates:
|
|
scripthash = scripthash_by_id.get(pending_id)
|
|
if scripthash is None:
|
|
continue # address derivation failed above; already logged
|
|
|
|
try:
|
|
if scripthash not in history_cache:
|
|
history_cache[scripthash] = await client.get_history(scripthash)
|
|
except Exception:
|
|
# One unresolvable scripthash must not stop the others: a tx the server
|
|
# no longer knows about (dropped from the mempool, replaced) used to
|
|
# abort the whole pass via a verbose blockchain.transaction.get call
|
|
# that some servers reject outright (B-41), so nothing confirmed again
|
|
# until an operator intervened (B-03). Abandoning such a row is
|
|
# app/tx/reconcile.py's job, not ours.
|
|
logger.warning("could not fetch history for pending_transaction %s (txid %s)", pending_id, txid, exc_info=True)
|
|
continue
|
|
|
|
entry = next((e for e in history_cache[scripthash] if e.get("tx_hash") == txid), None)
|
|
# height > 0 means confirmed at that height; 0 or absent means still in
|
|
# the mempool (or the server doesn't know this txid at all yet) — either
|
|
# way, not confirmed, so keep waiting.
|
|
if entry is None or entry.get("height", 0) <= 0:
|
|
continue
|
|
|
|
async with session_factory() as session:
|
|
await begin_immediate(session) # B-88: read the row and write its outcome under one lock
|
|
row = await session.get(PendingTransaction, pending_id)
|
|
if row is None or row.status != "pending":
|
|
continue
|
|
row.status = "confirmed"
|
|
handler = _handlers.get(kind)
|
|
if handler is not None:
|
|
await handler(session, row)
|
|
await session.commit()
|
|
broadcaster.publish() # a bet/withdrawal/payout just confirmed — balance and/or round state changed
|
|
confirmed += 1
|
|
|
|
return confirmed
|
|
|
|
|
|
class ConfirmationPoller:
|
|
def __init__(self, session_factory: async_sessionmaker, get_client: Callable[[], ElectrumClient | None]):
|
|
self._session_factory = session_factory
|
|
self._get_client = get_client
|
|
|
|
async def run(self) -> None:
|
|
while True:
|
|
client = self._get_client()
|
|
if client is not None:
|
|
try:
|
|
await poll_once(self._session_factory, client)
|
|
except asyncio.CancelledError:
|
|
raise
|
|
except Exception:
|
|
logger.exception("confirmation poll failed")
|
|
await asyncio.sleep(_POLL_INTERVAL_SECONDS)
|