diff --git a/config.json b/config.json index 02272e3..03be67f 100644 --- a/config.json +++ b/config.json @@ -1,6 +1,6 @@ { "id": "events", - "version": "1.6.1-aio.7", + "version": "1.6.1-aio.5", "name": "Events", "repo": "https://git.atitlan.io/aiolabs/events", "short_description": "Sell and register event tickets", diff --git a/models.py b/models.py index 7f1feac..04520a0 100644 --- a/models.py +++ b/models.py @@ -183,10 +183,6 @@ class TicketPaymentRequest(BaseModel): fiat_payment_request: str | None = None fiat_provider: str | None = None is_fiat: bool = False - # True when the tickets are already issued + paid with no invoice to - # settle — free events (price 0) or a 100%-off promo. The client skips - # the QR / payment-poll step and goes straight to the ticket QRs. - paid: bool = False # Row ids created on this invoice — one for single-ticket # purchases, N for multi-ticket (each independently scannable at # the door). Buyers fetch these after payment to render N QRs in diff --git a/nostr_publisher.py b/nostr_publisher.py index 2588fcb..81324fc 100644 --- a/nostr_publisher.py +++ b/nostr_publisher.py @@ -19,7 +19,6 @@ from loguru import logger from .models import Event from .nostr.event import NostrEvent -from .nostr_timestamp import monotonic_created_at def _has_time(value: str | None) -> bool: @@ -111,15 +110,9 @@ def build_nip52_event(event: Event, pubkey: str) -> NostrEvent: if event.fiat_currency: tags.append(["tickets_fiat_currency", event.fiat_currency]) - # NIP-52 calendar events are replaceable: this d-tag is republished - # whenever inventory changes (a ticket sells). Use a strictly-monotonic - # created_at anchored on the last published value so a same-second - # republish still outranks the prior version and relays push it to open - # subscriptions — a bare int(time.time()) can tie and be silently - # dropped, stalling clients' live "tickets remaining" badge. nostr_event = NostrEvent( pubkey=pubkey, - created_at=monotonic_created_at(event.nostr_event_created_at), + created_at=int(time.time()), kind=kind, tags=tags, content=event.info or "", diff --git a/nostr_timestamp.py b/nostr_timestamp.py deleted file mode 100644 index 625b21c..0000000 --- a/nostr_timestamp.py +++ /dev/null @@ -1,34 +0,0 @@ -"""Monotonic ``created_at`` for replaceable / addressable Nostr events. - -Relays only push a replaceable update to OPEN subscriptions when its -``created_at`` is strictly newer than the version they already hold. -``created_at`` is integer seconds, so a publisher that stamps -``int(time.time())`` can emit two versions within the same wall-clock -second (e.g. two ticket sales republishing the NIP-52 calendar event) — -the relay treats the second as not-newer and never propagates it to live -subscribers (it only surfaces on a reload / fresh REQ). - -Returning ``max(now, last_created_at + 1)`` guarantees a strictly -increasing timestamp across successive publishes of the same replaceable -event. When enough real seconds have elapsed it tracks wall-clock; only -same-second (or clock-skewed) republishes get nudged forward. - -Mirrors the webapp's ``monotonicCreatedAt`` (src/lib/nostr/timestamp.ts) -and ``docs/nostr-patterns/replaceable-events.md``. -""" - -import time - - -def monotonic_created_at(last_created_at: int | None, now: int | None = None) -> int: - """Strictly-newer ``created_at`` for the next publish of a coord. - - :param last_created_at: ``created_at`` of the previously published - version (seconds), or ``None`` if none has been published yet. - :param now: Current time in seconds — injectable for tests; defaults - to ``int(time.time())``. - """ - base = int(time.time()) if now is None else now - if last_created_at is None: - return base - return max(base, last_created_at + 1) diff --git a/tests/test_nostr_timestamp.py b/tests/test_nostr_timestamp.py deleted file mode 100644 index 693a997..0000000 --- a/tests/test_nostr_timestamp.py +++ /dev/null @@ -1,32 +0,0 @@ -from itertools import pairwise - -from ..nostr_timestamp import monotonic_created_at - - -def test_no_prior_uses_now(): - assert monotonic_created_at(None, now=1000) == 1000 - - -def test_same_second_bumps_past_prior(): - # now == last: a naive int(time.time()) would tie and the relay would - # drop the update; we must produce a strictly newer stamp. - assert monotonic_created_at(1000, now=1000) == 1001 - - -def test_tracks_wallclock_once_seconds_elapse(): - assert monotonic_created_at(1000, now=1005) == 1005 - - -def test_steps_past_future_dated_prior(): - # clock skew / rapid bursts left the stored value ahead of now - assert monotonic_created_at(2000, now=1000) == 2001 - - -def test_strictly_increasing_same_second_burst(): - last = None - stamps = [] - for _ in range(5): - last = monotonic_created_at(last, now=1000) # clock frozen at 1000 - stamps.append(last) - assert stamps == [1000, 1001, 1002, 1003, 1004] - assert all(b > a for a, b in pairwise(stamps)) diff --git a/views_api.py b/views_api.py index 5ced0ef..14d60e2 100644 --- a/views_api.py +++ b/views_api.py @@ -66,12 +66,7 @@ from .models import ( TicketPaymentRequest, ) from .nostr_hooks import publish_or_delete_nostr_event -from .services import ( - refund_tickets, - resend_ticket_email_notification, - send_ticket_notification_in_background, - set_ticket_paid, -) +from .services import refund_tickets, resend_ticket_email_notification from .tasks import deregister_payment_listener, register_payment_listener events_api_router = APIRouter(prefix="/api/v1/events") @@ -513,62 +508,6 @@ async def api_get_ticket(ticket_id: str) -> Ticket: return ticket -async def _issue_free_tickets( - *, - event: Event, - quantity: int, - name: str | None, - email: str | None, - user_id: str | None, - promo_code: str | None, - nostr_identifier: str | None, - request: Request, -) -> TicketPaymentRequest: - """Issue `quantity` free tickets without minting an invoice. - - Each row is created then run through `set_ticket_paid` — the exact path - `on_invoice_paid` drives for a settled payment: it flips `paid`, bumps - the sold / available counters under the per-event lock, and republishes - the NIP-52 calendar event so connected clients see the new counts. - Notifications fire the same way. No invoice exists, so `sats_paid` is 0 - and these tickets are naturally skipped by `refund_tickets`. - - All rows in the batch share one synthetic `payment_hash` — the join key - the poll / WebSocket / My-Tickets lookups use — mirroring how the paid - multi-ticket path shares the real invoice hash. - """ - payment_hash = urlsafe_short_hash() - ticket_ids: list[str] = [] - for _ in range(quantity): - row_id = urlsafe_short_hash() - ticket = await create_ticket( - payment_hash=payment_hash, - wallet=event.wallet, - event=event.id, - name=name, - email=email, - user_id=user_id, - ticket_id=row_id, - extra={ - "applied_promo_code": promo_code, - "nostr_identifier": nostr_identifier, - "ticket_base_url": str(request.base_url).rstrip("/"), - "sats_paid": 0, - }, - ) - await set_ticket_paid(ticket) - send_ticket_notification_in_background(ticket) - ticket_ids.append(row_id) - - return TicketPaymentRequest( - payment_hash=payment_hash, - payment_request=None, - is_fiat=False, - paid=True, - ticket_ids=ticket_ids, - ) - - @tickets_api_router.post("/{event_id}") async def api_ticket_create( event_id: str, data: CreateTicket, request: Request @@ -632,22 +571,6 @@ async def api_ticket_create( # Scale by quantity AFTER the promo applies. One invoice, N tickets. price = unit_price * quantity - # Free tickets (final charge 0 — a free event or a 100%-off promo). - # Short-circuit before any invoice / fiat-provider logic: no Lightning - # invoice can settle for 0, so we issue the rows and mark them paid - # directly. payment_method is irrelevant here (nothing is charged). - if price <= 0: - return await _issue_free_tickets( - event=event, - quantity=quantity, - name=name, - email=email, - user_id=user_id, - promo_code=promo_code, - nostr_identifier=nostr_identifier, - request=request, - ) - if payment_method == "fiat" and not event.allow_fiat: raise HTTPException( status_code=HTTPStatus.BAD_REQUEST,