Compare commits
8
Commits
8dd913ec59
...
526a649c8b
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
526a649c8b | ||
|
|
666cb1a0c9 | ||
|
|
162ceed40f | ||
|
|
5f6abe5b32 | ||
|
|
23d58796b6 | ||
|
|
c4b2dc3ea2 | ||
|
|
c0314e2bf0 | ||
|
|
8a0ebecfcc |
No files matched your search
@@ -38,118 +38,8 @@ remains the last prerequisite for running unattended.
|
|||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## Medium — correctness and robustness
|
|
||||||
|
|
||||||
### B-63 — `tip_height == 0` window right after connecting can seed a draw from a pre-close block
|
|
||||||
|
|
||||||
`app/electrum/listener.py:160-167`, `app/rounds/scheduler.py:153`.
|
|
||||||
|
|
||||||
`_run_once` assigns `self.client` *before* `subscribe_headers()` returns, so there
|
|
||||||
is a window in which the client looks alive while `tip_height` is still 0 and
|
|
||||||
`tip_header_hex` is `None`. A `_close_and_draw` entering that window records
|
|
||||||
`tip_at_close = 0`, and the first header applied — the current tip, a block mined
|
|
||||||
*before* the round closed — satisfies `tip_height > tip_at_close` and becomes the
|
|
||||||
draw's entropy. The draw must use a block that did not exist at close time; a block
|
|
||||||
whose hash was already public before betting closed is not the guarantee the
|
|
||||||
flowchart describes.
|
|
||||||
|
|
||||||
Fix: publish `self.client` only after the first header has been applied, or refuse
|
|
||||||
to draw while `tip_header_hex is None` / `tip_height == 0`.
|
|
||||||
|
|
||||||
### B-64 — `_apply_header` accepts a same-height header without the chaining check
|
|
||||||
|
|
||||||
`app/electrum/listener.py:271-296`.
|
|
||||||
|
|
||||||
The chain check only runs for `height == self.tip_height + 1`. A header at exactly
|
|
||||||
the current tip height replaces `tip_header_hex` after passing only the
|
|
||||||
self-target check — which, as the docstring of `header_meets_its_own_target`
|
|
||||||
already notes, a server can satisfy with a self-declared easy target. Separately,
|
|
||||||
a header with no `hex` field sets `tip_header_hex = None`, discarding a tip we
|
|
||||||
otherwise accepted.
|
|
||||||
|
|
||||||
Fix: treat a same-height header as either ignorable or as a reorg signal rather
|
|
||||||
than silently replacing the entropy source, and don't clear `tip_header_hex` on a
|
|
||||||
hex-less notification.
|
|
||||||
|
|
||||||
### B-65 — `/rounds/current` counts unconfirmed participants; the draw and payout do not
|
|
||||||
|
|
||||||
`app/api/routes/rounds.py:131-143` vs `app/rounds/scheduler.py:126`.
|
|
||||||
|
|
||||||
`participant_count` and `jackpot_sats` are computed over *all* `round_participants`
|
|
||||||
rows, while the draw and the payout only use `status == "confirmed"`. So the
|
|
||||||
advertised jackpot can exceed what is actually paid out, and a participant whose
|
|
||||||
bet is later abandoned appears in the count and then vanishes from it.
|
|
||||||
|
|
||||||
Fix: either count only `confirmed` (and accept that a fresh bet takes a block to
|
|
||||||
show up), or expose the two figures separately (confirmed vs in-flight) so the
|
|
||||||
number on screen and the number that gets paid agree by construction.
|
|
||||||
|
|
||||||
### B-66 — nothing stops rounds from opening with no `fee_address` configured
|
|
||||||
|
|
||||||
`app/rounds/config.py:12-17`, `app/rounds/scheduler.py:330-335`.
|
|
||||||
|
|
||||||
A fresh instance starts with `fee_address = ""`. Rounds open, bets are accepted and
|
|
||||||
confirm, and only then does the payout refuse to build — leaving the round in
|
|
||||||
`paying_out`, retrying every 60 s, with the audit log as the only signal.
|
|
||||||
|
|
||||||
Fix: refuse to open a round while `fee_address` is unset (and surface it on
|
|
||||||
`/admin` and as a maintenance-style banner), so the failure happens before anyone's
|
|
||||||
money is committed.
|
|
||||||
|
|
||||||
### B-67 — `/qr/{address}` is unauthenticated, synchronous and only shape-validated
|
|
||||||
|
|
||||||
`app/api/routes/qr.py:11-21`.
|
|
||||||
|
|
||||||
`qrcode.make` runs on the event loop, so the endpoint is a cheap CPU amplifier for
|
|
||||||
an unauthenticated caller, and the regex accepts any `plm1[a-z0-9]{10,90}` string
|
|
||||||
without validating the bech32 checksum — so it happily renders a QR for a
|
|
||||||
non-address.
|
|
||||||
|
|
||||||
Fix: validate with `is_valid_plm_address` (already used by withdrawals and by the
|
|
||||||
admin `fee_address` validator), and either offload the render or cache it per
|
|
||||||
address.
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
## Low — documentation and consistency drift
|
## Low — documentation and consistency drift
|
||||||
|
|
||||||
### B-68 — CLAUDE.md and README describe a state the code has moved past
|
|
||||||
|
|
||||||
- CLAUDE.md's tech-stack line still says JWT has **no revocation (B-34)**; `token_version`
|
|
||||||
implements exactly that revocation (`app/db/models.py:29`, `app/auth/dependencies.py:26`).
|
|
||||||
- "Known gaps" still says **no rate limiting anywhere (B-33)**; login and registration
|
|
||||||
are throttled (`app/auth/rate_limit.py`). What is genuinely still unthrottled is
|
|
||||||
bets, withdrawals and the admin endpoints — that is the claim worth keeping.
|
|
||||||
- "Known gaps" still says **`/report-bug` is a placeholder**; it is fully implemented
|
|
||||||
and translated, with admin triage. Only `/guida` is still a stub.
|
|
||||||
- Test counts are stale in three places: 264 actual, CLAUDE.md says 253 twice,
|
|
||||||
README says 232.
|
|
||||||
- The code map omits `app/auth/rate_limit.py`, `app/api/client_ip.py` and
|
|
||||||
`app/api/routes/bug_reports.py`.
|
|
||||||
- README links `flowchart.mmd`, which does not exist (the diagrams live in
|
|
||||||
`flowchart/`), describes `docs/running-the-server.md` as covering "local venv vs.
|
|
||||||
Docker" (that workflow was removed in B-44), and links the anchor
|
|
||||||
`CLAUDE.md#tech-stack-mvp`, which no longer exists.
|
|
||||||
|
|
||||||
### B-69 — stale in-code comments
|
|
||||||
|
|
||||||
- `app/tx/reconcile.py:206` calls the payout retry "a future payout-retry routine —
|
|
||||||
still an open gap"; it exists (B-26).
|
|
||||||
- `app/db/base.py:9` says "five concurrent background tasks"; there are six.
|
|
||||||
- `app/auth/routes.py:31` cites B-31 where it means B-33 (see B-58).
|
|
||||||
|
|
||||||
### B-70 — the flowchart's WITHDRAW precondition is not implemented as written
|
|
||||||
|
|
||||||
`flowchart/platform-overview.mmd:39` (node E1) states a withdrawal cannot happen
|
|
||||||
together with a bet in progress. The code only serializes the *builds* through the
|
|
||||||
per-user lock (`app/tx/locks.py`): a withdrawal is accepted while a bet is still
|
|
||||||
unconfirmed, as long as confirmed UTXOs cover it.
|
|
||||||
|
|
||||||
CLAUDE.md declares every node and edge label of the diagrams a behaviour that must
|
|
||||||
be implemented as described, so one of the two has to move — most likely the
|
|
||||||
diagram, since the lock already prevents the actual double-spend hazard, but that
|
|
||||||
is a decision, not a cleanup.
|
|
||||||
|
|
||||||
### B-71 — `.env` points `MASTER_KEY_PATH` at a second copy of the master key
|
### B-71 — `.env` points `MASTER_KEY_PATH` at a second copy of the master key
|
||||||
|
|
||||||
CLAUDE.md's deployment section prescribes pointing `MASTER_KEY_PATH` at the
|
CLAUDE.md's deployment section prescribes pointing `MASTER_KEY_PATH` at the
|
||||||
|
|||||||
@@ -8,7 +8,7 @@ The user communicates in Italian in chat — reply to them in Italian. Everythin
|
|||||||
|
|
||||||
## Project status
|
## Project status
|
||||||
|
|
||||||
All 10 stages of the original build order are code-complete and unit-tested — 313 tests, all under `tests/unit/` (`tests/integration/` is an empty package). Beyond them: Docker + Caddy deployment, admin dashboard (`/admin`), static test UI (`/`), pending-inclusive balance display, an SSE push channel layered over the original polling, self-service password change + admin password reset, and the reconciliation/corroboration machinery below.
|
All 10 stages of the original build order are code-complete and unit-tested — 351 tests, all under `tests/unit/` (`tests/integration/` is an empty package). Beyond them: Docker + Caddy deployment, admin dashboard (`/admin`), static test UI (`/`), pending-inclusive balance display, an SSE push channel layered over the original polling, self-service password change + admin password reset, and the reconciliation/corroboration machinery below.
|
||||||
|
|
||||||
Verified on mainnet with real money: registration + address derivation, deposit crediting (1-conf), a real 10 PLM bet (broadcast → confirmed → change credited back), and one full round cycle (close → draw on a real block hash → 70/30 payout with sat math checked against the broadcast tx → confirmation → close → next round auto-opened). **Withdrawal and the RBF bump path have never been exercised against a live broadcast** — unit-tested only.
|
Verified on mainnet with real money: registration + address derivation, deposit crediting (1-conf), a real 10 PLM bet (broadcast → confirmed → change credited back), and one full round cycle (close → draw on a real block hash → 70/30 payout with sat math checked against the broadcast tx → confirmation → close → next round auto-opened). **Withdrawal and the RBF bump path have never been exercised against a live broadcast** — unit-tested only.
|
||||||
|
|
||||||
@@ -33,7 +33,7 @@ PYTHONPATH=. python scripts/decrypt_master_key.py # ops recovery: decrypt+pr
|
|||||||
PYTHONPATH=. python scripts/encrypt_master_key.py # ops bootstrap: import an externally-generated xprv (--overwrite to replace)
|
PYTHONPATH=. python scripts/encrypt_master_key.py # ops bootstrap: import an externally-generated xprv (--overwrite to replace)
|
||||||
PYTHONPATH=. python scripts/electrum_smoke_test.py # manual check: connect, handshake, subscribe to headers, print the tip
|
PYTHONPATH=. python scripts/electrum_smoke_test.py # manual check: connect, handshake, subscribe to headers, print the tip
|
||||||
|
|
||||||
python -m pytest # all 313 tests
|
python -m pytest # all 351 tests
|
||||||
python -m pytest tests/unit/test_hd.py # one file
|
python -m pytest tests/unit/test_hd.py # one file
|
||||||
python -m pytest tests/unit/test_hd.py::test_derivation_is_deterministic # one test
|
python -m pytest tests/unit/test_hd.py::test_derivation_is_deterministic # one test
|
||||||
```
|
```
|
||||||
@@ -61,7 +61,7 @@ The `Caddyfile` sends baseline security headers — HSTS, `X-Content-Type-Option
|
|||||||
|
|
||||||
- Python 3.12+, FastAPI, SQLAlchemy 2 async + Alembic, SQLite via aiosqlite, `embit` for keys/PSBT/tx parsing.
|
- Python 3.12+, FastAPI, SQLAlchemy 2 async + Alembic, SQLite via aiosqlite, `embit` for keys/PSBT/tx parsing.
|
||||||
- **PLM access via the Electrum protocol only** (no full node/P2P). Dev bootstrap server: `santantonio.sytes.net:50002` (SSL).
|
- **PLM access via the Electrum protocol only** (no full node/P2P). Dev bootstrap server: `santantonio.sytes.net:50002` (SSL).
|
||||||
- Auth: Argon2 hashing + JWT (HS256, 24h, **no revocation** — B-34). Argon2 costs tens of ms of CPU per call by design, so every async caller goes through `hash_password_async`/`verify_password_async` (`run_in_threadpool`, B-55) — inline it froze the whole process, background tasks included, for the duration of every login. The sync pair stays for tests and scripts.
|
- Auth: Argon2 hashing + JWT (HS256, 24h). Tokens **are** revocable (B-34): the token carries a `tv` claim, `User.token_version` is bumped by a self-service password change and by an admin reset, and `get_current_user`/`get_optional_user` reject any token whose `tv` no longer matches — so changing the password invalidates every session issued before it, instead of leaving them valid for up to `jwt_expire_minutes`. A token predating the claim decodes as `tv = 0`, which is what a migrated user starts at, so the deploy didn't log everyone out. Argon2 costs tens of ms of CPU per call by design, so every async caller goes through `hash_password_async`/`verify_password_async` (`run_in_threadpool`, B-55) — inline it froze the whole process, background tasks included, for the duration of every login. The sync pair stays for tests and scripts.
|
||||||
- Secrets: master xprv Fernet-encrypted at rest, encryption key in an env var (never in the DB or git). `validate_runtime_secrets()` (`app/config.py`, called from the lifespan — deliberately *not* a `Settings` validator, so imports and tests need no real secrets) makes the server **refuse to serve** if `JWT_SECRET` < 32 chars or `XPRV_ENCRYPTION_KEY` is empty. An empty `ADMIN_TOKEN` is deliberately non-fatal: `require_admin` then denies everything, i.e. a locked panel, not an open one.
|
- Secrets: master xprv Fernet-encrypted at rest, encryption key in an env var (never in the DB or git). `validate_runtime_secrets()` (`app/config.py`, called from the lifespan — deliberately *not* a `Settings` validator, so imports and tests need no real secrets) makes the server **refuse to serve** if `JWT_SECRET` < 32 chars or `XPRV_ENCRYPTION_KEY` is empty. An empty `ADMIN_TOKEN` is deliberately non-fatal: `require_admin` then denies everything, i.e. a locked panel, not an open one.
|
||||||
- **Operational config lives in the DB, not in env vars**: every business/round parameter is one row of `round_config` (`app/rounds/config.py`), editable live from `/admin` — no redeploy, no restart. Defaults for a fresh instance are column defaults on `RoundConfig` (`app/db/models.py`), *not* `app/config.py`. Only secrets and infra wiring (master key, JWT secret, Electrum hosts, admin token, DB URL) stay in `.env`, since those need a restart anyway.
|
- **Operational config lives in the DB, not in env vars**: every business/round parameter is one row of `round_config` (`app/rounds/config.py`), editable live from `/admin` — no redeploy, no restart. Defaults for a fresh instance are column defaults on `RoundConfig` (`app/db/models.py`), *not* `app/config.py`. Only secrets and infra wiring (master key, JWT secret, Electrum hosts, admin token, DB URL) stay in `.env`, since those need a restart anyway.
|
||||||
|
|
||||||
@@ -95,19 +95,21 @@ Source of truth: the `PalladiumWallet` repo — [ChainProfiles.cs](../PalladiumW
|
|||||||
| Max inputs per *payout* | 500 (`MAX_PAYOUT_TX_INPUTS`, B-52) — the pool holds one UTXO per bet, so reusing the user cap made any round past ~50 players unpayable | hardcoded in `wallet/psbt_builder.py` |
|
| Max inputs per *payout* | 500 (`MAX_PAYOUT_TX_INPUTS`, B-52) — the pool holds one UTXO per bet, so reusing the user cap made any round past ~50 players unpayable | hardcoded in `wallet/psbt_builder.py` |
|
||||||
| Max participants per round | 400 (`MAX_PARTICIPANTS_PER_ROUND`, B-52) — the 401st bet is refused with `round_full` *before* any money moves, so "a round can always be paid out" is an invariant rather than something discovered at payout time | hardcoded in `wallet/psbt_builder.py`, enforced in `bets/service.py` |
|
| Max participants per round | 400 (`MAX_PARTICIPANTS_PER_ROUND`, B-52) — the 401st bet is refused with `round_full` *before* any money moves, so "a round can always be paid out" is an invariant rather than something discovered at payout time | hardcoded in `wallet/psbt_builder.py`, enforced in `bets/service.py` |
|
||||||
|
|
||||||
`GET /rounds/current`'s `jackpot_sats` is the winner's 70% share, not the whole pool, and the pool is summed from the participants' actual `bet_amount_sats` (each already net of its own bet fee) rather than `count × current bet amount` — editing the bet amount mid-round must not move an in-progress round's advertised jackpot (B-11).
|
`GET /rounds/current`'s `jackpot_sats` is the winner's 70% share, not the whole pool, and the pool is summed from the participants' actual `bet_amount_sats` (each already net of its own bet fee) rather than `count × current bet amount` — editing the bet amount mid-round must not move an in-progress round's advertised jackpot (B-11). It counts **confirmed participants only** (B-65), matching what the draw picks from and what the payout can spend, with `pending_participant_count`/`pending_jackpot_sats`/`has_pending_bets` reporting the in-flight bets alongside — inclusive figures, not deltas, exactly like `pending_balance_sats` (see "Balance display"). `/`'s round card shows the confirmed numbers big and the difference as an amber "+N in attesa" suffix, so a player who just bet sees their own bet immediately without the advertised jackpot ever exceeding what will be paid.
|
||||||
|
|
||||||
**Round cooldown** (`round_cooldown_seconds`, not in the original flowchart): gap after a round closes before the next opens, so players can see the outcome.
|
**Round cooldown** (`round_cooldown_seconds`, not in the original flowchart): gap after a round closes before the next opens, so players can see the outcome.
|
||||||
|
|
||||||
**Maintenance pause** (`RoundConfig.paused`): toggled by `POST /admin/pause` / `POST /admin/resume` — a deliberate operator action with its own "Manutenzione" card in `/admin`, audit-logged `lottery_paused`/`lottery_resumed`, not a plain config field. It only stops the *next* round from opening (`rounds/service.py:open_new_round_if_needed`); a round in progress still closes, draws and pays its winner. Exposed as `lottery_paused` so `/` can show a banner.
|
**Maintenance pause** (`RoundConfig.paused`): toggled by `POST /admin/pause` / `POST /admin/resume` — a deliberate operator action with its own "Manutenzione" card in `/admin`, audit-logged `lottery_paused`/`lottery_resumed`, not a plain config field. It only stops the *next* round from opening (`rounds/service.py:open_new_round_if_needed`); a round in progress still closes, draws and pays its winner. Exposed as `lottery_paused` so `/` can show a banner.
|
||||||
|
|
||||||
|
**No `fee_address`, no rounds** (`rounds/service.py:rounds_can_open`, B-66): the payout pays the 30% commission to `fee_address`, which has no column default because an operator must set their own — so until they do, `open_new_round_if_needed` refuses to open a round at all. Otherwise every round took bets, confirmed them and only then discovered it was unpayable, wedging in `paying_out` with money already in the pool and needing manual recovery. Same scope as pausing: a round already in progress still closes, draws and pays out (clearing the address mid-round is exactly the operator slip that must not strand a live round). Surfaced as `lottery_configured` on `GET /rounds/current` — `/` shows a *different* banner from the maintenance one, since "come back later" would be false — and as a warning on `/admin`'s Parametri card, the one screen that can fix it. Anything else that would make a round unpayable belongs in `rounds_can_open` next to it, not discovered at payout time.
|
||||||
|
|
||||||
## Code map
|
## Code map
|
||||||
|
|
||||||
| Package | Contents |
|
| Package | Contents |
|
||||||
|---|---|
|
|---|---|
|
||||||
| `app/main.py` | entry point: lifespan starts the six background tasks, mounts the routers and `app/static/` |
|
| `app/main.py` | entry point: lifespan starts the six background tasks, mounts the routers and `app/static/` |
|
||||||
| `app/api/routes/` | `admin`, `bets`, `withdrawals`, `rounds` (incl. SSE), `users`, `qr`; `app/api/errors.py` holds the error contract |
|
| `app/api/routes/` | `admin`, `bets`, `withdrawals`, `rounds` (incl. SSE), `users`, `qr`, `bug_reports`; `app/api/errors.py` holds the error contract and `app/api/client_ip.py` the trusted-peer extraction every IP-keyed control uses |
|
||||||
| `app/auth/` | routes (register/login), Argon2 + JWT (`security.py`), `get_current_user`/`get_optional_user` |
|
| `app/auth/` | routes (register/login), Argon2 + JWT (`security.py`), `get_current_user`/`get_optional_user`, login/registration throttling (`rate_limit.py`) |
|
||||||
| `app/db/` | `models.py` (all tables + the active-round index), engine/session factories |
|
| `app/db/` | `models.py` (all tables + the active-round index), engine/session factories |
|
||||||
| `app/wallet/` | HD derivation + WIF export (`hd.py`), PLM network constants, address/scripthash, balance math, `psbt_builder.py` (build/sign bet, withdrawal, payout; `select_utxos`) |
|
| `app/wallet/` | HD derivation + WIF export (`hd.py`), PLM network constants, address/scripthash, balance math, `psbt_builder.py` (build/sign bet, withdrawal, payout; `select_utxos`) |
|
||||||
| `app/electrum/` | `client.py` (JSON-RPC, endpoint parsing, timeouts), `listener.py` (the one connection: rotation, keepalive, header validation, corroboration, deposit crediting) |
|
| `app/electrum/` | `client.py` (JSON-RPC, endpoint parsing, timeouts), `listener.py` (the one connection: rotation, keepalive, header validation, corroboration, deposit crediting) |
|
||||||
@@ -130,7 +132,7 @@ Source of truth: the `PalladiumWallet` repo — [ChainProfiles.cs](../PalladiumW
|
|||||||
| `PendingTransactionReconciler` | `tx/reconcile.py` | at startup, then 120s | resolves `building`/`pending` rows against the chain |
|
| `PendingTransactionReconciler` | `tx/reconcile.py` | at startup, then 120s | resolves `building`/`pending` rows against the chain |
|
||||||
| `DepositReconciler` | `deposits/reconcile.py` | 300s (sleeps first) | re-`refresh_user`s every address, catching a silently-lost subscription (B-30) |
|
| `DepositReconciler` | `deposits/reconcile.py` | 300s (sleeps first) | re-`refresh_user`s every address, catching a silently-lost subscription (B-30) |
|
||||||
|
|
||||||
Chain access goes through `listener.client`, passed as `lambda: listener.client` so a reconnect swaps the client under its consumers; a task finding it `None` skips that cycle instead of failing. `DepositReconciler` takes the whole listener instead, reusing `refresh_user` so the periodic and notification-driven paths can't diverge.
|
Chain access goes through `listener.client`, passed as `lambda: listener.client` so a reconnect swaps the client under its consumers; a task finding it `None` skips that cycle instead of failing. **A non-null `client` means the tip is already known**: `_run_once` publishes it only after the first header has been applied (B-63), so `client is not None` can be read as "the chain is reachable *and* we know where it is" — `tip_height` is never the initial 0 behind a live client, which is what the draw depends on (see DRAW below). `DepositReconciler` takes the whole listener instead, reusing `refresh_user` so the periodic and notification-driven paths can't diverge.
|
||||||
|
|
||||||
## Electrum connection
|
## Electrum connection
|
||||||
|
|
||||||
@@ -139,7 +141,7 @@ One connection serves everything — deposit credits, broadcasts, confirmations,
|
|||||||
- **Rotation.** `ELECTRUM_HOST`/`PORT` is primary, `ELECTRUM_FALLBACK_SERVERS` a comma-separated `host:port[:notls]` list (`client.py:parse_endpoints` rejects malformed entries at startup, not during the outage when the fallback is needed). After any failed or dropped session the next server is tried immediately; the backoff (1s doubling to 30s) only kicks in once every server has had a turn.
|
- **Rotation.** `ELECTRUM_HOST`/`PORT` is primary, `ELECTRUM_FALLBACK_SERVERS` a comma-separated `host:port[:notls]` list (`client.py:parse_endpoints` rejects malformed entries at startup, not during the outage when the fallback is needed). After any failed or dropped session the next server is tried immediately; the backoff (1s doubling to 30s) only kicks in once every server has had a turn.
|
||||||
- **Bounded requests** (`_REQUEST_TIMEOUT_SECONDS` = 15s); a timeout tears the connection down. Unbounded waits used to hang `POST /bets` *while holding the per-user lock*, and could stall the confirmation poller permanently.
|
- **Bounded requests** (`_REQUEST_TIMEOUT_SECONDS` = 15s); a timeout tears the connection down. Unbounded waits used to hang `POST /bets` *while holding the per-user lock*, and could stall the confirmation poller permanently.
|
||||||
- **The drop is observable**: `client.wait_closed()` resolves when the read loop dies, and `_run_once` races it against the notification consumers and a 60s `server.ping`. Without it the listener sat on queues nobody would ever fill while `listener.client` still looked alive.
|
- **The drop is observable**: `client.wait_closed()` resolves when the read loop dies, and `_run_once` races it against the notification consumers and a 60s `server.ping`. Without it the listener sat on queues nobody would ever fill while `listener.client` still looked alive.
|
||||||
- **Headers are validated, not trusted** (`_apply_header`): the tip never regresses, a header must meet the difficulty target it claims, and a single-block advance must chain from the current tip's hash. Failure raises `HeaderValidationError`, which ends the session like a dropped connection and rotates away — that header is the draw's only entropy, so a fabricated one picks the winner.
|
- **Headers are validated, not trusted** (`_apply_header`): the tip never regresses, a header must meet the difficulty target it claims, and a single-block advance must chain from the current tip's hash. Failure raises `HeaderValidationError`, which ends the session like a dropped connection and rotates away — that header is the draw's only entropy, so a fabricated one picks the winner. Two more headers are refused *without* ending the session, since neither implies a hostile server (B-64): one at a height we already hold a header for (a reorg at the tip, or one server disagreeing — the hash committed to for a height is never swapped under us, and `corroborate_header` is what catches us holding an orphan), and one carrying no `hex` at all (nothing to validate or draw from, and applying the height alone would break the `tip_height`/`tip_header_hex` pairing). `_run_once` separately refuses to publish the client while *no* tip is known, so the ignore-don't-kill choice can't reopen B-63.
|
||||||
- **A quorum corroborates every money-moving decision** (`_corroborate_majority`, 10s per server, asking only the *other* endpoints — never the active one, which is what a MITM controls): `corroborate_header` before a block seeds the draw (B-28), `corroborate_utxo_spent` before a UTXO missing from one `listunspent` is written off as externally spent (B-29), and `corroborate_utxo_credit` before a new outpoint credits a balance — same outpoint, same amount, confirmed (B-59). Balances move in both directions, so both directions need the same quorum. No fallbacks configured → returns True (the accepted risk of an empty `ELECTRUM_FALLBACK_SERVERS`); nobody answers → returns **False**, since an unreachable network proves nothing. A failed credit corroboration only *delays*: `find_new_credit_candidates` re-offers the outpoint on the next refresh or `DepositReconciler` sweep.
|
- **A quorum corroborates every money-moving decision** (`_corroborate_majority`, 10s per server, asking only the *other* endpoints — never the active one, which is what a MITM controls): `corroborate_header` before a block seeds the draw (B-28), `corroborate_utxo_spent` before a UTXO missing from one `listunspent` is written off as externally spent (B-29), and `corroborate_utxo_credit` before a new outpoint credits a balance — same outpoint, same amount, confirmed (B-59). Balances move in both directions, so both directions need the same quorum. No fallbacks configured → returns True (the accepted risk of an empty `ELECTRUM_FALLBACK_SERVERS`); nobody answers → returns **False**, since an unreachable network proves nothing. A failed credit corroboration only *delays*: `find_new_credit_candidates` re-offers the outpoint on the next refresh or `DepositReconciler` sweep.
|
||||||
|
|
||||||
On reconnect `_subscribe_all_users` runs as its own task with bounded concurrency (`_RESUBSCRIBE_CONCURRENCY` = 20) rather than inline and serially — otherwise a large user base froze `tip_height`, and with it an in-flight draw, for the whole sweep (B-31); one user's failure is logged and skipped. `address_for_new_user` (called right after registration) is best-effort by design: on failure that address stays unsubscribed until the next reconnect or `DepositReconciler` sweep.
|
On reconnect `_subscribe_all_users` runs as its own task with bounded concurrency (`_RESUBSCRIBE_CONCURRENCY` = 20) rather than inline and serially — otherwise a large user base froze `tip_height`, and with it an in-flight draw, for the whole sweep (B-31); one user's failure is logged and skipped. `address_for_new_user` (called right after registration) is best-effort by design: on failure that address stays unsubscribed until the next reconnect or `DepositReconciler` sweep.
|
||||||
@@ -157,14 +159,14 @@ Diagrams: [platform-overview.mmd](flowchart/platform-overview.mmd), [round-lifec
|
|||||||
**DRAW** — configurable timer (default 600s):
|
**DRAW** — configurable timer (default 600s):
|
||||||
- *Bet cutoff is the round's own deadline* (`round_deadline` = `opened_at + Round.duration_seconds`, the value snapshotted at open time — B-61), **not** the DB status: `place_bet` calls `rounds/service.round_accepts_bets`, which rejects once the deadline passes even while `status` is still `"open"` (the 5s scheduler tick can lag behind it). Once a round leaves `open`, no new bets either, and no new round opens until this one is fully `closed`. The deadline is checked twice — on arrival and again after the transaction is built — and the participant row is then committed behind a **compare-and-set on the round row** (`UPDATE rounds ... WHERE status = 'open'`, B-53): the scheduler flips `open` → `closing` in a transaction of its own and only counts in-flight bets afterwards, so without the CAS a bet could commit in between, be excluded from the draw (only `confirmed` participants are drawn) and still have its sats land in the pool with no refund path. Its mirror image on the scheduler side is `_close_and_draw` re-counting in-flight bets in the same session it snapshots the participants from.
|
- *Bet cutoff is the round's own deadline* (`round_deadline` = `opened_at + Round.duration_seconds`, the value snapshotted at open time — B-61), **not** the DB status: `place_bet` calls `rounds/service.round_accepts_bets`, which rejects once the deadline passes even while `status` is still `"open"` (the 5s scheduler tick can lag behind it). Once a round leaves `open`, no new bets either, and no new round opens until this one is fully `closed`. The deadline is checked twice — on arrival and again after the transaction is built — and the participant row is then committed behind a **compare-and-set on the round row** (`UPDATE rounds ... WHERE status = 'open'`, B-53): the scheduler flips `open` → `closing` in a transaction of its own and only counts in-flight bets afterwards, so without the CAS a bet could commit in between, be excluded from the draw (only `confirmed` participants are drawn) and still have its sats land in the pool with no refund path. Its mirror image on the scheduler side is `_close_and_draw` re-counting in-flight bets in the same session it snapshots the participants from.
|
||||||
- *"Yellow light":* closing **waits for every already-broadcast bet to confirm** before drawing, so a bet in flight at the boundary isn't lost (`building` counts as in-flight; what bounds the wait is the reconciler eventually abandoning a bet that never confirms).
|
- *"Yellow light":* closing **waits for every already-broadcast bet to confirm** before drawing, so a bet in flight at the boundary isn't lost (`building` counts as in-flight; what bounds the wait is the reconciler eventually abandoning a bet that never confirms).
|
||||||
- *Algorithm* (deliberately simple, meant to be replaced): first block confirmed after closing — corroborated by the other servers first, and on failure the draw waits for a *further* block and writes a `draw_header_corroboration_failed` audit entry rather than stalling silently — hash as seed, `index = seed mod participant_count` over participants ordered by **broadcast timestamp** (also the tie-break when two bets land in the same block). Equal probability for everyone, regardless of amount.
|
- *Algorithm* (deliberately simple, meant to be replaced): first block confirmed after closing — corroborated by the other servers first, and on failure the draw waits for a *further* block and writes a `draw_header_corroboration_failed` audit entry rather than stalling silently — hash as seed, `index = seed mod participant_count` over participants ordered by **broadcast timestamp** (also the tie-break when two bets land in the same block). Equal probability for everyone, regardless of amount. The baseline the draw compares against (`tip_at_close`) must be a height we actually knew at closing time: a `0` there means *unknown*, not "the chain is at zero", so `_wait_for_next_block` adopts the first height it then learns as the baseline and waits for a block strictly after it (`draw_baseline_tip_unknown`, B-63) — seeding from a block that already existed while bets were open would make the winner predictable to whoever was watching the chain.
|
||||||
- *Payout* is signed with the pool key; its **fee comes out of the winner's 70%**, leaving the 30% fee share intact. Same timeout → RBF → rebroadcast pattern.
|
- *Payout* is signed with the pool key; its **fee comes out of the winner's 70%**, leaving the 30% fee share intact. Same timeout → RBF → rebroadcast pattern.
|
||||||
- *UI, two independent layers.* A generic phase box ("Pagamento al vincitore in corso…") shows to **every** viewer for the whole closing/drawing/paying_out span — pure cosmetic text driven by `status`. **Additively**, a personalized "Hai vinto!/Non hai vinto" box appears only where `user_played` is true (computed via `get_optional_user`, since the endpoint is reachable logged-out) — nobody else has anything to reveal.
|
- *UI, two independent layers.* A generic phase box ("Pagamento al vincitore in corso…") shows to **every** viewer for the whole closing/drawing/paying_out span — pure cosmetic text driven by `status`. **Additively**, a personalized "Hai vinto!/Non hai vinto" box appears only where `user_played` is true (computed via `get_optional_user`, since the endpoint is reachable logged-out) — nobody else has anything to reveal.
|
||||||
- *Reveal timing.* Delayed by at least `draw_animation_seconds`, anchored to the server's `closes_at` so a reload can't reset the countdown, and decoupled from the real (~block-time) wait for `winner_user_id`. Once revealed it's persisted in `localStorage.plm_persisted_result`, surviving the move to `closed` — at which point `get_active_round` stops returning the round and `winner_user_id` disappears from `GET /rounds/current`. `GET /users/me/last-round-result` is the durable DB-backed backstop for a device that missed the live window entirely. Full logic: `refreshRound`/`checkLastRoundResult` in `app/static/app.js`.
|
- *Reveal timing.* Delayed by at least `draw_animation_seconds`, anchored to the server's `closes_at` so a reload can't reset the countdown, and decoupled from the real (~block-time) wait for `winner_user_id`. Once revealed it's persisted in `localStorage.plm_persisted_result`, surviving the move to `closed` — at which point `get_active_round` stops returning the round and `winner_user_id` disappears from `GET /rounds/current`. `GET /users/me/last-round-result` is the durable DB-backed backstop for a device that missed the live window entirely. Full logic: `refreshRound`/`checkLastRoundResult` in `app/static/app.js`.
|
||||||
|
|
||||||
**WITHDRAW** — the only way out to an external address: PSBT user-address → external + change back to the user, fee deducted from the withdrawn amount, same RBF pattern. A full-balance withdrawal moves `balance - DUST_LIMIT_SATS` so the change output (and with it the ability to fee-bump) always exists — `Withdrawal.amount_requested_sats` vs `amount_sent_sats` is what records the difference (B-62).
|
**WITHDRAW** — the only way out to an external address: PSBT user-address → external + change back to the user, fee deducted from the withdrawn amount, same RBF pattern. A full-balance withdrawal moves `balance - DUST_LIMIT_SATS` so the change output (and with it the ability to fee-bump) always exists — `Withdrawal.amount_requested_sats` vs `amount_sent_sats` is what records the difference (B-62).
|
||||||
|
|
||||||
PLAY and WITHDRAW share a **per-user lock** (`tx/locks.py`): a bet-build and a withdrawal-build can never be in flight at once, since both spend the same UTXO set.
|
PLAY and WITHDRAW share a **per-user lock** (`tx/locks.py`): a bet-build and a withdrawal-build can never be in flight at once, since both spend the same UTXO set. That is the *only* mutual exclusion between them (B-70): a withdrawal is accepted while a bet is still unconfirmed, as long as confirmed, unspent UTXOs cover it — the lock plus `select_utxos` skipping anything already marked `spent_txid` is what prevents the two from picking the same input, so freezing the rest of the balance for a block on top of that would restrict the user without protecting anything.
|
||||||
|
|
||||||
**Three separate on-chain confirmations sit between the timer hitting zero and the payout landing** — a common point of confusion:
|
**Three separate on-chain confirmations sit between the timer hitting zero and the payout landing** — a common point of confusion:
|
||||||
1. **Last bet's confirmation** — the round doesn't even flip to `"closing"` until every broadcast bet has 1 conf (`_tick`'s `pending_count` check). May already have happened before the deadline.
|
1. **Last bet's confirmation** — the round doesn't even flip to `"closing"` until every broadcast bet has 1 conf (`_tick`'s `pending_count` check). May already have happened before the deadline.
|
||||||
@@ -208,7 +210,8 @@ Everything that spends money is written **before** it is broadcast and resolved
|
|||||||
Two static SPAs served directly by FastAPI (`main.py` mounts `app/static/` and adds routes for `/admin`, `/guida`, `/report-bug`) — no build step, no framework, no bundler, `Cache-Control: no-store`.
|
Two static SPAs served directly by FastAPI (`main.py` mounts `app/static/` and adds routes for `/admin`, `/guida`, `/report-bug`) — no build step, no framework, no bundler, `Cache-Control: no-store`.
|
||||||
|
|
||||||
- **`/`** — end-user test UI: register/login, then a navbar dashboard with four panels (Deposito with a QR from `GET /qr/{address}`, Bet, Prelievo, Profilo — account info + self-service password change via `POST /users/me/change-password`), above a persistent round-status card and the chain-status bar with the language switcher.
|
- **`/`** — end-user test UI: register/login, then a navbar dashboard with four panels (Deposito with a QR from `GET /qr/{address}`, Bet, Prelievo, Profilo — account info + self-service password change via `POST /users/me/change-password`), above a persistent round-status card and the chain-status bar with the language switcher.
|
||||||
- **`/admin`** — gated by a token screen (not a login: just `X-Admin-Token` vs `ADMIN_TOKEN`), then five sections each backed by its own `/admin/*` endpoint: Parametri (`RoundConfig` + the Manutenzione card), Utenti (list, WIF privkey export, password reset — both audit-logged), Round, Transazioni pendenti, Audit log; plus a live Electrum/tip-height pill. **Deliberately not linked from `/`** in either direction.
|
- **`/admin`** — gated by a token screen (not a login: just `X-Admin-Token` vs `ADMIN_TOKEN`), then six sections each backed by its own `/admin/*` endpoint: Parametri (`RoundConfig` + the Manutenzione card), Utenti (list, WIF privkey export, password reset — both audit-logged), Round, Transazioni pendenti, Audit log, Bug report (triage `open` → `read` → `resolved`, audit-logged `bug_report_status_changed`); plus a live Electrum/tip-height pill. **Deliberately not linked from `/`** in either direction.
|
||||||
|
- **`/report-bug`** — standalone page (no navbar, own language switcher), reachable logged-in or logged-out: `POST /bug-reports` stores the report with the submitter attached when there is one, `GET /bug-reports/mine` is the reporter-side status view for the logged-in case, and `/admin`'s Bug report section is the triage end.
|
||||||
|
|
||||||
Both talk to the same JSON API; there's no admin/user API split beyond `require_admin`.
|
Both talk to the same JSON API; there's no admin/user API split beyond `require_admin`.
|
||||||
|
|
||||||
@@ -243,9 +246,9 @@ Accepted **by design** — distinct from the audit findings above (all fixed), w
|
|||||||
- **`drawing` doesn't resume after a restart.** `_tick()` handles `open`, `closing` and `paying_out` (the last via `_retry_payout_if_due`); nothing re-enters `_wait_for_next_block` after a crash. That wait is unbounded by design (the draw's entropy genuinely depends on a future block) but no longer silent — past `_DRAW_STALL_THRESHOLD_SECONDS` it logs progress and writes a `draw_stalled` audit entry, and `GET /rounds/current`'s `draw_waiting_since` surfaces it live (B-36). Restart-resumption itself remains the last prerequisite for running unattended.
|
- **`drawing` doesn't resume after a restart.** `_tick()` handles `open`, `closing` and `paying_out` (the last via `_retry_payout_if_due`); nothing re-enters `_wait_for_next_block` after a crash. That wait is unbounded by design (the draw's entropy genuinely depends on a future block) but no longer silent — past `_DRAW_STALL_THRESHOLD_SECONDS` it logs progress and writes a `draw_stalled` audit entry, and `GET /rounds/current`'s `draw_waiting_since` surfaces it live (B-36). Restart-resumption itself remains the last prerequisite for running unattended.
|
||||||
- **RBF handles one shape only**: a single change output, back to the tx's own sender, big enough to absorb the increase. No extra-input fallback, and none would help the case that used to hurt (an amount equal to the whole input total leaves no other UTXO to add) — which is why `build_signed_transaction` now guarantees a change output of at least `DUST_LIMIT_SATS` instead (B-62): a withdrawal for the full balance moves a dust limit less, a bet from a balance equal to the bet is refused with `balance_leaves_no_change`. What's left is a bump whose *delta* exceeds an otherwise-fine change output, which still raises `RbfError`; that tx is eventually abandoned and its UTXOs released.
|
- **RBF handles one shape only**: a single change output, back to the tx's own sender, big enough to absorb the increase. No extra-input fallback, and none would help the case that used to hurt (an amount equal to the whole input total leaves no other UTXO to add) — which is why `build_signed_transaction` now guarantees a change output of at least `DUST_LIMIT_SATS` instead (B-62): a withdrawal for the full balance moves a dust limit less, a bet from a balance equal to the bet is refused with `balance_leaves_no_change`. What's left is a bump whose *delta* exceeds an otherwise-fine change output, which still raises `RbfError`; that tx is eventually abandoned and its UTXOs released.
|
||||||
- **Withdrawal and RBF bump are unit-tested but never live-broadcast** (failure and rollback branches included — still not a real network).
|
- **Withdrawal and RBF bump are unit-tested but never live-broadcast** (failure and rollback branches included — still not a real network).
|
||||||
- **No user-facing history.** `GET /users/me/last-round-result` covers exactly one case (the reveal backstop above). Admin has `/admin/rounds`, `/admin/pending-transactions`, `/admin/audit-log`; a user has no equivalent — a failed withdrawal leaves a `failed` row they can never see, which argues for closing this.
|
- **No user-facing history of rounds or transactions.** `GET /users/me/last-round-result` covers exactly one case (the reveal backstop above) and `GET /bug-reports/mine` one more (the reporter's own reports). Admin has `/admin/rounds`, `/admin/pending-transactions`, `/admin/audit-log`; a user has no equivalent — a failed withdrawal leaves a `failed` row they can never see, which argues for closing this.
|
||||||
- **Admin auth is one shared bearer token** (`ADMIN_TOKEN`) with no per-admin identity: `audit_log` records *what* changed (config edits as `config_updated`, with before/after) but never *who* did it. It gates the user list, privkey export, password resets and history, so a leak is high-blast-radius.
|
- **Admin auth is one shared bearer token** (`ADMIN_TOKEN`) with no per-admin identity: `audit_log` records *what* changed (config edits as `config_updated`, with before/after) but never *who* did it. It gates the user list, privkey export, password resets and history, so a leak is high-blast-radius.
|
||||||
- **No rate limiting on bet, withdrawal, admin or SSE.** Login has a per-username + per-IP failure throttle and registration a per-IP quota of 5 accounts/hour (`app/auth/rate_limit.py`: `RateLimiter` for failed guesses at a secret, `RollingQuota` for "how many of these may one source create" — B-33, B-58); everything else is unlimited.
|
- **No rate limiting on bet, withdrawal, admin or SSE.** Login has a per-username + per-IP failure throttle and registration a per-IP quota of 5 accounts/hour (`app/auth/rate_limit.py`: `RateLimiter` for failed guesses at a secret, `RollingQuota` for "how many of these may one source create" — B-33, B-58); everything else is unlimited.
|
||||||
- **`/guida` and `/report-bug` are placeholders** (`app/static/guida.html`, `report-bug.html`) — links work, content is "coming soon".
|
- **`/guida` is a placeholder** (`app/static/guida.html`) — the link works, the content is "coming soon". `/report-bug` is *not*: it is fully implemented and translated, with admin triage (see Frontends).
|
||||||
- **No integration tests against a live Electrum connection.** `tests/integration/` is empty; live verification has all been manual (`scripts/electrum_smoke_test.py`, ad hoc scripts, real mainnet txs).
|
- **No integration tests against a live Electrum connection.** `tests/integration/` is empty; live verification has all been manual (`scripts/electrum_smoke_test.py`, ad hoc scripts, real mainnet txs).
|
||||||
- **Single-process assumptions**: the SSE broadcaster and the per-user locks are in-process only. A multi-worker deployment needs a shared channel and a DB/Redis lock. The round-uniqueness invariant is *not* in this category — it's a DB index.
|
- **Single-process assumptions**: the SSE broadcaster and the per-user locks are in-process only. A multi-worker deployment needs a shared channel and a DB/Redis lock. The round-uniqueness invariant is *not* in this category — it's a DB index.
|
||||||
@@ -41,9 +41,9 @@ domain).
|
|||||||
## Documentation
|
## Documentation
|
||||||
|
|
||||||
- [CLAUDE.md](CLAUDE.md) — architecture, commands, domain decisions, known gaps (for anyone/anything working on the code)
|
- [CLAUDE.md](CLAUDE.md) — architecture, commands, domain decisions, known gaps (for anyone/anything working on the code)
|
||||||
- [flowchart.mmd](flowchart.mmd) — the source-of-truth flow diagram the implementation follows node-by-node
|
- [flowchart/](flowchart/) — the source-of-truth flow diagrams the implementation follows node-by-node: [platform-overview.mmd](flowchart/platform-overview.mmd) (the 5-phase flow) and [round-lifecycle.mmd](flowchart/round-lifecycle.mmd) (the round/draw lifecycle)
|
||||||
- [docs/setup.md](docs/setup.md) — one-time setup (secrets, master key, migrations)
|
- [docs/setup.md](docs/setup.md) — one-time setup (secrets, master key, migrations)
|
||||||
- [docs/running-the-server.md](docs/running-the-server.md) — how to launch it (local venv vs. Docker+Caddy, dev vs. production TLS)
|
- [docs/running-the-server.md](docs/running-the-server.md) — how to launch it with Docker+Caddy (dev vs. production TLS)
|
||||||
- [docs/guida-utente.md](docs/guida-utente.md) — end-user guide to the test UI (Italian)
|
- [docs/guida-utente.md](docs/guida-utente.md) — end-user guide to the test UI (Italian)
|
||||||
- [docs/guida-admin.md](docs/guida-admin.md) — admin dashboard guide (Italian)
|
- [docs/guida-admin.md](docs/guida-admin.md) — admin dashboard guide (Italian)
|
||||||
|
|
||||||
@@ -51,7 +51,7 @@ domain).
|
|||||||
|
|
||||||
Python (FastAPI, SQLAlchemy async + Alembic, Argon2 + JWT auth), Electrum
|
Python (FastAPI, SQLAlchemy async + Alembic, Argon2 + JWT auth), Electrum
|
||||||
protocol for PLM network access (no full node), Docker + Caddy for
|
protocol for PLM network access (no full node), Docker + Caddy for
|
||||||
deployment. See [CLAUDE.md](CLAUDE.md#tech-stack-mvp) for the complete list
|
deployment. See [CLAUDE.md](CLAUDE.md#tech-stack) for the complete list
|
||||||
and the reasoning behind each choice.
|
and the reasoning behind each choice.
|
||||||
|
|
||||||
## Testing
|
## Testing
|
||||||
@@ -61,7 +61,7 @@ python -m pytest # all tests
|
|||||||
python -m pytest tests/unit/test_hd.py # one file
|
python -m pytest tests/unit/test_hd.py # one file
|
||||||
```
|
```
|
||||||
|
|
||||||
232 unit tests cover HD derivation, PSBT building, the Electrum client, bets,
|
351 unit tests cover HD derivation, PSBT building, the Electrum client, bets,
|
||||||
deposits, withdrawals, the round/draw engine, RBF fee-bumping, admin config,
|
deposits, withdrawals, the round/draw engine, RBF fee-bumping, admin config,
|
||||||
the pending-inclusive balance calculation, and the SSE push channel. No
|
the pending-inclusive balance calculation, and the SSE push channel. No
|
||||||
automated integration tests against a live Electrum connection — mainnet
|
automated integration tests against a live Electrum connection — mainnet
|
||||||
|
|||||||
+46
-10
@@ -1,22 +1,58 @@
|
|||||||
|
"""PNG QR codes for PLM addresses.
|
||||||
|
|
||||||
|
Deliberately unauthenticated: the dashboard renders it with a plain `<img>`
|
||||||
|
tag, which cannot carry the bearer token, and the payload is an address the
|
||||||
|
caller already has. What the endpoint must not be is a free CPU amplifier
|
||||||
|
(B-67), so two things bound the work an anonymous caller can ask for:
|
||||||
|
|
||||||
|
- the address is validated for real (bech32 checksum + PLM HRP) via
|
||||||
|
`is_valid_plm_address`, the same check withdrawals and the admin
|
||||||
|
`fee_address` validator use, instead of a shape-only regex that happily
|
||||||
|
rendered a QR for any `plm1`-prefixed junk string;
|
||||||
|
- the render itself is memoized per address and pushed off the event loop, so
|
||||||
|
a repeat request costs a dict lookup and a first one never blocks the
|
||||||
|
scheduler, the listener or any other request.
|
||||||
|
"""
|
||||||
|
|
||||||
import io
|
import io
|
||||||
import re
|
from functools import lru_cache
|
||||||
|
|
||||||
import qrcode
|
import qrcode
|
||||||
from fastapi import APIRouter, HTTPException, status
|
from fastapi import APIRouter
|
||||||
|
from fastapi.concurrency import run_in_threadpool
|
||||||
from fastapi.responses import Response
|
from fastapi.responses import Response
|
||||||
|
|
||||||
|
from app.api.errors import http_error
|
||||||
|
from app.wallet.address import is_valid_plm_address
|
||||||
|
|
||||||
router = APIRouter(tags=["qr"])
|
router = APIRouter(tags=["qr"])
|
||||||
|
|
||||||
# PLM P2WPKH addresses: bech32 HRP "plm" + separator + witness program.
|
# Long enough for any bech32 address, short enough that a multi-kilobyte path
|
||||||
_ADDRESS_RE = re.compile(r"^plm1[a-z0-9]{10,90}$")
|
# is rejected before embit ever looks at it.
|
||||||
|
_MAX_ADDRESS_LENGTH = 100
|
||||||
|
|
||||||
|
# Bounded on purpose: valid addresses are cheap to generate, so an unbounded
|
||||||
|
# cache would just move the amplification from CPU to memory.
|
||||||
|
_CACHE_SIZE = 512
|
||||||
|
|
||||||
|
|
||||||
|
@lru_cache(maxsize=_CACHE_SIZE)
|
||||||
|
def _render_png(address: str) -> bytes:
|
||||||
|
image = qrcode.make(address)
|
||||||
|
buf = io.BytesIO()
|
||||||
|
image.save(buf, format="PNG")
|
||||||
|
return buf.getvalue()
|
||||||
|
|
||||||
|
|
||||||
@router.get("/qr/{address}")
|
@router.get("/qr/{address}")
|
||||||
async def address_qr(address: str) -> Response:
|
async def address_qr(address: str) -> Response:
|
||||||
if not _ADDRESS_RE.match(address):
|
if len(address) > _MAX_ADDRESS_LENGTH or not is_valid_plm_address(address):
|
||||||
raise HTTPException(status.HTTP_400_BAD_REQUEST, "invalid address")
|
raise http_error(400, "invalid_address", "not a valid PLM bech32 address")
|
||||||
|
|
||||||
image = qrcode.make(address)
|
png = await run_in_threadpool(_render_png, address)
|
||||||
buf = io.BytesIO()
|
# An address' QR never changes; let the browser stop asking for it.
|
||||||
image.save(buf, format="PNG")
|
return Response(
|
||||||
return Response(content=buf.getvalue(), media_type="image/png")
|
content=png,
|
||||||
|
media_type="image/png",
|
||||||
|
headers={"Cache-Control": "private, max-age=86400, immutable"},
|
||||||
|
)
|
||||||
@@ -15,7 +15,7 @@ from app.db.models import RoundParticipant, User
|
|||||||
from app.db.session import get_session
|
from app.db.session import get_session
|
||||||
from app.rounds.config import get_round_config
|
from app.rounds.config import get_round_config
|
||||||
from app.rounds.events import EVICTED, RoundEventCapacityError, broadcaster
|
from app.rounds.events import EVICTED, RoundEventCapacityError, broadcaster
|
||||||
from app.rounds.service import get_active_round, round_deadline, winner_share
|
from app.rounds.service import get_active_round, round_deadline, rounds_can_open, winner_share
|
||||||
|
|
||||||
router = APIRouter(prefix="/rounds", tags=["rounds"])
|
router = APIRouter(prefix="/rounds", tags=["rounds"])
|
||||||
|
|
||||||
@@ -91,9 +91,21 @@ class CurrentRoundResponse(BaseModel):
|
|||||||
status: str | None = None
|
status: str | None = None
|
||||||
opened_at: str | None = None
|
opened_at: str | None = None
|
||||||
closes_at: str | None = None
|
closes_at: str | None = None
|
||||||
|
# B-65: confirmed participants only — the ones the draw actually picks from and
|
||||||
|
# whose sats are actually in the pool. The pending_* pair below is the same
|
||||||
|
# confirmed/in-flight split the balance already exposes (see
|
||||||
|
# wallet/balance.py's balance_sats vs pending_balance_sats), and for the same
|
||||||
|
# reason: the authoritative number must be the one that will be paid, while the
|
||||||
|
# player who just bet still needs to see their own bet somewhere.
|
||||||
participant_count: int = 0
|
participant_count: int = 0
|
||||||
bet_amount_sats: int
|
bet_amount_sats: int
|
||||||
jackpot_sats: int = 0
|
jackpot_sats: int = 0
|
||||||
|
# Inclusive of bets still building/broadcast, exactly like pending_balance_sats
|
||||||
|
# is inclusive of unconfirmed change — not deltas. Equal to the confirmed
|
||||||
|
# figures above when nothing is in flight, which is what has_pending_bets says.
|
||||||
|
pending_participant_count: int = 0
|
||||||
|
pending_jackpot_sats: int = 0
|
||||||
|
has_pending_bets: bool = False
|
||||||
draw_animation_seconds: int
|
draw_animation_seconds: int
|
||||||
winner_user_id: int | None = None
|
winner_user_id: int | None = None
|
||||||
winner_amount_sats: int | None = None
|
winner_amount_sats: int | None = None
|
||||||
@@ -105,6 +117,12 @@ class CurrentRoundResponse(BaseModel):
|
|||||||
draw_waiting_since: str | None = None
|
draw_waiting_since: str | None = None
|
||||||
chain_tip_height: int | None = None
|
chain_tip_height: int | None = None
|
||||||
lottery_paused: bool = False
|
lottery_paused: bool = False
|
||||||
|
# B-66: false while the instance is missing configuration a round cannot run
|
||||||
|
# without (today: fee_address) — no round will open until it's set, so this is
|
||||||
|
# the difference between "wait, the next round is coming" and "nothing is coming
|
||||||
|
# until the operator finishes setting this up". Distinct from lottery_paused,
|
||||||
|
# which is a deliberate operator action rather than an unmet prerequisite.
|
||||||
|
lottery_configured: bool = True
|
||||||
user_played: bool = False
|
user_played: bool = False
|
||||||
|
|
||||||
|
|
||||||
@@ -126,21 +144,35 @@ async def current_round(
|
|||||||
draw_animation_seconds=config.draw_animation_seconds,
|
draw_animation_seconds=config.draw_animation_seconds,
|
||||||
chain_tip_height=chain_tip_height,
|
chain_tip_height=chain_tip_height,
|
||||||
lottery_paused=config.paused,
|
lottery_paused=config.paused,
|
||||||
|
lottery_configured=rounds_can_open(config),
|
||||||
)
|
)
|
||||||
|
|
||||||
participant_count = await session.scalar(
|
|
||||||
select(func.count()).select_from(RoundParticipant).where(RoundParticipant.round_id == round_.id)
|
|
||||||
) or 0
|
|
||||||
# The pool is the sum of what the participants' bets actually paid into the pool
|
# The pool is the sum of what the participants' bets actually paid into the pool
|
||||||
# address — each one is already net of that bet's network fee. Deriving it from
|
# address — each one is already net of that bet's network fee. Deriving it from
|
||||||
# participant_count * the *current* bet_amount_sats instead overstated it, and
|
# participant_count * the *current* bet_amount_sats instead overstated it, and
|
||||||
# silently changed the advertised jackpot of a round in progress whenever an
|
# silently changed the advertised jackpot of a round in progress whenever an
|
||||||
# operator edited the bet amount (B-11).
|
# operator edited the bet amount (B-11).
|
||||||
pool_amount_sats = await session.scalar(
|
#
|
||||||
select(func.coalesce(func.sum(RoundParticipant.bet_amount_sats), 0)).where(
|
# Split confirmed from in-flight (B-65): the draw only picks from confirmed
|
||||||
RoundParticipant.round_id == round_.id
|
# participants and the payout only spends their sats, so counting every row
|
||||||
|
# advertised a jackpot larger than the one that would be paid, and made a
|
||||||
|
# participant appear and then vanish again if their bet was later abandoned.
|
||||||
|
counts = (
|
||||||
|
await session.execute(
|
||||||
|
select(
|
||||||
|
func.count(),
|
||||||
|
func.coalesce(func.sum(RoundParticipant.bet_amount_sats), 0),
|
||||||
|
func.count().filter(RoundParticipant.status == "confirmed"),
|
||||||
|
func.coalesce(
|
||||||
|
func.sum(RoundParticipant.bet_amount_sats).filter(
|
||||||
|
RoundParticipant.status == "confirmed"
|
||||||
|
),
|
||||||
|
0,
|
||||||
|
),
|
||||||
|
).where(RoundParticipant.round_id == round_.id)
|
||||||
)
|
)
|
||||||
) or 0
|
).one()
|
||||||
|
all_count, all_pool_sats, participant_count, pool_amount_sats = counts
|
||||||
opened_at = round_.opened_at.replace(tzinfo=timezone.utc)
|
opened_at = round_.opened_at.replace(tzinfo=timezone.utc)
|
||||||
# B-61: from the round's own duration — the countdown clients are watching must
|
# B-61: from the round's own duration — the countdown clients are watching must
|
||||||
# not jump because an operator edited the config mid-round.
|
# not jump because an operator edited the config mid-round.
|
||||||
@@ -178,6 +210,9 @@ async def current_round(
|
|||||||
participant_count=participant_count,
|
participant_count=participant_count,
|
||||||
bet_amount_sats=config.bet_amount_sats,
|
bet_amount_sats=config.bet_amount_sats,
|
||||||
jackpot_sats=jackpot_sats,
|
jackpot_sats=jackpot_sats,
|
||||||
|
pending_participant_count=all_count,
|
||||||
|
pending_jackpot_sats=winner_share(all_pool_sats),
|
||||||
|
has_pending_bets=all_count > participant_count,
|
||||||
draw_animation_seconds=config.draw_animation_seconds,
|
draw_animation_seconds=config.draw_animation_seconds,
|
||||||
winner_user_id=round_.winner_user_id,
|
winner_user_id=round_.winner_user_id,
|
||||||
winner_amount_sats=round_.winner_amount_sats,
|
winner_amount_sats=round_.winner_amount_sats,
|
||||||
@@ -186,5 +221,6 @@ async def current_round(
|
|||||||
draw_waiting_since=isoformat_utc(round_.drawing_started_at) if round_.status == "drawing" else None,
|
draw_waiting_since=isoformat_utc(round_.drawing_started_at) if round_.status == "drawing" else None,
|
||||||
chain_tip_height=chain_tip_height,
|
chain_tip_height=chain_tip_height,
|
||||||
lottery_paused=config.paused,
|
lottery_paused=config.paused,
|
||||||
|
lottery_configured=rounds_can_open(config),
|
||||||
user_played=user_played,
|
user_played=user_played,
|
||||||
)
|
)
|
||||||
+3
-2
@@ -6,8 +6,9 @@ from app.config import settings
|
|||||||
|
|
||||||
# How long a writer waits for a lock held by another writer before SQLite raises
|
# How long a writer waits for a lock held by another writer before SQLite raises
|
||||||
# "database is locked" (B-39). A few seconds is enough to ride out this app's own
|
# "database is locked" (B-39). A few seconds is enough to ride out this app's own
|
||||||
# five concurrent background tasks (scheduler, confirmation poller, RBF bumper,
|
# six concurrent background tasks (Electrum listener, scheduler, confirmation
|
||||||
# two reconcilers) plus HTTP handlers briefly overlapping a write.
|
# poller, RBF bumper, two reconcilers) plus HTTP handlers briefly overlapping a
|
||||||
|
# write.
|
||||||
_SQLITE_BUSY_TIMEOUT_MS = 5000
|
_SQLITE_BUSY_TIMEOUT_MS = 5000
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
+69
-14
@@ -160,12 +160,31 @@ class ElectrumListener:
|
|||||||
reset its backoff), False if it never got that far."""
|
reset its backoff), False if it never got that far."""
|
||||||
client = self._client_factory(endpoint)
|
client = self._client_factory(endpoint)
|
||||||
await client.connect()
|
await client.connect()
|
||||||
self.client = client
|
|
||||||
logger.info("Electrum connected to %s", endpoint)
|
logger.info("Electrum connected to %s", endpoint)
|
||||||
|
|
||||||
try:
|
try:
|
||||||
header = await client.subscribe_headers()
|
header = await client.subscribe_headers()
|
||||||
self._apply_header(header)
|
self._apply_header(header)
|
||||||
|
if self.tip_header_hex is None:
|
||||||
|
# B-64: the header was unusable (no hex) and we have never had a tip,
|
||||||
|
# so publishing this client would hand every consumer a connection
|
||||||
|
# whose chain position is unknown — B-63 all over again. A server at
|
||||||
|
# or behind a tip we already know is fine and doesn't come through
|
||||||
|
# here: the point is only that *some* tip is established.
|
||||||
|
raise HeaderValidationError(
|
||||||
|
f"{endpoint} announced an unusable initial header ({header!r}) and no tip is known"
|
||||||
|
)
|
||||||
|
# B-63: published only now, never before the first header has been
|
||||||
|
# applied. `self.client is not None` is what every consumer treats as
|
||||||
|
# "the chain is reachable" — including RoundScheduler._tick, which then
|
||||||
|
# reads tip_height as the baseline a draw must find a *later* block than.
|
||||||
|
# Assigning it before this round-trip left a window where the connection
|
||||||
|
# looked alive while tip_height was still 0, so a round closing inside it
|
||||||
|
# recorded a baseline of 0 and the very first header we learned — the
|
||||||
|
# current tip, a block mined *before* the round closed, with a hash
|
||||||
|
# already public while bets were still open — satisfied
|
||||||
|
# `tip_height > tip_at_close` and seeded the draw.
|
||||||
|
self.client = client
|
||||||
|
|
||||||
headers_queue = client.notifications("blockchain.headers.subscribe")
|
headers_queue = client.notifications("blockchain.headers.subscribe")
|
||||||
scripthash_queue = client.notifications("blockchain.scripthash.subscribe")
|
scripthash_queue = client.notifications("blockchain.scripthash.subscribe")
|
||||||
@@ -250,7 +269,7 @@ class ElectrumListener:
|
|||||||
await self.refresh_user(user_id, scripthash)
|
await self.refresh_user(user_id, scripthash)
|
||||||
|
|
||||||
def _apply_header(self, header: dict) -> None:
|
def _apply_header(self, header: dict) -> None:
|
||||||
"""Record a new chain tip, refusing to move backwards.
|
"""Record a new chain tip, refusing to move backwards or sideways.
|
||||||
|
|
||||||
Full reorg handling is out of scope for v1 by explicit design decision, but
|
Full reorg handling is out of scope for v1 by explicit design decision, but
|
||||||
the tip must never regress: `_wait_for_next_block` waits for
|
the tip must never regress: `_wait_for_next_block` waits for
|
||||||
@@ -268,9 +287,29 @@ class ElectrumListener:
|
|||||||
silently ignoring the header, which (via _consume_headers/_run_once) ends
|
silently ignoring the header, which (via _consume_headers/_run_once) ends
|
||||||
this session the same way a dropped connection would, so run() rotates to
|
this session the same way a dropped connection would, so run() rotates to
|
||||||
the next configured server instead of continuing to trust this one.
|
the next configured server instead of continuing to trust this one.
|
||||||
|
|
||||||
|
Two more headers are refused without ending the session, since neither is
|
||||||
|
evidence of a hostile server the way the above are (B-64): one carrying no
|
||||||
|
hex, and one at the height we already hold a header for.
|
||||||
"""
|
"""
|
||||||
height = header["height"]
|
height = header["height"]
|
||||||
header_hex = header.get("hex")
|
header_hex = header.get("hex")
|
||||||
|
|
||||||
|
if not header_hex:
|
||||||
|
# Nothing to validate and nothing to draw from — and applying the height
|
||||||
|
# alone would break exactly the pairing this function exists to keep:
|
||||||
|
# tip_height would describe a block tip_header_hex doesn't (and on a
|
||||||
|
# session's first header, would publish a client whose tip is unknown,
|
||||||
|
# which is B-63). Ignored rather than fatal: a server that only ever
|
||||||
|
# pushed heights would freeze the draw — visibly, via B-36's
|
||||||
|
# draw_stalled — instead of costing us the one connection that also
|
||||||
|
# credits deposits and broadcasts transactions. _run_once separately
|
||||||
|
# refuses to publish a client while the tip is still unknown.
|
||||||
|
logger.warning(
|
||||||
|
"ignoring Electrum header at height %s: no header hex to validate or to draw from", height
|
||||||
|
)
|
||||||
|
return
|
||||||
|
|
||||||
if height < self.tip_height:
|
if height < self.tip_height:
|
||||||
logger.warning(
|
logger.warning(
|
||||||
"ignoring Electrum header at height %s, below the current tip %s (reorg or server switch?)",
|
"ignoring Electrum header at height %s, below the current tip %s (reorg or server switch?)",
|
||||||
@@ -279,19 +318,35 @@ class ElectrumListener:
|
|||||||
)
|
)
|
||||||
return
|
return
|
||||||
|
|
||||||
if header_hex:
|
if height == self.tip_height and self.tip_header_hex:
|
||||||
if not header_meets_its_own_target(header_hex):
|
# B-64: a second header for the height we already hold one for. Either the
|
||||||
raise HeaderValidationError(
|
# same block re-announced (nothing to do) or a competing one — a reorg at
|
||||||
f"header at height {height} does not satisfy its own claimed difficulty target"
|
# the tip, or a server swapping out the very hash a draw may be about to
|
||||||
)
|
# use. The linkage check above cannot speak to this case at all, since
|
||||||
if (
|
# there is no height advance to check. Whichever it is, the hash committed
|
||||||
self.tip_header_hex
|
# to for a height is not replaced under us: if ours turns out to be the
|
||||||
and height == self.tip_height + 1
|
# orphan, corroborate_header (B-28) refuses to seed a draw from it and the
|
||||||
and header_prev_hash(header_hex) != header_hex_to_block_hash(self.tip_header_hex)
|
# draw waits for a further block instead.
|
||||||
):
|
if header_hex != self.tip_header_hex:
|
||||||
raise HeaderValidationError(
|
logger.warning(
|
||||||
f"header at height {height} does not chain from the current tip (height {self.tip_height})"
|
"ignoring a competing header at the current tip height %s "
|
||||||
|
"(reorg at the tip, or a server disagreeing with the rest)",
|
||||||
|
height,
|
||||||
)
|
)
|
||||||
|
return
|
||||||
|
|
||||||
|
if not header_meets_its_own_target(header_hex):
|
||||||
|
raise HeaderValidationError(
|
||||||
|
f"header at height {height} does not satisfy its own claimed difficulty target"
|
||||||
|
)
|
||||||
|
if (
|
||||||
|
self.tip_header_hex
|
||||||
|
and height == self.tip_height + 1
|
||||||
|
and header_prev_hash(header_hex) != header_hex_to_block_hash(self.tip_header_hex)
|
||||||
|
):
|
||||||
|
raise HeaderValidationError(
|
||||||
|
f"header at height {height} does not chain from the current tip (height {self.tip_height})"
|
||||||
|
)
|
||||||
|
|
||||||
self.tip_height = height
|
self.tip_height = height
|
||||||
self.tip_header_hex = header_hex
|
self.tip_header_hex = header_hex
|
||||||
|
|||||||
@@ -224,9 +224,22 @@ class RoundScheduler:
|
|||||||
draw_stalled audit entry is written (and re-written every threshold
|
draw_stalled audit entry is written (and re-written every threshold
|
||||||
interval for as long as the stall continues) so the wait shows up next
|
interval for as long as the stall continues) so the wait shows up next
|
||||||
to the draw_header_corroboration_failed entries above.
|
to the draw_header_corroboration_failed entries above.
|
||||||
|
|
||||||
|
B-63: `tip_at_close` of 0 means the tip was *unknown* when the round closed,
|
||||||
|
not that the chain was at height zero — and "the first block we hear about"
|
||||||
|
is then not necessarily a block mined after the close. Rather than seed the
|
||||||
|
draw from a hash that may already have been public while bets were open, the
|
||||||
|
first height we do learn becomes the baseline and this waits for a block
|
||||||
|
strictly after it. Since the Electrum listener now only publishes its client
|
||||||
|
once a header has been applied, and _tick won't run without one, this should
|
||||||
|
be unreachable — it stays as the local statement of what the draw actually
|
||||||
|
requires, since nothing else in this function would notice if that stopped
|
||||||
|
holding.
|
||||||
"""
|
"""
|
||||||
next_progress_log_at = waiting_since + timedelta(seconds=_DRAW_PROGRESS_LOG_INTERVAL_SECONDS)
|
next_progress_log_at = waiting_since + timedelta(seconds=_DRAW_PROGRESS_LOG_INTERVAL_SECONDS)
|
||||||
next_stall_audit_at = waiting_since + timedelta(seconds=_DRAW_STALL_THRESHOLD_SECONDS)
|
next_stall_audit_at = waiting_since + timedelta(seconds=_DRAW_STALL_THRESHOLD_SECONDS)
|
||||||
|
if tip_at_close <= 0:
|
||||||
|
tip_at_close = await self._adopt_baseline_tip(round_id)
|
||||||
while True:
|
while True:
|
||||||
while self._listener.tip_height <= tip_at_close or not self._listener.tip_header_hex:
|
while self._listener.tip_height <= tip_at_close or not self._listener.tip_header_hex:
|
||||||
now = datetime.now(timezone.utc)
|
now = datetime.now(timezone.utc)
|
||||||
@@ -274,6 +287,33 @@ class RoundScheduler:
|
|||||||
await session.commit()
|
await session.commit()
|
||||||
tip_at_close = height
|
tip_at_close = height
|
||||||
|
|
||||||
|
async def _adopt_baseline_tip(self, round_id: int) -> int:
|
||||||
|
"""B-63: the height the draw must find a *later* block than, for the case
|
||||||
|
where the tip wasn't known at closing time. Waits for a header to arrive and
|
||||||
|
takes that height as the baseline — the block it describes may predate the
|
||||||
|
close, which is exactly why it is used as the floor rather than as the seed —
|
||||||
|
and records why, since a draw that waits one extra block should be explainable
|
||||||
|
from /admin rather than looking like a stall.
|
||||||
|
"""
|
||||||
|
while not self._listener.tip_header_hex or self._listener.tip_height <= 0:
|
||||||
|
await asyncio.sleep(_TICK_INTERVAL_SECONDS)
|
||||||
|
height = self._listener.tip_height
|
||||||
|
logger.warning(
|
||||||
|
"round %s: chain tip was unknown at closing time; using height %s as the draw baseline "
|
||||||
|
"and waiting for a further block",
|
||||||
|
round_id,
|
||||||
|
height,
|
||||||
|
)
|
||||||
|
async with self._session_factory() as session:
|
||||||
|
await write_audit_log(
|
||||||
|
session,
|
||||||
|
"draw_baseline_tip_unknown",
|
||||||
|
{"baseline_height": height},
|
||||||
|
round_id=round_id,
|
||||||
|
)
|
||||||
|
await session.commit()
|
||||||
|
return height
|
||||||
|
|
||||||
async def _retry_payout_if_due(self, round_id: int) -> None:
|
async def _retry_payout_if_due(self, round_id: int) -> None:
|
||||||
"""B-26: whether a "paying_out" round is due for another payout attempt.
|
"""B-26: whether a "paying_out" round is due for another payout attempt.
|
||||||
|
|
||||||
|
|||||||
+31
-5
@@ -5,7 +5,7 @@ from sqlalchemy import select
|
|||||||
from sqlalchemy.exc import IntegrityError
|
from sqlalchemy.exc import IntegrityError
|
||||||
from sqlalchemy.ext.asyncio import AsyncSession
|
from sqlalchemy.ext.asyncio import AsyncSession
|
||||||
|
|
||||||
from app.db.models import Round
|
from app.db.models import Round, RoundConfig
|
||||||
from app.rounds.config import get_round_config
|
from app.rounds.config import get_round_config
|
||||||
from app.rounds.events import broadcaster
|
from app.rounds.events import broadcaster
|
||||||
|
|
||||||
@@ -68,13 +68,29 @@ def round_accepts_bets(round_: Round) -> bool:
|
|||||||
return datetime.now(timezone.utc) < round_deadline(round_)
|
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:
|
async def open_new_round_if_needed(session: AsyncSession) -> Round | None:
|
||||||
"""Returns the active round if one exists (whatever its status). Otherwise
|
"""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)
|
opens a fresh one, unless the last closed round's cooldown (ROUND_COOLDOWN_SECONDS)
|
||||||
hasn't elapsed yet, or the lottery is paused for maintenance — in either case
|
hasn't elapsed yet, the lottery is paused for maintenance, or the instance isn't
|
||||||
returns None. Callers that need to attach a bet must additionally check the
|
configured well enough to pay a winner — in any of those cases returns None.
|
||||||
returned round's status == "open" — a round in closing/drawing/paying_out
|
Callers that need to attach a bet must additionally check the returned round's
|
||||||
isn't accepting new bets, but a new round can't open until it's done.
|
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
|
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
|
the *next* one, so the current round still closes, draws, and pays out the
|
||||||
@@ -86,6 +102,16 @@ async def open_new_round_if_needed(session: AsyncSession) -> Round | None:
|
|||||||
config = await get_round_config(session)
|
config = await get_round_config(session)
|
||||||
if config.paused:
|
if config.paused:
|
||||||
return None
|
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()))
|
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:
|
if last_closed is not None and last_closed.closed_at is not None:
|
||||||
|
|||||||
@@ -62,6 +62,13 @@
|
|||||||
</div>
|
</div>
|
||||||
|
|
||||||
<div class="card">
|
<div class="card">
|
||||||
|
<!-- B-66: no fee_address means no round can open at all (the payout pays the
|
||||||
|
30% commission to it, so it cannot even be built). Shown here because
|
||||||
|
this is the one screen that can fix it. -->
|
||||||
|
<div class="warning-banner hidden" id="admin-fee-address-warning">
|
||||||
|
⚠️ Nessun fee address configurato: finché resta vuoto <strong>non si aprirà nessun round</strong>
|
||||||
|
(il payout non sarebbe costruibile). Impostalo qui sotto e salva.
|
||||||
|
</div>
|
||||||
<div class="grid-2">
|
<div class="grid-2">
|
||||||
<div>
|
<div>
|
||||||
<label for="admin-fee-address">Fee address (dove finisce il 30% di ogni round)</label>
|
<label for="admin-fee-address">Fee address (dove finisce il 30% di ogni round)</label>
|
||||||
|
|||||||
@@ -141,6 +141,11 @@ async function adminLoadConfig() {
|
|||||||
try {
|
try {
|
||||||
const data = await callAdmin('GET', '/admin/config');
|
const data = await callAdmin('GET', '/admin/config');
|
||||||
document.getElementById('admin-fee-address').value = data.fee_address;
|
document.getElementById('admin-fee-address').value = data.fee_address;
|
||||||
|
// B-66: an empty fee address blocks every future round, so say so here rather
|
||||||
|
// than leaving an empty field to be noticed.
|
||||||
|
document
|
||||||
|
.getElementById('admin-fee-address-warning')
|
||||||
|
.classList.toggle('hidden', !!(data.fee_address || '').trim());
|
||||||
document.getElementById('admin-bet-amount').value = data.bet_amount_sats / SATS_PER_PLM;
|
document.getElementById('admin-bet-amount').value = data.bet_amount_sats / SATS_PER_PLM;
|
||||||
document.getElementById('admin-round-duration').value = data.round_duration_seconds;
|
document.getElementById('admin-round-duration').value = data.round_duration_seconds;
|
||||||
document.getElementById('admin-round-cooldown').value = data.round_cooldown_seconds;
|
document.getElementById('admin-round-cooldown').value = data.round_cooldown_seconds;
|
||||||
|
|||||||
+60
-11
@@ -235,7 +235,18 @@ function renderChainStatusBar() {
|
|||||||
label.textContent = t(CHAIN_STATUS_KEYS[labelKey]);
|
label.textContent = t(CHAIN_STATUS_KEYS[labelKey]);
|
||||||
block.textContent = t('chain.block', { n: data.chain_tip_height != null ? '#' + data.chain_tip_height : '—' });
|
block.textContent = t('chain.block', { n: data.chain_tip_height != null ? '#' + data.chain_tip_height : '—' });
|
||||||
|
|
||||||
document.getElementById('maintenance-banner').classList.toggle('hidden', !data.lottery_paused);
|
// Two separate reasons no round will open, and telling them apart matters to the
|
||||||
|
// reader: a pause ends when the operator resumes, while an unconfigured instance
|
||||||
|
// (B-66) won't produce a round at all until it's set up — "come back later" would
|
||||||
|
// be a lie. `=== false` so an older server that doesn't send the field at all
|
||||||
|
// can't flash the banner. A pause takes precedence: it's the deliberate action.
|
||||||
|
const notConfigured = data.lottery_configured === false;
|
||||||
|
const noRoundsComing = !!data.lottery_paused || notConfigured;
|
||||||
|
document.getElementById('maintenance-banner').classList.toggle('hidden', !noRoundsComing);
|
||||||
|
if (noRoundsComing) {
|
||||||
|
document.getElementById('maintenance-banner-text').textContent =
|
||||||
|
data.lottery_paused ? t('maintenance.banner') : t('maintenance.notConfigured');
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// After a couple of consecutive failed polls (network blip, server restart,
|
// After a couple of consecutive failed polls (network blip, server restart,
|
||||||
@@ -368,6 +379,49 @@ async function checkLastRoundResult() {
|
|||||||
|
|
||||||
let lastJackpotValue = null;
|
let lastJackpotValue = null;
|
||||||
|
|
||||||
|
// The round's own confirmed/in-flight split (B-65). The big numbers are the
|
||||||
|
// confirmed ones — the players the draw will pick from and the pool the payout
|
||||||
|
// will actually spend — because a jackpot advertised larger than the one paid out
|
||||||
|
// is the kind of gap nobody forgives. What has been bet but hasn't confirmed yet
|
||||||
|
// is shown next to them instead of being folded in, so the player who just bet
|
||||||
|
// still sees their own bet immediately (the same reasoning as the amber
|
||||||
|
// pending balance, see setBalanceDisplay).
|
||||||
|
//
|
||||||
|
// Kept out of the [data-i18n] mechanism on purpose: these come from server data,
|
||||||
|
// so onLanguageChange() re-renders them through t() like every other dynamic bit.
|
||||||
|
let lastRoundStats = null;
|
||||||
|
|
||||||
|
function renderRoundStats(data) {
|
||||||
|
lastRoundStats = data;
|
||||||
|
document.getElementById('round-players').textContent = data.participant_count;
|
||||||
|
|
||||||
|
const jackpotEl = document.getElementById('round-jackpot');
|
||||||
|
const jackpotValue = data.jackpot_sats / SATS_PER_PLM;
|
||||||
|
jackpotEl.textContent = formatPlm(data.jackpot_sats);
|
||||||
|
if (lastJackpotValue !== null && jackpotValue !== lastJackpotValue) {
|
||||||
|
jackpotEl.classList.remove('jackpot-bump');
|
||||||
|
void jackpotEl.offsetWidth; // restart the animation
|
||||||
|
jackpotEl.classList.add('jackpot-bump');
|
||||||
|
}
|
||||||
|
lastJackpotValue = jackpotValue;
|
||||||
|
|
||||||
|
// pending_* are inclusive of the confirmed figures (like pending_balance_sats),
|
||||||
|
// so what's shown alongside is the difference.
|
||||||
|
const pendingPlayers = (data.pending_participant_count || 0) - data.participant_count;
|
||||||
|
const pendingJackpotSats = (data.pending_jackpot_sats || 0) - data.jackpot_sats;
|
||||||
|
const show = !!data.has_pending_bets && pendingPlayers > 0;
|
||||||
|
|
||||||
|
const playersPendingEl = document.getElementById('round-players-pending');
|
||||||
|
playersPendingEl.textContent = show ? t('round.playersPending', { n: pendingPlayers }) : '';
|
||||||
|
playersPendingEl.classList.toggle('hidden', !show);
|
||||||
|
|
||||||
|
const jackpotPendingEl = document.getElementById('round-jackpot-pending');
|
||||||
|
jackpotPendingEl.textContent = show
|
||||||
|
? t('round.jackpotPending', { amount: formatPlm(pendingJackpotSats) })
|
||||||
|
: '';
|
||||||
|
jackpotPendingEl.classList.toggle('hidden', !show);
|
||||||
|
}
|
||||||
|
|
||||||
let timerHitZero = false;
|
let timerHitZero = false;
|
||||||
|
|
||||||
function updateRoundTimer() {
|
function updateRoundTimer() {
|
||||||
@@ -451,16 +505,7 @@ async function refreshRound() {
|
|||||||
: t('round.none');
|
: t('round.none');
|
||||||
betAmountSats = data.bet_amount_sats;
|
betAmountSats = data.bet_amount_sats;
|
||||||
renderBetButton();
|
renderBetButton();
|
||||||
document.getElementById('round-players').textContent = data.participant_count;
|
renderRoundStats(data);
|
||||||
const jackpotEl = document.getElementById('round-jackpot');
|
|
||||||
const jackpotValue = data.jackpot_sats / SATS_PER_PLM;
|
|
||||||
jackpotEl.textContent = formatPlm(data.jackpot_sats);
|
|
||||||
if (lastJackpotValue !== null && jackpotValue !== lastJackpotValue) {
|
|
||||||
jackpotEl.classList.remove('jackpot-bump');
|
|
||||||
void jackpotEl.offsetWidth; // restart the animation
|
|
||||||
jackpotEl.classList.add('jackpot-bump');
|
|
||||||
}
|
|
||||||
lastJackpotValue = jackpotValue;
|
|
||||||
if (data.server_time) serverTimeOffsetMs = new Date(data.server_time) - new Date();
|
if (data.server_time) serverTimeOffsetMs = new Date(data.server_time) - new Date();
|
||||||
roundCloseAt = data.closes_at ? new Date(data.closes_at) : null;
|
roundCloseAt = data.closes_at ? new Date(data.closes_at) : null;
|
||||||
updateRoundTimer();
|
updateRoundTimer();
|
||||||
@@ -858,6 +903,10 @@ function connectRoundEvents() {
|
|||||||
function onLanguageChange() {
|
function onLanguageChange() {
|
||||||
renderBetButton();
|
renderBetButton();
|
||||||
renderChainStatusBar(); // repaints from remembered state, without waiting for the next poll
|
renderChainStatusBar(); // repaints from remembered state, without waiting for the next poll
|
||||||
|
// Same reason, for the round's "+N in attesa" suffixes (B-65): repaint from what
|
||||||
|
// was last received rather than leaving them in the old language until the
|
||||||
|
// refreshRound() below happens to come back.
|
||||||
|
if (lastRoundStats) renderRoundStats(lastRoundStats);
|
||||||
if (token) {
|
if (token) {
|
||||||
refreshRound();
|
refreshRound();
|
||||||
refreshMe();
|
refreshMe();
|
||||||
|
|||||||
@@ -41,6 +41,7 @@ const TRANSLATIONS = {
|
|||||||
'chain.block': 'Block {n}',
|
'chain.block': 'Block {n}',
|
||||||
'chain.connectionLost': 'Connection to server lost — retrying…',
|
'chain.connectionLost': 'Connection to server lost — retrying…',
|
||||||
'maintenance.banner': 'Scheduled maintenance: the current round completes normally (winner included), but the next round will not open until maintenance ends.',
|
'maintenance.banner': 'Scheduled maintenance: the current round completes normally (winner included), but the next round will not open until maintenance ends.',
|
||||||
|
'maintenance.notConfigured': 'This lottery is not ready to play yet: the operator still has to finish setting it up, and no round will open until then.',
|
||||||
|
|
||||||
'hero.lead': 'Deposit PLM, join the round with a fixed entry fee, and if your number is drawn you win the jackpot.',
|
'hero.lead': 'Deposit PLM, join the round with a fixed entry fee, and if your number is drawn you win the jackpot.',
|
||||||
'hero.step1.title': '1. Deposit',
|
'hero.step1.title': '1. Deposit',
|
||||||
@@ -63,6 +64,8 @@ const TRANSLATIONS = {
|
|||||||
|
|
||||||
'round.players': 'Players',
|
'round.players': 'Players',
|
||||||
'round.jackpot': 'Jackpot',
|
'round.jackpot': 'Jackpot',
|
||||||
|
'round.playersPending': '+{n} pending',
|
||||||
|
'round.jackpotPending': '+{amount} pending',
|
||||||
'round.status.open': 'open',
|
'round.status.open': 'open',
|
||||||
'round.status.closing': 'closing',
|
'round.status.closing': 'closing',
|
||||||
'round.status.drawing': 'drawing in progress',
|
'round.status.drawing': 'drawing in progress',
|
||||||
@@ -206,6 +209,7 @@ const TRANSLATIONS = {
|
|||||||
'chain.block': 'Blocco {n}',
|
'chain.block': 'Blocco {n}',
|
||||||
'chain.connectionLost': 'Connessione al server persa — riprovo…',
|
'chain.connectionLost': 'Connessione al server persa — riprovo…',
|
||||||
'maintenance.banner': 'Manutenzione in programma: il round in corso viene completato regolarmente (vincitore incluso), ma il round successivo non si aprirà finché la manutenzione non sarà terminata.',
|
'maintenance.banner': 'Manutenzione in programma: il round in corso viene completato regolarmente (vincitore incluso), ma il round successivo non si aprirà finché la manutenzione non sarà terminata.',
|
||||||
|
'maintenance.notConfigured': 'Questa lotteria non è ancora pronta: l\'operatore deve completare la configurazione, e fino a quel momento non si aprirà nessun round.',
|
||||||
|
|
||||||
'hero.lead': 'Deposita PLM, entra nel round con una quota fissa, e se viene estratto il tuo numero vinci il montepremi.',
|
'hero.lead': 'Deposita PLM, entra nel round con una quota fissa, e se viene estratto il tuo numero vinci il montepremi.',
|
||||||
'hero.step1.title': '1. Deposita',
|
'hero.step1.title': '1. Deposita',
|
||||||
@@ -228,6 +232,8 @@ const TRANSLATIONS = {
|
|||||||
|
|
||||||
'round.players': 'Giocatori',
|
'round.players': 'Giocatori',
|
||||||
'round.jackpot': 'Jackpot',
|
'round.jackpot': 'Jackpot',
|
||||||
|
'round.playersPending': '+{n} in attesa',
|
||||||
|
'round.jackpotPending': '+{amount} in attesa',
|
||||||
'round.status.open': 'aperto',
|
'round.status.open': 'aperto',
|
||||||
'round.status.closing': 'in chiusura',
|
'round.status.closing': 'in chiusura',
|
||||||
'round.status.drawing': 'estrazione in corso',
|
'round.status.drawing': 'estrazione in corso',
|
||||||
@@ -368,6 +374,7 @@ const TRANSLATIONS = {
|
|||||||
'chain.block': 'Bloque {n}',
|
'chain.block': 'Bloque {n}',
|
||||||
'chain.connectionLost': 'Conexión con el servidor perdida — reintentando…',
|
'chain.connectionLost': 'Conexión con el servidor perdida — reintentando…',
|
||||||
'maintenance.banner': 'Mantenimiento programado: la ronda actual se completa con normalidad (ganador incluido), pero la siguiente ronda no se abrirá hasta que finalice el mantenimiento.',
|
'maintenance.banner': 'Mantenimiento programado: la ronda actual se completa con normalidad (ganador incluido), pero la siguiente ronda no se abrirá hasta que finalice el mantenimiento.',
|
||||||
|
'maintenance.notConfigured': 'Esta lotería todavía no está lista: el operador tiene que terminar de configurarla y, hasta entonces, no se abrirá ninguna ronda.',
|
||||||
|
|
||||||
'hero.lead': 'Deposita PLM, únete a la ronda con una cuota fija de entrada, y si sale tu número ganas el bote.',
|
'hero.lead': 'Deposita PLM, únete a la ronda con una cuota fija de entrada, y si sale tu número ganas el bote.',
|
||||||
'hero.step1.title': '1. Deposita',
|
'hero.step1.title': '1. Deposita',
|
||||||
@@ -390,6 +397,8 @@ const TRANSLATIONS = {
|
|||||||
|
|
||||||
'round.players': 'Jugadores',
|
'round.players': 'Jugadores',
|
||||||
'round.jackpot': 'Bote',
|
'round.jackpot': 'Bote',
|
||||||
|
'round.playersPending': '+{n} pendientes',
|
||||||
|
'round.jackpotPending': '+{amount} pendientes',
|
||||||
'round.status.open': 'abierta',
|
'round.status.open': 'abierta',
|
||||||
'round.status.closing': 'cerrando',
|
'round.status.closing': 'cerrando',
|
||||||
'round.status.drawing': 'sorteo en curso',
|
'round.status.drawing': 'sorteo en curso',
|
||||||
@@ -530,6 +539,7 @@ const TRANSLATIONS = {
|
|||||||
'chain.block': 'Bloc {n}',
|
'chain.block': 'Bloc {n}',
|
||||||
'chain.connectionLost': 'Connexion au serveur perdue — nouvelle tentative…',
|
'chain.connectionLost': 'Connexion au serveur perdue — nouvelle tentative…',
|
||||||
'maintenance.banner': "Maintenance programmée : le round en cours se termine normalement (gagnant inclus), mais le round suivant ne s'ouvrira qu'une fois la maintenance terminée.",
|
'maintenance.banner': "Maintenance programmée : le round en cours se termine normalement (gagnant inclus), mais le round suivant ne s'ouvrira qu'une fois la maintenance terminée.",
|
||||||
|
'maintenance.notConfigured': "Cette loterie n'est pas encore prête : l'opérateur doit terminer la configuration, et aucun round ne s'ouvrira avant.",
|
||||||
|
|
||||||
'hero.lead': 'Déposez des PLM, rejoignez le round avec une mise fixe, et si votre numéro est tiré vous remportez le jackpot.',
|
'hero.lead': 'Déposez des PLM, rejoignez le round avec une mise fixe, et si votre numéro est tiré vous remportez le jackpot.',
|
||||||
'hero.step1.title': '1. Déposez',
|
'hero.step1.title': '1. Déposez',
|
||||||
@@ -552,6 +562,8 @@ const TRANSLATIONS = {
|
|||||||
|
|
||||||
'round.players': 'Joueurs',
|
'round.players': 'Joueurs',
|
||||||
'round.jackpot': 'Jackpot',
|
'round.jackpot': 'Jackpot',
|
||||||
|
'round.playersPending': '+{n} en attente',
|
||||||
|
'round.jackpotPending': '+{amount} en attente',
|
||||||
'round.status.open': 'ouvert',
|
'round.status.open': 'ouvert',
|
||||||
'round.status.closing': 'en fermeture',
|
'round.status.closing': 'en fermeture',
|
||||||
'round.status.drawing': 'tirage en cours',
|
'round.status.drawing': 'tirage en cours',
|
||||||
@@ -692,6 +704,7 @@ const TRANSLATIONS = {
|
|||||||
'chain.block': 'Block {n}',
|
'chain.block': 'Block {n}',
|
||||||
'chain.connectionLost': 'Verbindung zum Server verloren — erneuter Versuch…',
|
'chain.connectionLost': 'Verbindung zum Server verloren — erneuter Versuch…',
|
||||||
'maintenance.banner': 'Geplante Wartung: Die laufende Runde wird regulär abgeschlossen (Gewinner inklusive), aber die nächste Runde öffnet erst, wenn die Wartung beendet ist.',
|
'maintenance.banner': 'Geplante Wartung: Die laufende Runde wird regulär abgeschlossen (Gewinner inklusive), aber die nächste Runde öffnet erst, wenn die Wartung beendet ist.',
|
||||||
|
'maintenance.notConfigured': 'Diese Lotterie ist noch nicht spielbereit: der Betreiber muss die Einrichtung abschließen, bis dahin öffnet keine Runde.',
|
||||||
|
|
||||||
'hero.lead': 'Zahle PLM ein, nimm mit einem festen Einsatz an der Runde teil, und wenn deine Zahl gezogen wird, gewinnst du den Jackpot.',
|
'hero.lead': 'Zahle PLM ein, nimm mit einem festen Einsatz an der Runde teil, und wenn deine Zahl gezogen wird, gewinnst du den Jackpot.',
|
||||||
'hero.step1.title': '1. Einzahlen',
|
'hero.step1.title': '1. Einzahlen',
|
||||||
@@ -714,6 +727,8 @@ const TRANSLATIONS = {
|
|||||||
|
|
||||||
'round.players': 'Spieler',
|
'round.players': 'Spieler',
|
||||||
'round.jackpot': 'Jackpot',
|
'round.jackpot': 'Jackpot',
|
||||||
|
'round.playersPending': '+{n} ausstehend',
|
||||||
|
'round.jackpotPending': '+{amount} ausstehend',
|
||||||
'round.status.open': 'offen',
|
'round.status.open': 'offen',
|
||||||
'round.status.closing': 'wird geschlossen',
|
'round.status.closing': 'wird geschlossen',
|
||||||
'round.status.drawing': 'Ziehung läuft',
|
'round.status.drawing': 'Ziehung läuft',
|
||||||
@@ -854,6 +869,7 @@ const TRANSLATIONS = {
|
|||||||
'chain.block': 'Блок {n}',
|
'chain.block': 'Блок {n}',
|
||||||
'chain.connectionLost': 'Соединение с сервером потеряно — повторная попытка…',
|
'chain.connectionLost': 'Соединение с сервером потеряно — повторная попытка…',
|
||||||
'maintenance.banner': 'Запланировано техобслуживание: текущий раунд завершится в обычном порядке (включая победителя), но следующий раунд не откроется до окончания техобслуживания.',
|
'maintenance.banner': 'Запланировано техобслуживание: текущий раунд завершится в обычном порядке (включая победителя), но следующий раунд не откроется до окончания техобслуживания.',
|
||||||
|
'maintenance.notConfigured': 'Эта лотерея пока не готова: оператору нужно завершить настройку, до этого ни один раунд не откроется.',
|
||||||
|
|
||||||
'hero.lead': 'Внесите PLM, вступите в раунд с фиксированной ставкой, и если выпадет ваш номер — вы выиграете джекпот.',
|
'hero.lead': 'Внесите PLM, вступите в раунд с фиксированной ставкой, и если выпадет ваш номер — вы выиграете джекпот.',
|
||||||
'hero.step1.title': '1. Внесите депозит',
|
'hero.step1.title': '1. Внесите депозит',
|
||||||
@@ -876,6 +892,8 @@ const TRANSLATIONS = {
|
|||||||
|
|
||||||
'round.players': 'Игроки',
|
'round.players': 'Игроки',
|
||||||
'round.jackpot': 'Джекпот',
|
'round.jackpot': 'Джекпот',
|
||||||
|
'round.playersPending': '+{n} в ожидании',
|
||||||
|
'round.jackpotPending': '+{amount} в ожидании',
|
||||||
'round.status.open': 'открыт',
|
'round.status.open': 'открыт',
|
||||||
'round.status.closing': 'закрывается',
|
'round.status.closing': 'закрывается',
|
||||||
'round.status.drawing': 'идёт розыгрыш',
|
'round.status.drawing': 'идёт розыгрыш',
|
||||||
@@ -1016,6 +1034,7 @@ const TRANSLATIONS = {
|
|||||||
'chain.block': '区块 {n}',
|
'chain.block': '区块 {n}',
|
||||||
'chain.connectionLost': '与服务器的连接已断开——正在重试…',
|
'chain.connectionLost': '与服务器的连接已断开——正在重试…',
|
||||||
'maintenance.banner': '计划维护:当前回合将照常完成(包括中奖者),但下一回合要等维护结束后才会开启。',
|
'maintenance.banner': '计划维护:当前回合将照常完成(包括中奖者),但下一回合要等维护结束后才会开启。',
|
||||||
|
'maintenance.notConfigured': '本彩票尚未就绪:运营方还需完成配置,在此之前不会开启任何回合。',
|
||||||
|
|
||||||
'hero.lead': '存入 PLM,以固定金额参与本回合,若抽中你的号码即可赢得奖池。',
|
'hero.lead': '存入 PLM,以固定金额参与本回合,若抽中你的号码即可赢得奖池。',
|
||||||
'hero.step1.title': '1. 存款',
|
'hero.step1.title': '1. 存款',
|
||||||
@@ -1038,6 +1057,8 @@ const TRANSLATIONS = {
|
|||||||
|
|
||||||
'round.players': '参与人数',
|
'round.players': '参与人数',
|
||||||
'round.jackpot': '奖池',
|
'round.jackpot': '奖池',
|
||||||
|
'round.playersPending': '+{n} 待确认',
|
||||||
|
'round.jackpotPending': '+{amount} 待确认',
|
||||||
'round.status.open': '进行中',
|
'round.status.open': '进行中',
|
||||||
'round.status.closing': '即将结束',
|
'round.status.closing': '即将结束',
|
||||||
'round.status.drawing': '正在开奖',
|
'round.status.drawing': '正在开奖',
|
||||||
|
|||||||
@@ -83,7 +83,10 @@
|
|||||||
|
|
||||||
<div class="maintenance-banner hidden" id="maintenance-banner">
|
<div class="maintenance-banner hidden" id="maintenance-banner">
|
||||||
<span>⚠️</span>
|
<span>⚠️</span>
|
||||||
<span data-i18n="maintenance.banner">Manutenzione in programma: il round in corso viene completato regolarmente (vincitore incluso), ma il round successivo non si aprirà finché la manutenzione non sarà terminata.</span>
|
<!-- Filled by renderChainStatusBar(): the text depends on *why* no round will
|
||||||
|
open — a deliberate pause, or an instance the operator hasn't finished
|
||||||
|
configuring (B-66) — so it renders through t() and carries no data-i18n. -->
|
||||||
|
<span id="maintenance-banner-text"></span>
|
||||||
</div>
|
</div>
|
||||||
|
|
||||||
<section id="landing-hero" class="hero">
|
<section id="landing-hero" class="hero">
|
||||||
@@ -150,11 +153,15 @@
|
|||||||
<div class="row-between" style="margin-top:10px" id="round-stats-row">
|
<div class="row-between" style="margin-top:10px" id="round-stats-row">
|
||||||
<div>
|
<div>
|
||||||
<div class="hint" style="margin-bottom:2px" data-i18n="round.players">Giocatori</div>
|
<div class="hint" style="margin-bottom:2px" data-i18n="round.players">Giocatori</div>
|
||||||
<span class="mono" id="round-players">—</span>
|
<!-- The two -pending spans are filled from server data by renderRoundStats()
|
||||||
|
(B-65), so they carry no data-i18n: an element belongs to one
|
||||||
|
translation mechanism or the other, never both. -->
|
||||||
|
<span class="mono" id="round-players">—</span> <span class="pending-suffix hidden" id="round-players-pending"></span>
|
||||||
</div>
|
</div>
|
||||||
<div style="text-align:right">
|
<div style="text-align:right">
|
||||||
<div class="hint" style="margin-bottom:2px" data-i18n="round.jackpot">Jackpot</div>
|
<div class="hint" style="margin-bottom:2px" data-i18n="round.jackpot">Jackpot</div>
|
||||||
<span class="mono" id="round-jackpot">—</span> <span class="balance-unit">PLM</span>
|
<span class="mono" id="round-jackpot">—</span> <span class="balance-unit">PLM</span>
|
||||||
|
<span class="pending-suffix hidden" id="round-jackpot-pending"></span>
|
||||||
</div>
|
</div>
|
||||||
</div>
|
</div>
|
||||||
|
|
||||||
|
|||||||
@@ -215,6 +215,12 @@ button.link:hover, a.link:hover { filter: none; color: var(--color-foreground);
|
|||||||
.balance-confirmed { color: var(--color-success); }
|
.balance-confirmed { color: var(--color-success); }
|
||||||
.balance-pending { color: var(--color-primary); }
|
.balance-pending { color: var(--color-primary); }
|
||||||
|
|
||||||
|
/* The in-flight part of the round's own figures (B-65): the players/jackpot next
|
||||||
|
to it are the confirmed ones the draw and the payout will actually use, and this
|
||||||
|
is what has been bet but hasn't confirmed yet. Same amber as .balance-pending,
|
||||||
|
for the same "not settled" meaning. */
|
||||||
|
.pending-suffix { color: var(--color-primary); font-size: 0.8rem; font-weight: 600; }
|
||||||
|
|
||||||
.icon { width: 16px; height: 16px; flex-shrink: 0; }
|
.icon { width: 16px; height: 16px; flex-shrink: 0; }
|
||||||
|
|
||||||
.dash-panel { display: none; }
|
.dash-panel { display: none; }
|
||||||
|
|||||||
+4
-2
@@ -202,8 +202,10 @@ async def _abandon(session: AsyncSession, row: PendingTransaction, reason: str)
|
|||||||
elif row.kind == "payout":
|
elif row.kind == "payout":
|
||||||
# Payout funds come from the pool address, which isn't tracked in
|
# Payout funds come from the pool address, which isn't tracked in
|
||||||
# utxo_events, so there's nothing to release. Clearing payout_txid leaves the
|
# utxo_events, so there's nothing to release. Clearing payout_txid leaves the
|
||||||
# round in "paying_out" with no tx attached, which is the state an operator
|
# round in "paying_out" with no tx attached, which is exactly the state the
|
||||||
# (or a future payout-retry routine — still an open gap) can act on.
|
# scheduler's payout retry picks up (B-26: `_retry_payout_if_due`, one attempt
|
||||||
|
# per 60s), so an abandoned payout is rebuilt on its own rather than waiting
|
||||||
|
# for an operator — the log line below is the alert, not the recovery path.
|
||||||
round_ = await session.get(Round, row.round_id) if row.round_id else None
|
round_ = await session.get(Round, row.round_id) if row.round_id else None
|
||||||
if round_ is not None and round_.status == "paying_out":
|
if round_ is not None and round_.status == "paying_out":
|
||||||
round_.payout_txid = None
|
round_.payout_txid = None
|
||||||
|
|||||||
+1
-1
@@ -36,7 +36,7 @@ business — quelli si toccano solo da qui.
|
|||||||
|
|
||||||
| Campo | Significato |
|
| Campo | Significato |
|
||||||
|---|---|
|
|---|---|
|
||||||
| **Fee address** | L'indirizzo PLM su cui finisce il 30% di ogni round (fee). Obbligatorio: i payout **non partono** se questo campo è vuoto. |
|
| **Fee address** | L'indirizzo PLM su cui finisce il 30% di ogni round (fee). Obbligatorio: finché è vuoto **non si apre nessun round** (il payout non sarebbe costruibile, quindi il round accetterebbe scommesse per poi restare bloccato con i soldi già nel montepremi). Il pannello lo segnala con un avviso in cima ai Parametri, e la pagina utente mostra un banner "lotteria non ancora pronta". Un round già in corso non viene interrotto se svuoti il campo: chiude, estrae e paga normalmente. |
|
||||||
| **Bet amount (PLM)** | Il costo fisso d'ingresso per round. È anche l'importo minimo prelevabile: un prelievo sotto questa soglia viene rifiutato (i depositi non hanno un controllo minimo lato server). |
|
| **Bet amount (PLM)** | Il costo fisso d'ingresso per round. È anche l'importo minimo prelevabile: un prelievo sotto questa soglia viene rifiutato (i depositi non hanno un controllo minimo lato server). |
|
||||||
| **Durata round (secondi)** | Quanto resta aperto un round prima di chiudersi ed estrarre il vincitore. Il taglio per le nuove giocate scatta esattamente allo scadere di questo tempo (verificato ad ogni bet, non dipende dal ciclo dello scheduler) — è un "semaforo giallo": nessuna nuova entrata, ma le bet già trasmesse prima dello scadere hanno comunque tempo di confermarsi prima che il round chiuda ed estragga. |
|
| **Durata round (secondi)** | Quanto resta aperto un round prima di chiudersi ed estrarre il vincitore. Il taglio per le nuove giocate scatta esattamente allo scadere di questo tempo (verificato ad ogni bet, non dipende dal ciclo dello scheduler) — è un "semaforo giallo": nessuna nuova entrata, ma le bet già trasmesse prima dello scadere hanno comunque tempo di confermarsi prima che il round chiuda ed estragga. |
|
||||||
| **Pausa tra un round e il successivo (secondi)** | Cooldown dopo la chiusura di un round, prima che il successivo si apra — dà tempo ai giocatori di vedere l'esito. |
|
| **Pausa tra un round e il successivo (secondi)** | Cooldown dopo la chiusura di un round, prima che il successivo si apra — dà tempo ai giocatori di vedere l'esito. |
|
||||||
|
|||||||
@@ -36,7 +36,7 @@ flowchart LR
|
|||||||
|
|
||||||
subgraph WITHDRAW["FASE 5 - Prelievo"]
|
subgraph WITHDRAW["FASE 5 - Prelievo"]
|
||||||
direction TB
|
direction TB
|
||||||
E1["L'utente richiede un prelievo:\nindirizzo esterno + importo\n(non puo' avvenire insieme\na una scommessa in corso)"] --> E2["Si prepara e firma la transazione:\ndal suo indirizzo verso\nl'indirizzo esterno indicato\n(con resto che torna a lui)"]
|
E1["L'utente richiede un prelievo:\nindirizzo esterno + importo\n(spende solo saldo confermato\ne non ancora impegnato: una scommessa\nin attesa di conferma non lo blocca,\nma le due operazioni non vengono\nmai preparate nello stesso momento)"] --> E2["Si prepara e firma la transazione:\ndal suo indirizzo verso\nl'indirizzo esterno indicato\n(con resto che torna a lui)"]
|
||||||
E2 --> E3["Transazione inviata\nalla rete"]
|
E2 --> E3["Transazione inviata\nalla rete"]
|
||||||
E3 --> E4{"Confermata?"}
|
E3 --> E4{"Confermata?"}
|
||||||
E4 -- "No, troppo tempo" --> E5["Si aumenta la commissione\ne si reinvia"]
|
E4 -- "No, troppo tempo" --> E5["Si aumenta la commissione\ne si reinvia"]
|
||||||
|
|||||||
@@ -5,11 +5,14 @@ from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
|
|||||||
from app.bets.service import place_bet
|
from app.bets.service import place_bet
|
||||||
from app.config import settings
|
from app.config import settings
|
||||||
from app.db.base import Base
|
from app.db.base import Base
|
||||||
from app.db.models import PendingTransaction, User, UtxoEvent
|
from app.db.models import PendingTransaction, RoundConfig, User, UtxoEvent
|
||||||
from app.wallet.balance import compute_pending_balance, recompute_balance
|
from app.wallet.balance import compute_pending_balance, recompute_balance
|
||||||
from app.wallet.hd import derive_user_address
|
from app.wallet.hd import derive_user_address
|
||||||
|
|
||||||
|
|
||||||
|
_FEE_ADDRESS = "plm1q5x25wd6q463mfhckjraaedgjg0lyu73qfcj43n"
|
||||||
|
|
||||||
|
|
||||||
class FakeElectrumClient:
|
class FakeElectrumClient:
|
||||||
async def broadcast(self, raw_tx_hex: str) -> str:
|
async def broadcast(self, raw_tx_hex: str) -> str:
|
||||||
return "fake-network-txid"
|
return "fake-network-txid"
|
||||||
@@ -31,6 +34,13 @@ async def session_factory(tmp_path, monkeypatch):
|
|||||||
engine = create_async_engine("sqlite+aiosqlite:///:memory:")
|
engine = create_async_engine("sqlite+aiosqlite:///:memory:")
|
||||||
async with engine.begin() as conn:
|
async with engine.begin() as conn:
|
||||||
await conn.run_sync(Base.metadata.create_all)
|
await conn.run_sync(Base.metadata.create_all)
|
||||||
|
|
||||||
|
# B-66: a round only opens on an instance that could actually pay a winner, so
|
||||||
|
# every test that expects one needs a fee address configured — the column has no
|
||||||
|
# default on purpose (an operator must set their own).
|
||||||
|
async with async_sessionmaker(engine, expire_on_commit=False)() as session:
|
||||||
|
session.add(RoundConfig(fee_address=_FEE_ADDRESS))
|
||||||
|
await session.commit()
|
||||||
yield async_sessionmaker(engine, expire_on_commit=False)
|
yield async_sessionmaker(engine, expire_on_commit=False)
|
||||||
await engine.dispose()
|
await engine.dispose()
|
||||||
hd._account_key = None
|
hd._account_key = None
|
||||||
|
|||||||
+12
-1
@@ -14,6 +14,9 @@ from app.wallet.hd import derive_user_address
|
|||||||
from app.wallet.psbt_builder import MAX_PARTICIPANTS_PER_ROUND, MAX_TX_INPUTS
|
from app.wallet.psbt_builder import MAX_PARTICIPANTS_PER_ROUND, MAX_TX_INPUTS
|
||||||
|
|
||||||
|
|
||||||
|
_FEE_ADDRESS = "plm1q5x25wd6q463mfhckjraaedgjg0lyu73qfcj43n"
|
||||||
|
|
||||||
|
|
||||||
class FakeElectrumClient:
|
class FakeElectrumClient:
|
||||||
def __init__(self):
|
def __init__(self):
|
||||||
self.broadcasted: list[str] = []
|
self.broadcasted: list[str] = []
|
||||||
@@ -35,6 +38,13 @@ async def session_factory(tmp_path, monkeypatch):
|
|||||||
engine = create_async_engine("sqlite+aiosqlite:///:memory:")
|
engine = create_async_engine("sqlite+aiosqlite:///:memory:")
|
||||||
async with engine.begin() as conn:
|
async with engine.begin() as conn:
|
||||||
await conn.run_sync(Base.metadata.create_all)
|
await conn.run_sync(Base.metadata.create_all)
|
||||||
|
|
||||||
|
# B-66: a round only opens on an instance that could actually pay a winner, so
|
||||||
|
# every test that expects one needs a fee address configured — the column has no
|
||||||
|
# default on purpose (an operator must set their own).
|
||||||
|
async with async_sessionmaker(engine, expire_on_commit=False)() as session:
|
||||||
|
session.add(RoundConfig(fee_address=_FEE_ADDRESS))
|
||||||
|
await session.commit()
|
||||||
yield async_sessionmaker(engine, expire_on_commit=False)
|
yield async_sessionmaker(engine, expire_on_commit=False)
|
||||||
await engine.dispose()
|
await engine.dispose()
|
||||||
hd._account_key = None
|
hd._account_key = None
|
||||||
@@ -217,7 +227,8 @@ async def test_place_bet_rejects_after_timer_expires_even_if_still_open(session_
|
|||||||
client = FakeElectrumClient()
|
client = FakeElectrumClient()
|
||||||
|
|
||||||
async with session_factory() as session:
|
async with session_factory() as session:
|
||||||
session.add(RoundConfig(fee_address="", round_duration_seconds=60))
|
config = (await session.scalars(select(RoundConfig))).one() # seeded by the fixture
|
||||||
|
config.round_duration_seconds = 60
|
||||||
round_ = await open_new_round_if_needed(session)
|
round_ = await open_new_round_if_needed(session)
|
||||||
round_.opened_at = datetime.now(timezone.utc) - timedelta(seconds=61)
|
round_.opened_at = datetime.now(timezone.utc) - timedelta(seconds=61)
|
||||||
await session.commit()
|
await session.commit()
|
||||||
|
|||||||
@@ -0,0 +1,47 @@
|
|||||||
|
"""B-69: in-code comments that describe the rest of the system must stay true.
|
||||||
|
|
||||||
|
Three had rotted: the reconciler still called the payout retry "a future
|
||||||
|
payout-retry routine — still an open gap" long after B-26 shipped it,
|
||||||
|
app/db/base.py sized the SQLite busy timeout against "five" background tasks
|
||||||
|
when there are six, and app/auth/routes.py cited the wrong B-nn. A comment is
|
||||||
|
invisible to every other test in the suite, so the claims are pinned here.
|
||||||
|
"""
|
||||||
|
|
||||||
|
import re
|
||||||
|
from pathlib import Path
|
||||||
|
|
||||||
|
|
||||||
|
_ROOT = Path(__file__).resolve().parents[2]
|
||||||
|
|
||||||
|
|
||||||
|
def _read(relative: str) -> str:
|
||||||
|
return (_ROOT / relative).read_text(encoding="utf-8")
|
||||||
|
|
||||||
|
|
||||||
|
def test_background_task_count_in_the_busy_timeout_comment_is_right():
|
||||||
|
started = len(re.findall(r"asyncio\.create_task\(", _read("app/main.py")))
|
||||||
|
assert started == 6, "the lifespan's task count changed — update app/db/base.py's comment"
|
||||||
|
|
||||||
|
comment = _read("app/db/base.py").split("_SQLITE_BUSY_TIMEOUT_MS", 1)[0]
|
||||||
|
match = re.search(r"(\w+) concurrent background tasks", comment)
|
||||||
|
assert match, "app/db/base.py no longer explains what the busy timeout is sized for"
|
||||||
|
words = {"four": 4, "five": 5, "six": 6, "seven": 7, "eight": 8}
|
||||||
|
assert words.get(match.group(1)) == started
|
||||||
|
|
||||||
|
|
||||||
|
def test_the_reconciler_does_not_call_the_payout_retry_an_open_gap():
|
||||||
|
source = _read("app/tx/reconcile.py")
|
||||||
|
assert "still an open gap" not in source
|
||||||
|
# It exists (B-26) and is what actually recovers an abandoned payout, so the
|
||||||
|
# comment must point at it rather than at an operator.
|
||||||
|
assert "B-26" in source
|
||||||
|
|
||||||
|
|
||||||
|
def test_the_payout_retry_the_comment_points_at_still_exists():
|
||||||
|
assert "_retry_payout_if_due" in _read("app/rounds/scheduler.py")
|
||||||
|
|
||||||
|
|
||||||
|
def test_the_login_throttle_comment_cites_its_own_finding():
|
||||||
|
limiters = _read("app/auth/routes.py").split("_rate_limiters", 1)[1][:1500]
|
||||||
|
assert "B-33" in limiters
|
||||||
|
assert "B-31" not in limiters # B-31 is the resubscribe fan-out, a different fix
|
||||||
@@ -0,0 +1,91 @@
|
|||||||
|
"""B-68: CLAUDE.md and README must describe the code as it is now.
|
||||||
|
|
||||||
|
The audit found both files still asserting things the code had moved past —
|
||||||
|
JWT "no revocation" after token_version implemented exactly that, /report-bug
|
||||||
|
"a placeholder" after it shipped with admin triage, three stale test counts, a
|
||||||
|
code map missing three modules, and README links to a file and an anchor that
|
||||||
|
no longer exist. None of that is catchable by reading the code, so it is
|
||||||
|
pinned here instead.
|
||||||
|
"""
|
||||||
|
|
||||||
|
import re
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
from pathlib import Path
|
||||||
|
|
||||||
|
import pytest
|
||||||
|
|
||||||
|
|
||||||
|
_ROOT = Path(__file__).resolve().parents[2]
|
||||||
|
CLAUDE_MD = (_ROOT / "CLAUDE.md").read_text(encoding="utf-8")
|
||||||
|
README = (_ROOT / "README.md").read_text(encoding="utf-8")
|
||||||
|
|
||||||
|
|
||||||
|
def _collected_test_count() -> int:
|
||||||
|
result = subprocess.run(
|
||||||
|
[sys.executable, "-m", "pytest", "--collect-only", "-q"],
|
||||||
|
cwd=_ROOT,
|
||||||
|
capture_output=True,
|
||||||
|
text=True,
|
||||||
|
timeout=300,
|
||||||
|
)
|
||||||
|
match = re.search(r"(\d+) tests? collected", result.stdout)
|
||||||
|
assert match, f"could not parse the collection summary:\n{result.stdout[-2000:]}"
|
||||||
|
return int(match.group(1))
|
||||||
|
|
||||||
|
|
||||||
|
def test_documented_test_counts_match_reality():
|
||||||
|
actual = _collected_test_count()
|
||||||
|
documented = [int(n) for n in re.findall(r"(\d+) tests\b", CLAUDE_MD)]
|
||||||
|
documented += [int(n) for n in re.findall(r"(\d+) unit tests\b", README)]
|
||||||
|
assert documented, "no test count found in CLAUDE.md or README — did the wording change?"
|
||||||
|
for count in documented:
|
||||||
|
assert count == actual, (
|
||||||
|
f"docs claim {count} tests, the suite collects {actual} — "
|
||||||
|
"update the counts in CLAUDE.md (twice) and README.md"
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
@pytest.mark.parametrize(
|
||||||
|
"stale",
|
||||||
|
[
|
||||||
|
"no revocation", # token_version implements it (app/auth/dependencies.py)
|
||||||
|
"`/report-bug` are placeholders", # /report-bug shipped, only /guida is a stub
|
||||||
|
],
|
||||||
|
)
|
||||||
|
def test_claude_md_has_no_stale_claims(stale):
|
||||||
|
assert stale not in CLAUDE_MD
|
||||||
|
|
||||||
|
|
||||||
|
@pytest.mark.parametrize(
|
||||||
|
"module",
|
||||||
|
["rate_limit.py", "client_ip.py", "bug_reports"],
|
||||||
|
)
|
||||||
|
def test_code_map_covers_every_package_member(module):
|
||||||
|
code_map = CLAUDE_MD.split("## Code map", 1)[1].split("## Background tasks", 1)[0]
|
||||||
|
assert module in code_map
|
||||||
|
|
||||||
|
|
||||||
|
@pytest.mark.parametrize(
|
||||||
|
"link",
|
||||||
|
["(flowchart.mmd)", "CLAUDE.md#tech-stack-mvp"],
|
||||||
|
)
|
||||||
|
def test_readme_has_no_dead_links(link):
|
||||||
|
assert link not in README
|
||||||
|
|
||||||
|
|
||||||
|
def test_readme_relative_links_resolve():
|
||||||
|
for target in re.findall(r"\]\(([^)#]+)(?:#[^)]*)?\)", README):
|
||||||
|
if target.startswith(("http://", "https://", "mailto:")):
|
||||||
|
continue
|
||||||
|
assert (_ROOT / target).exists(), f"README links {target}, which does not exist"
|
||||||
|
|
||||||
|
|
||||||
|
def test_claude_md_anchors_into_itself_resolve():
|
||||||
|
headings = {
|
||||||
|
re.sub(r"[^a-z0-9 -]", "", line.lstrip("# ").lower()).replace(" ", "-")
|
||||||
|
for line in CLAUDE_MD.splitlines()
|
||||||
|
if line.startswith("#")
|
||||||
|
}
|
||||||
|
for anchor in re.findall(r"\(CLAUDE\.md#([a-z0-9-]+)\)", README + CLAUDE_MD):
|
||||||
|
assert anchor in headings, f"anchor #{anchor} matches no CLAUDE.md heading"
|
||||||
@@ -247,6 +247,52 @@ def test_apply_header_rejects_one_that_does_not_chain_from_the_tip(session_facto
|
|||||||
assert (listener.tip_height, listener.tip_header_hex) == (100, header_100) # untouched
|
assert (listener.tip_height, listener.tip_header_hex) == (100, header_100) # untouched
|
||||||
|
|
||||||
|
|
||||||
|
def test_apply_header_ignores_a_competing_header_at_the_current_tip_height(session_factory, caplog): # B-64
|
||||||
|
"""The linkage check only fires on a single-block advance, so a header at the
|
||||||
|
height we already hold one for used to be applied on nothing but its own
|
||||||
|
self-consistency — replacing the very hash a draw may be about to be seeded
|
||||||
|
with. Whichever it is (a reorg at the tip, or a server disagreeing with the
|
||||||
|
rest), the hash committed to for a height is not swapped under us; if ours is
|
||||||
|
the orphan, corroborate_header refuses to draw from it anyway."""
|
||||||
|
listener = ElectrumListener(lambda endpoint: None, session_factory, _ENDPOINTS)
|
||||||
|
header_100 = _mine_header("00" * 32)
|
||||||
|
listener._apply_header({"height": 100, "hex": header_100})
|
||||||
|
|
||||||
|
competing_100 = _mine_header("11" * 32) # same height, well-formed, different block
|
||||||
|
assert competing_100 != header_100
|
||||||
|
with caplog.at_level(logging.WARNING):
|
||||||
|
listener._apply_header({"height": 100, "hex": competing_100})
|
||||||
|
|
||||||
|
assert (listener.tip_height, listener.tip_header_hex) == (100, header_100) # untouched
|
||||||
|
assert "competing header" in caplog.text
|
||||||
|
|
||||||
|
|
||||||
|
def test_apply_header_treats_the_same_header_re_announced_as_a_no_op(session_factory): # B-64
|
||||||
|
listener = ElectrumListener(lambda endpoint: None, session_factory, _ENDPOINTS)
|
||||||
|
header_100 = _mine_header("00" * 32)
|
||||||
|
listener._apply_header({"height": 100, "hex": header_100})
|
||||||
|
|
||||||
|
listener._apply_header({"height": 100, "hex": header_100}) # must not raise
|
||||||
|
|
||||||
|
assert (listener.tip_height, listener.tip_header_hex) == (100, header_100)
|
||||||
|
|
||||||
|
|
||||||
|
def test_apply_header_ignores_one_carrying_no_hex(session_factory, caplog): # B-64
|
||||||
|
"""A hex-less header can be neither validated nor drawn from, and applying its
|
||||||
|
height alone used to *clear* the hex we already had — leaving tip_height and
|
||||||
|
tip_header_hex describing different blocks, which is the one thing this function
|
||||||
|
exists to prevent."""
|
||||||
|
listener = ElectrumListener(lambda endpoint: None, session_factory, _ENDPOINTS)
|
||||||
|
header_100 = _mine_header("00" * 32)
|
||||||
|
listener._apply_header({"height": 100, "hex": header_100})
|
||||||
|
|
||||||
|
with caplog.at_level(logging.WARNING):
|
||||||
|
listener._apply_header({"height": 101}) # height only, no hex
|
||||||
|
|
||||||
|
assert (listener.tip_height, listener.tip_header_hex) == (100, header_100) # pair intact
|
||||||
|
assert "no header hex" in caplog.text
|
||||||
|
|
||||||
|
|
||||||
def test_apply_header_skips_linkage_check_across_a_height_gap(session_factory):
|
def test_apply_header_skips_linkage_check_across_a_height_gap(session_factory):
|
||||||
"""A reconnect (or the very first header of a session) hands us whatever the
|
"""A reconnect (or the very first header of a session) hands us whatever the
|
||||||
server's current tip is — which is legitimately not a single-block advance
|
server's current tip is — which is legitimately not a single-block advance
|
||||||
@@ -601,6 +647,74 @@ async def _wait_until(predicate, *, timeout: float = 2.0, interval: float = 0.01
|
|||||||
await asyncio.wait_for(_poll(), timeout=timeout)
|
await asyncio.wait_for(_poll(), timeout=timeout)
|
||||||
|
|
||||||
|
|
||||||
|
async def test_run_once_publishes_the_client_only_once_the_tip_is_known(session_factory): # B-63
|
||||||
|
"""`self.client is not None` is what every consumer reads as "the chain is
|
||||||
|
reachable" — RoundScheduler._tick included, which then takes tip_height as the
|
||||||
|
baseline a draw must find a *later* block than. Publishing the client before the
|
||||||
|
first header left a window where the connection looked alive at tip_height 0, so a
|
||||||
|
round closing inside it would have seeded its draw from a block mined before the
|
||||||
|
close, whose hash was already public while bets were open."""
|
||||||
|
header_hex = _mine_header("00" * 32)
|
||||||
|
client = _FakeConnectClient({"height": 100, "hex": header_hex})
|
||||||
|
listener = ElectrumListener(lambda endpoint: client, session_factory, _ENDPOINTS)
|
||||||
|
|
||||||
|
seen_while_subscribing: list[tuple[object, int]] = []
|
||||||
|
original_subscribe_headers = client.subscribe_headers
|
||||||
|
|
||||||
|
async def observing_subscribe_headers():
|
||||||
|
# Exactly the window that used to be exposed: connected, but no header yet.
|
||||||
|
seen_while_subscribing.append((listener.client, listener.tip_height))
|
||||||
|
return await original_subscribe_headers()
|
||||||
|
|
||||||
|
client.subscribe_headers = observing_subscribe_headers
|
||||||
|
|
||||||
|
run_once_task = asyncio.create_task(listener._run_once(_ENDPOINTS[0]))
|
||||||
|
try:
|
||||||
|
await _wait_until(lambda: listener.client is not None)
|
||||||
|
# Whenever the client is visible, the tip is already known — never 0.
|
||||||
|
assert listener.tip_height == 100
|
||||||
|
assert listener.tip_header_hex == header_hex
|
||||||
|
assert seen_while_subscribing == [(None, 0)]
|
||||||
|
finally:
|
||||||
|
await client.close()
|
||||||
|
await run_once_task
|
||||||
|
|
||||||
|
|
||||||
|
async def test_run_once_refuses_a_session_whose_initial_header_carries_no_hex(session_factory): # B-64
|
||||||
|
"""A hex-less header is ignored rather than fatal (a server that only pushes
|
||||||
|
heights must not cost us the connection that also credits deposits) — but on the
|
||||||
|
*first* header of a process there is no tip to fall back on, and publishing the
|
||||||
|
client anyway would hand consumers a connection whose chain position is unknown,
|
||||||
|
which is exactly what B-63 closed."""
|
||||||
|
client = _FakeConnectClient({"height": 100}) # no "hex"
|
||||||
|
listener = ElectrumListener(lambda endpoint: client, session_factory, _ENDPOINTS)
|
||||||
|
|
||||||
|
# Bounded: without the guard _run_once goes on to wait on the session's tasks,
|
||||||
|
# which nothing in this test ever ends — a regression must fail, not hang.
|
||||||
|
with pytest.raises(HeaderValidationError):
|
||||||
|
await asyncio.wait_for(listener._run_once(_ENDPOINTS[0]), timeout=5)
|
||||||
|
|
||||||
|
assert listener.client is None
|
||||||
|
assert (listener.tip_height, listener.tip_header_hex) == (0, None)
|
||||||
|
|
||||||
|
|
||||||
|
async def test_run_once_leaves_no_client_published_when_the_first_header_is_rejected(
|
||||||
|
session_factory,
|
||||||
|
): # B-63
|
||||||
|
"""A fabricated first header ends the session (B-28). The client must never
|
||||||
|
become visible on the way out either, or consumers would briefly see a
|
||||||
|
connection whose tip was never established."""
|
||||||
|
client = _FakeConnectClient({"height": 100, "hex": "00" * 80}) # fails its own target
|
||||||
|
|
||||||
|
listener = ElectrumListener(lambda endpoint: client, session_factory, _ENDPOINTS)
|
||||||
|
|
||||||
|
with pytest.raises(HeaderValidationError):
|
||||||
|
await asyncio.wait_for(listener._run_once(_ENDPOINTS[0]), timeout=5)
|
||||||
|
|
||||||
|
assert listener.client is None
|
||||||
|
assert (listener.tip_height, listener.tip_header_hex) == (0, None)
|
||||||
|
|
||||||
|
|
||||||
async def test_run_once_keeps_consuming_headers_while_resubscribing(session_factory):
|
async def test_run_once_keeps_consuming_headers_while_resubscribing(session_factory):
|
||||||
"""The core B-31 fix: before this, _subscribe_all_users ran to completion
|
"""The core B-31 fix: before this, _subscribe_all_users ran to completion
|
||||||
*before* the header-consuming task even started, so a reconnect with many
|
*before* the header-consuming task even started, so a reconnect with many
|
||||||
|
|||||||
@@ -0,0 +1,101 @@
|
|||||||
|
"""B-67: /qr/{address} must validate the address for real and must not render
|
||||||
|
QR codes on the event loop for every anonymous request."""
|
||||||
|
|
||||||
|
import asyncio
|
||||||
|
|
||||||
|
import pytest
|
||||||
|
from fastapi import FastAPI
|
||||||
|
from httpx import ASGITransport, AsyncClient
|
||||||
|
|
||||||
|
from app.api.routes import qr
|
||||||
|
|
||||||
|
|
||||||
|
VALID_ADDRESS = "plm1q0xcqpzrky6eff2g52qdye53xkk9jxkvraxkkwd"
|
||||||
|
|
||||||
|
|
||||||
|
@pytest.fixture
|
||||||
|
async def client():
|
||||||
|
qr._render_png.cache_clear()
|
||||||
|
app = FastAPI()
|
||||||
|
app.include_router(qr.router)
|
||||||
|
transport = ASGITransport(app=app)
|
||||||
|
async with AsyncClient(transport=transport, base_url="http://test") as ac:
|
||||||
|
yield ac
|
||||||
|
|
||||||
|
|
||||||
|
async def test_valid_address_renders_a_png(client):
|
||||||
|
resp = await client.get(f"/qr/{VALID_ADDRESS}")
|
||||||
|
assert resp.status_code == 200
|
||||||
|
assert resp.headers["content-type"] == "image/png"
|
||||||
|
assert resp.content.startswith(b"\x89PNG")
|
||||||
|
assert "max-age" in resp.headers["cache-control"]
|
||||||
|
|
||||||
|
|
||||||
|
@pytest.mark.parametrize(
|
||||||
|
"address",
|
||||||
|
[
|
||||||
|
"plm1qbogus0000000000000000000000000000000000", # right shape, broken checksum
|
||||||
|
"bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4", # valid bech32, wrong chain
|
||||||
|
"plm1q", # too short to be anything
|
||||||
|
"P" + "a" * 40, # not bech32 at all
|
||||||
|
"plm1" + "q" * 200, # over the length guard
|
||||||
|
],
|
||||||
|
)
|
||||||
|
async def test_non_addresses_are_rejected_without_rendering(client, address, monkeypatch):
|
||||||
|
def explode(*args, **kwargs): # pragma: no cover - must never run
|
||||||
|
raise AssertionError("rendered a QR for a non-address")
|
||||||
|
|
||||||
|
monkeypatch.setattr(qr.qrcode, "make", explode)
|
||||||
|
|
||||||
|
resp = await client.get(f"/qr/{address}")
|
||||||
|
assert resp.status_code == 400
|
||||||
|
assert resp.json()["detail"]["code"] == "invalid_address"
|
||||||
|
|
||||||
|
|
||||||
|
async def test_render_is_memoized_per_address(client):
|
||||||
|
calls = 0
|
||||||
|
original = qr.qrcode.make
|
||||||
|
|
||||||
|
def counting_make(data, *args, **kwargs):
|
||||||
|
nonlocal calls
|
||||||
|
calls += 1
|
||||||
|
return original(data, *args, **kwargs)
|
||||||
|
|
||||||
|
qr.qrcode.make = counting_make
|
||||||
|
try:
|
||||||
|
for _ in range(3):
|
||||||
|
assert (await client.get(f"/qr/{VALID_ADDRESS}")).status_code == 200
|
||||||
|
finally:
|
||||||
|
qr.qrcode.make = original
|
||||||
|
|
||||||
|
assert calls == 1
|
||||||
|
|
||||||
|
|
||||||
|
async def test_render_does_not_block_the_event_loop(client):
|
||||||
|
"""The render runs in a threadpool, so the loop stays responsive while it does."""
|
||||||
|
ticks = 0
|
||||||
|
|
||||||
|
async def ticker():
|
||||||
|
nonlocal ticks
|
||||||
|
while True:
|
||||||
|
ticks += 1
|
||||||
|
await asyncio.sleep(0)
|
||||||
|
|
||||||
|
original = qr.qrcode.make
|
||||||
|
|
||||||
|
def slow_make(data, *args, **kwargs):
|
||||||
|
# Blocking sleep: on the event loop this would freeze the ticker.
|
||||||
|
import time
|
||||||
|
|
||||||
|
time.sleep(0.05)
|
||||||
|
return original(data, *args, **kwargs)
|
||||||
|
|
||||||
|
qr.qrcode.make = slow_make
|
||||||
|
task = asyncio.create_task(ticker())
|
||||||
|
try:
|
||||||
|
assert (await client.get(f"/qr/{VALID_ADDRESS}")).status_code == 200
|
||||||
|
finally:
|
||||||
|
qr.qrcode.make = original
|
||||||
|
task.cancel()
|
||||||
|
|
||||||
|
assert ticks > 1
|
||||||
@@ -134,6 +134,92 @@ async def test_jackpot_comes_from_the_participants_actual_bets(client):
|
|||||||
assert body["jackpot_sats"] == (999_800_000 * 2) * 70 // 100
|
assert body["jackpot_sats"] == (999_800_000 * 2) * 70 // 100
|
||||||
|
|
||||||
|
|
||||||
|
async def test_advertised_jackpot_covers_only_the_bets_that_will_be_paid(client): # B-65
|
||||||
|
"""The draw picks from confirmed participants and the payout spends only their
|
||||||
|
sats, so counting every participant row advertised a jackpot bigger than the one
|
||||||
|
that would actually be paid — and let a player appear in the count and then
|
||||||
|
vanish again if their bet was abandoned. The confirmed figures are the headline
|
||||||
|
ones; what's in flight is reported alongside, never folded in."""
|
||||||
|
from app.db.models import Round, RoundConfig, RoundParticipant
|
||||||
|
|
||||||
|
ac, session_factory = client
|
||||||
|
|
||||||
|
async with session_factory() as session:
|
||||||
|
session.add(RoundConfig(fee_address="", bet_amount_sats=1_000_000_000))
|
||||||
|
session.add(Round(id=60, status="open"))
|
||||||
|
await session.flush()
|
||||||
|
session.add(
|
||||||
|
RoundParticipant(round_id=60, user_id=1, bet_amount_sats=999_800_000, bet_txid="a", status="confirmed")
|
||||||
|
)
|
||||||
|
# One mid-broadcast and one written but not yet broadcast: both in flight,
|
||||||
|
# neither drawn from nor spent by the payout as things stand.
|
||||||
|
session.add(
|
||||||
|
RoundParticipant(round_id=60, user_id=2, bet_amount_sats=999_800_000, bet_txid="b", status="broadcast")
|
||||||
|
)
|
||||||
|
session.add(
|
||||||
|
RoundParticipant(round_id=60, user_id=3, bet_amount_sats=999_800_000, bet_txid="c", status="building")
|
||||||
|
)
|
||||||
|
await session.commit()
|
||||||
|
|
||||||
|
body = (await ac.get("/rounds/current")).json()
|
||||||
|
|
||||||
|
assert body["participant_count"] == 1
|
||||||
|
assert body["jackpot_sats"] == 999_800_000 * 70 // 100
|
||||||
|
# Inclusive, like pending_balance_sats — not a delta.
|
||||||
|
assert body["pending_participant_count"] == 3
|
||||||
|
assert body["pending_jackpot_sats"] == (999_800_000 * 3) * 70 // 100
|
||||||
|
assert body["has_pending_bets"] is True
|
||||||
|
|
||||||
|
|
||||||
|
async def test_no_pending_bets_reported_once_every_bet_has_confirmed(client): # B-65
|
||||||
|
from app.db.models import Round, RoundConfig, RoundParticipant
|
||||||
|
|
||||||
|
ac, session_factory = client
|
||||||
|
|
||||||
|
async with session_factory() as session:
|
||||||
|
session.add(RoundConfig(fee_address="", bet_amount_sats=1_000_000_000))
|
||||||
|
session.add(Round(id=61, status="open"))
|
||||||
|
await session.flush()
|
||||||
|
session.add(
|
||||||
|
RoundParticipant(round_id=61, user_id=1, bet_amount_sats=999_800_000, bet_txid="a", status="confirmed")
|
||||||
|
)
|
||||||
|
await session.commit()
|
||||||
|
|
||||||
|
body = (await ac.get("/rounds/current")).json()
|
||||||
|
|
||||||
|
assert body["has_pending_bets"] is False
|
||||||
|
assert body["pending_participant_count"] == body["participant_count"] == 1
|
||||||
|
assert body["pending_jackpot_sats"] == body["jackpot_sats"]
|
||||||
|
|
||||||
|
|
||||||
|
async def test_lottery_configured_flags_a_missing_fee_address(client): # B-66
|
||||||
|
"""The frontend has to tell "the next round is coming" apart from "nothing is
|
||||||
|
coming until the operator finishes setting this up" — the banner says different
|
||||||
|
things, and only one of them is worth waiting for."""
|
||||||
|
from sqlalchemy import select
|
||||||
|
|
||||||
|
from app.db.models import RoundConfig
|
||||||
|
|
||||||
|
ac, session_factory = client
|
||||||
|
|
||||||
|
async with session_factory() as session:
|
||||||
|
session.add(RoundConfig(fee_address=""))
|
||||||
|
await session.commit()
|
||||||
|
|
||||||
|
body = (await ac.get("/rounds/current")).json()
|
||||||
|
assert body["lottery_configured"] is False
|
||||||
|
assert body["lottery_paused"] is False # not a pause: a prerequisite that isn't met
|
||||||
|
assert body["round_id"] is None # and indeed no round was opened
|
||||||
|
|
||||||
|
async with session_factory() as session:
|
||||||
|
(await session.scalars(select(RoundConfig))).one().fee_address = (
|
||||||
|
"plm1q5x25wd6q463mfhckjraaedgjg0lyu73qfcj43n"
|
||||||
|
)
|
||||||
|
await session.commit()
|
||||||
|
|
||||||
|
assert (await ac.get("/rounds/current")).json()["lottery_configured"] is True
|
||||||
|
|
||||||
|
|
||||||
async def test_draw_waiting_since_is_exposed_only_while_drawing(client):
|
async def test_draw_waiting_since_is_exposed_only_while_drawing(client):
|
||||||
"""B-36: the "drawing" wait on a future block has no timeout, so the frontend
|
"""B-36: the "drawing" wait on a future block has no timeout, so the frontend
|
||||||
needs draw_waiting_since to show "still waiting" instead of implying a bounded
|
needs draw_waiting_since to show "still waiting" instead of implying a bounded
|
||||||
|
|||||||
@@ -9,6 +9,7 @@ from app.db.models import Round, RoundConfig
|
|||||||
from app.rounds.service import get_active_round, open_new_round_if_needed
|
from app.rounds.service import get_active_round, open_new_round_if_needed
|
||||||
|
|
||||||
ROUND_COOLDOWN_SECONDS = 30 # matches RoundConfig.round_cooldown_seconds' column default
|
ROUND_COOLDOWN_SECONDS = 30 # matches RoundConfig.round_cooldown_seconds' column default
|
||||||
|
_FEE_ADDRESS = "plm1q5x25wd6q463mfhckjraaedgjg0lyu73qfcj43n"
|
||||||
|
|
||||||
|
|
||||||
@pytest.fixture
|
@pytest.fixture
|
||||||
@@ -16,6 +17,14 @@ async def session_factory():
|
|||||||
engine = create_async_engine("sqlite+aiosqlite:///:memory:")
|
engine = create_async_engine("sqlite+aiosqlite:///:memory:")
|
||||||
async with engine.begin() as conn:
|
async with engine.begin() as conn:
|
||||||
await conn.run_sync(Base.metadata.create_all)
|
await conn.run_sync(Base.metadata.create_all)
|
||||||
|
|
||||||
|
# B-66: no fee address means no round may open at all, which would make most of
|
||||||
|
# the assertions below pass for the wrong reason. Seeded once here so every test
|
||||||
|
# in this file runs against an instance that could actually pay a winner, and the
|
||||||
|
# ones that care about other config values edit this same single row.
|
||||||
|
async with async_sessionmaker(engine, expire_on_commit=False)() as session:
|
||||||
|
session.add(RoundConfig(fee_address=_FEE_ADDRESS))
|
||||||
|
await session.commit()
|
||||||
yield async_sessionmaker(engine, expire_on_commit=False)
|
yield async_sessionmaker(engine, expire_on_commit=False)
|
||||||
await engine.dispose()
|
await engine.dispose()
|
||||||
|
|
||||||
@@ -88,7 +97,7 @@ async def test_withholds_new_round_while_paused(session_factory):
|
|||||||
stale_close = datetime.now(timezone.utc) - timedelta(seconds=ROUND_COOLDOWN_SECONDS + 1)
|
stale_close = datetime.now(timezone.utc) - timedelta(seconds=ROUND_COOLDOWN_SECONDS + 1)
|
||||||
async with session_factory() as session:
|
async with session_factory() as session:
|
||||||
session.add(Round(status="closed", closed_at=stale_close))
|
session.add(Round(status="closed", closed_at=stale_close))
|
||||||
session.add(RoundConfig(fee_address="", paused=True))
|
(await session.scalars(select(RoundConfig))).one().paused = True
|
||||||
await session.commit()
|
await session.commit()
|
||||||
|
|
||||||
async with session_factory() as session:
|
async with session_factory() as session:
|
||||||
@@ -99,7 +108,7 @@ async def test_withholds_new_round_while_paused(session_factory):
|
|||||||
async def test_pause_does_not_interrupt_a_round_in_progress(session_factory):
|
async def test_pause_does_not_interrupt_a_round_in_progress(session_factory):
|
||||||
async with session_factory() as session:
|
async with session_factory() as session:
|
||||||
session.add(Round(status="drawing"))
|
session.add(Round(status="drawing"))
|
||||||
session.add(RoundConfig(fee_address="", paused=True))
|
(await session.scalars(select(RoundConfig))).one().paused = True
|
||||||
await session.commit()
|
await session.commit()
|
||||||
|
|
||||||
async with session_factory() as session:
|
async with session_factory() as session:
|
||||||
@@ -173,12 +182,73 @@ async def test_closed_rounds_can_coexist_with_an_active_one(session_factory):
|
|||||||
assert len((await session.scalars(select(Round))).all()) == 3
|
assert len((await session.scalars(select(Round))).all()) == 3
|
||||||
|
|
||||||
|
|
||||||
|
# --- B-66: no round opens on an instance that could not pay its winner ------------
|
||||||
|
|
||||||
|
|
||||||
|
async def test_withholds_new_round_while_no_fee_address_is_configured(session_factory): # B-66
|
||||||
|
"""A fresh instance starts with no fee_address, and the payout pays the 30%
|
||||||
|
commission to it — so a round opened without one takes bets, confirms them, and
|
||||||
|
only then discovers it cannot be paid, wedging in "paying_out" with money already
|
||||||
|
in the pool and needing manual recovery. Every round, until an operator notices."""
|
||||||
|
async with session_factory() as session:
|
||||||
|
(await session.scalars(select(RoundConfig))).one().fee_address = ""
|
||||||
|
await session.commit()
|
||||||
|
|
||||||
|
async with session_factory() as session:
|
||||||
|
assert await open_new_round_if_needed(session) is None
|
||||||
|
|
||||||
|
async with session_factory() as session:
|
||||||
|
assert (await session.scalars(select(Round))).all() == [] # nothing opened at all
|
||||||
|
|
||||||
|
|
||||||
|
async def test_opens_a_round_as_soon_as_a_fee_address_is_set(session_factory): # B-66
|
||||||
|
async with session_factory() as session:
|
||||||
|
(await session.scalars(select(RoundConfig))).one().fee_address = ""
|
||||||
|
await session.commit()
|
||||||
|
|
||||||
|
async with session_factory() as session:
|
||||||
|
assert await open_new_round_if_needed(session) is None
|
||||||
|
|
||||||
|
async with session_factory() as session:
|
||||||
|
(await session.scalars(select(RoundConfig))).one().fee_address = _FEE_ADDRESS
|
||||||
|
await session.commit()
|
||||||
|
|
||||||
|
async with session_factory() as session:
|
||||||
|
round_ = await open_new_round_if_needed(session)
|
||||||
|
await session.commit()
|
||||||
|
assert round_ is not None and round_.status == "open"
|
||||||
|
|
||||||
|
|
||||||
|
async def test_a_round_in_progress_survives_the_fee_address_being_cleared(session_factory): # B-66
|
||||||
|
"""Same rule as pausing: an unmet prerequisite only stops the *next* round. The
|
||||||
|
one in progress keeps its participants and still has to be drawn and paid — and
|
||||||
|
clearing the address is exactly the mistake an operator might make mid-round."""
|
||||||
|
async with session_factory() as session:
|
||||||
|
session.add(Round(status="open"))
|
||||||
|
(await session.scalars(select(RoundConfig))).one().fee_address = ""
|
||||||
|
await session.commit()
|
||||||
|
|
||||||
|
async with session_factory() as session:
|
||||||
|
returned = await open_new_round_if_needed(session)
|
||||||
|
assert returned is not None and returned.status == "open"
|
||||||
|
|
||||||
|
|
||||||
|
def test_rounds_can_open_ignores_a_whitespace_only_fee_address(): # B-66
|
||||||
|
from app.rounds.service import rounds_can_open
|
||||||
|
|
||||||
|
assert rounds_can_open(RoundConfig(fee_address=_FEE_ADDRESS)) is True
|
||||||
|
assert rounds_can_open(RoundConfig(fee_address="")) is False
|
||||||
|
assert rounds_can_open(RoundConfig(fee_address=" ")) is False
|
||||||
|
|
||||||
|
|
||||||
# --- B-61: a round runs by the timing it opened with, not by the live config ------
|
# --- B-61: a round runs by the timing it opened with, not by the live config ------
|
||||||
|
|
||||||
|
|
||||||
async def test_a_new_round_snapshots_the_current_config_timing(session_factory):
|
async def test_a_new_round_snapshots_the_current_config_timing(session_factory):
|
||||||
async with session_factory() as session:
|
async with session_factory() as session:
|
||||||
session.add(RoundConfig(fee_address="", round_duration_seconds=120, round_cooldown_seconds=45))
|
config = (await session.scalars(select(RoundConfig))).one()
|
||||||
|
config.round_duration_seconds = 120
|
||||||
|
config.round_cooldown_seconds = 45
|
||||||
await session.commit()
|
await session.commit()
|
||||||
|
|
||||||
async with session_factory() as session:
|
async with session_factory() as session:
|
||||||
@@ -205,7 +275,7 @@ async def test_cooldown_comes_from_the_round_that_closed(session_factory):
|
|||||||
round_cooldown_seconds afterwards must not open the next round early, nor
|
round_cooldown_seconds afterwards must not open the next round early, nor
|
||||||
lengthening it hold the lottery shut."""
|
lengthening it hold the lottery shut."""
|
||||||
async with session_factory() as session:
|
async with session_factory() as session:
|
||||||
session.add(RoundConfig(fee_address="", round_cooldown_seconds=0)) # just lowered to 0
|
(await session.scalars(select(RoundConfig))).one().round_cooldown_seconds = 0 # just lowered
|
||||||
session.add(
|
session.add(
|
||||||
Round(
|
Round(
|
||||||
status="closed",
|
status="closed",
|
||||||
|
|||||||
@@ -446,6 +446,63 @@ async def test_wait_for_next_block_retries_after_a_failed_corroboration(session_
|
|||||||
assert events == ["draw_header_corroboration_failed"]
|
assert events == ["draw_header_corroboration_failed"]
|
||||||
|
|
||||||
|
|
||||||
|
# --- B-63: an unknown tip at closing time must not become the draw's seed --------
|
||||||
|
|
||||||
|
|
||||||
|
class LateTipListener:
|
||||||
|
"""A listener that doesn't know the tip yet and learns it only once asked —
|
||||||
|
the state the old code could observe while `client` already looked alive."""
|
||||||
|
|
||||||
|
def __init__(self, *, learns: tuple[int, str], then_advances_to: tuple[int, str]):
|
||||||
|
self.tip_height = 0
|
||||||
|
self.tip_header_hex = None
|
||||||
|
self._learns = learns
|
||||||
|
self._then_advances_to = then_advances_to
|
||||||
|
self.corroboration_calls: list[int] = []
|
||||||
|
|
||||||
|
def learn_tip(self) -> None:
|
||||||
|
self.tip_height, self.tip_header_hex = self._learns
|
||||||
|
|
||||||
|
async def corroborate_header(self, height: int, expected_hash: str) -> bool:
|
||||||
|
self.corroboration_calls.append(height)
|
||||||
|
return True
|
||||||
|
|
||||||
|
|
||||||
|
async def test_wait_for_next_block_never_seeds_the_draw_from_a_pre_close_block(
|
||||||
|
session_factory, monkeypatch
|
||||||
|
): # B-63
|
||||||
|
"""A tip_at_close of 0 means the tip was *unknown* when the round closed, not
|
||||||
|
that the chain was at height zero. The first header we then learn describes a
|
||||||
|
block that may well predate the close — whose hash was public while bets were
|
||||||
|
still open — so it must become the baseline, never the seed: the draw waits for a
|
||||||
|
block strictly after it."""
|
||||||
|
import app.rounds.scheduler as scheduler_module
|
||||||
|
|
||||||
|
listener = LateTipListener(learns=(500, "aa"), then_advances_to=(501, "bb"))
|
||||||
|
scheduler = RoundScheduler(session_factory, listener)
|
||||||
|
|
||||||
|
async def fake_sleep(_seconds):
|
||||||
|
# First sleep: the tip becomes known (height 500, the pre-close block).
|
||||||
|
# Second: a genuinely new block arrives on top of it.
|
||||||
|
if listener.tip_height == 0:
|
||||||
|
listener.learn_tip()
|
||||||
|
else:
|
||||||
|
listener.tip_height, listener.tip_header_hex = listener._then_advances_to
|
||||||
|
|
||||||
|
monkeypatch.setattr(scheduler_module.asyncio, "sleep", fake_sleep)
|
||||||
|
|
||||||
|
height, _block_hash = await scheduler._wait_for_next_block(
|
||||||
|
round_id=1, tip_at_close=0, waiting_since=datetime.now(timezone.utc)
|
||||||
|
)
|
||||||
|
|
||||||
|
assert height == 501 # the block *after* the one we first learned about
|
||||||
|
assert listener.corroboration_calls == [501] # 500 was never even a candidate
|
||||||
|
|
||||||
|
async with session_factory() as session:
|
||||||
|
events = [e.event_type for e in (await session.scalars(select(AuditLog))).all()]
|
||||||
|
assert events == ["draw_baseline_tip_unknown"] # explainable from /admin
|
||||||
|
|
||||||
|
|
||||||
# --- B-36: a stalled draw must be visible, not a silent frozen wait --------------
|
# --- B-36: a stalled draw must be visible, not a silent frozen wait --------------
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@@ -5,12 +5,15 @@ from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
|
|||||||
from app.bets.service import place_bet
|
from app.bets.service import place_bet
|
||||||
from app.config import settings
|
from app.config import settings
|
||||||
from app.db.base import Base
|
from app.db.base import Base
|
||||||
from app.db.models import PendingTransaction, User, UtxoEvent, Withdrawal
|
from app.db.models import PendingTransaction, RoundConfig, User, UtxoEvent, Withdrawal
|
||||||
from app.rounds.events import broadcaster
|
from app.rounds.events import broadcaster
|
||||||
from app.wallet.hd import derive_user_address
|
from app.wallet.hd import derive_user_address
|
||||||
from app.withdrawals.service import WithdrawalError, request_withdrawal
|
from app.withdrawals.service import WithdrawalError, request_withdrawal
|
||||||
|
|
||||||
|
|
||||||
|
_FEE_ADDRESS = "plm1q5x25wd6q463mfhckjraaedgjg0lyu73qfcj43n"
|
||||||
|
|
||||||
|
|
||||||
class FakeElectrumClient:
|
class FakeElectrumClient:
|
||||||
def __init__(self):
|
def __init__(self):
|
||||||
self.broadcasted: list[str] = []
|
self.broadcasted: list[str] = []
|
||||||
@@ -40,6 +43,13 @@ async def session_factory(tmp_path, monkeypatch):
|
|||||||
engine = create_async_engine("sqlite+aiosqlite:///:memory:")
|
engine = create_async_engine("sqlite+aiosqlite:///:memory:")
|
||||||
async with engine.begin() as conn:
|
async with engine.begin() as conn:
|
||||||
await conn.run_sync(Base.metadata.create_all)
|
await conn.run_sync(Base.metadata.create_all)
|
||||||
|
|
||||||
|
# B-66: a round only opens on an instance that could actually pay a winner, so
|
||||||
|
# every test that expects one needs a fee address configured — the column has no
|
||||||
|
# default on purpose (an operator must set their own).
|
||||||
|
async with async_sessionmaker(engine, expire_on_commit=False)() as session:
|
||||||
|
session.add(RoundConfig(fee_address=_FEE_ADDRESS))
|
||||||
|
await session.commit()
|
||||||
yield async_sessionmaker(engine, expire_on_commit=False)
|
yield async_sessionmaker(engine, expire_on_commit=False)
|
||||||
await engine.dispose()
|
await engine.dispose()
|
||||||
hd._account_key = None
|
hd._account_key = None
|
||||||
@@ -291,3 +301,57 @@ async def test_a_bet_with_a_dust_limit_of_headroom_is_accepted(session_factory):
|
|||||||
participant = await place_bet(session, client, user)
|
participant = await place_bet(session, client, user)
|
||||||
|
|
||||||
assert participant.status == "broadcast"
|
assert participant.status == "broadcast"
|
||||||
|
|
||||||
|
|
||||||
|
async def test_withdrawal_is_allowed_while_a_bet_is_still_unconfirmed(session_factory):
|
||||||
|
"""B-70: the flowchart's WITHDRAW node used to state that a withdrawal cannot
|
||||||
|
happen together with a bet in progress. It can, and should: the hazard is the two
|
||||||
|
picking the *same* UTXO, which is already excluded twice over — the per-user lock
|
||||||
|
(app/tx/locks.py) keeps the two builds from ever being in flight at once, and
|
||||||
|
select_utxos skips anything already marked spent_txid. What is left is untouched,
|
||||||
|
confirmed money, and freezing it for a block just because a bet is in flight would
|
||||||
|
be a restriction with no safety behind it. The diagram was corrected to match."""
|
||||||
|
user_id = await _make_funded_user(session_factory, 43, 2_000_000_000)
|
||||||
|
async with session_factory() as session:
|
||||||
|
# A second confirmed UTXO the bet won't touch (select_utxos is largest-first).
|
||||||
|
session.add(
|
||||||
|
UtxoEvent(user_id=user_id, txid="ab" * 32, vout=1, amount_sats=1_500_000_000, confirmed_height=100)
|
||||||
|
)
|
||||||
|
await session.commit()
|
||||||
|
|
||||||
|
bet_client = FakeElectrumClient()
|
||||||
|
async with session_factory() as session:
|
||||||
|
user = await session.get(User, user_id)
|
||||||
|
participant = await place_bet(session, bet_client, user)
|
||||||
|
assert participant.status == "broadcast" # broadcast, not yet confirmed
|
||||||
|
|
||||||
|
withdraw_client = FakeElectrumClient()
|
||||||
|
async with session_factory() as session:
|
||||||
|
user = await session.get(User, user_id)
|
||||||
|
withdrawal = await request_withdrawal(session, withdraw_client, user, EXTERNAL_ADDRESS, BET_AMOUNT_SATS)
|
||||||
|
|
||||||
|
assert withdrawal.status == "broadcast"
|
||||||
|
assert withdraw_client.broadcasted
|
||||||
|
|
||||||
|
async with session_factory() as session:
|
||||||
|
utxos = (await session.scalars(select(UtxoEvent).where(UtxoEvent.user_id == user_id))).all()
|
||||||
|
spenders = {u.amount_sats: u.spent_txid for u in utxos}
|
||||||
|
# Each transaction took its own input; neither is spending the other's.
|
||||||
|
assert spenders[2_000_000_000] != spenders[1_500_000_000]
|
||||||
|
assert all(txid is not None for txid in spenders.values())
|
||||||
|
pending_kinds = {
|
||||||
|
p.kind for p in (await session.scalars(select(PendingTransaction))).all()
|
||||||
|
}
|
||||||
|
assert pending_kinds == {"bet", "withdrawal"}
|
||||||
|
|
||||||
|
|
||||||
|
def test_the_flowchart_no_longer_claims_bets_and_withdrawals_are_exclusive():
|
||||||
|
from pathlib import Path
|
||||||
|
|
||||||
|
diagram = (
|
||||||
|
Path(__file__).resolve().parents[2] / "flowchart" / "platform-overview.mmd"
|
||||||
|
).read_text(encoding="utf-8")
|
||||||
|
node = [line for line in diagram.splitlines() if line.strip().startswith("E1[")]
|
||||||
|
assert len(node) == 1
|
||||||
|
assert "non puo' avvenire insieme" not in node[0]
|
||||||
|
assert "saldo confermato" in node[0]
|
||||||
Reference in new issue
Block a user