diff --git a/src/modules/events/components/PurchaseTicketDialog.vue b/src/modules/events/components/PurchaseTicketDialog.vue
index 6726b20..a1737fb 100644
--- a/src/modules/events/components/PurchaseTicketDialog.vue
+++ b/src/modules/events/components/PurchaseTicketDialog.vue
@@ -1,14 +1,20 @@
 <script setup lang="ts">
-import { computed, onUnmounted, ref, watch } from 'vue'
-import { useI18n } from 'vue-i18n'
-import { useForm } from 'vee-validate'
-import { toTypedSchema } from '@vee-validate/zod'
-import * as z from 'zod'
-import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription } from '@/components/ui/dialog'
-import { Button } from '@/components/ui/button'
-import { Badge } from '@/components/ui/badge'
-import { Input } from '@/components/ui/input'
-import { Alert, AlertDescription } from '@/components/ui/alert'
+import { computed, onUnmounted, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { useForm } from "vee-validate";
+import { toTypedSchema } from "@vee-validate/zod";
+import * as z from "zod";
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogDescription,
+} from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { Input } from "@/components/ui/input";
+import { Alert, AlertDescription } from "@/components/ui/alert";
 import {
   FormControl,
   FormDescription,
@@ -16,50 +22,82 @@ import {
   FormItem,
   FormLabel,
   FormMessage,
-} from '@/components/ui/form'
-import { useTicketPurchase } from '../composables/useTicketPurchase'
-import { usePromoCode } from '../composables/usePromoCode'
-import { normalizePromoCode } from '../lib/promoCodes'
-import { useAuth } from '@/composables/useAuthService'
-import { injectService, SERVICE_TOKENS } from '@/core/di-container'
-import type { TicketApiService } from '../services/TicketApiService'
-import { User, Wallet, CreditCard, Zap, Ticket, Landmark, Minus, Plus, Copy, Check, Loader2, Mail, Tag, X } from 'lucide-vue-next'
-import { formatEventPrice, formatWalletBalance } from '@/lib/utils/formatting'
+} from "@/components/ui/form";
+import { useTicketPurchase } from "../composables/useTicketPurchase";
+import { usePromoCode } from "../composables/usePromoCode";
+import { normalizePromoCode } from "../lib/promoCodes";
+import { useAuth } from "@/composables/useAuthService";
+import { injectService, SERVICE_TOKENS } from "@/core/di-container";
+import type { TicketApiService } from "../services/TicketApiService";
+import {
+  User,
+  Wallet,
+  CreditCard,
+  Zap,
+  Ticket,
+  Landmark,
+  Minus,
+  Plus,
+  Copy,
+  Check,
+  Loader2,
+  Mail,
+  Tag,
+  X,
+} from "lucide-vue-next";
+import { formatEventPrice, formatWalletBalance } from "@/lib/utils/formatting";
 import PaymentMethodSelector, {
   type PaymentMethod as PaymentMethodEntry,
-} from '@/modules/base/components/payments/PaymentMethodSelector.vue'
-import PriceConversionPreview from '@/modules/base/components/payments/PriceConversionPreview.vue'
-import { useFiatProviders } from '@/modules/base/composables/useFiatProviders'
-import { usePriceConversion } from '@/modules/base/composables/usePriceConversion'
-import { effectivePaymentMethods } from '../lib/paymentMethods'
-import { frontendRoot } from '../lib/frontendRoot'
-import { PENDING_CHECKOUT_KEY, type PendingCheckout } from '../lib/pendingCheckout'
+} from "@/modules/base/components/payments/PaymentMethodSelector.vue";
+import PriceConversionPreview from "@/modules/base/components/payments/PriceConversionPreview.vue";
+import { useFiatProviders } from "@/modules/base/composables/useFiatProviders";
+import { usePriceConversion } from "@/modules/base/composables/usePriceConversion";
+import { effectivePaymentMethods } from "../lib/paymentMethods";
+import {
+  activeTicketWaves,
+  ensureTicketWaves,
+  resolveTicketWave,
+} from "../lib/ticketWaves";
+import type { TicketWave } from "../types/ticket";
+import { frontendRoot } from "../lib/frontendRoot";
+import {
+  PENDING_CHECKOUT_KEY,
+  type PendingCheckout,
+} from "../lib/pendingCheckout";
 
 interface Props {
   event: {
-    id: string
-    name: string
-    price_per_ticket: number
-    currency: string
+    id: string;
+    name: string;
+    price_per_ticket: number;
+    currency: string;
     /** Whether the event accepts fiat payments. From v1.4.0+ */
-    allow_fiat?: boolean
-    fiat_currency?: string
+    allow_fiat?: boolean;
+    fiat_currency?: string;
     /** Rails the organizer enabled (`tickets_payment_methods`). Absent
      *  on legacy events — falls back to the allow_fiat rule. */
-    payment_methods?: string[]
-  }
-  isOpen: boolean
+    payment_methods?: string[];
+    /** Fields a legacy event's implied single wave is synthesized from. */
+    time?: string | number | null;
+    closing_date?: string | null;
+    event_start_date?: string;
+    event_end_date?: string | null;
+    amount_tickets?: number;
+    /** Pricing tiers, public since events ext v1.6.8-aio.2. */
+    extra?: { ticket_waves?: TicketWave[] } | null;
+  };
+  isOpen: boolean;
 }
 
 interface Emits {
-  (e: 'update:isOpen', value: boolean): void
+  (e: "update:isOpen", value: boolean): void;
 }
 
-const props = defineProps<Props>()
-const emit = defineEmits<Emits>()
-const { t } = useI18n()
+const props = defineProps<Props>();
+const emit = defineEmits<Emits>();
+const { t } = useI18n();
 
-const { isAuthenticated, userDisplay, currentUser } = useAuth()
+const { isAuthenticated, userDisplay, currentUser } = useAuth();
 const {
   isLoading,
   error,
@@ -78,79 +116,114 @@ const {
   purchasedTicketIds,
   ticketQRCodes,
   showTicketQR,
-  finalizePurchasedTickets
-} = useTicketPurchase()
+  finalizePurchasedTickets,
+} = useTicketPurchase();
 
-const MAX_QUANTITY = 10
-const quantity = ref(1)
-const copiedInvoice = ref(false)
+const MAX_QUANTITY = 10;
+const quantity = ref(1);
+const copiedInvoice = ref(false);
 
 function decreaseQuantity() {
-  if (quantity.value > 1) quantity.value -= 1
+  if (quantity.value > 1) quantity.value -= 1;
 }
 function increaseQuantity() {
-  if (quantity.value < MAX_QUANTITY) quantity.value += 1
+  if (quantity.value < MAX_QUANTITY) quantity.value += 1;
 }
 
-const totalPrice = computed(() => props.event.price_per_ticket * quantity.value)
+// --- Ticket wave ----------------------------------------------------
+// Price, currency and fiat availability come from the WAVE being bought,
+// never from the event: since events ext v1.6.8 the event-level fields
+// are the PRIMARY wave's, which after early bird closes is not what
+// anyone pays. Reading them here showed the closed tier's price while
+// the backend charged the open one.
+const selectedWaveId = ref<string | null>(null);
+const openWaves = computed(() => activeTicketWaves(props.event));
+const waveChoice = computed(() =>
+  resolveTicketWave(props.event, selectedWaveId.value),
+);
+const selectedWave = computed<TicketWave | null>(() =>
+  waveChoice.value.ok ? waveChoice.value.wave : null,
+);
+/** Several waves open and the buyer hasn't picked — the backend refuses
+ *  to guess, so the dialog must ask. */
+const needsWaveChoice = computed(
+  () => !waveChoice.value.ok && waveChoice.value.reason === "must-choose",
+);
+const nothingOnSale = computed(
+  () => !waveChoice.value.ok && waveChoice.value.reason === "none-open",
+);
+/** What to price from. Falls back to the implied primary wave so events
+ *  predating waves, and sold-out ones, still render a sensible price. */
+const pricing = computed<TicketWave>(
+  () => selectedWave.value ?? ensureTicketWaves(props.event)[0],
+);
+const waveIdToSend = computed<string | undefined>(() => selectedWave.value?.id);
+
+const totalPrice = computed(
+  () => pricing.value.price_per_ticket * quantity.value,
+);
 
 // Free events (price 0): no invoice is minted — the backend issues the
 // tickets already-paid. Drop the payment-method selector and price line
 // and label the CTA "Get ticket" instead of "Proceed".
-const isFree = computed(() => props.event.price_per_ticket <= 0)
+const isFree = computed(() => pricing.value.price_per_ticket <= 0);
 
 // Guests may buy paid tickets (name + email identity); free claims stay
 // login-gated so an anonymous script can't drain a free event's
 // capacity (events#29).
-const guestNeedsLogin = computed(() => isFree.value && !isAuthenticated.value)
+const guestNeedsLogin = computed(() => isFree.value && !isAuthenticated.value);
 
 // --- Promo code -----------------------------------------------------
 // Server-validated preview (`POST /promo/validate`); the purchase
 // endpoint re-checks the code anyway, so the client never trusts its
 // own arithmetic for what gets charged.
-const promo = usePromoCode(() => props.event.id, quantity)
+const promo = usePromoCode(() => props.event.id, quantity, waveIdToSend);
 const {
   input: promoInput,
   state: promoState,
   isChecking: promoChecking,
   codeToSend: promoCodeToSend,
-} = promo
+} = promo;
 
 const hasDiscount = computed(
-  () => promoState.value.status === 'applied' && promoState.value.total < promoState.value.subtotal,
-)
+  () =>
+    promoState.value.status === "applied" &&
+    promoState.value.total < promoState.value.subtotal,
+);
 const promoDiscountAmount = computed(() =>
-  promoState.value.status === 'applied' ? promoState.value.discount : 0,
-)
+  promoState.value.status === "applied" ? promoState.value.discount : 0,
+);
 /** What the buyer will actually be charged for the current quantity. */
 const effectiveTotal = computed(() =>
-  promoState.value.status === 'applied' ? promoState.value.total : totalPrice.value,
-)
-const isZeroTotal = computed(() => effectiveTotal.value <= 0)
+  promoState.value.status === "applied"
+    ? promoState.value.total
+    : totalPrice.value,
+);
+const isZeroTotal = computed(() => effectiveTotal.value <= 0);
 // A 100 %-off code turns a paid ticket into a free claim, which stays
 // login-gated (events#29). Prompt inline — swapping the whole form would
 // hide the Remove button the guest needs to back out of the code.
 const guestNeedsLoginForDiscount = computed(
   () => !isFree.value && isZeroTotal.value && !isAuthenticated.value,
-)
+);
 
 function onPromoInput(event: Event) {
-  const el = event.target as HTMLInputElement
-  const value = normalizePromoCode(el.value)
-  el.value = value
-  promoInput.value = value
+  const el = event.target as HTMLInputElement;
+  const value = normalizePromoCode(el.value);
+  el.value = value;
+  promoInput.value = value;
 }
 
 function isPromoError(err: unknown): boolean {
-  return err instanceof Error && /promo code/i.test(err.message)
+  return err instanceof Error && /promo code/i.test(err.message);
 }
 
 async function copyInvoice() {
-  if (!paymentRequest.value) return
+  if (!paymentRequest.value) return;
   try {
-    await navigator.clipboard.writeText(paymentRequest.value)
-    copiedInvoice.value = true
-    setTimeout(() => (copiedInvoice.value = false), 1500)
+    await navigator.clipboard.writeText(paymentRequest.value);
+    copiedInvoice.value = true;
+    setTimeout(() => (copiedInvoice.value = false), 1500);
   } catch {
     // Older browsers / insecure contexts; the Open-in-wallet button
     // still works as a fallback.
@@ -168,160 +241,184 @@ const contactSchema = computed(() =>
     z
       .object({
         name: isAuthenticated.value
-          ? z.string().optional().default('')
-          : z.string().trim().min(1, t('events.purchase.contact.nameRequired')).max(100),
-        email: z.string().trim().email(t('events.purchase.contact.emailInvalid')),
+          ? z.string().optional().default("")
+          : z
+              .string()
+              .trim()
+              .min(1, t("events.purchase.contact.nameRequired"))
+              .max(100),
+        email: z
+          .string()
+          .trim()
+          .email(t("events.purchase.contact.emailInvalid")),
         confirmEmail: z.string().trim(),
       })
       .superRefine((v, ctx) => {
         if (v.email.toLowerCase() !== v.confirmEmail.toLowerCase()) {
           ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            path: ['confirmEmail'],
-            message: t('events.purchase.contact.emailMismatch'),
-          })
+            path: ["confirmEmail"],
+            message: t("events.purchase.contact.emailMismatch"),
+          });
         }
       }),
   ),
-)
+);
 
 const form = useForm({
   validationSchema: contactSchema,
-  initialValues: { name: '', email: '', confirmEmail: '' },
-})
+  initialValues: { name: "", email: "", confirmEmail: "" },
+});
 
 // The dialog stays mounted across opens — reseed on every open so a
 // login/logout between purchases is reflected.
 watch(
   () => props.isOpen,
   (open) => {
-    if (!open) return
+    if (!open) return;
     form.resetForm({
-      values: { name: '', email: currentUser.value?.email ?? '', confirmEmail: '' },
-    })
-    promo.clear()
+      values: {
+        name: "",
+        email: currentUser.value?.email ?? "",
+        confirmEmail: "",
+      },
+    });
+    promo.clear();
   },
   { immediate: true },
-)
+);
 
-const { providers, providerMeta } = useFiatProviders()
-const { convert } = usePriceConversion()
+const { providers, providerMeta } = useFiatProviders();
+const { convert } = usePriceConversion();
 
 // Empty until the dialog opens: the watcher below picks the default per
 // rail availability + auth state, so a guest lands on Card, not Lightning.
-const selectedMethodId = ref<string>('')
-const isFiatPending = ref(false)
-const fiatError = ref<string | null>(null)
+const selectedMethodId = ref<string>("");
+const isFiatPending = ref(false);
+const fiatError = ref<string | null>(null);
 
 const enabledRails = computed(() =>
   effectivePaymentMethods({
-    allowFiat: props.event.allow_fiat,
+    // Fiat is a per-wave opt-in; `event.allow_fiat` is only the primary
+    // wave's and can disagree with the tier being bought.
+    allowFiat: pricing.value.allow_fiat,
     paymentMethods: props.event.payment_methods,
   }),
-)
-const canChooseFiat = computed(() => enabledRails.value.includes('fiat'))
+);
+const canChooseFiat = computed(() => enabledRails.value.includes("fiat"));
 const isPriceInSats = computed(
-  () => props.event.currency === 'sat' || props.event.currency === 'sats',
-)
+  () => pricing.value.currency === "sat" || pricing.value.currency === "sats",
+);
 
 // Lightning-button badge: when the price is denominated in fiat, show
 // the live sat equivalent so the buyer knows roughly what their wallet
 // will be charged. Best-effort — silent if the conversion fails.
-const lightningSats = ref<number | null>(null)
+const lightningSats = ref<number | null>(null);
 watch(
-  () => [props.event.currency, props.event.price_per_ticket, props.isOpen] as const,
+  () =>
+    [
+      pricing.value.currency,
+      pricing.value.price_per_ticket,
+      props.isOpen,
+    ] as const,
   async ([cur, amt, open]) => {
-    if (!open || !amt || cur === 'sat' || cur === 'sats') {
-      lightningSats.value = null
-      return
+    if (!open || !amt || cur === "sat" || cur === "sats") {
+      lightningSats.value = null;
+      return;
     }
-    lightningSats.value = await convert(amt as number, cur as string, 'sat')
+    lightningSats.value = await convert(amt as number, cur as string, "sat");
   },
   { immediate: true },
-)
+);
 
-function iconFor(hint: 'card' | 'bank' | 'wallet') {
-  if (hint === 'bank') return Landmark
-  if (hint === 'wallet') return Wallet
-  return CreditCard
+function iconFor(hint: "card" | "bank" | "wallet") {
+  if (hint === "bank") return Landmark;
+  if (hint === "wallet") return Wallet;
+  return CreditCard;
 }
 
 const paymentMethods = computed<PaymentMethodEntry[]>(() => {
-  const entries: PaymentMethodEntry[] = []
-  if (enabledRails.value.includes('lightning')) {
+  const entries: PaymentMethodEntry[] = [];
+  if (enabledRails.value.includes("lightning")) {
     entries.push({
-      id: 'lightning',
-      rail: 'lightning',
-      label: 'Lightning',
+      id: "lightning",
+      rail: "lightning",
+      label: "Lightning",
       icon: Zap,
       available: true,
       badge:
         !isPriceInSats.value && lightningSats.value
           ? `≈ ${Math.round(lightningSats.value).toLocaleString()} sats`
           : undefined,
-    })
+    });
   }
   if (canChooseFiat.value) {
     if (providers.value.length > 0) {
       for (const id of providers.value) {
-        const meta = providerMeta(id)
+        const meta = providerMeta(id);
         entries.push({
           id: `fiat:${id}`,
-          rail: 'fiat',
+          rail: "fiat",
           provider: id,
           label: meta.label,
           icon: iconFor(meta.icon),
           available: true,
-        })
+        });
       }
     } else {
       // Guests (and sessions without provider info) can't enumerate the
       // organizer's providers. Show a generic Card button and let the
       // backend pick the organizer's default at request time.
       entries.push({
-        id: 'fiat',
-        rail: 'fiat',
-        label: t('events.purchase.card'),
+        id: "fiat",
+        rail: "fiat",
+        label: t("events.purchase.card"),
         icon: CreditCard,
         available: true,
-      })
+      });
     }
   }
-  return entries
-})
+  return entries;
+});
 
 // Default rail: guests lean to card when it's on offer (no wallet to
 // pay a bolt11 with); everyone else takes the first enabled rail.
 watch(
   [paymentMethods, () => props.isOpen, isAuthenticated],
   ([methods, open, authed]) => {
-    if (!open || methods.length === 0) return
-    const current = methods.find((m) => m.id === selectedMethodId.value)
-    if (current) return
-    const preferred = !authed ? methods.find((m) => m.rail === 'fiat') : undefined
-    selectedMethodId.value = (preferred ?? methods[0]).id
+    if (!open || methods.length === 0) return;
+    const current = methods.find((m) => m.id === selectedMethodId.value);
+    if (current) return;
+    const preferred = !authed
+      ? methods.find((m) => m.rail === "fiat")
+      : undefined;
+    selectedMethodId.value = (preferred ?? methods[0]).id;
   },
   { immediate: true },
-)
+);
 
-const selectedMethod = computed(() =>
-  paymentMethods.value.find((m) => m.id === selectedMethodId.value) ?? paymentMethods.value[0],
-)
+const selectedMethod = computed(
+  () =>
+    paymentMethods.value.find((m) => m.id === selectedMethodId.value) ??
+    paymentMethods.value[0],
+);
 
 const onSubmit = form.handleSubmit(async (contact) => {
-  await handlePurchase(contact)
-})
+  await handlePurchase(contact);
+});
 
 async function handlePurchase(contact: { name?: string; email: string }) {
-  fiatError.value = null
-  const method = selectedMethod.value
-  if (!method) return
+  fiatError.value = null;
+  const method = selectedMethod.value;
+  if (!method) return;
 
-  const isGuest = !isAuthenticated.value
-  const guestContact = isGuest ? { name: contact.name ?? '', email: contact.email } : undefined
-  const promoCode = promoCodeToSend.value
+  const isGuest = !isAuthenticated.value;
+  const guestContact = isGuest
+    ? { name: contact.name ?? "", email: contact.email }
+    : undefined;
+  const promoCode = promoCodeToSend.value;
 
-  if (guestNeedsLoginForDiscount.value) return
+  if (guestNeedsLoginForDiscount.value) return;
 
   // Nothing to charge (100 %-off code on a paid event): skip the rail
   // choice entirely — the backend issues the tickets already-paid and
@@ -333,30 +430,32 @@ async function handlePurchase(contact: { name?: string; email: string }) {
         contact: guestContact,
         email: contact.email,
         promoCode,
-      })
+        ticketWaveId: waveIdToSend.value,
+      });
     } catch (err) {
-      console.error('Error claiming discounted ticket:', err)
-      if (isPromoError(err)) void promo.revalidate()
+      console.error("Error claiming discounted ticket:", err);
+      if (isPromoError(err)) void promo.revalidate();
     }
-    return
+    return;
   }
 
   // Lightning path: the composable creates the invoice + starts polling.
   // The buyer pays from their LNbits wallet or an external one on the
   // invoice screen (restaurant pattern), so no auto-pay here.
-  if (method.rail === 'lightning') {
+  if (method.rail === "lightning") {
     try {
       await purchaseTicketForEvent(props.event.id, {
         quantity: quantity.value,
         contact: guestContact,
         email: contact.email,
         promoCode,
-      })
+        ticketWaveId: waveIdToSend.value,
+      });
     } catch (err) {
-      console.error('Error purchasing ticket:', err)
-      if (isPromoError(err)) void promo.revalidate()
+      console.error("Error purchasing ticket:", err);
+      if (isPromoError(err)) void promo.revalidate();
     }
-    return
+    return;
   }
 
   // Fiat path: POST with the chosen provider, remember what we're
@@ -364,34 +463,39 @@ async function handlePurchase(contact: { name?: string; email: string }) {
   // brings the buyer back to the event page with ?checkout=success&
   // tickets=… (or ?checkout=cancelled) — see EventDetailPage.
   try {
-    isFiatPending.value = true
-    const lnbitsAPI = injectService(SERVICE_TOKENS.LNBITS_API) as any
-    const accessToken = isGuest ? undefined : (lnbitsAPI?.getAccessToken?.() || undefined)
-    const ticketApi = injectService(SERVICE_TOKENS.TICKET_API) as TicketApiService
+    isFiatPending.value = true;
+    const lnbitsAPI = injectService(SERVICE_TOKENS.LNBITS_API) as any;
+    const accessToken = isGuest
+      ? undefined
+      : lnbitsAPI?.getAccessToken?.() || undefined;
+    const ticketApi = injectService(
+      SERVICE_TOKENS.TICKET_API,
+    ) as TicketApiService;
     const invoice = await ticketApi.requestTicket(props.event.id, {
       userId: isGuest ? undefined : currentUser.value?.id,
       name: guestContact?.name,
       email: contact.email,
       accessToken,
       frontendUrl: frontendRoot(),
-      paymentMethod: 'fiat',
+      paymentMethod: "fiat",
       fiatProvider: method.provider,
       quantity: quantity.value,
       promoCode,
-    })
+      ticketWaveId: waveIdToSend.value,
+    });
     // The backend may still short-circuit to the free path (e.g. a code
     // that became 100 % between preview and pay): no checkout URL, the
     // tickets are already issued — show them instead of an error.
     if (invoice.paid) {
-      paymentHash.value = invoice.paymentHash
-      await finalizePurchasedTickets(invoice.ticketIds ?? [])
-      isFiatPending.value = false
-      return
+      paymentHash.value = invoice.paymentHash;
+      await finalizePurchasedTickets(invoice.ticketIds ?? []);
+      isFiatPending.value = false;
+      return;
     }
     if (!invoice.isFiat || !invoice.fiatPaymentRequest) {
-      fiatError.value = t('events.purchase.noCheckoutUrl')
-      isFiatPending.value = false
-      return
+      fiatError.value = t("events.purchase.noCheckoutUrl");
+      isFiatPending.value = false;
+      return;
     }
     const pending: PendingCheckout = {
       eventId: props.event.id,
@@ -399,36 +503,38 @@ async function handlePurchase(contact: { name?: string; email: string }) {
       ticketIds: invoice.ticketIds ?? [],
       email: contact.email,
       ts: Date.now(),
-    }
+    };
     try {
-      localStorage.setItem(PENDING_CHECKOUT_KEY, JSON.stringify(pending))
+      localStorage.setItem(PENDING_CHECKOUT_KEY, JSON.stringify(pending));
     } catch {
       // Storage unavailable (private mode) — the return URL still
       // carries the ticket ids, so the flow survives without it.
     }
-    window.location.assign(invoice.fiatPaymentRequest)
+    window.location.assign(invoice.fiatPaymentRequest);
     // Keep the spinner up until the navigation lands.
   } catch (err) {
-    fiatError.value = err instanceof Error ? err.message : t('events.purchase.fiatFailed')
-    isFiatPending.value = false
-    if (isPromoError(err)) void promo.revalidate()
+    fiatError.value =
+      err instanceof Error ? err.message : t("events.purchase.fiatFailed");
+    isFiatPending.value = false;
+    if (isPromoError(err)) void promo.revalidate();
   }
 }
 
 function handleClose() {
-  emit('update:isOpen', false)
-  resetPaymentState()
-  promo.clear()
-  selectedMethodId.value = ''
-  fiatError.value = null
-  isFiatPending.value = false
-  quantity.value = 1
-  copiedInvoice.value = false
+  emit("update:isOpen", false);
+  resetPaymentState();
+  promo.clear();
+  selectedMethodId.value = "";
+  fiatError.value = null;
+  isFiatPending.value = false;
+  quantity.value = 1;
+  selectedWaveId.value = null;
+  copiedInvoice.value = false;
 }
 
 onUnmounted(() => {
-  cleanup()
-})
+  cleanup();
+});
 </script>
 
 <template>
@@ -437,11 +543,15 @@ onUnmounted(() => {
       <DialogHeader>
         <DialogTitle class="flex items-center gap-2">
           <CreditCard class="w-5 h-5" />
-          {{ quantity > 1 ? `Purchase ${quantity} tickets` : 'Purchase ticket' }}
+          {{
+            quantity > 1 ? `Purchase ${quantity} tickets` : "Purchase ticket"
+          }}
         </DialogTitle>
         <DialogDescription>
           <span v-if="isFree">
-            <template v-if="quantity > 1">{{ quantity }} free tickets for</template>
+            <template v-if="quantity > 1"
+              >{{ quantity }} free tickets for</template
+            >
             <template v-else>Get a free ticket for</template>
             <strong>{{ event.name }}</strong>
           </span>
@@ -449,9 +559,15 @@ onUnmounted(() => {
             <template v-if="quantity > 1">{{ quantity }} tickets for</template>
             <template v-else>Purchase a ticket for</template>
             <strong>{{ event.name }}</strong> ·
-            <s v-if="hasDiscount" class="text-muted-foreground">{{ formatEventPrice(totalPrice, event.currency) }}</s>
+            <s v-if="hasDiscount" class="text-muted-foreground">{{
+              formatEventPrice(totalPrice, pricing.currency)
+            }}</s>
             <span :class="{ 'text-primary font-medium': hasDiscount }">
-              {{ isZeroTotal ? 'Free' : formatEventPrice(effectiveTotal, event.currency) }}
+              {{
+                isZeroTotal
+                  ? "Free"
+                  : formatEventPrice(effectiveTotal, pricing.currency)
+              }}
             </span>
           </span>
         </DialogDescription>
@@ -463,20 +579,27 @@ onUnmounted(() => {
           <User class="w-12 h-12 text-muted-foreground" />
         </div>
         <div class="space-y-2">
-          <h3 class="text-lg font-semibold">{{ t('events.purchase.loginRequiredTitle') }}</h3>
+          <h3 class="text-lg font-semibold">
+            {{ t("events.purchase.loginRequiredTitle") }}
+          </h3>
           <p class="text-sm text-muted-foreground">
-            {{ t('events.purchase.loginRequiredFree') }}
+            {{ t("events.purchase.loginRequiredFree") }}
           </p>
         </div>
         <div class="flex gap-2 justify-center">
-          <Button @click="() => $router.push('/login')">{{ t('events.detail.logIn') }}</Button>
+          <Button @click="() => $router.push('/login')">{{
+            t("events.detail.logIn")
+          }}</Button>
           <Button @click="handleClose" variant="outline">Close</Button>
         </div>
       </div>
 
       <!-- Contact + payment details, then submit -->
       <form v-else-if="!paymentHash" class="py-4 space-y-4" @submit="onSubmit">
-        <div v-if="isAuthenticated" class="bg-muted/50 rounded-lg p-4 space-y-3">
+        <div
+          v-if="isAuthenticated"
+          class="bg-muted/50 rounded-lg p-4 space-y-3"
+        >
           <div class="flex items-center gap-2">
             <User class="w-4 h-4 text-muted-foreground" />
             <span class="text-sm font-medium">Purchasing as:</span>
@@ -488,7 +611,9 @@ onUnmounted(() => {
             </div>
             <div class="flex items-center gap-2">
               <span class="text-sm text-muted-foreground">User ID:</span>
-              <Badge variant="secondary" class="text-xs font-mono">{{ userDisplay?.shortId }}</Badge>
+              <Badge variant="secondary" class="text-xs font-mono">{{
+                userDisplay?.shortId
+              }}</Badge>
             </div>
           </div>
         </div>
@@ -497,33 +622,65 @@ onUnmounted(() => {
         <div class="bg-muted/50 rounded-lg p-4 space-y-3">
           <div class="flex items-center gap-2">
             <Mail class="w-4 h-4 text-muted-foreground" />
-            <span class="text-sm font-medium">{{ t('events.purchase.contact.title') }}</span>
+            <span class="text-sm font-medium">{{
+              t("events.purchase.contact.title")
+            }}</span>
           </div>
-          <FormField v-if="!isAuthenticated" v-slot="{ componentField }" name="name">
+          <FormField
+            v-if="!isAuthenticated"
+            v-slot="{ componentField }"
+            name="name"
+          >
             <FormItem>
-              <FormLabel>{{ t('events.purchase.contact.name') }} *</FormLabel>
+              <FormLabel>{{ t("events.purchase.contact.name") }} *</FormLabel>
               <FormControl>
-                <Input v-bind="componentField" autocomplete="name" :placeholder="t('events.purchase.contact.namePlaceholder')" />
+                <Input
+                  v-bind="componentField"
+                  autocomplete="name"
+                  :placeholder="t('events.purchase.contact.namePlaceholder')"
+                />
               </FormControl>
               <FormMessage />
             </FormItem>
           </FormField>
           <FormField v-slot="{ componentField }" name="email">
             <FormItem>
-              <FormLabel>{{ t('events.purchase.contact.email') }} *</FormLabel>
+              <FormLabel>{{ t("events.purchase.contact.email") }} *</FormLabel>
               <FormControl>
-                <Input v-bind="componentField" type="email" inputmode="email" autocomplete="email" autocapitalize="none" spellcheck="false" placeholder="email@example.com" />
+                <Input
+                  v-bind="componentField"
+                  type="email"
+                  inputmode="email"
+                  autocomplete="email"
+                  autocapitalize="none"
+                  spellcheck="false"
+                  placeholder="email@example.com"
+                />
               </FormControl>
-              <FormDescription class="text-xs">{{ t('events.purchase.contact.emailHint') }}</FormDescription>
-              <p class="text-xs font-medium text-destructive">{{ t('events.purchase.contact.spamHint') }}</p>
+              <FormDescription class="text-xs">{{
+                t("events.purchase.contact.emailHint")
+              }}</FormDescription>
+              <p class="text-xs font-medium text-destructive">
+                {{ t("events.purchase.contact.spamHint") }}
+              </p>
               <FormMessage />
             </FormItem>
           </FormField>
           <FormField v-slot="{ componentField }" name="confirmEmail">
             <FormItem>
-              <FormLabel>{{ t('events.purchase.contact.confirmEmail') }} *</FormLabel>
+              <FormLabel
+                >{{ t("events.purchase.contact.confirmEmail") }} *</FormLabel
+              >
               <FormControl>
-                <Input v-bind="componentField" type="email" inputmode="email" autocomplete="off" autocapitalize="none" spellcheck="false" placeholder="email@example.com" />
+                <Input
+                  v-bind="componentField"
+                  type="email"
+                  inputmode="email"
+                  autocomplete="off"
+                  autocapitalize="none"
+                  spellcheck="false"
+                  placeholder="email@example.com"
+                />
               </FormControl>
               <FormMessage />
             </FormItem>
@@ -536,19 +693,43 @@ onUnmounted(() => {
         <div v-if="!isFree" class="bg-muted/50 rounded-lg p-4 space-y-2">
           <div class="flex items-center gap-2">
             <Tag class="w-4 h-4 text-muted-foreground" />
-            <span class="text-sm font-medium">{{ t('events.purchase.promo.label') }}</span>
+            <span class="text-sm font-medium">{{
+              t("events.purchase.promo.label")
+            }}</span>
           </div>
 
-          <div v-if="promoState.status === 'applied' || promoState.status === 'unverified'" class="flex items-center justify-between gap-2">
-            <Badge :variant="promoState.status === 'applied' ? 'default' : 'secondary'" class="font-mono">
+          <div
+            v-if="
+              promoState.status === 'applied' ||
+              promoState.status === 'unverified'
+            "
+            class="flex items-center justify-between gap-2"
+          >
+            <Badge
+              :variant="
+                promoState.status === 'applied' ? 'default' : 'secondary'
+              "
+              class="font-mono"
+            >
               <template v-if="promoState.status === 'applied'">
-                {{ t('events.purchase.promo.applied', { code: promoState.code, percent: promoState.discountPercent }) }}
+                {{
+                  t("events.purchase.promo.applied", {
+                    code: promoState.code,
+                    percent: promoState.discountPercent,
+                  })
+                }}
               </template>
               <template v-else>{{ promoState.code }}</template>
             </Badge>
-            <Button type="button" variant="ghost" size="sm" class="gap-1 h-7" @click="promo.clear()">
+            <Button
+              type="button"
+              variant="ghost"
+              size="sm"
+              class="gap-1 h-7"
+              @click="promo.clear()"
+            >
               <X class="w-3.5 h-3.5" />
-              {{ t('events.purchase.promo.remove') }}
+              {{ t("events.purchase.promo.remove") }}
             </Button>
           </div>
           <div v-else class="flex gap-2">
@@ -571,54 +752,100 @@ onUnmounted(() => {
               @click="promo.apply()"
             >
               <Loader2 v-if="promoChecking" class="w-4 h-4 mr-2 animate-spin" />
-              {{ promoChecking ? t('events.purchase.promo.checking') : t('events.purchase.promo.apply') }}
+              {{
+                promoChecking
+                  ? t("events.purchase.promo.checking")
+                  : t("events.purchase.promo.apply")
+              }}
             </Button>
           </div>
 
-          <p v-if="promoState.status === 'invalid'" class="text-xs text-destructive">
-            {{ t('events.purchase.promo.invalid') }}
+          <p
+            v-if="promoState.status === 'invalid'"
+            class="text-xs text-destructive"
+          >
+            {{ t("events.purchase.promo.invalid") }}
           </p>
-          <p v-else-if="promoState.status === 'unverified'" class="text-xs text-muted-foreground">
-            {{ t('events.purchase.promo.unverified') }}
+          <p
+            v-else-if="promoState.status === 'unverified'"
+            class="text-xs text-muted-foreground"
+          >
+            {{ t("events.purchase.promo.unverified") }}
           </p>
 
           <Alert v-if="guestNeedsLoginForDiscount" class="mt-2">
             <User class="w-4 h-4" />
             <AlertDescription class="flex flex-col gap-2">
-              <span>{{ t('events.purchase.promo.loginRequiredDiscount') }}</span>
-              <Button type="button" size="sm" class="w-fit" @click="() => $router.push('/login')">
-                {{ t('events.detail.logIn') }}
+              <span>{{
+                t("events.purchase.promo.loginRequiredDiscount")
+              }}</span>
+              <Button
+                type="button"
+                size="sm"
+                class="w-fit"
+                @click="() => $router.push('/login')"
+              >
+                {{ t("events.detail.logIn") }}
               </Button>
             </AlertDescription>
           </Alert>
         </div>
 
         <!-- Wallet Information (logged-in Lightning buyers) -->
-        <div v-if="isAuthenticated && selectedMethod?.rail === 'lightning' && !isZeroTotal" class="bg-muted/50 rounded-lg p-4 space-y-3">
+        <div
+          v-if="
+            isAuthenticated &&
+            selectedMethod?.rail === 'lightning' &&
+            !isZeroTotal
+          "
+          class="bg-muted/50 rounded-lg p-4 space-y-3"
+        >
           <div class="flex items-center gap-2">
             <Wallet class="w-4 h-4 text-muted-foreground" />
             <span class="text-sm font-medium">Wallet Status:</span>
           </div>
           <div class="space-y-2">
-            <div v-if="userWallets.length === 0" class="text-sm text-muted-foreground">
+            <div
+              v-if="userWallets.length === 0"
+              class="text-sm text-muted-foreground"
+            >
               No wallets found
             </div>
             <div v-else class="space-y-2">
-              <div v-for="wallet in userWallets" :key="wallet.id" class="flex items-center justify-between">
+              <div
+                v-for="wallet in userWallets"
+                :key="wallet.id"
+                class="flex items-center justify-between"
+              >
                 <div class="flex items-center gap-2">
                   <span class="text-sm font-medium">{{ wallet.name }}</span>
-                  <Badge v-if="wallet.balance_msat > 0" variant="default" class="text-xs">
+                  <Badge
+                    v-if="wallet.balance_msat > 0"
+                    variant="default"
+                    class="text-xs"
+                  >
                     {{ formatWalletBalance(wallet.balance_msat) }}
                   </Badge>
-                  <Badge v-else variant="secondary" class="text-xs">Empty</Badge>
+                  <Badge v-else variant="secondary" class="text-xs"
+                    >Empty</Badge
+                  >
                 </div>
               </div>
-              <div v-if="hasWalletWithBalance" class="flex items-center gap-2 text-sm text-primary">
+              <div
+                v-if="hasWalletWithBalance"
+                class="flex items-center gap-2 text-sm text-primary"
+              >
                 <Zap class="w-4 h-4" />
                 <span>Auto-payment available</span>
               </div>
-              <div v-else class="flex items-center gap-2 text-sm text-muted-foreground">
-                <span>No funds available, fill your wallet or pay with an external one</span>
+              <div
+                v-else
+                class="flex items-center gap-2 text-sm text-muted-foreground"
+              >
+                <span
+                  >No funds available, fill your wallet or pay with an external
+                  one</span
+                >
               </div>
             </div>
           </div>
@@ -630,6 +857,43 @@ onUnmounted(() => {
             <span class="text-sm font-medium">Payment Details:</span>
           </div>
 
+          <!-- Ticket wave picker. Only shown when the buyer actually has a
+               choice: a single open wave is implied, exactly as the backend
+               resolves it, so the common case gains no extra click. -->
+          <div v-if="openWaves.length > 1" class="space-y-2">
+            <span class="text-sm text-muted-foreground">Ticket type:</span>
+            <div class="grid gap-2">
+              <button
+                v-for="wave in openWaves"
+                :key="wave.id"
+                type="button"
+                class="flex items-center justify-between rounded-md border px-3 py-2 text-left transition-colors"
+                :class="
+                  wave.id === selectedWave?.id
+                    ? 'border-primary bg-primary/5'
+                    : 'border-input hover:bg-accent'
+                "
+                @click="selectedWaveId = wave.id"
+              >
+                <span class="flex flex-col">
+                  <span class="text-sm font-medium">{{ wave.title }}</span>
+                  <span class="text-xs text-muted-foreground">
+                    {{ wave.amount_tickets }} left
+                  </span>
+                </span>
+                <span class="text-sm font-medium">
+                  {{ formatEventPrice(wave.price_per_ticket, wave.currency) }}
+                </span>
+              </button>
+            </div>
+          </div>
+
+          <Alert v-if="nothingOnSale" variant="destructive">
+            <AlertDescription>
+              No ticket type is currently on sale for this event.
+            </AlertDescription>
+          </Alert>
+
           <!-- Quantity selector — backend caps at 10. One invoice for
                the whole purchase, N ticket rows (one per attendee). -->
           <div class="flex items-center justify-between">
@@ -645,7 +909,9 @@ onUnmounted(() => {
               >
                 <Minus class="h-3.5 w-3.5" />
               </Button>
-              <span class="w-6 text-center text-sm font-medium">{{ quantity }}</span>
+              <span class="w-6 text-center text-sm font-medium">{{
+                quantity
+              }}</span>
               <Button
                 type="button"
                 variant="outline"
@@ -666,20 +932,43 @@ onUnmounted(() => {
             </div>
             <div class="flex justify-between">
               <span class="text-sm text-muted-foreground">
-                {{ quantity > 1 && !isFree ? `${quantity} × ${formatEventPrice(event.price_per_ticket, event.currency)}` : 'Price' }}
+                {{
+                  quantity > 1 && !isFree
+                    ? `${quantity} × ${formatEventPrice(pricing.price_per_ticket, pricing.currency)}`
+                    : "Price"
+                }}
               </span>
               <span class="text-sm font-medium">
                 <template v-if="isFree">Free</template>
                 <template v-else-if="hasDiscount">
-                  <s class="text-muted-foreground font-normal mr-1">{{ formatEventPrice(totalPrice, event.currency) }}</s>
-                  {{ isZeroTotal ? 'Free' : formatEventPrice(effectiveTotal, event.currency) }}
+                  <s class="text-muted-foreground font-normal mr-1">{{
+                    formatEventPrice(totalPrice, pricing.currency)
+                  }}</s>
+                  {{
+                    isZeroTotal
+                      ? "Free"
+                      : formatEventPrice(effectiveTotal, pricing.currency)
+                  }}
                 </template>
-                <template v-else>{{ formatEventPrice(totalPrice, event.currency) }}</template>
+                <template v-else>{{
+                  formatEventPrice(totalPrice, pricing.currency)
+                }}</template>
               </span>
             </div>
-            <div v-if="hasDiscount && promoState.status === 'applied'" class="flex justify-between text-primary">
-              <span class="text-sm">{{ t('events.purchase.promo.discountLine', { code: promoState.code }) }}</span>
-              <span class="text-sm font-medium">−{{ formatEventPrice(promoDiscountAmount, event.currency) }}</span>
+            <div
+              v-if="hasDiscount && promoState.status === 'applied'"
+              class="flex justify-between text-primary"
+            >
+              <span class="text-sm">{{
+                t("events.purchase.promo.discountLine", {
+                  code: promoState.code,
+                })
+              }}</span>
+              <span class="text-sm font-medium"
+                >−{{
+                  formatEventPrice(promoDiscountAmount, pricing.currency)
+                }}</span
+              >
             </div>
             <PriceConversionPreview
               v-if="canChooseFiat && isPriceInSats && event.fiat_currency"
@@ -695,12 +984,15 @@ onUnmounted(() => {
         <!-- Payment method selector — one button per enabled rail /
              configured fiat provider. Hidden when only one rail is on
              (nothing to choose) and for free tickets. -->
-        <div v-if="paymentMethods.length > 1 && !isZeroTotal" class="bg-muted/50 rounded-lg p-4 space-y-2">
+        <div
+          v-if="paymentMethods.length > 1 && !isZeroTotal"
+          class="bg-muted/50 rounded-lg p-4 space-y-2"
+        >
           <div class="text-sm font-medium">Payment method</div>
           <p class="text-xs text-muted-foreground">
-            Both methods charge the same amount via different rails.
-            Live rates shown are estimates; the exact sat amount locks
-            in when you start checkout.
+            Both methods charge the same amount via different rails. Live rates
+            shown are estimates; the exact sat amount locks in when you start
+            checkout.
           </p>
           <PaymentMethodSelector
             :methods="paymentMethods"
@@ -709,31 +1001,54 @@ onUnmounted(() => {
           />
         </div>
 
-        <div v-if="error || fiatError" class="text-sm text-destructive bg-destructive/10 p-3 rounded-lg">
+        <div
+          v-if="error || fiatError"
+          class="text-sm text-destructive bg-destructive/10 p-3 rounded-lg"
+        >
           {{ error || fiatError }}
         </div>
 
         <Button
           type="submit"
-          :disabled="isLoading || isFiatPending || promoChecking || guestNeedsLoginForDiscount || (paymentMethods.length === 0 && !isZeroTotal)"
+          :disabled="
+            isLoading ||
+            isFiatPending ||
+            promoChecking ||
+            guestNeedsLoginForDiscount ||
+            needsWaveChoice ||
+            nothingOnSale ||
+            (paymentMethods.length === 0 && !isZeroTotal)
+          "
           class="w-full"
         >
-          <Loader2 v-if="isLoading || isFiatPending" class="w-4 h-4 mr-2 animate-spin" />
+          <Loader2
+            v-if="isLoading || isFiatPending"
+            class="w-4 h-4 mr-2 animate-spin"
+          />
           <template v-else-if="isZeroTotal">
             <Ticket class="w-4 h-4 mr-2" />
-            {{ quantity > 1 ? `Get ${quantity} tickets` : 'Get ticket' }}
+            {{ quantity > 1 ? `Get ${quantity} tickets` : "Get ticket" }}
           </template>
           <template v-else-if="selectedMethod?.rail === 'fiat'">
             <CreditCard class="w-4 h-4 mr-2" />
-            {{ t('events.purchase.continueTo', { provider: selectedMethod.label }) }}
+            {{
+              t("events.purchase.continueTo", {
+                provider: selectedMethod.label,
+              })
+            }}
           </template>
           <template v-else>
             <Zap class="w-4 h-4 mr-2" />
-            {{ quantity > 1 ? `Proceed buying (${quantity} tickets)` : 'Proceed' }}
+            {{
+              quantity > 1 ? `Proceed buying (${quantity} tickets)` : "Proceed"
+            }}
           </template>
         </Button>
-        <p v-if="selectedMethod?.rail === 'fiat' && !isZeroTotal" class="text-xs text-muted-foreground text-center">
-          {{ t('events.purchase.fiatRedirectHint') }}
+        <p
+          v-if="selectedMethod?.rail === 'fiat' && !isZeroTotal"
+          class="text-xs text-muted-foreground text-center"
+        >
+          {{ t("events.purchase.fiatRedirectHint") }}
         </p>
       </form>
 
@@ -747,8 +1062,8 @@ onUnmounted(() => {
           <h3 class="text-lg font-semibold">Pay the invoice</h3>
           <p class="text-sm text-muted-foreground">
             <template v-if="hasWalletWithBalance">
-              Scan with any Lightning wallet, or tap the button below to
-              pay from your LNbits wallet.
+              Scan with any Lightning wallet, or tap the button below to pay
+              from your LNbits wallet.
             </template>
             <template v-else>
               Scan with any Lightning wallet, or open it in your wallet app.
@@ -760,7 +1075,9 @@ onUnmounted(() => {
              OrderInvoiceCard pattern). The QR keeps a white background
              regardless of theme so phone cameras parse it reliably. -->
         <div class="bg-muted/50 rounded-lg p-4 space-y-3">
-          <div class="mx-auto w-fit overflow-hidden rounded-lg border border-border bg-white p-2">
+          <div
+            class="mx-auto w-fit overflow-hidden rounded-lg border border-border bg-white p-2"
+          >
             <img
               v-if="qrCode"
               :src="qrCode"
@@ -771,8 +1088,11 @@ onUnmounted(() => {
           <div class="flex items-baseline justify-between">
             <span class="text-xs text-muted-foreground">Amount</span>
             <span class="font-mono text-sm font-semibold text-primary">
-              {{ formatEventPrice(effectiveTotal, event.currency) }}
-              <span v-if="quantity > 1" class="text-muted-foreground font-normal">
+              {{ formatEventPrice(effectiveTotal, pricing.currency) }}
+              <span
+                v-if="quantity > 1"
+                class="text-muted-foreground font-normal"
+              >
                 ({{ quantity }} tickets)
               </span>
             </span>
@@ -786,7 +1106,7 @@ onUnmounted(() => {
             >
               <Check v-if="copiedInvoice" class="mr-2 h-3.5 w-3.5" />
               <Copy v-else class="mr-2 h-3.5 w-3.5" />
-              {{ copiedInvoice ? 'Copied' : 'Copy' }}
+              {{ copiedInvoice ? "Copied" : "Copy" }}
             </Button>
             <Button
               variant="default"
@@ -811,21 +1131,26 @@ onUnmounted(() => {
           :disabled="isPayingWithWallet"
           @click="payCurrentInvoiceWithWallet"
         >
-          <Loader2 v-if="isPayingWithWallet" class="mr-2 h-4 w-4 animate-spin" />
+          <Loader2
+            v-if="isPayingWithWallet"
+            class="mr-2 h-4 w-4 animate-spin"
+          />
           <Wallet v-else class="mr-2 h-4 w-4" />
-          {{ isPayingWithWallet ? 'Paying…' : 'Pay from my LNbits wallet' }}
+          {{ isPayingWithWallet ? "Paying…" : "Pay from my LNbits wallet" }}
         </Button>
         <p
           v-else-if="userWallets.length > 0"
           class="text-center text-xs text-muted-foreground"
         >
-          Your LNbits wallet is empty — pay with an external wallet
-          using the QR or "Open in wallet" above.
+          Your LNbits wallet is empty — pay with an external wallet using the QR
+          or "Open in wallet" above.
         </p>
 
         <div v-if="isPaymentPending" class="text-center space-y-1">
           <div class="flex items-center justify-center gap-2">
-            <div class="animate-spin w-4 h-4 border-2 border-primary border-t-transparent rounded-full"></div>
+            <div
+              class="animate-spin w-4 h-4 border-2 border-primary border-t-transparent rounded-full"
+            ></div>
             <span class="text-sm text-muted-foreground">
               Waiting for payment…
             </span>
@@ -839,27 +1164,30 @@ onUnmounted(() => {
       <!-- Success state. Logged-in buyers get routed to My Tickets
            (QRs live there); guests have no My Tickets, so their QRs
            render right here alongside the "emailed to" note. -->
-      <div v-else-if="showTicketQR && purchasedTicketIds.length > 0" class="py-6 flex flex-col items-center gap-4">
+      <div
+        v-else-if="showTicketQR && purchasedTicketIds.length > 0"
+        class="py-6 flex flex-col items-center gap-4"
+      >
         <div class="flex justify-center">
           <Ticket class="w-12 h-12 text-primary" />
         </div>
         <div class="text-center space-y-2">
           <h3 class="text-lg font-semibold text-primary">
-            {{ purchasedTicketIds.length > 1
+            {{
+              purchasedTicketIds.length > 1
                 ? `${purchasedTicketIds.length} tickets purchased!`
-                : 'Ticket purchased!' }}
+                : "Ticket purchased!"
+            }}
           </h3>
           <p v-if="isAuthenticated" class="text-sm text-muted-foreground">
             <span v-if="purchasedTicketIds.length > 1">
-              Each attendee gets their own scannable QR in My Tickets —
-              hand them out independently for the door scan.
-            </span>
-            <span v-else>
-              Your ticket is now in My Tickets.
+              Each attendee gets their own scannable QR in My Tickets — hand
+              them out independently for the door scan.
             </span>
+            <span v-else> Your ticket is now in My Tickets. </span>
           </p>
           <p v-if="form.values.email" class="text-sm text-muted-foreground">
-            {{ t('events.checkout.emailedTo', { email: form.values.email }) }}
+            {{ t("events.checkout.emailedTo", { email: form.values.email }) }}
           </p>
         </div>
 
@@ -869,20 +1197,42 @@ onUnmounted(() => {
             :key="id"
             class="bg-muted/50 rounded-lg p-3 flex flex-col items-center gap-2"
           >
-            <span v-if="purchasedTicketIds.length > 1" class="text-xs text-muted-foreground">
-              {{ t('events.checkout.ticketN', { n: idx + 1, total: purchasedTicketIds.length }) }}
+            <span
+              v-if="purchasedTicketIds.length > 1"
+              class="text-xs text-muted-foreground"
+            >
+              {{
+                t("events.checkout.ticketN", {
+                  n: idx + 1,
+                  total: purchasedTicketIds.length,
+                })
+              }}
             </span>
-            <div class="overflow-hidden rounded-lg border border-border bg-white p-2">
-              <img v-if="ticketQRCodes[id]" :src="ticketQRCodes[id]" :alt="`Ticket ${id}`" class="block h-40 w-40" />
+            <div
+              class="overflow-hidden rounded-lg border border-border bg-white p-2"
+            >
+              <img
+                v-if="ticketQRCodes[id]"
+                :src="ticketQRCodes[id]"
+                :alt="`Ticket ${id}`"
+                class="block h-40 w-40"
+              />
             </div>
-            <RouterLink :to="`/events/ticket/${id}`" class="text-xs text-primary underline underline-offset-2">
-              {{ t('events.checkout.viewTicket') }}
+            <RouterLink
+              :to="`/events/ticket/${id}`"
+              class="text-xs text-primary underline underline-offset-2"
+            >
+              {{ t("events.checkout.viewTicket") }}
             </RouterLink>
           </div>
         </div>
 
         <div class="space-y-3 w-full">
-          <Button v-if="isAuthenticated" @click="() => $router.push('/my-tickets')" class="w-full">
+          <Button
+            v-if="isAuthenticated"
+            @click="() => $router.push('/my-tickets')"
+            class="w-full"
+          >
             View My Tickets
           </Button>
           <Button variant="outline" @click="handleClose" class="w-full">
diff --git a/src/modules/events/composables/usePromoCode.ts b/src/modules/events/composables/usePromoCode.ts
index 0642fe7..f11dc07 100644
--- a/src/modules/events/composables/usePromoCode.ts
+++ b/src/modules/events/composables/usePromoCode.ts
@@ -1,7 +1,17 @@
-import { computed, ref, toValue, watch, type MaybeRefOrGetter, type Ref } from 'vue'
-import { injectService, SERVICE_TOKENS } from '@/core/di-container'
-import type { TicketApiService } from '../services/TicketApiService'
-import { isUnsupportedEndpointError, normalizePromoCode } from '../lib/promoCodes'
+import {
+  computed,
+  ref,
+  toValue,
+  watch,
+  type MaybeRefOrGetter,
+  type Ref,
+} from "vue";
+import { injectService, SERVICE_TOKENS } from "@/core/di-container";
+import type { TicketApiService } from "../services/TicketApiService";
+import {
+  isUnsupportedEndpointError,
+  normalizePromoCode,
+} from "../lib/promoCodes";
 
 /**
  * Buyer-side promo state for the purchase dialog.
@@ -17,111 +27,138 @@ import { isUnsupportedEndpointError, normalizePromoCode } from '../lib/promoCode
  *                 every extension version.
  */
 export type PromoState =
-  | { status: 'idle' }
-  | { status: 'checking'; code: string }
+  | { status: "idle" }
+  | { status: "checking"; code: string }
   | {
-      status: 'applied'
-      code: string
-      discountPercent: number
-      subtotal: number
-      discount: number
-      total: number
-      currency: string
+      status: "applied";
+      code: string;
+      discountPercent: number;
+      subtotal: number;
+      discount: number;
+      total: number;
+      currency: string;
     }
-  | { status: 'invalid'; code: string }
-  | { status: 'unverified'; code: string }
+  | { status: "invalid"; code: string }
+  | { status: "unverified"; code: string };
 
-const REVALIDATE_DEBOUNCE_MS = 300
+const REVALIDATE_DEBOUNCE_MS = 300;
 
-export function usePromoCode(eventId: MaybeRefOrGetter<string>, quantity: Ref<number>) {
-  const ticketApi = injectService(SERVICE_TOKENS.TICKET_API) as TicketApiService
+export function usePromoCode(
+  eventId: MaybeRefOrGetter<string>,
+  quantity: Ref<number>,
+  ticketWaveId?: MaybeRefOrGetter<string | undefined>,
+) {
+  const ticketApi = injectService(
+    SERVICE_TOKENS.TICKET_API,
+  ) as TicketApiService;
 
   /** What the buyer typed (kept upper-case by the input handler). */
-  const input = ref('')
-  const state = ref<PromoState>({ status: 'idle' })
+  const input = ref("");
+  const state = ref<PromoState>({ status: "idle" });
 
   // Monotonic request counter so a slow response for a previous code or
   // quantity can never overwrite a newer result.
-  let requestSeq = 0
-  let debounceTimer: ReturnType<typeof setTimeout> | null = null
+  let requestSeq = 0;
+  let debounceTimer: ReturnType<typeof setTimeout> | null = null;
 
-  const isChecking = computed(() => state.value.status === 'checking')
+  const isChecking = computed(() => state.value.status === "checking");
 
   /** Code to put on the purchase request. `invalid` deliberately sends
    *  nothing so the buyer is not surprised by a 400 at pay time. */
   const codeToSend = computed<string | undefined>(() => {
-    const s = state.value
-    return s.status === 'applied' || s.status === 'unverified' ? s.code : undefined
-  })
+    const s = state.value;
+    return s.status === "applied" || s.status === "unverified"
+      ? s.code
+      : undefined;
+  });
 
   const appliedTotal = computed<number | null>(() =>
-    state.value.status === 'applied' ? state.value.total : null,
-  )
+    state.value.status === "applied" ? state.value.total : null,
+  );
 
   async function validate(code: string): Promise<void> {
-    const seq = ++requestSeq
-    state.value = { status: 'checking', code }
+    const seq = ++requestSeq;
+    state.value = { status: "checking", code };
     try {
-      const totals = await ticketApi.validatePromoCode(toValue(eventId), code, quantity.value)
-      if (seq !== requestSeq) return
-      const hit = totals.discounts_applied.find((d) => d.code === code) ?? totals.discounts_applied[0]
+      const totals = await ticketApi.validatePromoCode(
+        toValue(eventId),
+        code,
+        quantity.value,
+        toValue(ticketWaveId),
+      );
+      if (seq !== requestSeq) return;
+      const hit =
+        totals.discounts_applied.find((d) => d.code === code) ??
+        totals.discounts_applied[0];
       if (!hit) {
-        state.value = { status: 'invalid', code }
-        return
+        state.value = { status: "invalid", code };
+        return;
       }
       state.value = {
-        status: 'applied',
+        status: "applied",
         code: hit.code,
         discountPercent: hit.discount_percent ?? 0,
         subtotal: totals.subtotal,
         discount: totals.discount,
         total: totals.total,
         currency: totals.currency,
-      }
+      };
     } catch (err) {
-      if (seq !== requestSeq) return
+      if (seq !== requestSeq) return;
       if (isUnsupportedEndpointError(err)) {
-        state.value = { status: 'unverified', code }
-        return
+        state.value = { status: "unverified", code };
+        return;
       }
       // Network / 5xx: don't block the purchase on an advisory call.
-      console.warn('[usePromoCode] validate failed, sending code unverified:', err)
-      state.value = { status: 'unverified', code }
+      console.warn(
+        "[usePromoCode] validate failed, sending code unverified:",
+        err,
+      );
+      state.value = { status: "unverified", code };
     }
   }
 
   async function apply(): Promise<void> {
-    const code = normalizePromoCode(input.value)
-    if (!code) return
-    input.value = code
-    await validate(code)
+    const code = normalizePromoCode(input.value);
+    if (!code) return;
+    input.value = code;
+    await validate(code);
   }
 
   function clear(): void {
-    requestSeq++
-    if (debounceTimer) clearTimeout(debounceTimer)
-    debounceTimer = null
-    input.value = ''
-    state.value = { status: 'idle' }
+    requestSeq++;
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = null;
+    input.value = "";
+    state.value = { status: "idle" };
   }
 
   /** Re-check the current code (quantity changed, or the purchase
    *  endpoint rejected it — e.g. the last use went to someone else). */
   async function revalidate(): Promise<void> {
-    const s = state.value
-    if (s.status === 'idle' || s.status === 'checking') return
-    await validate(s.code)
+    const s = state.value;
+    if (s.status === "idle" || s.status === "checking") return;
+    await validate(s.code);
   }
 
   watch(quantity, () => {
-    const s = state.value
-    if (s.status === 'idle') return
-    if (debounceTimer) clearTimeout(debounceTimer)
+    const s = state.value;
+    if (s.status === "idle") return;
+    if (debounceTimer) clearTimeout(debounceTimer);
     debounceTimer = setTimeout(() => {
-      debounceTimer = null
-      void revalidate()
-    }, REVALIDATE_DEBOUNCE_MS)
-  })
+      debounceTimer = null;
+      void revalidate();
+    }, REVALIDATE_DEBOUNCE_MS);
+  });
 
-  return { input, state, isChecking, codeToSend, appliedTotal, apply, clear, revalidate }
+  return {
+    input,
+    state,
+    isChecking,
+    codeToSend,
+    appliedTotal,
+    apply,
+    clear,
+    revalidate,
+  };
 }
diff --git a/src/modules/events/composables/useTicketPurchase.ts b/src/modules/events/composables/useTicketPurchase.ts
index 5854497..265e842 100644
--- a/src/modules/events/composables/useTicketPurchase.ts
+++ b/src/modules/events/composables/useTicketPurchase.ts
@@ -1,49 +1,56 @@
-import { ref, computed, onUnmounted } from 'vue'
-import { useAuth } from '@/composables/useAuthService'
-import { toast } from 'vue-sonner'
-import { useAsyncOperation } from '@/core/composables/useAsyncOperation'
-import { injectService, SERVICE_TOKENS } from '@/core/di-container'
-import type { PaymentService } from '@/core/services/PaymentService'
-import type { TicketApiService } from '../services/TicketApiService'
-import { useOwnedTickets } from './useOwnedTickets'
-import { frontendRoot } from '../lib/frontendRoot'
-import { renderTicketQr } from '../lib/ticketQr'
+import { ref, computed, onUnmounted } from "vue";
+import { useAuth } from "@/composables/useAuthService";
+import { toast } from "vue-sonner";
+import { useAsyncOperation } from "@/core/composables/useAsyncOperation";
+import { injectService, SERVICE_TOKENS } from "@/core/di-container";
+import type { PaymentService } from "@/core/services/PaymentService";
+import type { TicketApiService } from "../services/TicketApiService";
+import { useOwnedTickets } from "./useOwnedTickets";
+import { frontendRoot } from "../lib/frontendRoot";
+import { renderTicketQr } from "../lib/ticketQr";
 
 /** Guest identity for a purchase without an LNbits account. */
 export interface PurchaseContact {
-  name: string
-  email: string
+  name: string;
+  email: string;
 }
 
 export interface PurchaseTicketOptions {
-  quantity?: number
+  quantity?: number;
   /** Guest buyer (no account). Required when not authenticated. */
-  contact?: PurchaseContact
+  contact?: PurchaseContact;
   /** Delivery email for a logged-in buyer (guests carry it in `contact`). */
-  email?: string
+  email?: string;
   /** Promo code to redeem (already normalised by the dialog). */
-  promoCode?: string
+  promoCode?: string;
+  /** Pricing tier the buyer chose. Required when several waves are open;
+   *  the backend refuses to guess. */
+  ticketWaveId?: string;
 }
 
 export function useTicketPurchase() {
-  const { isAuthenticated, currentUser } = useAuth()
-  const paymentService = injectService(SERVICE_TOKENS.PAYMENT_SERVICE) as PaymentService
-  const ticketApi = injectService(SERVICE_TOKENS.TICKET_API) as TicketApiService
+  const { isAuthenticated, currentUser } = useAuth();
+  const paymentService = injectService(
+    SERVICE_TOKENS.PAYMENT_SERVICE,
+  ) as PaymentService;
+  const ticketApi = injectService(
+    SERVICE_TOKENS.TICKET_API,
+  ) as TicketApiService;
 
   // Refresh the shared owned-tickets singleton after a purchase so the
   // feed/calendar "My tickets" filter and EventCard owned badges update
   // without a reload — purchase is exactly the "consumer that mutates
   // the ticket set" useOwnedTickets's docs anticipate.
-  const { refresh: refreshOwnedTickets } = useOwnedTickets()
+  const { refresh: refreshOwnedTickets } = useOwnedTickets();
 
   // Async operations
-  const purchaseOperation = useAsyncOperation()
+  const purchaseOperation = useAsyncOperation();
 
   // State
-  const paymentHash = ref<string | null>(null)
-  const paymentRequest = ref<string | null>(null)
-  const qrCode = ref<string | null>(null)
-  const isPaymentPending = ref(false)
+  const paymentHash = ref<string | null>(null);
+  const paymentRequest = ref<string | null>(null);
+  const qrCode = ref<string | null>(null);
+  const isPaymentPending = ref(false);
 
   // Ticket QR code state. After payment lands, `purchasedTicketIds`
   // is populated with every row id created on the invoice (one for
@@ -51,62 +58,68 @@ export function useTicketPurchase() {
   // parallel map id → QR data URL so the UI can render one QR per
   // attendee. `purchasedTicketId` stays for back-compat with the
   // single-id success path.
-  const ticketQRCode = ref<string | null>(null)
-  const ticketQRCodes = ref<Record<string, string>>({})
-  const purchasedTicketId = ref<string | null>(null)
-  const purchasedTicketIds = ref<string[]>([])
-  const showTicketQR = ref(false)
+  const ticketQRCode = ref<string | null>(null);
+  const ticketQRCodes = ref<Record<string, string>>({});
+  const purchasedTicketId = ref<string | null>(null);
+  const purchasedTicketIds = ref<string[]>([]);
+  const showTicketQR = ref(false);
 
   // Computed properties
-  const canPurchase = computed(() => isAuthenticated.value && currentUser.value)
+  const canPurchase = computed(
+    () => isAuthenticated.value && currentUser.value,
+  );
   const userDisplay = computed(() => {
-    if (!currentUser.value) return null
+    if (!currentUser.value) return null;
     return {
       name: currentUser.value.username || currentUser.value.id,
-      shortId: currentUser.value.id.slice(0, 8)
-    }
-  })
+      shortId: currentUser.value.id.slice(0, 8),
+    };
+  });
 
   // Delegate to PaymentService
-  const userWallets = computed(() => paymentService.userWallets)
-  const hasWalletWithBalance = computed(() => paymentService.hasWalletWithBalance)
-  const isPayingWithWallet = computed(() => paymentService.isProcessingPayment.value)
+  const userWallets = computed(() => paymentService.userWallets);
+  const hasWalletWithBalance = computed(
+    () => paymentService.hasWalletWithBalance,
+  );
+  const isPayingWithWallet = computed(
+    () => paymentService.isProcessingPayment.value,
+  );
 
   async function generateQRCode(bolt11: string) {
     try {
-      qrCode.value = await paymentService.generateQRCode(bolt11)
+      qrCode.value = await paymentService.generateQRCode(bolt11);
     } catch (err) {
-      console.error('Error generating QR code:', err)
+      console.error("Error generating QR code:", err);
     }
   }
 
   async function generateTicketQRCode(ticketId: string) {
     try {
-      const dataUrl = await renderTicketQr(ticketId, { width: 160 })
-      ticketQRCode.value = dataUrl
-      return dataUrl
+      const dataUrl = await renderTicketQr(ticketId, { width: 160 });
+      ticketQRCode.value = dataUrl;
+      return dataUrl;
     } catch (error) {
-      console.error('Error generating ticket QR code:', error)
-      return null
+      console.error("Error generating ticket QR code:", error);
+      return null;
     }
   }
 
   async function payWithWallet(pr: string) {
     try {
       await paymentService.payWithWallet(pr, undefined, {
-        showToast: false
-      })
-      return true
+        showToast: false,
+      });
+      return true;
     } catch (error) {
-      console.error('Wallet payment failed:', error)
-      throw error
+      console.error("Wallet payment failed:", error);
+      throw error;
     }
   }
 
   /** The event id this composable is currently driving — kept so
    *  `payCurrentInvoiceWithWallet` and `startPaymentStatusCheck` don't
    *  have to take it as an argument from the UI. */
-  const currentEventId = ref<string | null>(null)
+  const currentEventId = ref<string | null>(null);
 
   /**
    * Advance to the ticket-QR success state for the given row ids. Shared
@@ -118,26 +131,26 @@ export function useTicketPurchase() {
     // Ticket row(s) now exist — refresh the shared owned-tickets state so
     // the feed/calendar My-tickets filter and owned badges reflect the
     // purchase immediately (no reload). Runs in parallel with QR gen.
-    void refreshOwnedTickets()
+    void refreshOwnedTickets();
 
     if (ids.length > 0) {
-      purchasedTicketIds.value = ids
-      purchasedTicketId.value = ids[0]
-      const qrMap: Record<string, string> = {}
+      purchasedTicketIds.value = ids;
+      purchasedTicketId.value = ids[0];
+      const qrMap: Record<string, string> = {};
       for (const id of ids) {
-        const dataUrl = await generateTicketQRCode(id)
-        if (dataUrl) qrMap[id] = dataUrl
+        const dataUrl = await generateTicketQRCode(id);
+        if (dataUrl) qrMap[id] = dataUrl;
       }
-      ticketQRCodes.value = qrMap
-      ticketQRCode.value = qrMap[ids[0]] ?? null
-      showTicketQR.value = true
+      ticketQRCodes.value = qrMap;
+      ticketQRCode.value = qrMap[ids[0]] ?? null;
+      showTicketQR.value = true;
     }
 
     toast.success(
       ids.length > 1
         ? `${ids.length} tickets purchased!`
-        : 'Ticket purchased successfully!',
-    )
+        : "Ticket purchased successfully!",
+    );
   }
 
   async function purchaseTicketForEvent(
@@ -147,78 +160,82 @@ export function useTicketPurchase() {
     // Guests are identified by name + email; logged-in buyers by user id.
     // Either is enough for a paid ticket — free tickets stay login-gated
     // in the dialog (events#29: no anonymous free issuance).
-    const isGuest = !canPurchase.value || !currentUser.value
+    const isGuest = !canPurchase.value || !currentUser.value;
     if (isGuest && !options.contact) {
-      throw new Error('User must be authenticated to purchase tickets')
+      throw new Error("User must be authenticated to purchase tickets");
     }
 
-    return await purchaseOperation.execute(async () => {
-      // Clear previous state
-      paymentHash.value = null
-      paymentRequest.value = null
-      qrCode.value = null
-      ticketQRCode.value = null
-      ticketQRCodes.value = {}
-      purchasedTicketId.value = null
-      purchasedTicketIds.value = []
-      showTicketQR.value = false
-      currentEventId.value = eventId
+    return await purchaseOperation.execute(
+      async () => {
+        // Clear previous state
+        paymentHash.value = null;
+        paymentRequest.value = null;
+        qrCode.value = null;
+        ticketQRCode.value = null;
+        ticketQRCodes.value = {};
+        purchasedTicketId.value = null;
+        purchasedTicketIds.value = [];
+        showTicketQR.value = false;
+        currentEventId.value = eventId;
 
-      // Get the invoice via TicketApiService
-      const lnbitsAPI = injectService(SERVICE_TOKENS.LNBITS_API) as any
-      const accessToken = lnbitsAPI?.getAccessToken?.() || ''
+        // Get the invoice via TicketApiService
+        const lnbitsAPI = injectService(SERVICE_TOKENS.LNBITS_API) as any;
+        const accessToken = lnbitsAPI?.getAccessToken?.() || "";
 
-      const invoice = await ticketApi.requestTicket(eventId, {
-        userId: isGuest ? undefined : currentUser.value!.id,
-        name: isGuest ? options.contact?.name : undefined,
-        email: isGuest ? options.contact?.email : options.email,
-        accessToken: isGuest ? undefined : accessToken,
-        frontendUrl: frontendRoot(),
-        quantity: options.quantity,
-        promoCode: options.promoCode,
-      })
+        const invoice = await ticketApi.requestTicket(eventId, {
+          userId: isGuest ? undefined : currentUser.value!.id,
+          name: isGuest ? options.contact?.name : undefined,
+          email: isGuest ? options.contact?.email : options.email,
+          accessToken: isGuest ? undefined : accessToken,
+          frontendUrl: frontendRoot(),
+          quantity: options.quantity,
+          promoCode: options.promoCode,
+          ticketWaveId: options.ticketWaveId,
+        });
 
-      // Free tickets (price 0 / 100%-off promo): the backend already
-      // issued + marked them paid, so there's no invoice to settle. Skip
-      // the QR / payment-poll and jump straight to the ticket-QR success
-      // state with the ids returned inline.
-      if (invoice.paid) {
-        paymentHash.value = invoice.paymentHash
-        await finalizePurchasedTickets(invoice.ticketIds ?? [])
-        return invoice
-      }
+        // Free tickets (price 0 / 100%-off promo): the backend already
+        // issued + marked them paid, so there's no invoice to settle. Skip
+        // the QR / payment-poll and jump straight to the ticket-QR success
+        // state with the ids returned inline.
+        if (invoice.paid) {
+          paymentHash.value = invoice.paymentHash;
+          await finalizePurchasedTickets(invoice.ticketIds ?? []);
+          return invoice;
+        }
 
-      // Otherwise the backend returns either a Lightning invoice or a fiat
-      // checkout URL (post-events-v1.4.0). This composable only knows how
-      // to drive the Lightning path; fiat would need a separate
-      // redirect-to-provider flow that lives in PurchaseTicketDialog (it
-      // has the user-visible payment-method selector). Reject the fiat
-      // response here so callers get a clear error instead of a silent
-      // broken QR.
-      if (invoice.isFiat || !invoice.paymentRequest) {
-        throw new Error(
-          'This event uses fiat checkout. Use the purchase dialog ' +
-          'to follow the provider link.',
-        )
-      }
-      const bolt11: string = invoice.paymentRequest
-      paymentHash.value = invoice.paymentHash
-      paymentRequest.value = bolt11
+        // Otherwise the backend returns either a Lightning invoice or a fiat
+        // checkout URL (post-events-v1.4.0). This composable only knows how
+        // to drive the Lightning path; fiat would need a separate
+        // redirect-to-provider flow that lives in PurchaseTicketDialog (it
+        // has the user-visible payment-method selector). Reject the fiat
+        // response here so callers get a clear error instead of a silent
+        // broken QR.
+        if (invoice.isFiat || !invoice.paymentRequest) {
+          throw new Error(
+            "This event uses fiat checkout. Use the purchase dialog " +
+              "to follow the provider link.",
+          );
+        }
+        const bolt11: string = invoice.paymentRequest;
+        paymentHash.value = invoice.paymentHash;
+        paymentRequest.value = bolt11;
 
-      // Generate QR code for payment
-      await generateQRCode(bolt11)
+        // Generate QR code for payment
+        await generateQRCode(bolt11);
 
-      // Restaurant-style: don't auto-pay. Surface the QR + amount and
-      // let the buyer pick "Pay with my LNbits wallet" vs "Open in
-      // external wallet" on the same screen. The composable just
-      // starts polling so when payment lands (from any path) the UI
-      // advances to the ticket-QR success state.
-      await startPaymentStatusCheck(eventId, invoice.paymentHash)
+        // Restaurant-style: don't auto-pay. Surface the QR + amount and
+        // let the buyer pick "Pay with my LNbits wallet" vs "Open in
+        // external wallet" on the same screen. The composable just
+        // starts polling so when payment lands (from any path) the UI
+        // advances to the ticket-QR success state.
+        await startPaymentStatusCheck(eventId, invoice.paymentHash);
 
-      return invoice
-    }, {
-      errorMessage: 'Failed to purchase ticket'
-    })
+        return invoice;
+      },
+      {
+        errorMessage: "Failed to purchase ticket",
+      },
+    );
   }
 
   /**
@@ -227,76 +244,77 @@ export function useTicketPurchase() {
    * my LNbits wallet" button on the invoice screen.
    */
   async function payCurrentInvoiceWithWallet(): Promise<void> {
-    if (!paymentRequest.value) return
-    await payWithWallet(paymentRequest.value)
+    if (!paymentRequest.value) return;
+    await payWithWallet(paymentRequest.value);
     // Polling is already running from purchaseTicketForEvent — when
     // the payment lands, it advances to showTicketQR. No need to
     // restart it here.
   }
 
   async function startPaymentStatusCheck(eventId: string, hash: string) {
-    isPaymentPending.value = true
-    let checkInterval: number | null = null
+    isPaymentPending.value = true;
+    let checkInterval: number | null = null;
 
     const checkPayment = async () => {
       try {
-        const result = await ticketApi.checkPaymentStatus(eventId, hash)
+        const result = await ticketApi.checkPaymentStatus(eventId, hash);
 
         if (result.paid) {
-          isPaymentPending.value = false
+          isPaymentPending.value = false;
           if (checkInterval) {
-            clearInterval(checkInterval)
+            clearInterval(checkInterval);
           }
 
           // Multi-ticket purchases come back with `ticketIds` (N rows
           // sharing one invoice). Single-ticket purchases include
           // `ticketId` only.
-          const ids = result.ticketIds && result.ticketIds.length > 0
-            ? result.ticketIds
-            : result.ticketId
-              ? [result.ticketId]
-              : []
-          await finalizePurchasedTickets(ids)
+          const ids =
+            result.ticketIds && result.ticketIds.length > 0
+              ? result.ticketIds
+              : result.ticketId
+                ? [result.ticketId]
+                : [];
+          await finalizePurchasedTickets(ids);
         }
       } catch (err) {
-        console.error('Error checking payment status:', err)
+        console.error("Error checking payment status:", err);
       }
-    }
+    };
 
-    await checkPayment()
-    checkInterval = setInterval(checkPayment, 2000) as unknown as number
+    await checkPayment();
+    checkInterval = setInterval(checkPayment, 2000) as unknown as number;
   }
 
   function stopPaymentStatusCheck() {
-    isPaymentPending.value = false
+    isPaymentPending.value = false;
   }
 
   function resetPaymentState() {
-    purchaseOperation.clear()
-    paymentHash.value = null
-    paymentRequest.value = null
-    qrCode.value = null
-    isPaymentPending.value = false
-    ticketQRCode.value = null
-    ticketQRCodes.value = {}
-    purchasedTicketId.value = null
-    purchasedTicketIds.value = []
-    showTicketQR.value = false
+    purchaseOperation.clear();
+    paymentHash.value = null;
+    paymentRequest.value = null;
+    qrCode.value = null;
+    isPaymentPending.value = false;
+    ticketQRCode.value = null;
+    ticketQRCodes.value = {};
+    purchasedTicketId.value = null;
+    purchasedTicketIds.value = [];
+    showTicketQR.value = false;
   }
 
   function handleOpenLightningWallet() {
     if (paymentRequest.value) {
-      paymentService.openExternalWallet(paymentRequest.value)
+      paymentService.openExternalWallet(paymentRequest.value);
     }
   }
 
   function cleanup() {
-    stopPaymentStatusCheck()
+    stopPaymentStatusCheck();
   }
 
   onUnmounted(() => {
-    cleanup()
-  })
+    cleanup();
+  });
 
   return {
     // State
@@ -329,6 +347,6 @@ export function useTicketPurchase() {
     // Exposed so the dialog's fiat branch can land a 100 %-off purchase
     // (backend returns `paid: true`, no checkout URL) on the same
     // success screen as the Lightning / free paths.
-    finalizePurchasedTickets
-  }
+    finalizePurchasedTickets,
+  };
 }
diff --git a/src/modules/events/services/TicketApiService.spec.ts b/src/modules/events/services/TicketApiService.spec.ts
index 3559f03..876e5d6 100644
--- a/src/modules/events/services/TicketApiService.spec.ts
+++ b/src/modules/events/services/TicketApiService.spec.ts
@@ -1,146 +1,300 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { TicketApiService } from './TicketApiService'
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { TicketApiService } from "./TicketApiService";
 
-const BASE = 'https://lnbits.test'
+const BASE = "https://lnbits.test";
 
 function okJson(body: unknown) {
-  return { ok: true, json: async () => body } as Response
+  return { ok: true, json: async () => body } as Response;
 }
 
-describe('TicketApiService.requestTicket', () => {
-  const fetchMock = vi.fn()
-  let api: TicketApiService
+describe("TicketApiService.requestTicket", () => {
+  const fetchMock = vi.fn();
+  let api: TicketApiService;
 
   beforeEach(() => {
-    fetchMock.mockReset()
-    vi.stubGlobal('fetch', fetchMock)
-    api = new TicketApiService({ baseUrl: BASE, apiKey: 'inst-key' })
-  })
-  afterEach(() => vi.unstubAllGlobals())
+    fetchMock.mockReset();
+    vi.stubGlobal("fetch", fetchMock);
+    api = new TicketApiService({ baseUrl: BASE, apiKey: "inst-key" });
+  });
+  afterEach(() => vi.unstubAllGlobals());
 
   function lastCall() {
-    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
-    return { url, init, body: JSON.parse(init.body as string), headers: init.headers as Record<string, string> }
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    return {
+      url,
+      init,
+      body: JSON.parse(init.body as string),
+      headers: init.headers as Record<string, string>,
+    };
   }
 
-  it('sends name + email and no user_id / Authorization for guests', async () => {
-    fetchMock.mockResolvedValue(okJson({ payment_hash: 'h', fiat_payment_request: 'https://checkout', is_fiat: true, ticket_ids: ['a', 'b'] }))
-    const res = await api.requestTicket('evt', {
-      name: 'Guest', email: 'g@example.com', frontendUrl: 'https://demo.aiolabs.dev/events',
-      paymentMethod: 'fiat', quantity: 2,
-    })
-    const { url, body, headers } = lastCall()
-    expect(url).toBe(`${BASE}/events/api/v1/tickets/evt`)
+  it("sends name + email and no user_id / Authorization for guests", async () => {
+    fetchMock.mockResolvedValue(
+      okJson({
+        payment_hash: "h",
+        fiat_payment_request: "https://checkout",
+        is_fiat: true,
+        ticket_ids: ["a", "b"],
+      }),
+    );
+    const res = await api.requestTicket("evt", {
+      name: "Guest",
+      email: "g@example.com",
+      frontendUrl: "https://demo.aiolabs.dev/events",
+      paymentMethod: "fiat",
+      quantity: 2,
+    });
+    const { url, body, headers } = lastCall();
+    expect(url).toBe(`${BASE}/events/api/v1/tickets/evt`);
     expect(body).toEqual({
-      name: 'Guest', email: 'g@example.com', frontend_url: 'https://demo.aiolabs.dev/events',
-      payment_method: 'fiat', quantity: 2,
-    })
-    expect(body.user_id).toBeUndefined()
-    expect(headers.Authorization).toBeUndefined()
-    expect(headers['X-API-KEY']).toBe('inst-key')
-    expect(res).toMatchObject({ isFiat: true, fiatPaymentRequest: 'https://checkout', ticketIds: ['a', 'b'] })
-  })
+      name: "Guest",
+      email: "g@example.com",
+      frontend_url: "https://demo.aiolabs.dev/events",
+      payment_method: "fiat",
+      quantity: 2,
+    });
+    expect(body.user_id).toBeUndefined();
+    expect(headers.Authorization).toBeUndefined();
+    expect(headers["X-API-KEY"]).toBe("inst-key");
+    expect(res).toMatchObject({
+      isFiat: true,
+      fiatPaymentRequest: "https://checkout",
+      ticketIds: ["a", "b"],
+    });
+  });
 
-  it('sends user_id + email with a Bearer token for logged-in buyers', async () => {
-    fetchMock.mockResolvedValue(okJson({ payment_hash: 'h', payment_request: 'lnbc1', is_fiat: false }))
-    await api.requestTicket('evt', {
-      userId: 'u1', email: 'me@example.com', accessToken: 'tok', frontendUrl: 'http://localhost:5173',
-    })
-    const { body, headers } = lastCall()
-    expect(body).toEqual({ user_id: 'u1', email: 'me@example.com', frontend_url: 'http://localhost:5173' })
-    expect(headers.Authorization).toBe('Bearer tok')
-  })
+  it("sends user_id + email with a Bearer token for logged-in buyers", async () => {
+    fetchMock.mockResolvedValue(
+      okJson({ payment_hash: "h", payment_request: "lnbc1", is_fiat: false }),
+    );
+    await api.requestTicket("evt", {
+      userId: "u1",
+      email: "me@example.com",
+      accessToken: "tok",
+      frontendUrl: "http://localhost:5173",
+    });
+    const { body, headers } = lastCall();
+    expect(body).toEqual({
+      user_id: "u1",
+      email: "me@example.com",
+      frontend_url: "http://localhost:5173",
+    });
+    expect(headers.Authorization).toBe("Bearer tok");
+  });
 
-  it('surfaces the backend detail string as the error message', async () => {
-    fetchMock.mockResolvedValue({ ok: false, json: async () => ({ detail: 'Payment method not enabled for this event.' }) } as Response)
-    await expect(api.requestTicket('evt', { name: 'G', email: 'g@x.io', paymentMethod: 'fiat' }))
-      .rejects.toThrow('Payment method not enabled for this event.')
-  })
-})
+  it("surfaces the backend detail string as the error message", async () => {
+    fetchMock.mockResolvedValue({
+      ok: false,
+      json: async () => ({
+        detail: "Payment method not enabled for this event.",
+      }),
+    } as Response);
+    await expect(
+      api.requestTicket("evt", {
+        name: "G",
+        email: "g@x.io",
+        paymentMethod: "fiat",
+      }),
+    ).rejects.toThrow("Payment method not enabled for this event.");
+  });
+});
 
-describe('TicketApiService.getTicket / resendTicketEmail', () => {
-  const fetchMock = vi.fn()
-  let api: TicketApiService
+describe("TicketApiService.getTicket / resendTicketEmail", () => {
+  const fetchMock = vi.fn();
+  let api: TicketApiService;
 
   beforeEach(() => {
-    fetchMock.mockReset()
-    vi.stubGlobal('fetch', fetchMock)
-    api = new TicketApiService({ baseUrl: BASE, apiKey: 'k' })
-  })
-  afterEach(() => vi.unstubAllGlobals())
+    fetchMock.mockReset();
+    vi.stubGlobal("fetch", fetchMock);
+    api = new TicketApiService({ baseUrl: BASE, apiKey: "k" });
+  });
+  afterEach(() => vi.unstubAllGlobals());
 
-  it('maps the anonymous PublicTicket shape', async () => {
-    fetchMock.mockResolvedValue(okJson({ event: 'evt', name: 'G', registered: false, paid: true, time: 't', reg_timestamp: 'r' }))
-    const t = await api.getTicket('tid')
-    expect(fetchMock.mock.calls[0][0]).toBe(`${BASE}/events/api/v1/tickets/tid`)
-    expect(t).toEqual({ eventId: 'evt', name: 'G', registered: false, paid: true, time: 't', regTimestamp: 'r' })
-  })
+  it("maps the anonymous PublicTicket shape", async () => {
+    fetchMock.mockResolvedValue(
+      okJson({
+        event: "evt",
+        name: "G",
+        registered: false,
+        paid: true,
+        time: "t",
+        reg_timestamp: "r",
+      }),
+    );
+    const t = await api.getTicket("tid");
+    expect(fetchMock.mock.calls[0][0]).toBe(
+      `${BASE}/events/api/v1/tickets/tid`,
+    );
+    expect(t).toEqual({
+      eventId: "evt",
+      name: "G",
+      registered: false,
+      paid: true,
+      time: "t",
+      regTimestamp: "r",
+    });
+  });
 
-  it('maps the structured resend result and tolerates the legacy bare-ticket shape', async () => {
-    const ticket = { id: 'tid', wallet: 'w', event: 'evt', name: 'G', email: 'g@x.io', user_id: null, registered: false, paid: true, time: 't', reg_timestamp: 'r', extra: {} }
-    fetchMock.mockResolvedValueOnce(okJson({ ticket, email: { attempted: true, sent: false, error: 'smtp down' }, nostr: { attempted: false, sent: false, error: null } }))
-    const r = await api.resendTicketEmail('tid', 'admin')
-    expect(r.ticket.id).toBe('tid')
-    expect(r.email).toEqual({ attempted: true, sent: false, error: 'smtp down' })
-    expect(r.nostr.attempted).toBe(false)
+  it("maps the structured resend result and tolerates the legacy bare-ticket shape", async () => {
+    const ticket = {
+      id: "tid",
+      wallet: "w",
+      event: "evt",
+      name: "G",
+      email: "g@x.io",
+      user_id: null,
+      registered: false,
+      paid: true,
+      time: "t",
+      reg_timestamp: "r",
+      extra: {},
+    };
+    fetchMock.mockResolvedValueOnce(
+      okJson({
+        ticket,
+        email: { attempted: true, sent: false, error: "smtp down" },
+        nostr: { attempted: false, sent: false, error: null },
+      }),
+    );
+    const r = await api.resendTicketEmail("tid", "admin");
+    expect(r.ticket.id).toBe("tid");
+    expect(r.email).toEqual({
+      attempted: true,
+      sent: false,
+      error: "smtp down",
+    });
+    expect(r.nostr.attempted).toBe(false);
 
-    fetchMock.mockResolvedValueOnce(okJson(ticket))
-    const legacy = await api.resendTicketEmail('tid', 'admin')
-    expect(legacy.ticket.id).toBe('tid')
-    expect(legacy.email).toEqual({ attempted: false, sent: false, error: null })
-  })
-})
+    fetchMock.mockResolvedValueOnce(okJson(ticket));
+    const legacy = await api.resendTicketEmail("tid", "admin");
+    expect(legacy.ticket.id).toBe("tid");
+    expect(legacy.email).toEqual({
+      attempted: false,
+      sent: false,
+      error: null,
+    });
+  });
+});
 
-describe('TicketApiService promo codes', () => {
-  const fetchMock = vi.fn()
-  let api: TicketApiService
+describe("TicketApiService promo codes", () => {
+  const fetchMock = vi.fn();
+  let api: TicketApiService;
 
   beforeEach(() => {
-    fetchMock.mockReset()
-    vi.stubGlobal('fetch', fetchMock)
-    api = new TicketApiService({ baseUrl: BASE, apiKey: 'inst-key' })
-  })
-  afterEach(() => vi.unstubAllGlobals())
+    fetchMock.mockReset();
+    vi.stubGlobal("fetch", fetchMock);
+    api = new TicketApiService({ baseUrl: BASE, apiKey: "inst-key" });
+  });
+  afterEach(() => vi.unstubAllGlobals());
 
   function lastCall() {
-    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
-    return { url, init, body: JSON.parse(init.body as string), headers: init.headers as Record<string, string> }
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    return {
+      url,
+      init,
+      body: JSON.parse(init.body as string),
+      headers: init.headers as Record<string, string>,
+    };
   }
 
-  it('validatePromoCode posts the v2 shape with an upper-cased code', async () => {
+  it("validatePromoCode posts the v2 shape with an upper-cased code", async () => {
     const totals = {
-      subtotal: 2000, discount: 1000, total: 1000, currency: 'sat',
-      discounts_applied: [{ code: 'HALF', discount_percent: 50, discount_fixed: null, amount_saved: 1000 }],
-    }
-    fetchMock.mockResolvedValue(okJson(totals))
-    const res = await api.validatePromoCode('evt', ' half ', 2)
-    const { url, init, body } = lastCall()
-    expect(url).toBe(`${BASE}/events/api/v1/promo/validate/evt`)
-    expect(init.method).toBe('POST')
-    expect(body).toEqual({ codes: ['HALF'], quantity: 2 })
-    expect(res).toEqual(totals)
-  })
+      subtotal: 2000,
+      discount: 1000,
+      total: 1000,
+      currency: "sat",
+      discounts_applied: [
+        {
+          code: "HALF",
+          discount_percent: 50,
+          discount_fixed: null,
+          amount_saved: 1000,
+        },
+      ],
+    };
+    fetchMock.mockResolvedValue(okJson(totals));
+    const res = await api.validatePromoCode("evt", " half ", 2);
+    const { url, init, body } = lastCall();
+    expect(url).toBe(`${BASE}/events/api/v1/promo/validate/evt`);
+    expect(init.method).toBe("POST");
+    expect(body).toEqual({ codes: ["HALF"], quantity: 2 });
+    expect(res).toEqual(totals);
+  });
 
-  it('carries the HTTP status on errors so a missing route (older extension) is recognisable', async () => {
-    fetchMock.mockResolvedValue({ ok: false, status: 404, json: async () => ({ detail: 'Not Found' }) } as Response)
-    await expect(api.validatePromoCode('evt', 'HALF')).rejects.toMatchObject({ message: 'Not Found', status: 404 })
-  })
+  it("carries the HTTP status on errors so a missing route (older extension) is recognisable", async () => {
+    fetchMock.mockResolvedValue({
+      ok: false,
+      status: 404,
+      json: async () => ({ detail: "Not Found" }),
+    } as Response);
+    await expect(api.validatePromoCode("evt", "HALF")).rejects.toMatchObject({
+      message: "Not Found",
+      status: 404,
+    });
+  });
 
-  it('requestTicket forwards promo_code verbatim', async () => {
-    fetchMock.mockResolvedValue(okJson({ payment_hash: 'h', payment_request: 'lnbc1', is_fiat: false }))
-    await api.requestTicket('evt', { userId: 'u1', promoCode: 'HALF', quantity: 2 })
-    expect(lastCall().body).toEqual({ user_id: 'u1', promo_code: 'HALF', quantity: 2 })
-  })
+  it("requestTicket forwards promo_code verbatim", async () => {
+    fetchMock.mockResolvedValue(
+      okJson({ payment_hash: "h", payment_request: "lnbc1", is_fiat: false }),
+    );
+    await api.requestTicket("evt", {
+      userId: "u1",
+      promoCode: "HALF",
+      quantity: 2,
+    });
+    expect(lastCall().body).toEqual({
+      user_id: "u1",
+      promo_code: "HALF",
+      quantity: 2,
+    });
+  });
 
-  it('createEvent sends extra.promo_codes verbatim', async () => {
-    fetchMock.mockResolvedValue(okJson({ id: 'evt' }))
-    const promo_codes = [{ code: 'HALF', discount_percent: 50, active: true, max_uses: 2 }]
+  it("requestTicket names the chosen ticket wave", async () => {
+    // Without it the backend refuses ("Please select a ticket wave")
+    // whenever more than one wave is open.
+    fetchMock.mockResolvedValue(
+      okJson({ payment_hash: "h", payment_request: "lnbc1", is_fiat: false }),
+    );
+    await api.requestTicket("evt", { userId: "u1", ticketWaveId: "regular" });
+    expect(lastCall().body).toEqual({
+      user_id: "u1",
+      ticket_wave_id: "regular",
+    });
+  });
+
+  it("requestTicket omits the wave when none was chosen", async () => {
+    // A single open wave is implied server-side; sending an empty value
+    // would be rejected as naming a wave that does not exist.
+    fetchMock.mockResolvedValue(
+      okJson({ payment_hash: "h", payment_request: "lnbc1", is_fiat: false }),
+    );
+    await api.requestTicket("evt", { userId: "u1" });
+    expect(lastCall().body).not.toHaveProperty("ticket_wave_id");
+  });
+
+  it("validatePromoCode prices against the same wave the purchase will", async () => {
+    fetchMock.mockResolvedValue(
+      okJson({ subtotal: 50, discount: 0, total: 50, currency: "sat" }),
+    );
+    await api.validatePromoCode("evt", "HALF", 2, "regular");
+    expect(lastCall().body).toEqual({
+      codes: ["HALF"],
+      quantity: 2,
+      ticket_wave_id: "regular",
+    });
+  });
+
+  it("createEvent sends extra.promo_codes verbatim", async () => {
+    fetchMock.mockResolvedValue(okJson({ id: "evt" }));
+    const promo_codes = [
+      { code: "HALF", discount_percent: 50, active: true, max_uses: 2 },
+    ];
     await api.createEvent(
-      { name: 'E', event_start_date: '2030-01-01', extra: { promo_codes } },
-      'inkey',
-    )
-    const { body, headers } = lastCall()
-    expect(body.extra.promo_codes).toEqual(promo_codes)
-    expect(headers['X-API-KEY']).toBe('inkey')
-  })
-})
+      { name: "E", event_start_date: "2030-01-01", extra: { promo_codes } },
+      "inkey",
+    );
+    const { body, headers } = lastCall();
+    expect(body.extra.promo_codes).toEqual(promo_codes);
+    expect(headers["X-API-KEY"]).toBe("inkey");
+  });
+});
diff --git a/src/modules/events/services/TicketApiService.ts b/src/modules/events/services/TicketApiService.ts
index 2f8b291..ee7af01 100644
--- a/src/modules/events/services/TicketApiService.ts
+++ b/src/modules/events/services/TicketApiService.ts
@@ -11,33 +11,36 @@ import type {
   TicketedEvent,
   CreateEventRequest,
   PromoValidateRequest,
-} from '../types/ticket'
-import { normalizePromoCode } from '../lib/promoCodes'
+} from "../types/ticket";
+import { normalizePromoCode } from "../lib/promoCodes";
 
 export interface TicketApiConfig {
-  baseUrl: string
-  apiKey: string
+  baseUrl: string;
+  apiKey: string;
 }
 
 /** Options for `TicketApiService.requestTicket`. */
 export interface RequestTicketOptions {
   /** LNbits user id — logged-in buyers. */
-  userId?: string
+  userId?: string;
   /** Guest buyer name (required together with `email` when no `userId`). */
-  name?: string
+  name?: string;
   /** Delivery email — required for guests, optional for logged-in buyers. */
-  email?: string
+  email?: string;
   /** Bearer token; forwarded only when present. */
-  accessToken?: string
+  accessToken?: string;
   /** App root for return URLs + emailed link (see `lib/frontendRoot.ts`). */
-  frontendUrl?: string
-  paymentMethod?: PaymentMethod
-  fiatProvider?: string
-  promoCode?: string
-  refundAddress?: string
-  nostrIdentifier?: string
+  frontendUrl?: string;
+  paymentMethod?: PaymentMethod;
+  fiatProvider?: string;
+  promoCode?: string;
+  refundAddress?: string;
+  nostrIdentifier?: string;
   /** Number of tickets to buy on this invoice. Backend caps at 10. */
-  quantity?: number
+  quantity?: number;
+  /** Which pricing tier to buy from. Required when several waves are
+   *  open — the backend refuses to guess. */
+  ticketWaveId?: string;
 }
 
 /**
@@ -56,11 +59,10 @@ export class TicketApiService {
    * Used to correlate Nostr events with ticketed events.
    */
   async fetchTicketedEvents(): Promise<any[]> {
-    const response = await this.request(
-      '/events/api/v1/events/public',
-      { method: 'GET' }
-    )
-    return response
+    const response = await this.request("/events/api/v1/events/public", {
+      method: "GET",
+    });
+    return response;
   }
 
   /**
@@ -71,10 +73,10 @@ export class TicketApiService {
    * own event the moment it drops to `proposed`.
    */
   async fetchMyEvents(invoiceKey: string): Promise<any[]> {
-    return this.request('/events/api/v1/events?all_wallets=true', {
-      method: 'GET',
-      headers: { 'X-API-KEY': invoiceKey },
-    })
+    return this.request("/events/api/v1/events?all_wallets=true", {
+      method: "GET",
+      headers: { "X-API-KEY": invoiceKey },
+    });
   }
 
   /**
@@ -99,29 +101,32 @@ export class TicketApiService {
     eventId: string,
     options: RequestTicketOptions = {},
   ): Promise<TicketPurchaseInvoice> {
-    const body: CreateTicketRequest = {}
-    if (options.userId) body.user_id = options.userId
-    if (options.name) body.name = options.name
-    if (options.email) body.email = options.email
-    if (options.frontendUrl) body.frontend_url = options.frontendUrl
-    if (options.paymentMethod) body.payment_method = options.paymentMethod
-    if (options.fiatProvider) body.fiat_provider = options.fiatProvider
-    if (options.promoCode) body.promo_code = options.promoCode
-    if (options.refundAddress) body.refund_address = options.refundAddress
-    if (options.nostrIdentifier) body.nostr_identifier = options.nostrIdentifier
-    if (options.quantity && options.quantity > 1) body.quantity = options.quantity
+    const body: CreateTicketRequest = {};
+    if (options.userId) body.user_id = options.userId;
+    if (options.name) body.name = options.name;
+    if (options.email) body.email = options.email;
+    if (options.frontendUrl) body.frontend_url = options.frontendUrl;
+    if (options.paymentMethod) body.payment_method = options.paymentMethod;
+    if (options.fiatProvider) body.fiat_provider = options.fiatProvider;
+    if (options.promoCode) body.promo_code = options.promoCode;
+    if (options.refundAddress) body.refund_address = options.refundAddress;
+    if (options.nostrIdentifier)
+      body.nostr_identifier = options.nostrIdentifier;
+    if (options.quantity && options.quantity > 1)
+      body.quantity = options.quantity;
+    if (options.ticketWaveId) body.ticket_wave_id = options.ticketWaveId;
 
-    const headers: Record<string, string> = { 'Content-Type': 'application/json' }
-    if (options.accessToken) headers['Authorization'] = `Bearer ${options.accessToken}`
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+    };
+    if (options.accessToken)
+      headers["Authorization"] = `Bearer ${options.accessToken}`;
 
-    const data = await this.request(
-      `/events/api/v1/tickets/${eventId}`,
-      {
-        method: 'POST',
-        headers,
-        body: JSON.stringify(body),
-      }
-    )
+    const data = await this.request(`/events/api/v1/tickets/${eventId}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+    });
 
     return {
       paymentHash: data.payment_hash,
@@ -133,7 +138,7 @@ export class TicketApiService {
       // and no invoice to settle.
       paid: Boolean(data.paid),
       ticketIds: Array.isArray(data.ticket_ids) ? data.ticket_ids : undefined,
-    }
+    };
   }
 
   /**
@@ -142,7 +147,9 @@ export class TicketApiService {
    * the public ticket page the emailed link opens.
    */
   async getTicket(ticketId: string): Promise<PublicTicket> {
-    const t = await this.request(`/events/api/v1/tickets/${ticketId}`, { method: 'GET' })
+    const t = await this.request(`/events/api/v1/tickets/${ticketId}`, {
+      method: "GET",
+    });
     return {
       eventId: t.event,
       name: t.name ?? null,
@@ -150,7 +157,7 @@ export class TicketApiService {
       paid: Boolean(t.paid),
       time: t.time,
       regTimestamp: t.reg_timestamp,
-    }
+    };
   }
 
   /**
@@ -160,7 +167,7 @@ export class TicketApiService {
    * failure here as non-fatal.
    */
   async getPublicEvent(eventId: string): Promise<TicketedEvent> {
-    return this.request(`/events/api/v1/events/${eventId}`, { method: 'GET' })
+    return this.request(`/events/api/v1/events/${eventId}`, { method: "GET" });
   }
 
   /**
@@ -168,18 +175,18 @@ export class TicketApiService {
    */
   async checkPaymentStatus(
     eventId: string,
-    paymentHash: string
+    paymentHash: string,
   ): Promise<TicketPaymentStatus> {
     const data = await this.request(
       `/events/api/v1/tickets/${eventId}/${paymentHash}`,
-      { method: 'POST' }
-    )
+      { method: "POST" },
+    );
 
     return {
       paid: data.paid === true,
       ticketId: data.ticket_id,
       ticketIds: Array.isArray(data.ticket_ids) ? data.ticket_ids : undefined,
-    }
+    };
   }
 
   /**
@@ -187,19 +194,16 @@ export class TicketApiService {
    */
   async fetchUserTickets(
     userId: string,
-    accessToken: string
+    accessToken: string,
   ): Promise<EventTicket[]> {
-    const data = await this.request(
-      `/events/api/v1/tickets/user/${userId}`,
-      {
-        method: 'GET',
-        headers: {
-          'Authorization': `Bearer ${accessToken}`,
-        },
-      }
-    )
+    const data = await this.request(`/events/api/v1/tickets/user/${userId}`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
 
-    return (data as any[]).map(t => ({
+    return (data as any[]).map((t) => ({
       id: t.id,
       wallet: t.wallet,
       eventId: t.event,
@@ -211,7 +215,7 @@ export class TicketApiService {
       time: t.time,
       regTimestamp: t.reg_timestamp,
       extra: t.extra as EventTicketExtra | undefined,
-    }))
+    }));
   }
 
   /**
@@ -220,10 +224,10 @@ export class TicketApiService {
   async validateTicket(ticketId: string): Promise<EventTicket[]> {
     const data = await this.request(
       `/events/api/v1/register/ticket/${ticketId}`,
-      { method: 'GET' }
-    )
+      { method: "GET" },
+    );
 
-    return (data as any[]).map(t => ({
+    return (data as any[]).map((t) => ({
       id: t.id,
       wallet: t.wallet,
       eventId: t.event,
@@ -235,22 +239,25 @@ export class TicketApiService {
       time: t.time,
       regTimestamp: t.reg_timestamp,
       extra: t.extra as EventTicketExtra | undefined,
-    }))
+    }));
   }
 
   /**
    * Create a new event. Uses invoice key (any user).
    * Backend determines approval status based on user role and settings.
    */
-  async createEvent(eventData: CreateEventRequest, invoiceKey: string): Promise<TicketedEvent> {
-    return this.request('/events/api/v1/events', {
-      method: 'POST',
+  async createEvent(
+    eventData: CreateEventRequest,
+    invoiceKey: string,
+  ): Promise<TicketedEvent> {
+    return this.request("/events/api/v1/events", {
+      method: "POST",
       headers: {
-        'Content-Type': 'application/json',
-        'X-API-KEY': invoiceKey,
+        "Content-Type": "application/json",
+        "X-API-KEY": invoiceKey,
       },
       body: JSON.stringify(eventData),
-    })
+    });
   }
 
   /**
@@ -265,13 +272,13 @@ export class TicketApiService {
     adminKey: string,
   ): Promise<TicketedEvent> {
     return this.request(`/events/api/v1/events/${eventId}`, {
-      method: 'PUT',
+      method: "PUT",
       headers: {
-        'Content-Type': 'application/json',
-        'X-API-KEY': adminKey,
+        "Content-Type": "application/json",
+        "X-API-KEY": adminKey,
       },
       body: JSON.stringify(eventData),
-    })
+    });
   }
 
   /**
@@ -289,16 +296,16 @@ export class TicketApiService {
     const r = await this.request(
       `/events/api/v1/tickets/${ticketId}/resend-email`,
       {
-        method: 'POST',
-        headers: { 'X-API-KEY': adminKey },
-      }
-    )
-    const t = r.ticket ?? r
+        method: "POST",
+        headers: { "X-API-KEY": adminKey },
+      },
+    );
+    const t = r.ticket ?? r;
     const delivery = (d: any) => ({
       attempted: Boolean(d?.attempted),
       sent: Boolean(d?.sent),
       error: d?.error ?? null,
-    })
+    });
     return {
       ticket: {
         id: t.id,
@@ -315,7 +322,7 @@ export class TicketApiService {
       },
       email: delivery(r.email),
       nostr: delivery(r.nostr),
-    }
+    };
   }
 
   /**
@@ -329,23 +336,23 @@ export class TicketApiService {
     eventId: string,
     adminKey: string,
   ): Promise<{
-    event_id: string
-    sold: number
-    registered: number
-    remaining: number
+    event_id: string;
+    sold: number;
+    registered: number;
+    remaining: number;
     tickets: Array<{
-      id: string
-      name?: string | null
-      registered: boolean
-      registered_at: string | null
+      id: string;
+      name?: string | null;
+      registered: boolean;
+      registered_at: string | null;
       /** Promo code the buyer redeemed (events ext >= v1.6.1-aio.12). */
-      applied_promo_code?: string | null
-    }>
+      applied_promo_code?: string | null;
+    }>;
   }> {
     return this.request(`/events/api/v1/tickets/event/${eventId}/stats`, {
-      method: 'GET',
-      headers: { 'X-API-KEY': adminKey },
-    })
+      method: "GET",
+      headers: { "X-API-KEY": adminKey },
+    });
   }
 
   /**
@@ -355,13 +362,24 @@ export class TicketApiService {
    * means "not valid". Older extensions 404 — the thrown error carries
    * `status` so callers can fall back to "applied at checkout".
    */
-  async validatePromoCode(eventId: string, code: string, quantity = 1): Promise<BasketTotals> {
-    const body: PromoValidateRequest = { codes: [normalizePromoCode(code)], quantity }
+  async validatePromoCode(
+    eventId: string,
+    code: string,
+    quantity = 1,
+    ticketWaveId?: string,
+  ): Promise<BasketTotals> {
+    // The preview must name the same wave the purchase will, or the quote
+    // and the charge are priced against different tiers.
+    const body: PromoValidateRequest = {
+      codes: [normalizePromoCode(code)],
+      quantity,
+    };
+    if (ticketWaveId) body.ticket_wave_id = ticketWaveId;
     return this.request(`/events/api/v1/promo/validate/${eventId}`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
       body: JSON.stringify(body),
-    })
+    });
   }
 
   /**
@@ -370,11 +388,17 @@ export class TicketApiService {
    * unpaid / already-registered / not-owned cases with HTTP errors
    * whose `detail` becomes the thrown Error message.
    */
-  async registerTicket(ticketId: string, adminKey: string): Promise<EventTicket> {
-    const t = await this.request(`/events/api/v1/tickets/register/${ticketId}`, {
-      method: 'PUT',
-      headers: { 'X-API-KEY': adminKey },
-    })
+  async registerTicket(
+    ticketId: string,
+    adminKey: string,
+  ): Promise<EventTicket> {
+    const t = await this.request(
+      `/events/api/v1/tickets/register/${ticketId}`,
+      {
+        method: "PUT",
+        headers: { "X-API-KEY": adminKey },
+      },
+    );
     return {
       id: t.id,
       wallet: t.wallet,
@@ -387,7 +411,7 @@ export class TicketApiService {
       time: t.time,
       regTimestamp: t.reg_timestamp,
       extra: t.extra as EventTicketExtra | undefined,
-    }
+    };
   }
 
   /**
@@ -397,13 +421,13 @@ export class TicketApiService {
    */
   async isAdmin(adminKey: string): Promise<boolean> {
     try {
-      await this.request('/events/api/v1/events/all', {
-        method: 'GET',
-        headers: { 'X-API-KEY': adminKey },
-      })
-      return true
+      await this.request("/events/api/v1/events/all", {
+        method: "GET",
+        headers: { "X-API-KEY": adminKey },
+      });
+      return true;
     } catch {
-      return false
+      return false;
     }
   }
 
@@ -415,13 +439,16 @@ export class TicketApiService {
    */
   async getAutoApprove(invoiceKey: string): Promise<boolean> {
     try {
-      const settings = await this.request('/events/api/v1/events/settings/public', {
-        method: 'GET',
-        headers: { 'X-API-KEY': invoiceKey },
-      })
-      return Boolean(settings?.auto_approve)
+      const settings = await this.request(
+        "/events/api/v1/events/settings/public",
+        {
+          method: "GET",
+          headers: { "X-API-KEY": invoiceKey },
+        },
+      );
+      return Boolean(settings?.auto_approve);
     } catch {
-      return false
+      return false;
     }
   }
 
@@ -430,13 +457,15 @@ export class TicketApiService {
    */
   async getCurrencies(): Promise<string[]> {
     try {
-      const currencies = await this.request('/api/v1/currencies', { method: 'GET' })
+      const currencies = await this.request("/api/v1/currencies", {
+        method: "GET",
+      });
       if (Array.isArray(currencies)) {
-        return ['sats', ...currencies.filter((c: string) => c !== 'sats')]
+        return ["sats", ...currencies.filter((c: string) => c !== "sats")];
       }
-      return ['sats']
+      return ["sats"];
     } catch {
-      return ['sats']
+      return ["sats"];
     }
   }
 
@@ -445,28 +474,31 @@ export class TicketApiService {
    */
   private async request(path: string, init: RequestInit = {}): Promise<any> {
     const headers: Record<string, string> = {
-      'accept': 'application/json',
-      'X-API-KEY': this.config.apiKey,
-      ...(init.headers as Record<string, string> ?? {}),
-    }
+      accept: "application/json",
+      "X-API-KEY": this.config.apiKey,
+      ...((init.headers as Record<string, string>) ?? {}),
+    };
 
     const response = await fetch(`${this.config.baseUrl}${path}`, {
       ...init,
       headers,
-    })
+    });
 
     if (!response.ok) {
-      const error = await response.json().catch(() => ({ detail: `Request failed: ${path}` }))
-      const errorMessage = typeof error.detail === 'string'
-        ? error.detail
-        : Array.isArray(error.detail)
-          ? error.detail[0]?.msg ?? 'Request failed'
-          : 'Request failed'
+      const error = await response
+        .json()
+        .catch(() => ({ detail: `Request failed: ${path}` }));
+      const errorMessage =
+        typeof error.detail === "string"
+          ? error.detail
+          : Array.isArray(error.detail)
+            ? (error.detail[0]?.msg ?? "Request failed")
+            : "Request failed";
       // Carry the HTTP status so callers can tell "route missing on an
       // older extension" (404) apart from "bad input" (400).
-      throw Object.assign(new Error(errorMessage), { status: response.status })
+      throw Object.assign(new Error(errorMessage), { status: response.status });
     }
 
-    return response.json()
+    return response.json();
   }
 }
diff --git a/src/modules/events/views/EventDetailPage.vue b/src/modules/events/views/EventDetailPage.vue
index 96280d7..5beec6d 100644
--- a/src/modules/events/views/EventDetailPage.vue
+++ b/src/modules/events/views/EventDetailPage.vue
@@ -1,117 +1,157 @@
 <script setup lang="ts">
-import { computed, onMounted, ref, watch } from 'vue'
-import { useElementVisibility } from '@vueuse/core'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { format } from 'date-fns'
-import { useDateLocale } from '../composables/useDateLocale'
-import { Button } from '@/components/ui/button'
-import { Badge } from '@/components/ui/badge'
-import { Separator } from '@/components/ui/separator'
+import { computed, onMounted, ref, watch } from "vue";
+import { useElementVisibility } from "@vueuse/core";
+import { useRoute, useRouter } from "vue-router";
+import { useI18n } from "vue-i18n";
+import { format } from "date-fns";
+import { useDateLocale } from "../composables/useDateLocale";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { Separator } from "@/components/ui/separator";
 import {
-  Calendar, MapPin, ArrowLeft, Pencil, Ticket, CheckCircle2, ScanLine, History,
-} from 'lucide-vue-next'
-import { useEventDetail } from '../composables/useEventDetail'
-import BookmarkButton from '../components/BookmarkButton.vue'
-import OrganizerCard from '../components/OrganizerCard.vue'
-import PurchaseTicketDialog from '../components/PurchaseTicketDialog.vue'
-import CheckoutReturnDialog from '../components/CheckoutReturnDialog.vue'
-import { clearPendingCheckout, readPendingCheckout } from '../lib/pendingCheckout'
-import { useAuth } from '@/composables/useAuthService'
-import { useEventsStore } from '../stores/events'
-import { useOwnedTickets } from '../composables/useOwnedTickets'
-import { toastService } from '@/core/services/ToastService'
-import { injectService, SERVICE_TOKENS } from '@/core/di-container'
-import type { TicketApiService } from '../services/TicketApiService'
-import type { TicketedEvent } from '../types/ticket'
+  Calendar,
+  MapPin,
+  ArrowLeft,
+  Pencil,
+  Ticket,
+  CheckCircle2,
+  ScanLine,
+  History,
+} from "lucide-vue-next";
+import { useEventDetail } from "../composables/useEventDetail";
+import BookmarkButton from "../components/BookmarkButton.vue";
+import OrganizerCard from "../components/OrganizerCard.vue";
+import PurchaseTicketDialog from "../components/PurchaseTicketDialog.vue";
+import CheckoutReturnDialog from "../components/CheckoutReturnDialog.vue";
+import {
+  clearPendingCheckout,
+  readPendingCheckout,
+} from "../lib/pendingCheckout";
+import { useAuth } from "@/composables/useAuthService";
+import { useEventsStore } from "../stores/events";
+import { useOwnedTickets } from "../composables/useOwnedTickets";
+import { toastService } from "@/core/services/ToastService";
+import { injectService, SERVICE_TOKENS } from "@/core/di-container";
+import type { TicketApiService } from "../services/TicketApiService";
+import type { TicketedEvent } from "../types/ticket";
 
-const route = useRoute()
-const router = useRouter()
-const { t } = useI18n()
+const route = useRoute();
+const router = useRouter();
+const { t } = useI18n();
 
-const eventId = route.params.id as string
-const { event, isLoading, error, reload } = useEventDetail(eventId)
-const { dateLocale } = useDateLocale()
+const eventId = route.params.id as string;
+const { event, isLoading, error, reload } = useEventDetail(eventId);
+const { dateLocale } = useDateLocale();
 
 // Owner-edit affordance: the NIP-52 d-tag we use for the event id is
 // the same as the LNbits event id (set at publish time in
 // nostr_publisher.build_nip52_event). Look the user's own events up
 // once and offer an Edit button on a match.
-const { isAuthenticated, currentUser } = useAuth()
-const eventsStore = useEventsStore()
-const ownedLnbitsEvent = ref<TicketedEvent | null>(null)
+const { isAuthenticated, currentUser } = useAuth();
+const eventsStore = useEventsStore();
+const ownedLnbitsEvent = ref<TicketedEvent | null>(null);
 
 async function loadOwnedEvent() {
-  ownedLnbitsEvent.value = null
-  if (!isAuthenticated.value) return
-  const invoiceKey = currentUser.value?.wallets?.[0]?.inkey
-  if (!invoiceKey) return
+  ownedLnbitsEvent.value = null;
+  if (!isAuthenticated.value) return;
+  const invoiceKey = currentUser.value?.wallets?.[0]?.inkey;
+  if (!invoiceKey) return;
   try {
-    const ticketApi = injectService(SERVICE_TOKENS.TICKET_API) as TicketApiService
-    const mine = await ticketApi.fetchMyEvents(invoiceKey)
+    const ticketApi = injectService(
+      SERVICE_TOKENS.TICKET_API,
+    ) as TicketApiService;
+    const mine = await ticketApi.fetchMyEvents(invoiceKey);
     ownedLnbitsEvent.value =
-      (mine as TicketedEvent[]).find((e) => e.id === eventId) ?? null
+      (mine as TicketedEvent[]).find((e) => e.id === eventId) ?? null;
   } catch {
-    ownedLnbitsEvent.value = null
+    ownedLnbitsEvent.value = null;
   }
 }
 
-onMounted(loadOwnedEvent)
-watch(isAuthenticated, () => loadOwnedEvent())
+// Ticket waves live on the LNbits record, not in the NIP-52 tags: the
+// published tags describe the ACTIVE wave but carry no wave id, and a
+// buyer needs one to choose a tier. Fetched anonymously and treated as
+// non-fatal — the backend answers 410 for sold-out or closed events,
+// where there is nothing to pick anyway.
+const publicLnbitsEvent = ref<TicketedEvent | null>(null);
+
+async function loadPublicEvent() {
+  try {
+    const ticketApi = injectService(
+      SERVICE_TOKENS.TICKET_API,
+    ) as TicketApiService;
+    publicLnbitsEvent.value = await ticketApi.getPublicEvent(eventId);
+  } catch {
+    publicLnbitsEvent.value = null;
+  }
+}
+
+/** Whichever LNbits record we have; the organizer's carries the same waves. */
+const lnbitsEvent = computed<TicketedEvent | null>(
+  () => ownedLnbitsEvent.value ?? publicLnbitsEvent.value,
+);
+
+onMounted(loadOwnedEvent);
+onMounted(loadPublicEvent);
+watch(isAuthenticated, () => loadOwnedEvent());
 
 function openEditDialog() {
-  if (!ownedLnbitsEvent.value) return
-  eventsStore.editingEvent = ownedLnbitsEvent.value
-  eventsStore.showCreateDialog = true
+  if (!ownedLnbitsEvent.value) return;
+  eventsStore.editingEvent = ownedLnbitsEvent.value;
+  eventsStore.showCreateDialog = true;
 }
 
 function openScannerPage() {
-  router.push({ name: 'scan-tickets', params: { eventId } })
+  router.push({ name: "scan-tickets", params: { eventId } });
 }
 
 const dateDisplay = computed(() => {
-  if (!event.value) return ''
-  const a = event.value
-  const opts = { locale: dateLocale.value }
-  if (a.type === 'date') {
-    const start = format(a.startDate, 'EEEE, MMMM d, yyyy', opts)
+  if (!event.value) return "";
+  const a = event.value;
+  const opts = { locale: dateLocale.value };
+  if (a.type === "date") {
+    const start = format(a.startDate, "EEEE, MMMM d, yyyy", opts);
     if (a.endDate) {
-      return `${start} — ${format(a.endDate, 'EEEE, MMMM d, yyyy', opts)}`
+      return `${start} — ${format(a.endDate, "EEEE, MMMM d, yyyy", opts)}`;
     }
-    return start
+    return start;
   }
   // Time-based event. If start and end share the same calendar day,
   // show end as time-only ("19:00 — 21:45"). Otherwise repeat the full
   // date on the end side so a multi-day event reads unambiguously
   // ("May 29 • 19:00 — May 30 • 21:45").
-  const FULL = 'EEEE, MMMM d, yyyy \u2022 HH:mm'
-  const start = format(a.startDate, FULL, opts)
-  if (!a.endDate) return start
+  const FULL = "EEEE, MMMM d, yyyy \u2022 HH:mm";
+  const start = format(a.startDate, FULL, opts);
+  if (!a.endDate) return start;
   const sameDay =
     a.startDate.getFullYear() === a.endDate.getFullYear() &&
     a.startDate.getMonth() === a.endDate.getMonth() &&
-    a.startDate.getDate() === a.endDate.getDate()
-  return `${start} — ${format(a.endDate, sameDay ? 'HH:mm' : FULL, opts)}`
-})
+    a.startDate.getDate() === a.endDate.getDate();
+  return `${start} — ${format(a.endDate, sameDay ? "HH:mm" : FULL, opts)}`;
+});
 
 const categoryLabel = computed(() => {
-  if (!event.value?.category) return null
-  return t(`events.categories.${event.value.category}`, event.value.category)
-})
+  if (!event.value?.category) return null;
+  return t(`events.categories.${event.value.category}`, event.value.category);
+});
 
 function goBack() {
-  router.push({ name: 'events' })
+  router.push({ name: "events" });
 }
 
 // --- Ticket purchase + owned-tickets surface ----------------------
 
-const { paidCount, refresh: refreshOwnedTickets } = useOwnedTickets()
+const { paidCount, refresh: refreshOwnedTickets } = useOwnedTickets();
 
-const ownedPaidCount = computed(() => paidCount(eventId))
+const ownedPaidCount = computed(() => paidCount(eventId));
 
 const purchaseEvent = computed(() => {
-  const a = event.value
-  if (!a || !a.ticketInfo) return null
+  const a = event.value;
+  if (!a || !a.ticketInfo) return null;
+  // Nostr tags describe the active wave but name no wave id, so the
+  // pickable tiers come from the LNbits record when we have one. The tag
+  // values stay the fallback for events with no waves at all.
+  const lnbits = lnbitsEvent.value;
   return {
     id: a.id,
     name: a.title,
@@ -120,45 +160,52 @@ const purchaseEvent = computed(() => {
     allow_fiat: a.ticketInfo.allowFiat,
     fiat_currency: a.ticketInfo.fiatCurrency,
     payment_methods: a.ticketInfo.paymentMethods,
-  }
-})
+    // Fields the dialog synthesizes an implied wave from when an event
+    // predates waves entirely.
+    closing_date: lnbits?.closing_date ?? null,
+    event_start_date: lnbits?.event_start_date,
+    event_end_date: lnbits?.event_end_date ?? null,
+    amount_tickets: lnbits?.amount_tickets ?? a.ticketInfo.available,
+    extra: lnbits?.extra ? { ticket_waves: lnbits.extra.ticket_waves } : null,
+  };
+});
 
 // available === undefined → unlimited capacity, button always shown
 // available === 0          → sold out, button hidden
 // available > 0            → button shown
 const canBuyTicket = computed(() => {
-  const info = event.value?.ticketInfo
-  if (!info) return false
-  return info.available === undefined || info.available > 0
-})
+  const info = event.value?.ticketInfo;
+  if (!info) return false;
+  return info.available === undefined || info.available > 0;
+});
 
 // Past events can't be bought into. The notice below replaces the
 // buy CTA so the flow is unambiguous — date alone is easy to miss
 // on a long detail page.
 const isPast = computed(() => {
-  const a = event.value
-  if (!a) return false
-  const end = a.endDate ?? a.startDate
-  if (!end || isNaN(end.getTime())) return false
-  return end.getTime() < Date.now()
-})
+  const a = event.value;
+  if (!a) return false;
+  const end = a.endDate ?? a.startDate;
+  if (!end || isNaN(end.getTime())) return false;
+  return end.getTime() < Date.now();
+});
 
-const showPurchaseDialog = ref(false)
+const showPurchaseDialog = ref(false);
 
 function openPurchaseDialog() {
   // Paid tickets are open to guests (name + email identity). Free
   // claims still need an account so seats can't be drained anonymously.
-  const isFreeEvent = (purchaseEvent.value?.price_per_ticket ?? 0) <= 0
+  const isFreeEvent = (purchaseEvent.value?.price_per_ticket ?? 0) <= 0;
   if (!isAuthenticated.value && isFreeEvent) {
-    toastService.info(t('events.detail.loginToBuyTickets'), {
+    toastService.info(t("events.detail.loginToBuyTickets"), {
       action: {
-        label: t('events.detail.logIn'),
-        onClick: () => router.push('/login'),
+        label: t("events.detail.logIn"),
+        onClick: () => router.push("/login"),
       },
-    })
-    return
+    });
+    return;
   }
-  showPurchaseDialog.value = true
+  showPurchaseDialog.value = true;
 }
 
 // --- Return from the fiat provider ---------------------------------
@@ -167,36 +214,37 @@ function openPurchaseDialog() {
 // or ?checkout=cancelled. The query is stripped immediately so the
 // ticket ids don't linger in history; the localStorage record written
 // before the redirect is the fallback source and carries the email.
-const showReturnDialog = ref(false)
-const returnTicketIds = ref<string[]>([])
-const returnEmail = ref<string | undefined>(undefined)
+const showReturnDialog = ref(false);
+const returnTicketIds = ref<string[]>([]);
+const returnEmail = ref<string | undefined>(undefined);
 
 function handleCheckoutReturn() {
-  const status = route.query.checkout
-  if (status !== 'success' && status !== 'cancelled') return
+  const status = route.query.checkout;
+  if (status !== "success" && status !== "cancelled") return;
 
-  const pending = readPendingCheckout()
-  const samePurchase = pending?.eventId === eventId
-  void router.replace({ query: {} })
+  const pending = readPendingCheckout();
+  const samePurchase = pending?.eventId === eventId;
+  void router.replace({ query: {} });
 
-  if (status === 'cancelled') {
-    clearPendingCheckout()
-    toastService.info(t('events.checkout.cancelled'))
-    return
+  if (status === "cancelled") {
+    clearPendingCheckout();
+    toastService.info(t("events.checkout.cancelled"));
+    return;
   }
 
-  const fromQuery = String(route.query.tickets ?? '')
-    .split(',')
+  const fromQuery = String(route.query.tickets ?? "")
+    .split(",")
     .map((s) => s.trim())
-    .filter(Boolean)
-  const ids = fromQuery.length > 0 ? fromQuery : samePurchase ? pending!.ticketIds : []
-  if (ids.length === 0) return
-  returnTicketIds.value = ids
-  returnEmail.value = samePurchase ? pending?.email : undefined
-  showReturnDialog.value = true
+    .filter(Boolean);
+  const ids =
+    fromQuery.length > 0 ? fromQuery : samePurchase ? pending!.ticketIds : [];
+  if (ids.length === 0) return;
+  returnTicketIds.value = ids;
+  returnEmail.value = samePurchase ? pending?.email : undefined;
+  showReturnDialog.value = true;
 }
 
-onMounted(handleCheckoutReturn)
+onMounted(handleCheckoutReturn);
 
 // --- Sticky buy bar --------------------------------------------------
 // The ticket block sits right under the date/location so it is above the
@@ -204,20 +252,22 @@ onMounted(handleCheckoutReturn)
 // it leaves the viewport a compact bar with the price + the same CTA
 // pins above the bottom nav so the primary action is never more than a
 // tap away. Hidden while a dialog is open (the dialog is the action).
-const ticketBlockRef = ref<HTMLElement | null>(null)
-const ticketBlockVisible = useElementVisibility(ticketBlockRef)
+const ticketBlockRef = ref<HTMLElement | null>(null);
+const ticketBlockVisible = useElementVisibility(ticketBlockRef);
 
 const priceLabel = computed(() => {
-  const info = event.value?.ticketInfo
-  if (!info) return ''
-  return info.price === 0 ? t('events.detail.free') : `${info.price} ${info.currency}`
-})
+  const info = event.value?.ticketInfo;
+  if (!info) return "";
+  return info.price === 0
+    ? t("events.detail.free")
+    : `${info.price} ${info.currency}`;
+});
 
 const buyLabel = computed(() =>
   ownedPaidCount.value > 0
-    ? t('events.detail.buyAnotherTicket', 'Buy another ticket')
-    : t('events.detail.buyTicket', 'Buy ticket'),
-)
+    ? t("events.detail.buyAnotherTicket", "Buy another ticket")
+    : t("events.detail.buyTicket", "Buy ticket"),
+);
 
 const showStickyCta = computed(
   () =>
@@ -228,22 +278,25 @@ const showStickyCta = computed(
     !ticketBlockVisible.value &&
     !showPurchaseDialog.value &&
     !showReturnDialog.value,
-)
+);
 
 // Re-fetch the user's tickets when the purchase dialog closes (the
 // buyer may have just paid). The inventory side updates automatically
 // via the relay republish from the events extension.
 watch(showPurchaseDialog, (open) => {
-  if (!open) refreshOwnedTickets()
-})
+  if (!open) refreshOwnedTickets();
+});
 
 function goToMyTickets() {
-  router.push('/my-tickets')
+  router.push("/my-tickets");
 }
 </script>
 
 <template>
-  <div class="container mx-auto py-6 px-4 max-w-3xl" :class="{ 'pb-24': showStickyCta }">
+  <div
+    class="container mx-auto py-6 px-4 max-w-3xl"
+    :class="{ 'pb-24': showStickyCta }"
+  >
     <!-- Top bar — back-link only. Edit moves into the title row as a
          prominent icon button; Scan moves into the tickets section
          where it replaces the Buy-ticket CTA for the host. -->
@@ -264,7 +317,9 @@ function goToMyTickets() {
 
     <!-- Error -->
     <div v-else-if="error" class="text-center py-16">
-      <h2 class="text-xl font-semibold text-foreground mb-2">Event not found</h2>
+      <h2 class="text-xl font-semibold text-foreground mb-2">
+        Event not found
+      </h2>
       <p class="text-muted-foreground mb-4">{{ error }}</p>
       <Button variant="outline" @click="reload">Retry</Button>
     </div>
@@ -286,11 +341,7 @@ function goToMyTickets() {
           <!-- "Yours" leads the row in the highlighted variant so the
                ownership signal stands out against the neutral
                category/tag chips that follow. -->
-          <Badge
-            v-if="event.isMine"
-            variant="secondary"
-            class="shrink-0"
-          >
+          <Badge v-if="event.isMine" variant="secondary" class="shrink-0">
             Yours
           </Badge>
           <Badge v-if="categoryLabel" variant="outline" class="shrink-0">
@@ -298,10 +349,14 @@ function goToMyTickets() {
           </Badge>
           <Badge
             v-if="event.lnbitsStatus && event.lnbitsStatus !== 'approved'"
-            :variant="event.lnbitsStatus === 'rejected' ? 'destructive' : 'secondary'"
+            :variant="
+              event.lnbitsStatus === 'rejected' ? 'destructive' : 'secondary'
+            "
             class="shrink-0 capitalize"
           >
-            {{ event.lnbitsStatus === 'rejected' ? 'Rejected' : 'Pending review' }}
+            {{
+              event.lnbitsStatus === "rejected" ? "Rejected" : "Pending review"
+            }}
           </Badge>
           <div v-for="tag in event.tags.slice(1)" :key="tag">
             <Badge variant="outline" class="text-xs">{{ tag }}</Badge>
@@ -342,7 +397,9 @@ function goToMyTickets() {
             <Calendar class="w-4 h-4 shrink-0 mt-0.5" />
             <span>
               {{ dateDisplay }}
-              <span v-if="event.timezone" class="opacity-70">({{ event.timezone }})</span>
+              <span v-if="event.timezone" class="opacity-70"
+                >({{ event.timezone }})</span
+              >
             </span>
           </div>
           <div v-if="event.location" class="flex items-start gap-1.5">
@@ -364,7 +421,7 @@ function goToMyTickets() {
         @click="openScannerPage"
       >
         <ScanLine class="w-4 h-4" />
-        {{ t('events.detail.scanTickets', 'Scan tickets') }}
+        {{ t("events.detail.scanTickets", "Scan tickets") }}
       </Button>
 
       <!-- Tickets — gated on the event carrying ticketInfo (set
@@ -384,13 +441,21 @@ function goToMyTickets() {
           v-if="ownedPaidCount > 0"
           class="bg-primary/15 border border-primary/40 rounded-lg p-4 flex items-center justify-between gap-3"
         >
-          <div class="flex items-center gap-2 text-sm font-medium text-foreground">
+          <div
+            class="flex items-center gap-2 text-sm font-medium text-foreground"
+          >
             <CheckCircle2 class="w-4 h-4 text-primary shrink-0" />
-            {{ t('events.detail.ticketsOwned', { count: ownedPaidCount }, ownedPaidCount) }}
+            {{
+              t(
+                "events.detail.ticketsOwned",
+                { count: ownedPaidCount },
+                ownedPaidCount,
+              )
+            }}
           </div>
           <Button size="sm" class="gap-1.5 shrink-0" @click="goToMyTickets">
             <Ticket class="w-4 h-4" />
-            {{ t('events.detail.viewMyTickets', 'View in My Tickets') }}
+            {{ t("events.detail.viewMyTickets", "View in My Tickets") }}
           </Button>
         </div>
 
@@ -399,7 +464,7 @@ function goToMyTickets() {
           class="flex items-center justify-center gap-1.5 text-sm text-muted-foreground bg-muted/40 rounded-lg p-3"
         >
           <History class="w-4 h-4 shrink-0" />
-          {{ t('events.detail.pastEvent', 'This event has already happened') }}
+          {{ t("events.detail.pastEvent", "This event has already happened") }}
         </div>
         <div v-else-if="canBuyTicket" class="space-y-1">
           <Button
@@ -414,10 +479,15 @@ function goToMyTickets() {
           </Button>
           <p class="text-xs text-muted-foreground text-center">
             <span v-if="event.ticketInfo.available === undefined">
-              {{ t('events.detail.unlimitedTickets', 'Unlimited tickets') }}
+              {{ t("events.detail.unlimitedTickets", "Unlimited tickets") }}
             </span>
             <span v-else>
-              {{ t('events.detail.ticketsRemainingOfTotal', { count: event.ticketInfo.available, total: event.ticketInfo.total }) }}
+              {{
+                t("events.detail.ticketsRemainingOfTotal", {
+                  count: event.ticketInfo.available,
+                  total: event.ticketInfo.total,
+                })
+              }}
             </span>
           </p>
         </div>
@@ -425,7 +495,7 @@ function goToMyTickets() {
           v-else-if="ownedPaidCount === 0"
           class="text-sm text-destructive text-center"
         >
-          {{ t('events.detail.soldOut') }}
+          {{ t("events.detail.soldOut") }}
         </p>
       </div>
 
@@ -458,50 +528,69 @@ function goToMyTickets() {
            parent's space-y margin (margins offset fixed boxes too) and
            float 24px above the nav. -->
       <Teleport to="body">
-      <Transition
-        enter-active-class="transition duration-200 ease-out"
-        enter-from-class="translate-y-4 opacity-0"
-        leave-active-class="transition duration-150 ease-in"
-        leave-to-class="translate-y-4 opacity-0"
-      >
-        <div
-          v-if="showStickyCta && event"
-          class="fixed inset-x-0 z-40 border-t border-border bg-background/95 backdrop-blur supports-[backdrop-filter]:bg-background/80"
-          style="bottom: var(--bottom-nav-height)"
-          role="region"
-          :aria-label="t('events.detail.tickets')"
+        <Transition
+          enter-active-class="transition duration-200 ease-out"
+          enter-from-class="translate-y-4 opacity-0"
+          leave-active-class="transition duration-150 ease-in"
+          leave-to-class="translate-y-4 opacity-0"
         >
-          <div class="container mx-auto max-w-3xl px-4 py-2.5 flex items-center gap-3">
-            <div class="min-w-0 flex-1">
-              <p class="text-sm font-medium text-foreground truncate">{{ event.title }}</p>
-              <p class="text-xs text-muted-foreground truncate">
-                <span v-if="ownedPaidCount > 0">
-                  {{ t('events.detail.ticketsOwned', { count: ownedPaidCount }, ownedPaidCount) }}
-                </span>
-                <span v-else-if="event.ticketInfo?.available === undefined">
-                  {{ priceLabel }} · {{ t('events.detail.unlimitedTickets', 'Unlimited tickets') }}
-                </span>
-                <span v-else>
-                  {{ priceLabel }} · {{ t('events.detail.ticketsRemainingOfTotal', { count: event.ticketInfo.available, total: event.ticketInfo.total }) }}
-                </span>
-              </p>
-            </div>
-            <Button
-              v-if="canBuyTicket"
-              class="gap-1.5 shrink-0"
-              :variant="ownedPaidCount > 0 ? 'outline' : 'default'"
-              @click="openPurchaseDialog"
+          <div
+            v-if="showStickyCta && event"
+            class="fixed inset-x-0 z-40 border-t border-border bg-background/95 backdrop-blur supports-[backdrop-filter]:bg-background/80"
+            style="bottom: var(--bottom-nav-height)"
+            role="region"
+            :aria-label="t('events.detail.tickets')"
+          >
+            <div
+              class="container mx-auto max-w-3xl px-4 py-2.5 flex items-center gap-3"
             >
-              <Ticket class="w-4 h-4" />
-              {{ buyLabel }}
-            </Button>
-            <Button v-else class="gap-1.5 shrink-0" @click="goToMyTickets">
-              <Ticket class="w-4 h-4" />
-              {{ t('events.detail.viewMyTickets', 'View in My Tickets') }}
-            </Button>
+              <div class="min-w-0 flex-1">
+                <p class="text-sm font-medium text-foreground truncate">
+                  {{ event.title }}
+                </p>
+                <p class="text-xs text-muted-foreground truncate">
+                  <span v-if="ownedPaidCount > 0">
+                    {{
+                      t(
+                        "events.detail.ticketsOwned",
+                        { count: ownedPaidCount },
+                        ownedPaidCount,
+                      )
+                    }}
+                  </span>
+                  <span v-else-if="event.ticketInfo?.available === undefined">
+                    {{ priceLabel }} ·
+                    {{
+                      t("events.detail.unlimitedTickets", "Unlimited tickets")
+                    }}
+                  </span>
+                  <span v-else>
+                    {{ priceLabel }} ·
+                    {{
+                      t("events.detail.ticketsRemainingOfTotal", {
+                        count: event.ticketInfo.available,
+                        total: event.ticketInfo.total,
+                      })
+                    }}
+                  </span>
+                </p>
+              </div>
+              <Button
+                v-if="canBuyTicket"
+                class="gap-1.5 shrink-0"
+                :variant="ownedPaidCount > 0 ? 'outline' : 'default'"
+                @click="openPurchaseDialog"
+              >
+                <Ticket class="w-4 h-4" />
+                {{ buyLabel }}
+              </Button>
+              <Button v-else class="gap-1.5 shrink-0" @click="goToMyTickets">
+                <Ticket class="w-4 h-4" />
+                {{ t("events.detail.viewMyTickets", "View in My Tickets") }}
+              </Button>
+            </div>
           </div>
-        </div>
-      </Transition>
+        </Transition>
       </Teleport>
 
       <!-- External references -->
@@ -513,8 +602,10 @@ function goToMyTickets() {
 
       <!-- Organizer -->
       <div class="bg-muted/50 rounded-lg p-4">
-        <p class="text-xs font-medium text-muted-foreground uppercase tracking-wide mb-2">
-          {{ t('events.detail.organizer') }}
+        <p
+          class="text-xs font-medium text-muted-foreground uppercase tracking-wide mb-2"
+        >
+          {{ t("events.detail.organizer") }}
         </p>
         <OrganizerCard :pubkey="event.organizer.pubkey" />
       </div>