Add round lifecycle, draw algorithm and scheduler

Periodic scheduler (configurable round duration) that closes a round
only once all broadcast bets confirm, waits for the next block after
closing, draws a winner via block-hash-seeded modulo over participants
ordered by broadcast time, triggers the 70/30 payout, and only opens the
next round once that payout confirms. Draw logic is isolated in
draw.py as a deliberately simple, replaceable component.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

tests/unit/test_draw.py

@@ -0,0 +1,32 @@
+import pytest
+
+from app.rounds.draw import draw_winner, header_hex_to_block_hash
+
+
+def test_header_hex_to_block_hash_matches_known_mainnet_block():
+    # Real PLM mainnet block 477486: header from blockchain.block.header, hash
+    # cross-checked against the blockhash reported by blockchain.transaction.get
+    # for a tx confirmed in that block.
+    header_hex = (
+        "0020ed30fbc39ee45200d10214f5107c5f36e7bf753032fd1d3279810c170000000000"
+        "009a4ea723f732be4c538f3a2490837dd6560103d73ece606aa7d578a66700447b28875"
+        "e6a47a61b1ad8012582"
+    )
+    known_block_hash = "00000000000008788b55ade13b74d54ceffda9e54315b802411be1ca65064e86"
+    assert header_hex_to_block_hash(header_hex) == known_block_hash
+
+
+def test_draw_winner_is_deterministic_and_within_range():
+    participants = ["addrA", "addrB", "addrC"]
+    block_hash = "00" * 31 + "05"  # seed = 5, index = 5 % 3 = 2
+    assert draw_winner(participants, block_hash) == "addrC"
+
+
+def test_draw_winner_single_participant_always_wins():
+    block_hash = "ff" * 32
+    assert draw_winner(["only"], block_hash) == "only"
+
+
+def test_draw_winner_raises_on_empty_participants():
+    with pytest.raises(ValueError):
+        draw_winner([], "00" * 32)

tests/unit/test_rounds_service.py

@@ -0,0 +1,58 @@
+import pytest
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+
+from app.db.base import Base
+from app.db.models import Round
+from app.rounds.service import get_active_round, open_new_round_if_needed
+
+
+@pytest.fixture
+async def session_factory():
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    yield async_sessionmaker(engine, expire_on_commit=False)
+    await engine.dispose()
+
+
+async def test_opens_a_round_when_none_exists(session_factory):
+    async with session_factory() as session:
+        round_ = await open_new_round_if_needed(session)
+        await session.commit()
+        assert round_.status == "open"
+
+
+async def test_reuses_existing_open_round(session_factory):
+    async with session_factory() as session:
+        first = await open_new_round_if_needed(session)
+        await session.commit()
+        first_id = first.id
+
+    async with session_factory() as session:
+        second = await open_new_round_if_needed(session)
+        assert second.id == first_id
+
+
+@pytest.mark.parametrize("status", ["closing", "drawing", "paying_out"])
+async def test_does_not_open_new_round_while_previous_is_in_progress(session_factory, status):
+    async with session_factory() as session:
+        session.add(Round(status=status))
+        await session.commit()
+
+    async with session_factory() as session:
+        active = await get_active_round(session)
+        assert active is not None
+        assert active.status == status
+        # open_new_round_if_needed must return the in-progress round, not open a new one
+        returned = await open_new_round_if_needed(session)
+        assert returned.status == status
+
+
+async def test_opens_new_round_after_previous_is_closed(session_factory):
+    async with session_factory() as session:
+        session.add(Round(status="closed"))
+        await session.commit()
+
+    async with session_factory() as session:
+        round_ = await open_new_round_if_needed(session)
+        assert round_.status == "open"

tests/unit/test_scheduler.py

@@ -0,0 +1,55 @@
+from datetime import datetime, timedelta, timezone
+
+import pytest
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+
+from app.config import settings
+from app.db.base import Base
+from app.db.models import Round
+from app.rounds.scheduler import RoundScheduler
+
+
+class FakeListener:
+    client = object()  # truthy sentinel; _tick only checks "is not None"
+    tip_height = 100
+    tip_header_hex = "00"
+
+
+@pytest.fixture
+async def session_factory():
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    yield async_sessionmaker(engine, expire_on_commit=False)
+    await engine.dispose()
+
+
+async def test_tick_survives_sqlite_naive_datetime_roundtrip(session_factory, monkeypatch):
+    """Regression test: SQLite drops tzinfo on round-trip, so opened_at comes back
+    naive even though it was written as an aware UTC datetime. A prior bug compared
+    it directly against datetime.now(timezone.utc) and crashed with
+    "can't compare offset-naive and offset-aware datetimes" on every tick once a
+    round existed — this must not happen."""
+    monkeypatch.setattr(settings, "round_duration_seconds", 3600)  # not due yet
+    async with session_factory() as session:
+        session.add(Round(status="open", opened_at=datetime.now(timezone.utc)))
+        await session.commit()
+
+    scheduler = RoundScheduler(session_factory, FakeListener())
+    await scheduler._tick()  # must not raise
+
+
+async def test_tick_closes_round_with_no_participants_once_due(session_factory, monkeypatch):
+    monkeypatch.setattr(settings, "round_duration_seconds", 1)
+    past = datetime.now(timezone.utc) - timedelta(seconds=10)
+    async with session_factory() as session:
+        session.add(Round(status="open", opened_at=past))
+        await session.commit()
+
+    scheduler = RoundScheduler(session_factory, FakeListener())
+    await scheduler._tick()
+
+    async with session_factory() as session:
+        round_ = (await session.scalars(select(Round))).one()
+        assert round_.status == "closed"