From 37fad05c1faaab9a6c75dfea03f3efad6e2bbeaf Mon Sep 17 00:00:00 2001 From: Padreug Date: Sun, 24 May 2026 18:56:07 +0200 Subject: [PATCH 1/8] chore: bump config.json version to 1.6.1-aio.3 --- config.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config.json b/config.json index 57a7f75..021565f 100644 --- a/config.json +++ b/config.json @@ -1,6 +1,6 @@ { "id": "events", - "version": "1.6.1-aio.1", + "version": "1.6.1-aio.3", "name": "Events", "repo": "https://git.atitlan.io/aiolabs/events", "short_description": "Sell and register event tickets", From 66076d6ca75295ce27bd68c8b6e87801ea83dcb5 Mon Sep 17 00:00:00 2001 From: Padreug Date: Wed, 27 May 2026 21:55:56 +0200 Subject: [PATCH 2/8] =?UTF-8?q?feat(signer):=20migrate=20Nostr=20publishin?= =?UTF-8?q?g=20off=20account.prvkey=20=E2=86=92=20resolve=5Ffor=5Fwallet?= =?UTF-8?q?=20(#23)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes aiolabs/events#23. Pre-cascade prerequisite for aiolabs/lnbits#17 (signer abstraction phase 1), which lands an m002 startup job that NULLs the legacy `accounts.prvkey` column. After this migration, the events extension reads no plaintext nsec and works with any NostrSigner backend (LocalSigner / RemoteBunkerSigner / ClientSideOnlySigner). ## What changed ### nostr_hooks.py — publish_or_delete_nostr_event Was: pulled `(account.pubkey, account.prvkey)` from the wallet owner, passed both to `publish_event_to_nostr`. Hard-skipped publish when `account.prvkey` was None. Now: calls `await resolve_for_wallet(event.wallet)` (the DRY helper from aiolabs/lnbits#23 — wallet → account → signer → can_sign-check in one call, returns None on any soft-fail). Passes the resolved `NostrSigner` to the publisher. Soft-skip on None (wallet missing, account unclassified, or ClientSideOnlySigner where the server has no signing authority) — matching previous "no prvkey" behavior. ### nostr_publisher.py — publish_event_to_nostr Was: accepted `(account_pubkey, account_prvkey)` and signed via a local `sign_nostr_event` helper that called `coincurve.PrivateKey .sign_schnorr` directly on the plaintext nsec. Now: accepts `signer: NostrSigner`. Builds the unsigned event dict (`kind`/`created_at`/`tags`/`content`), hands it to `await signer.sign_event(...)`, reconstructs the local `NostrEvent` model from the signed dict (`id`/`pubkey`/`sig` fields). The signer backend (LocalSigner / RemoteBunkerSigner) is transparent. Removed the `sign_nostr_event` helper entirely — the signer abstraction handles all signing now. Dropped the `coincurve` import; no direct crypto in this extension. ## Acceptance - [x] keypair helper replaced (nostr_hooks no longer touches account.prvkey) - [x] publish_event_to_nostr accepts NostrSigner instead of (pubkey, prvkey) - [x] extension-local Schnorr code removed (sign_nostr_event gone) - [x] re-grep `events/`: zero `account.prvkey` references - [x] version bumped: 1.6.1-aio.3 → 1.6.1-aio.4 Manual smoke testing + tag + catalog entry follow the migration landing; will run against the regtest stack with lnbits on `issue-18-phase-2.3` (which validates both LocalSigner and RemoteBunkerSigner signing paths end-to-end). ## Cross-references - aiolabs/events#23 — issue this commit closes - aiolabs/lnbits#17 — the cascading signer-abstraction PR - aiolabs/lnbits#23 — the resolve_for_wallet helper this uses - aiolabs/lnbits#26 — phase 2.3 (sign_event over bunker, validated against aiolabs/nsecbunkerd@fb1c239) - aiolabs/lnbits#21 — umbrella audit identifying 5 affected extensions Co-Authored-By: Claude Opus 4.7 (1M context) --- config.json | 2 +- nostr_hooks.py | 27 ++++++++++++++++----------- nostr_publisher.py | 42 +++++++++++++++++++++++++++--------------- 3 files changed, 44 insertions(+), 27 deletions(-) diff --git a/config.json b/config.json index 021565f..9691da4 100644 --- a/config.json +++ b/config.json @@ -1,6 +1,6 @@ { "id": "events", - "version": "1.6.1-aio.3", + "version": "1.6.1-aio.4", "name": "Events", "repo": "https://git.atitlan.io/aiolabs/events", "short_description": "Sell and register event tickets", diff --git a/nostr_hooks.py b/nostr_hooks.py index 3211b24..32ea11c 100644 --- a/nostr_hooks.py +++ b/nostr_hooks.py @@ -15,25 +15,30 @@ from .nostr_publisher import publish_event_to_nostr async def publish_or_delete_nostr_event(event: Event, *, delete: bool = False) -> None: """Publish or delete the NIP-52 calendar event for `event`. - Pulls the wallet owner's pubkey/prvkey to sign with the user's identity. - Failures are logged and swallowed so a Nostr outage doesn't break the - HTTP flow that triggered the publish. + Resolves a `NostrSigner` for the wallet owner — backend-agnostic + (LocalSigner / RemoteBunkerSigner / ClientSideOnlySigner). The + signer abstraction handles the actual key material; this hook + only needs `signer.pubkey` for event construction and + `await signer.sign_event(...)` for signing. Failures are logged + and swallowed so a Nostr outage doesn't break the HTTP flow that + triggered the publish. """ try: - from lnbits.core.crud.users import get_account - from lnbits.core.crud.wallets import get_wallet + from lnbits.core.signers import resolve_for_wallet from . import nostr_client - wallet_obj = await get_wallet(event.wallet) - if not wallet_obj: - return - account = await get_account(wallet_obj.user) - if not account or not account.pubkey or not account.prvkey: + signer = await resolve_for_wallet(event.wallet) + if signer is None: + # Wallet missing, account missing, unclassified row, or + # ClientSideOnlySigner account (server can't sign for them). + # Soft-fail: skip the publish silently. The user can still + # publish kind-31922/31923 events client-side once we have + # that path. return nostr_event = await publish_event_to_nostr( - nostr_client, event, account.pubkey, account.prvkey, delete=delete + nostr_client, event, signer, delete=delete ) if nostr_event and not delete: event.nostr_event_id = nostr_event.id diff --git a/nostr_publisher.py b/nostr_publisher.py index 6867041..81324fc 100644 --- a/nostr_publisher.py +++ b/nostr_publisher.py @@ -1,8 +1,9 @@ """ NIP-52 calendar event publishing for the events extension. -Builds NIP-52 calendar events from the Event model, signs them with the -creator's Account keypair, and publishes via the NostrClient. +Builds NIP-52 calendar events from the Event model, signs them via the +core `NostrSigner` abstraction (backend-agnostic: LocalSigner, +RemoteBunkerSigner, etc.), and publishes via the NostrClient. Kind 31922 is used for date-only events; kind 31923 (time-based) is used when event_start_date / event_end_date include a time component. @@ -13,7 +14,7 @@ Reference: https://github.com/nostr-protocol/nips/blob/master/52.md import time from datetime import datetime, timezone -import coincurve +from lnbits.core.signers import NostrSigner from loguru import logger from .models import Event @@ -142,23 +143,20 @@ def build_nip52_delete_event(event: Event, pubkey: str) -> NostrEvent: return nostr_event -def sign_nostr_event(nostr_event: NostrEvent, private_key_hex: str) -> None: - """Sign a NostrEvent in-place using Schnorr signature.""" - privkey = coincurve.PrivateKey(bytes.fromhex(private_key_hex)) - sig = privkey.sign_schnorr(bytes.fromhex(nostr_event.id)) - nostr_event.sig = sig.hex() - - async def publish_event_to_nostr( nostr_client, event: Event, - account_pubkey: str, - account_prvkey: str, + signer: NostrSigner, delete: bool = False, ) -> NostrEvent | None: """ Build, sign, and publish a NIP-52 calendar event (or delete event). + Signing routes through the core `NostrSigner` abstraction — + `signer.pubkey` for the event identity, `await signer.sign_event(...)` + for the Schnorr signature. The signer backend (LocalSigner / + RemoteBunkerSigner) is transparent to this function. + Returns the published NostrEvent for metadata storage, or None on failure. """ if not nostr_client: @@ -167,11 +165,25 @@ async def publish_event_to_nostr( try: if delete: - nostr_event = build_nip52_delete_event(event, account_pubkey) + nostr_event = build_nip52_delete_event(event, signer.pubkey) else: - nostr_event = build_nip52_event(event, account_pubkey) + nostr_event = build_nip52_event(event, signer.pubkey) + + # Hand the unsigned event to the signer — it fills in `id`, + # `pubkey`, and `sig`. The signer's serialization rules match + # NIP-01 (same as the local `event_id` property uses), so the + # returned id matches what we'd have computed locally. + unsigned = { + "kind": nostr_event.kind, + "created_at": nostr_event.created_at, + "tags": nostr_event.tags, + "content": nostr_event.content, + } + signed = await signer.sign_event(unsigned) + nostr_event.id = signed["id"] + nostr_event.pubkey = signed["pubkey"] + nostr_event.sig = signed["sig"] - sign_nostr_event(nostr_event, account_prvkey) await nostr_client.publish_nostr_event(nostr_event) logger.info( From 4238b41f108fd1b883a023998e254a5d8fec024a Mon Sep 17 00:00:00 2001 From: Padreug Date: Wed, 3 Jun 2026 19:47:49 +0200 Subject: [PATCH 3/8] feat: GET /tickets/event/{event_id}/stats for door-scanner roster MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Mirrors the events_list_event_tickets nostr-transport RPC for callers that don't hold a raw user prvkey (the webapp post-#9, in particular — useTicketScanner.refreshStats now has a working HTTP path). Auth: wallet admin_key + the event's wallet must be in the caller's wallet set, matching the register endpoint's owner check. Without this endpoint the activities scanner page loaded its initial counts (via no-op fallbacks) but every post-scan refreshStats returned 404, leaving the Scanned counter stuck at 0 even though registrations landed correctly. Surfaced by aio-demo manual test on 2026-06-03. Co-Authored-By: Claude Opus 4.7 (1M context) --- views_api.py | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/views_api.py b/views_api.py index 3edd953..14d60e2 100644 --- a/views_api.py +++ b/views_api.py @@ -47,6 +47,7 @@ from .crud import ( get_settings, get_ticket, get_tickets, + get_tickets_by_event, get_tickets_by_payment_hash, get_tickets_by_user_id, purge_unpaid_tickets, @@ -832,3 +833,52 @@ async def api_event_register_ticket( ticket.reg_timestamp = datetime.now(timezone.utc) ticket = await update_ticket(ticket) return ticket + + +@tickets_api_router.get("/event/{event_id}/stats") +async def api_event_ticket_stats( + event_id: str, + key_info: WalletTypeInfo = Depends(require_admin_key), +) -> dict: + """Door-scanner roster + counts for one event, organizer-only. + + Mirrors the `events_list_event_tickets` nostr-transport RPC for + callers that don't hold a raw user prvkey (the webapp post-#9, in + particular). Auth: wallet admin_key + the event's wallet must be + in the caller's wallet set. + """ + event = await get_event(event_id) + if not event: + raise HTTPException( + status_code=HTTPStatus.NOT_FOUND, detail="Event does not exist." + ) + + user = await get_user(key_info.wallet.user) + owned_wallet_ids = user.wallet_ids if user else [key_info.wallet.id] + if event.wallet not in owned_wallet_ids: + raise HTTPException( + status_code=HTTPStatus.FORBIDDEN, + detail="You do not own this event.", + ) + + tickets = await get_tickets_by_event(event_id) + paid_tickets = [t for t in tickets if t.paid] + registered_count = sum(1 for t in paid_tickets if t.registered) + + return { + "event_id": event_id, + "sold": len(paid_tickets), + "registered": registered_count, + "remaining": len(paid_tickets) - registered_count, + "tickets": [ + { + "id": t.id, + "name": t.name, + "registered": t.registered, + "registered_at": ( + t.reg_timestamp.isoformat() if t.reg_timestamp else None + ), + } + for t in paid_tickets + ], + } From 1fb96bfe3cd7c325c89657372100ad800677800c Mon Sep 17 00:00:00 2001 From: Padreug Date: Wed, 3 Jun 2026 19:48:18 +0200 Subject: [PATCH 4/8] chore: bump config.json version to 1.6.1-aio.5 Releases the door-scanner stats endpoint. Co-Authored-By: Claude Opus 4.7 (1M context) --- config.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config.json b/config.json index 9691da4..03be67f 100644 --- a/config.json +++ b/config.json @@ -1,6 +1,6 @@ { "id": "events", - "version": "1.6.1-aio.4", + "version": "1.6.1-aio.5", "name": "Events", "repo": "https://git.atitlan.io/aiolabs/events", "short_description": "Sell and register event tickets", From b5c87c60b478a23b529505a9546c6ef3b5965a9c Mon Sep 17 00:00:00 2001 From: Padreug Date: Thu, 18 Jun 2026 14:13:10 +0200 Subject: [PATCH 5/8] fix: publish NIP-52 events with monotonic created_at (#26) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit NIP-52 calendar events (31922/31923) are replaceable and republished whenever inventory changes (a ticket sells). build_nip52_event stamped created_at=int(time.time()); relays only push a replacement to OPEN subscriptions when created_at is strictly newer, so two republishes in the same wall-clock second tie and the second is silently dropped for live subscribers — clients' "tickets remaining" badge stalls until a reload. Same root cause as the webapp fix (aiolabs/webapp#122). - Add monotonic_created_at() in nostr_timestamp.py = max(now, last+1), mirroring the webapp helper + docs/nostr-patterns/replaceable-events.md. - Anchor it on the already-persisted Event.nostr_event_created_at (set after each publish in nostr_hooks.py). The kind-5 delete event is not replaceable, so it keeps plain int(time.time()). - Unit tests mirror the webapp's timestamp suite. Concurrent same-second sales reading the same stored anchor can still collide; full hardening (row-level lock) is noted as follow-up in #26. Co-Authored-By: Claude Opus 4.8 (1M context) --- nostr_publisher.py | 9 ++++++++- nostr_timestamp.py | 34 ++++++++++++++++++++++++++++++++++ tests/test_nostr_timestamp.py | 32 ++++++++++++++++++++++++++++++++ 3 files changed, 74 insertions(+), 1 deletion(-) create mode 100644 nostr_timestamp.py create mode 100644 tests/test_nostr_timestamp.py diff --git a/nostr_publisher.py b/nostr_publisher.py index 81324fc..2588fcb 100644 --- a/nostr_publisher.py +++ b/nostr_publisher.py @@ -19,6 +19,7 @@ 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: @@ -110,9 +111,15 @@ 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=int(time.time()), + created_at=monotonic_created_at(event.nostr_event_created_at), kind=kind, tags=tags, content=event.info or "", diff --git a/nostr_timestamp.py b/nostr_timestamp.py new file mode 100644 index 0000000..625b21c --- /dev/null +++ b/nostr_timestamp.py @@ -0,0 +1,34 @@ +"""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 new file mode 100644 index 0000000..693a997 --- /dev/null +++ b/tests/test_nostr_timestamp.py @@ -0,0 +1,32 @@ +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)) From cfc2e38a5eda997bffca684a192ca6aa93b2603c Mon Sep 17 00:00:00 2001 From: Padreug Date: Thu, 18 Jun 2026 14:13:11 +0200 Subject: [PATCH 6/8] chore: bump config.json version to 1.6.1-aio.6 Marks the monotonic created_at fix (#26). aio semver stays ahead of the upstream 1.6.1 tag per fork versioning rules. Co-Authored-By: Claude Opus 4.8 (1M context) --- config.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config.json b/config.json index 03be67f..36da491 100644 --- a/config.json +++ b/config.json @@ -1,6 +1,6 @@ { "id": "events", - "version": "1.6.1-aio.5", + "version": "1.6.1-aio.6", "name": "Events", "repo": "https://git.atitlan.io/aiolabs/events", "short_description": "Sell and register event tickets", From 9d7efd7662c70c9068553109f2396ee8545284d1 Mon Sep 17 00:00:00 2001 From: Padreug Date: Sat, 20 Jun 2026 09:03:44 +0200 Subject: [PATCH 7/8] feat: issue free tickets without minting an invoice MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Free events (price_per_ticket == 0) tried to mint a 0-amount Lightning invoice via create_payment_request — an invoice that can't settle, and which the invoice listener would never mark paid, so the ticket never became scannable. api_ticket_create now short-circuits when the final charge is 0 (a free event or a 100%-off promo, computed after promo + quantity) before any invoice / fiat-provider logic: _issue_free_tickets creates the N rows and runs each through the existing set_ticket_paid — the same path on_invoice_paid drives for a settled payment (flip paid, bump sold/available under the per-event lock, republish the NIP-52 event) — plus the ticket notification. The response carries a new TicketPaymentRequest.paid=True with no payment_request so the client skips the QR / payment-poll and goes straight to the ticket QRs. No invoice means sats_paid=0, so free tickets are naturally skipped by refund_tickets. All rows in a batch share one synthetic payment_hash — the join key the poll / WebSocket / My-Tickets lookups use — mirroring the paid multi-ticket path. Self-service forfeit (#28), abuse/identity limits (#29) and pay-what-you-want/donation tickets (#30) are tracked as follow-ups. Co-Authored-By: Claude Opus 4.8 --- models.py | 4 +++ views_api.py | 79 +++++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 82 insertions(+), 1 deletion(-) diff --git a/models.py b/models.py index 04520a0..7f1feac 100644 --- a/models.py +++ b/models.py @@ -183,6 +183,10 @@ 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/views_api.py b/views_api.py index 14d60e2..5ced0ef 100644 --- a/views_api.py +++ b/views_api.py @@ -66,7 +66,12 @@ from .models import ( TicketPaymentRequest, ) from .nostr_hooks import publish_or_delete_nostr_event -from .services import refund_tickets, resend_ticket_email_notification +from .services import ( + refund_tickets, + resend_ticket_email_notification, + send_ticket_notification_in_background, + set_ticket_paid, +) from .tasks import deregister_payment_listener, register_payment_listener events_api_router = APIRouter(prefix="/api/v1/events") @@ -508,6 +513,62 @@ 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 @@ -571,6 +632,22 @@ 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, From 2093e63020a1b1ba424c67d74e16478dcb5559ff Mon Sep 17 00:00:00 2001 From: Padreug Date: Sat, 20 Jun 2026 09:04:02 +0200 Subject: [PATCH 8/8] chore: bump config.json version to 1.6.1-aio.7 Co-Authored-By: Claude Opus 4.8 --- config.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config.json b/config.json index 36da491..02272e3 100644 --- a/config.json +++ b/config.json @@ -1,6 +1,6 @@ { "id": "events", - "version": "1.6.1-aio.6", + "version": "1.6.1-aio.7", "name": "Events", "repo": "https://git.atitlan.io/aiolabs/events", "short_description": "Sell and register event tickets",