From b5c87c60b478a23b529505a9546c6ef3b5965a9c Mon Sep 17 00:00:00 2001 From: Padreug Date: Thu, 18 Jun 2026 14:13:10 +0200 Subject: [PATCH 1/2] fix: publish NIP-52 events with monotonic created_at (#26) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit NIP-52 calendar events (31922/31923) are replaceable and republished whenever inventory changes (a ticket sells). build_nip52_event stamped created_at=int(time.time()); relays only push a replacement to OPEN subscriptions when created_at is strictly newer, so two republishes in the same wall-clock second tie and the second is silently dropped for live subscribers — clients' "tickets remaining" badge stalls until a reload. Same root cause as the webapp fix (aiolabs/webapp#122). - Add monotonic_created_at() in nostr_timestamp.py = max(now, last+1), mirroring the webapp helper + docs/nostr-patterns/replaceable-events.md. - Anchor it on the already-persisted Event.nostr_event_created_at (set after each publish in nostr_hooks.py). The kind-5 delete event is not replaceable, so it keeps plain int(time.time()). - Unit tests mirror the webapp's timestamp suite. Concurrent same-second sales reading the same stored anchor can still collide; full hardening (row-level lock) is noted as follow-up in #26. Co-Authored-By: Claude Opus 4.8 (1M context) --- nostr_publisher.py | 9 ++++++++- nostr_timestamp.py | 34 ++++++++++++++++++++++++++++++++++ tests/test_nostr_timestamp.py | 32 ++++++++++++++++++++++++++++++++ 3 files changed, 74 insertions(+), 1 deletion(-) create mode 100644 nostr_timestamp.py create mode 100644 tests/test_nostr_timestamp.py diff --git a/nostr_publisher.py b/nostr_publisher.py index 81324fc..2588fcb 100644 --- a/nostr_publisher.py +++ b/nostr_publisher.py @@ -19,6 +19,7 @@ from loguru import logger from .models import Event from .nostr.event import NostrEvent +from .nostr_timestamp import monotonic_created_at def _has_time(value: str | None) -> bool: @@ -110,9 +111,15 @@ def build_nip52_event(event: Event, pubkey: str) -> NostrEvent: if event.fiat_currency: tags.append(["tickets_fiat_currency", event.fiat_currency]) + # NIP-52 calendar events are replaceable: this d-tag is republished + # whenever inventory changes (a ticket sells). Use a strictly-monotonic + # created_at anchored on the last published value so a same-second + # republish still outranks the prior version and relays push it to open + # subscriptions — a bare int(time.time()) can tie and be silently + # dropped, stalling clients' live "tickets remaining" badge. nostr_event = NostrEvent( pubkey=pubkey, - created_at=int(time.time()), + created_at=monotonic_created_at(event.nostr_event_created_at), kind=kind, tags=tags, content=event.info or "", diff --git a/nostr_timestamp.py b/nostr_timestamp.py new file mode 100644 index 0000000..625b21c --- /dev/null +++ b/nostr_timestamp.py @@ -0,0 +1,34 @@ +"""Monotonic ``created_at`` for replaceable / addressable Nostr events. + +Relays only push a replaceable update to OPEN subscriptions when its +``created_at`` is strictly newer than the version they already hold. +``created_at`` is integer seconds, so a publisher that stamps +``int(time.time())`` can emit two versions within the same wall-clock +second (e.g. two ticket sales republishing the NIP-52 calendar event) — +the relay treats the second as not-newer and never propagates it to live +subscribers (it only surfaces on a reload / fresh REQ). + +Returning ``max(now, last_created_at + 1)`` guarantees a strictly +increasing timestamp across successive publishes of the same replaceable +event. When enough real seconds have elapsed it tracks wall-clock; only +same-second (or clock-skewed) republishes get nudged forward. + +Mirrors the webapp's ``monotonicCreatedAt`` (src/lib/nostr/timestamp.ts) +and ``docs/nostr-patterns/replaceable-events.md``. +""" + +import time + + +def monotonic_created_at(last_created_at: int | None, now: int | None = None) -> int: + """Strictly-newer ``created_at`` for the next publish of a coord. + + :param last_created_at: ``created_at`` of the previously published + version (seconds), or ``None`` if none has been published yet. + :param now: Current time in seconds — injectable for tests; defaults + to ``int(time.time())``. + """ + base = int(time.time()) if now is None else now + if last_created_at is None: + return base + return max(base, last_created_at + 1) diff --git a/tests/test_nostr_timestamp.py b/tests/test_nostr_timestamp.py new file mode 100644 index 0000000..693a997 --- /dev/null +++ b/tests/test_nostr_timestamp.py @@ -0,0 +1,32 @@ +from itertools import pairwise + +from ..nostr_timestamp import monotonic_created_at + + +def test_no_prior_uses_now(): + assert monotonic_created_at(None, now=1000) == 1000 + + +def test_same_second_bumps_past_prior(): + # now == last: a naive int(time.time()) would tie and the relay would + # drop the update; we must produce a strictly newer stamp. + assert monotonic_created_at(1000, now=1000) == 1001 + + +def test_tracks_wallclock_once_seconds_elapse(): + assert monotonic_created_at(1000, now=1005) == 1005 + + +def test_steps_past_future_dated_prior(): + # clock skew / rapid bursts left the stored value ahead of now + assert monotonic_created_at(2000, now=1000) == 2001 + + +def test_strictly_increasing_same_second_burst(): + last = None + stamps = [] + for _ in range(5): + last = monotonic_created_at(last, now=1000) # clock frozen at 1000 + stamps.append(last) + assert stamps == [1000, 1001, 1002, 1003, 1004] + assert all(b > a for a, b in pairwise(stamps)) From cfc2e38a5eda997bffca684a192ca6aa93b2603c Mon Sep 17 00:00:00 2001 From: Padreug Date: Thu, 18 Jun 2026 14:13:11 +0200 Subject: [PATCH 2/2] chore: bump config.json version to 1.6.1-aio.6 Marks the monotonic created_at fix (#26). aio semver stays ahead of the upstream 1.6.1 tag per fork versioning rules. Co-Authored-By: Claude Opus 4.8 (1M context) --- config.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config.json b/config.json index 03be67f..36da491 100644 --- a/config.json +++ b/config.json @@ -1,6 +1,6 @@ { "id": "events", - "version": "1.6.1-aio.5", + "version": "1.6.1-aio.6", "name": "Events", "repo": "https://git.atitlan.io/aiolabs/events", "short_description": "Sell and register event tickets",