Close the smaller state inconsistencies (B-96, BET-02, BET-07, WDR-01, WDR-15, TX-16, TX-18, TX-27, TX-29, DEP-15, DEP-16, AUD-30, AUD-46, DAT-22)
- bet/withdrawal routes read listener.client after taking the user lock - a reduced full-balance withdrawal is checked against the minimum again - a bet covered only by pending balance answers balance_pending_confirmation - a recovered bet/withdrawal/payout writes bet_placed/withdrawal_sent/payout_sent - an abandoned payout clears winner/fee/reserve amounts with payout_txid - the reconciler pings SSE only for rows it changed - closing_stalled every 30 minutes past the deadline; closing_waiting_since on /rounds/current - one refresh per user at a time; a failed refresh no longer ends the Electrum session Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
24e5fc3d8b
commit
9520c80dcf
23 files changed
+445
-151
No files matched your search
+10
-7
@@ -26,16 +26,19 @@ async def create_bet(
|
||||
session: AsyncSession = Depends(get_session),
|
||||
) -> BetResponse:
|
||||
listener = request.app.state.electrum_listener
|
||||
if listener.client is None:
|
||||
raise http_error(
|
||||
status.HTTP_503_SERVICE_UNAVAILABLE,
|
||||
"network_unavailable",
|
||||
"not connected to the network, try again shortly",
|
||||
)
|
||||
|
||||
async with request.app.state.user_locks.acquire(user.id):
|
||||
# B-96 (BET-02): read after the lock is taken — a wait on it across a reconnection
|
||||
# must not hand place_bet the connection that closed while this request queued.
|
||||
client = listener.client
|
||||
if client is None:
|
||||
raise http_error(
|
||||
status.HTTP_503_SERVICE_UNAVAILABLE,
|
||||
"network_unavailable",
|
||||
"not connected to the network, try again shortly",
|
||||
)
|
||||
try:
|
||||
participant = await place_bet(session, listener.client, user, network=listener)
|
||||
participant = await place_bet(session, client, user, network=listener)
|
||||
except BetError as exc:
|
||||
# A rejected broadcast isn't the client's fault — it's the network
|
||||
# refusing our transaction, so it answers 502 rather than 400 (B-07).
|
||||
|
||||
@@ -119,6 +119,8 @@ class CurrentRoundResponse(BaseModel):
|
||||
# waiting for a block" rather than a countdown implying a bounded wait — this
|
||||
# phase has no timeout, only draw_animation_seconds' cosmetic minimum.
|
||||
draw_waiting_since: str | None = None
|
||||
# B-96 (TX-29): since when the round has waited in "closing" for in-flight bets; only then.
|
||||
closing_waiting_since: str | None = None
|
||||
# B-73 (RND-34, RND-14): the commitment published from the opening, and what is fixed
|
||||
# on entering "drawing". The secret itself is never in this response (API-45 has it, once
|
||||
# revealed).
|
||||
@@ -233,6 +235,7 @@ async def current_round(
|
||||
draw_block_height=round_.draw_block_height,
|
||||
draw_block_hash=round_.draw_block_hash,
|
||||
draw_waiting_since=isoformat_utc(round_.drawing_started_at) if round_.status == "drawing" else None,
|
||||
closing_waiting_since=isoformat_utc(round_.closed_at) if round_.status == "closing" and round_.closed_at else None,
|
||||
server_seed_hash=round_.server_seed_hash,
|
||||
participants_hash=round_.participants_hash,
|
||||
draw_height=round_.draw_height,
|
||||
|
||||
@@ -32,17 +32,19 @@ async def create_withdrawal(
|
||||
session: AsyncSession = Depends(get_session),
|
||||
) -> WithdrawalResponse:
|
||||
listener = request.app.state.electrum_listener
|
||||
if listener.client is None:
|
||||
raise http_error(
|
||||
status.HTTP_503_SERVICE_UNAVAILABLE,
|
||||
"network_unavailable",
|
||||
"not connected to the network, try again shortly",
|
||||
)
|
||||
|
||||
async with request.app.state.user_locks.acquire(user.id):
|
||||
# B-96 (WDR-01): read after the lock is taken, as in create_bet.
|
||||
client = listener.client
|
||||
if client is None:
|
||||
raise http_error(
|
||||
status.HTTP_503_SERVICE_UNAVAILABLE,
|
||||
"network_unavailable",
|
||||
"not connected to the network, try again shortly",
|
||||
)
|
||||
try:
|
||||
withdrawal = await request_withdrawal(
|
||||
session, listener.client, user, body.external_address, body.amount_sats, network=listener
|
||||
session, client, user, body.external_address, body.amount_sats, network=listener
|
||||
)
|
||||
except WithdrawalError as exc:
|
||||
code = (
|
||||
|
||||
+14
-2
@@ -16,7 +16,7 @@ from app.rounds.events import broadcaster
|
||||
from app.rounds.service import open_new_round_if_needed, round_accepts_bets
|
||||
from app.tx.versions import delete_versions, record_version
|
||||
from app.tx.outcome import BroadcastOutcome, TransactionNetwork, broadcast_with_verdict
|
||||
from app.wallet.balance import recompute_balance
|
||||
from app.wallet.balance import compute_pending_balance, recompute_balance
|
||||
from app.wallet.hd import derive_user_key
|
||||
from app.wallet.psbt_builder import (
|
||||
MAX_PARTICIPANTS_PER_ROUND,
|
||||
@@ -125,7 +125,19 @@ async def place_bet(
|
||||
select(UtxoEvent).where(UtxoEvent.user_id == user.id, UtxoEvent.spent_txid.is_(None))
|
||||
)
|
||||
).all()
|
||||
if sum(u.amount_sats for u in unspent) < bet_amount:
|
||||
confirmed_sats = sum(u.amount_sats for u in unspent)
|
||||
if confirmed_sats < bet_amount:
|
||||
# B-96 (BET-07, DEP-13): the balance on screen includes unconfirmed change and deposits
|
||||
# short of their threshold; a bet that balance would cover gets "wait for the
|
||||
# confirmation", as a withdrawal does, instead of a flat "insufficient".
|
||||
waiting_sats = network.pending_deposit_sats(user.id) if hasattr(network, "pending_deposit_sats") else 0
|
||||
pending_inclusive_sats, has_pending = await compute_pending_balance(session, user, waiting_sats)
|
||||
if has_pending and pending_inclusive_sats >= bet_amount:
|
||||
raise BetError(
|
||||
"balance_pending_confirmation",
|
||||
"the bet cost is covered by your pending balance, which has not confirmed yet",
|
||||
pending_sats=pending_inclusive_sats - confirmed_sats,
|
||||
)
|
||||
raise BetError("insufficient_balance", "insufficient balance", required_sats=bet_amount)
|
||||
|
||||
user_key = derive_user_key(user.derivation_index)
|
||||
|
||||
@@ -119,6 +119,7 @@ class ElectrumListener:
|
||||
self._allow_no_quorum = allow_no_quorum
|
||||
self._endpoint_index = 0
|
||||
self._restore_checked = False
|
||||
self._refresh_locks: dict[int, asyncio.Lock] = {}
|
||||
self._scripthash_to_user: dict[str, int] = {}
|
||||
# Retains address_for_new_user's fire-and-forget subscribe task so it
|
||||
# can't be garbage-collected mid-flight, and so its exception (if any) is
|
||||
@@ -1143,9 +1144,26 @@ class ElectrumListener:
|
||||
scripthash, _status = await queue.get()
|
||||
user_id = self._scripthash_to_user.get(scripthash)
|
||||
if user_id is not None:
|
||||
await self.refresh_user(user_id, scripthash)
|
||||
try:
|
||||
await self.refresh_user(user_id, scripthash)
|
||||
except asyncio.CancelledError:
|
||||
raise
|
||||
except Exception:
|
||||
# B-96 (DEP-16): one user's failed refresh (a coin already recorded, a
|
||||
# corroboration error) ends neither the session nor the other users'
|
||||
# notifications; a dropped connection ends it through wait_closed(), and
|
||||
# this user is picked up again by the next refresh or the periodic sweep.
|
||||
logger.warning("refresh of user %s failed after a notification", user_id, exc_info=True)
|
||||
|
||||
async def refresh_user(self, user_id: int, scripthash: str) -> None:
|
||||
"""One refresh of a user at a time (B-96, DEP-15): a notification, the re-subscription
|
||||
and the periodic sweep can ask together, and two of them reading the same new coin would
|
||||
both try to credit it. The lock is the refresh's own, not the bet/withdrawal one, so a
|
||||
corroboration in progress never delays a bet. Other users refresh in parallel."""
|
||||
async with self._refresh_locks.setdefault(user_id, asyncio.Lock()):
|
||||
await self._refresh_user_locked(user_id, scripthash)
|
||||
|
||||
async def _refresh_user_locked(self, user_id: int, scripthash: str) -> None:
|
||||
"""Three phases, so no DB session is held across a network call (B-18),
|
||||
same shape as _trigger_payout: read what's needed, corroborate every
|
||||
balance-moving candidate against other servers — new credits (B-59) as
|
||||
|
||||
@@ -47,6 +47,9 @@ _PAYOUT_RETRY_INTERVAL_SECONDS = 60
|
||||
# corroboration failure. These only make an already-long wait *observable*, they
|
||||
# never cut it short.
|
||||
_DRAW_PROGRESS_LOG_INTERVAL_SECONDS = 60
|
||||
# B-96 (TX-29, AUD-46): how long past its deadline a round may sit in `closing` on an in-flight bet before
|
||||
# `closing_stalled` is written, and how often it repeats. The wait itself has no limit (ADR-51).
|
||||
CLOSING_STALL_THRESHOLD_SECONDS = 1800
|
||||
_DRAW_STALL_THRESHOLD_SECONDS = 360 # a few multiples of PLM's 120s block time
|
||||
|
||||
|
||||
@@ -143,10 +146,50 @@ class RoundScheduler:
|
||||
)
|
||||
)
|
||||
if pending_count:
|
||||
await self._note_closing_stall(round_id, deadline)
|
||||
return # wait for in-flight bets to confirm before closing; stays "closing"
|
||||
|
||||
await self._close_and_draw(round_id)
|
||||
|
||||
async def _note_closing_stall(self, round_id: int, deadline: datetime) -> None:
|
||||
"""B-96 (TX-29, AUD-46): the wait in `closing` is unbounded by design, so it is made
|
||||
visible — one `closing_stalled` row per CLOSING_STALL_THRESHOLD_SECONDS once the round has
|
||||
been past its deadline for that long. The latest row is the clock of the next one (read
|
||||
from the log, not from memory, so a restart neither repeats nor anticipates it)."""
|
||||
now = datetime.now(timezone.utc)
|
||||
seconds_past = (now - deadline).total_seconds()
|
||||
if seconds_past < CLOSING_STALL_THRESHOLD_SECONDS:
|
||||
return
|
||||
async with self._session_factory() as session:
|
||||
last = await session.scalar(
|
||||
select(AuditLog.created_at)
|
||||
.where(AuditLog.event_type == "closing_stalled", AuditLog.round_id == round_id)
|
||||
.order_by(AuditLog.id.desc())
|
||||
.limit(1)
|
||||
)
|
||||
if last is not None and now < last.replace(tzinfo=timezone.utc) + timedelta(
|
||||
seconds=CLOSING_STALL_THRESHOLD_SECONDS
|
||||
):
|
||||
return
|
||||
txids = list(
|
||||
await session.scalars(
|
||||
select(RoundParticipant.bet_txid)
|
||||
.where(
|
||||
RoundParticipant.round_id == round_id,
|
||||
RoundParticipant.status.in_(("building", "broadcast")),
|
||||
)
|
||||
.order_by(RoundParticipant.id)
|
||||
)
|
||||
)
|
||||
await write_audit_log(
|
||||
session,
|
||||
"closing_stalled",
|
||||
{"in_flight": len(txids), "txids": txids, "seconds_past_deadline": int(seconds_past)},
|
||||
round_id=round_id,
|
||||
)
|
||||
await session.commit()
|
||||
logger.warning("round %s has waited %ss past its deadline for %s in-flight bet(s)", round_id, int(seconds_past), len(txids))
|
||||
|
||||
async def _close_and_draw(self, round_id: int) -> None:
|
||||
"""Close a `closing` round once nothing is in flight: either close it (no confirmed
|
||||
participant) or commit to the draw — fix the participant list, its fingerprint and the
|
||||
|
||||
+40
-2
@@ -214,8 +214,9 @@ async def reconcile_once(
|
||||
await _abandon(session, row, payload)
|
||||
changed = True
|
||||
await session.commit()
|
||||
resolved += changed
|
||||
broadcaster.publish()
|
||||
if changed: # B-96 (TX-27): a row that was only examined moved nothing to refetch
|
||||
resolved += 1
|
||||
broadcaster.publish()
|
||||
|
||||
return resolved
|
||||
|
||||
@@ -360,6 +361,9 @@ async def _promote(session: AsyncSession, row: PendingTransaction) -> None:
|
||||
"""The tx did make it onto the chain before we died — finish what phase 2 of
|
||||
place_bet/request_withdrawal would have done."""
|
||||
row.status = "pending"
|
||||
# B-96 (TX-16, AUD-30): besides pending_tx_recovered, the event the successful send would have
|
||||
# written — a recovered bet, withdrawal or payout is otherwise absent from the audit trail.
|
||||
sent_event: tuple[str, dict, int | None] | None = None
|
||||
if row.kind == "bet":
|
||||
participant = await session.scalar(
|
||||
select(RoundParticipant).where(
|
||||
@@ -368,10 +372,39 @@ async def _promote(session: AsyncSession, row: PendingTransaction) -> None:
|
||||
)
|
||||
if participant is not None and participant.status == "building":
|
||||
participant.status = "broadcast"
|
||||
sent_event = (
|
||||
"bet_placed",
|
||||
{"txid": row.current_txid, "amount_sats": participant.bet_amount_sats},
|
||||
row.user_id,
|
||||
)
|
||||
elif row.kind == "withdrawal" and row.withdrawal_id is not None:
|
||||
withdrawal = await session.get(Withdrawal, row.withdrawal_id)
|
||||
if withdrawal is not None and withdrawal.status == "building":
|
||||
withdrawal.status = "broadcast"
|
||||
sent_event = (
|
||||
"withdrawal_sent",
|
||||
{
|
||||
"txid": row.current_txid,
|
||||
"amount_sent_sats": withdrawal.amount_sent_sats,
|
||||
"external_address": withdrawal.external_address,
|
||||
},
|
||||
row.user_id,
|
||||
)
|
||||
elif row.kind == "payout" and row.round_id is not None:
|
||||
round_ = await session.get(Round, row.round_id)
|
||||
if round_ is not None:
|
||||
sent_event = (
|
||||
"payout_sent",
|
||||
{
|
||||
"txid": row.current_txid,
|
||||
"winner_sats": round_.winner_amount_sats,
|
||||
"commission_sats": round_.fee_amount_sats,
|
||||
},
|
||||
round_.winner_user_id,
|
||||
)
|
||||
if sent_event is not None:
|
||||
event, payload, event_user_id = sent_event
|
||||
await write_audit_log(session, event, payload, user_id=event_user_id, round_id=row.round_id)
|
||||
await write_audit_log(
|
||||
session,
|
||||
"pending_tx_recovered",
|
||||
@@ -418,6 +451,11 @@ async def _abandon(session: AsyncSession, row: PendingTransaction, reason: str)
|
||||
round_ = await session.get(Round, row.round_id) if row.round_id else None
|
||||
if round_ is not None and round_.status == "paying_out":
|
||||
round_.payout_txid = None
|
||||
# B-96 (TX-18, DAT-22): the amounts belong to the attempt that no longer exists; the
|
||||
# next attempt writes its own.
|
||||
round_.winner_amount_sats = None
|
||||
round_.fee_amount_sats = None
|
||||
round_.bump_reserve_sats = None
|
||||
logger.error(
|
||||
"round %s payout tx %s vanished — round needs operator attention", round_.id, row.current_txid
|
||||
)
|
||||
|
||||
@@ -144,6 +144,16 @@ async def request_withdrawal(
|
||||
except InsufficientFundsError as exc:
|
||||
raise WithdrawalError(exc.code, str(exc), **exc.params) from exc
|
||||
|
||||
# B-96 (WDR-15): the reduction above can take a full-balance withdrawal a dust limit under
|
||||
# the minimum that was checked on the requested amount.
|
||||
moved_sats = built.recipient_sats + built.fee_sats
|
||||
if moved_sats < config.bet_amount_sats:
|
||||
raise WithdrawalError(
|
||||
"amount_below_minimum",
|
||||
f"amount below the minimum of {config.bet_amount_sats} sats",
|
||||
minimum_sats=config.bet_amount_sats,
|
||||
)
|
||||
|
||||
# Persist the intent before broadcasting, and only promote the rows once the
|
||||
# network has accepted the tx — same two-phase shape as place_bet (B-08).
|
||||
spent_by_key = {(u.txid, u.vout): u for u in unspent}
|
||||
|
||||
Reference in new issue
Block a user