davideandClaude Sonnet 5.5
db24287ea5
The seed was the hash of the first block seen after the close, so a miner holding tickets
could withhold blocks until one made them win, the active Electrum server could pick which
real block was used by not announcing another (a failed corroboration even moved the draw to
the next block), and the participant order was the server-only `broadcast_at` with no
tie-break, so nobody could recompute the result.
- Open: every round gets a 32-byte `server_seed`, stored only Fernet-encrypted with the
master-xprv key (`server_seed_enc`), with its published `server_seed_hash`;
`draw_confirmations` is copied from round_config. The plaintext column is written only by
the reveal.
- Entering `drawing` (one transaction, `draw_committed` audit row): participants ordered by
bet txid, each `draw_position`, `participants_hash` (sha256 of `txid:vout:address\n`
lines; new `bet_vout`), `draw_height = tip_at_close + 1`. A tip of 0 keeps the round
`closing` (`draw_baseline_tip_unknown`, once per round). All persisted, so a resumed draw
reads rather than recomputes (the `_tick` branch itself is B-81).
- `_complete_draw` / `_wait_for_draw_block` replace `_wait_for_next_block`: wait for
`draw_confirmations` blocks from `draw_height`, then `ElectrumListener.agreed_block_hash`
asks every server, the active one included, for the header at that exact height (valid
work, >= 2 other answers, strict majority of all); no agreement means the same height is
asked again and `draw_header_corroboration_failed` is written once per distinct reported
hash. `draw_stalled` now counts from the last tip advance, or from when the quorum started
to fail. Seed = sha256(server_seed || block_hash || participants_hash), index = seed mod n.
- The winner, the seed and the reveal (`server_seed`, `winner_drawn` payload) are written in
one transaction; a round closing with no participants reveals too. A round opened before
this change (no commitment) is given a secret as it enters `drawing`.
- `GET /rounds/{id}/proof` (public, 404 `round_not_found`, translated in all 7 languages) and
the new fields on `GET /rounds/current`; `draw_confirmations` in `/admin/config` and the
/admin form; `server_seed_hash`/`draw_height` in `/admin/rounds`, never the secret.
- Alembic d3e8b15a7c42 (plain add_column / create_index, expression indexes untouched).
- Docs: the B-73 `*Stato:*`/`*Oggi:*` lines are gone, guides and CLAUDE.md describe the new
draw. Ambiguities resolved in api.md: the proof's participants also carry `amount_sats`
(RND-37 lists it); `seed` is decimal in the proof and hex in the audit row, as specified.
Tests changed because the spec changed: ElectrumListener.corroborate_header (asked only the
other servers about the block the active one announced) is replaced by agreed_block_hash and
its quorum tests ported; draw_winner takes the secret and the list fingerprint; the four
_wait_for_next_block scheduler tests are replaced by _wait_for_draw_block ones (fixed height,
confirmations, same-height retry, stall clock). New: test_draw_proof.py recomputes the winner
independently from the public proof, checks the plaintext secret is nowhere in the database,
the API or the log before the reveal, and that a second pass over a `drawing` round yields
the same winner. Mutation-checked: ordering by broadcast_at, an early reveal and asking the
tip instead of the draw height each fail tests.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
180 lines
8.8 KiB
Python
180 lines
8.8 KiB
Python
import logging
|
|
from datetime import datetime, timedelta, timezone
|
|
|
|
from sqlalchemy import select
|
|
from sqlalchemy.exc import IntegrityError
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.db.models import Round, RoundConfig
|
|
from app.rounds.config import get_round_config
|
|
from app.rounds.events import broadcaster
|
|
from app.rounds.draw import new_server_seed, server_seed_commitment
|
|
from app.wallet.hd import derive_pool_address
|
|
from app.wallet.keystore import encrypt_round_seed
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
_ACTIVE_STATUSES = ("open", "closing", "drawing", "paying_out")
|
|
|
|
# Bounded: a conflict means someone else is opening a round right now, so a couple
|
|
# of retries is plenty. Unbounded retries could spin if the invariant were ever
|
|
# broken in a way we don't anticipate.
|
|
_OPEN_ROUND_ATTEMPTS = 3
|
|
|
|
# 70% winner / 30% fees. Hardcoded by design (see CLAUDE.md) — changing the split
|
|
# is a code change, not an admin-editable setting. Single source of truth so the
|
|
# advertised jackpot (rounds.py) and the actual payout (scheduler.py) can't diverge.
|
|
|
|
|
|
def _new_round_secret() -> dict:
|
|
"""B-73 (RND-34): a fresh secret for a round about to open, as the columns that hold it —
|
|
its published commitment and its encrypted form, never the plaintext."""
|
|
server_seed = new_server_seed()
|
|
return {
|
|
"server_seed_hash": server_seed_commitment(server_seed),
|
|
"server_seed_enc": encrypt_round_seed(server_seed),
|
|
}
|
|
|
|
|
|
def winner_share(pool_amount_sats: int) -> int:
|
|
return pool_amount_sats * 70 // 100
|
|
|
|
|
|
async def get_active_round(session: AsyncSession) -> Round | None:
|
|
"""The round currently in progress (in any non-closed state), if any. Rounds
|
|
never overlap: a new round only opens once the previous one is fully closed
|
|
(payout confirmed, or no participants to pay out).
|
|
|
|
The database enforces "at most one active round" (ix_rounds_single_active, see
|
|
app/db/models.py), so the ordering below is belt-and-braces; if it ever does
|
|
see two, that's a broken invariant and worth a loud log rather than silently
|
|
picking one."""
|
|
active = (
|
|
await session.scalars(select(Round).where(Round.status.in_(_ACTIVE_STATUSES)).order_by(Round.id.desc()))
|
|
).all()
|
|
if len(active) > 1:
|
|
logger.error(
|
|
"invariant violated: %s rounds are active at once (ids=%s) — using the newest",
|
|
len(active),
|
|
[r.id for r in active],
|
|
)
|
|
return active[0] if active else None
|
|
|
|
|
|
def round_deadline(round_: Round) -> datetime:
|
|
"""When this round stops accepting bets. B-61: from the round's own snapshotted
|
|
duration, not from the live config — an operator editing round_duration_seconds
|
|
mid-round must not move a deadline clients are already counting down to, nor
|
|
close an in-progress round on the spot."""
|
|
return round_.opened_at.replace(tzinfo=timezone.utc) + timedelta(seconds=round_.duration_seconds)
|
|
|
|
|
|
def round_accepts_bets(round_: Round) -> bool:
|
|
"""The authoritative "yellow light" check: once a round's timer has expired,
|
|
no new bet may be accepted, even though its DB status is still "open" (the
|
|
scheduler only flips it to "closing" on its next tick, up to
|
|
_TICK_INTERVAL_SECONDS later — see rounds/scheduler.py). Bets already placed
|
|
before the deadline are unaffected: the round still waits for them to confirm
|
|
before actually closing."""
|
|
if round_.status != "open":
|
|
return False
|
|
return datetime.now(timezone.utc) < round_deadline(round_)
|
|
|
|
|
|
def rounds_can_open(config: RoundConfig) -> bool:
|
|
"""Whether the instance is configured well enough to run a round at all (B-66).
|
|
|
|
Only fee_address today, and only because a round without one is unpayable: the
|
|
payout pays the 30% commission to it, so build_payout_transaction cannot even be
|
|
built. It has no column default for exactly this reason (rounds/config.py) — an
|
|
operator must set their own, and until they do there is nothing to guess.
|
|
|
|
Anything else that would make a round unpayable belongs here too, next to it,
|
|
rather than being discovered at payout time. Deliberately not about *pausing*,
|
|
which is a decision an operator took (RoundConfig.paused) rather than a
|
|
prerequisite they haven't met yet."""
|
|
return bool(config.fee_address.strip())
|
|
|
|
|
|
async def open_new_round_if_needed(session: AsyncSession) -> Round | None:
|
|
"""Returns the active round if one exists (whatever its status). Otherwise
|
|
opens a fresh one, unless the last closed round's cooldown (ROUND_COOLDOWN_SECONDS)
|
|
hasn't elapsed yet, the lottery is paused for maintenance, or the instance isn't
|
|
configured well enough to pay a winner — in any of those cases returns None.
|
|
Callers that need to attach a bet must additionally check the returned round's
|
|
status == "open" — a round in closing/drawing/paying_out isn't accepting new bets,
|
|
but a new round can't open until it's done.
|
|
|
|
Pausing never touches a round already in progress: it only suppresses opening
|
|
the *next* one, so the current round still closes, draws, and pays out the
|
|
winner normally (see admin.py's /admin/pause and /admin/resume)."""
|
|
active = await get_active_round(session)
|
|
if active is not None:
|
|
return active
|
|
|
|
config = await get_round_config(session)
|
|
if config.paused:
|
|
return None
|
|
if not rounds_can_open(config):
|
|
# B-66: a fresh instance starts with no fee_address, and a round opened
|
|
# without one takes bets, confirms them, and only then discovers that the
|
|
# payout cannot be built — leaving the round wedged in "paying_out",
|
|
# retrying every 60s, with money already in the pool. Every round would
|
|
# need its own manual recovery. Refusing to open costs nothing by
|
|
# comparison: no money has moved yet, and it is the operator's own missing
|
|
# setup, surfaced through GET /rounds/current's lottery_configured and the
|
|
# admin panel rather than discovered a round too late.
|
|
return None
|
|
|
|
last_closed = await session.scalar(select(Round).where(Round.status == "closed").order_by(Round.id.desc()))
|
|
if last_closed is not None and last_closed.closed_at is not None:
|
|
closed_at = last_closed.closed_at.replace(tzinfo=timezone.utc)
|
|
# B-61: the cooldown the closing round announced is the one honoured, so
|
|
# editing the config never retroactively shortens or extends a gap already
|
|
# under way. The new value applies from the next round on.
|
|
if datetime.now(timezone.utc) < closed_at + timedelta(seconds=last_closed.cooldown_seconds):
|
|
return None
|
|
|
|
for attempt in range(_OPEN_ROUND_ATTEMPTS):
|
|
# B-61: the timing this round will run by, fixed at open time.
|
|
round_ = Round(
|
|
status="open",
|
|
duration_seconds=config.round_duration_seconds,
|
|
cooldown_seconds=config.round_cooldown_seconds,
|
|
draw_confirmations=config.draw_confirmations, # B-73 (DAT-61)
|
|
# B-73 (RND-34, DAT-64): the commitment, then the secret itself encrypted — the
|
|
# plaintext column stays NULL until the reveal.
|
|
**_new_round_secret(),
|
|
)
|
|
session.add(round_)
|
|
try:
|
|
await session.flush()
|
|
except IntegrityError:
|
|
# Another caller (the scheduler tick, or a concurrent place_bet) got
|
|
# there first — ix_rounds_single_active turns what used to be two live
|
|
# rounds into a clean failure here. Roll our insert back and use theirs.
|
|
# Safe to roll back: this runs before its callers have written anything
|
|
# else in this session.
|
|
await session.rollback()
|
|
existing = await get_active_round(session)
|
|
if existing is not None:
|
|
logger.info("lost the race to open a round; using round %s", existing.id)
|
|
return existing
|
|
# Nothing active *and* the insert conflicted: the winner's transaction
|
|
# hadn't committed yet when we looked. Try again rather than failing the
|
|
# caller — a bet shouldn't 500 because of a scheduler tick's timing.
|
|
logger.info("round-open conflict with nothing active yet (attempt %s), retrying", attempt + 1)
|
|
continue
|
|
# Published pre-commit (the caller commits right after) — acceptable: this
|
|
# only tells subscribers "go refetch", and by the time an SSE client's
|
|
# refetch request actually lands, this in-process commit (microseconds
|
|
# away) has essentially always already happened.
|
|
# B-80 (RND-35, DAT-60): the round's own pool address, now that its id exists —
|
|
# still inside the caller's transaction, so no committed round ever lacks one.
|
|
round_.pool_address = derive_pool_address(round_.id)
|
|
broadcaster.publish()
|
|
return round_
|
|
|
|
logger.error("could not open a round after %s attempts", _OPEN_ROUND_ATTEMPTS)
|
|
return await get_active_round(session)
|