libp2r2p 0.11.19 → 0.11.20

package/README.md

@@ -955,22 +955,26 @@ also admits relay policy refusals (`blocked:`, `restricted:`, `auth-required:`,
 Local authentication denials, invalid events and unknown errors qualify for
 neither policy. Predicates classify individual native errors; callers decide
 how to handle mixed per-relay outcomes and application-specific aggregates.
-`parseRelayRetryAdvice(reason, extra, { now = Date.now() })`, exported by
+`parseRelayRetryAdvice(reason, params, { now = Date.now() })`, exported by
 `libp2r2p/relay`, returns `{ retryAt, retryAfterMs? }` or `null`. It only interprets
-leading `rate-limited:` refusals. Optional `retry_at` is a Unix timestamp in
-seconds (fractions allowed), converted to milliseconds. Finite positive absolute
-advice takes precedence over `retry_after`, including when already expired;
-expired advice does not restart a relative wait. Future waits are capped at five
-minutes from processing. Missing/invalid absolute advice falls back to finite
-positive relative seconds, capped at 300. A valid relative value is retained as
-`retryAfterMs` even when the absolute deadline wins. Schedulers wait until
+leading `rate-limited:` refusals. The optional string `params` is relative
+milliseconds (e.g. "2500") or an absolute Unix timestamp in milliseconds
+prefixed with `@` (e.g. "@1791738154332"). Values must be positive safe integers
+in canonical decimal form, without signs, whitespace, fractions or leading zeros.
+Relative values produce both `retryAfterMs` and `retryAt`; absolute values produce
+only `retryAt` and retain an expired deadline without starting a new wait.
+Future waits are capped at five minutes. Missing or invalid params are ignored
+and do not instruct clients to retry immediately. Schedulers wait until
 max(local backoff deadline, retryAt), never sum the two or renew the deadline on
 online notifications.
 
-The optional Nostr extension works with older relays that only send
-`retry_after` and older consumers that ignore `retry_at`. Neither field supplies
-provenance or retry eligibility: `local`, `origin`, `retryable`, category and code
-claims in extras are ignored. Native messages, causes and codes remain intact.
+Rate limits apply only to the client message type that triggered the refusal:
+`EVENT`, `AUTH`, `REQ` and `COUNT` have independent connection cooldowns. Responses
+are correlated with pending operations; unknown IDs never create cooldowns.
+CLOSE cleanup remains immediate. The launcher can replace valid relative params
+with `@` timestamps before queueing bridge delivery because its consumers share
+its clock. No legacy timing objects are interpreted. Params never supply provenance
+or retry eligibility; native messages, causes and codes remain intact.
 
 ## Binary encodings
 
@@ -1091,10 +1095,11 @@ user-facing send error.
 
 ### Relay backpressure and bounded synchronization (0.11.7)
 
-Optional `retry_at` Unix seconds or numeric `retry_after` seconds on relay `CLOSED` and rejected `OK`
-responses are preserved as `retryAfterMs` and `retryAt` on native relay errors.
-Only `rate-limited:` responses apply this advice; invalid values are ignored
-and delays are capped at five minutes. New operations on that connection wait
+Optional decimal `params` milliseconds or `@` Unix milliseconds on relay `CLOSED`
+and rejected `OK` responses are preserved as normalized `retryAt` (and
+`retryAfterMs` for relative params) on native relay errors. Only `rate-limited:`
+responses apply this advice; invalid values are ignored
+and delays are capped at five minutes. New operations of the refused type wait
 within their existing deadlines; active subscriptions remain live and `CLOSE`
 never waits. Cancelled or timed-out operations cannot be sent later. A rejection
 is still reported to the caller; this does not silently republish failed events.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2r2p",
-  "version": "0.11.19",
+  "version": "0.11.20",
   "description": "Peer-to-relay-to-peer",
   "keywords": [
     "p2r2p",

package/relay/helpers/error.js

@@ -33,8 +33,8 @@ export function relayCloseError (event, category, cause) {
 
 // Keep native diagnostics and attach only bounded timing advice. An absolute
 // deadline survives delayed delivery through a launcher-owned relay bridge.
-export function relayRejectionError (reason, extra, fallback) {
+export function relayRejectionError (reason, params, fallback) {
   const error = categorizeRelayError(reason, 'relay', fallback)
-  Object.assign(error, parseRelayRetryAdvice(error.message, extra))
+  Object.assign(error, parseRelayRetryAdvice(error.message, params))
   return error
 }

package/relay/helpers/retry-advice.js

@@ -1,18 +1,13 @@
-// Nostr transport extensions, in seconds. Timing advice is bounded and never
+// Nostr params use relative milliseconds or @Unix milliseconds. Advice never
 // supplies an error category, provenance or a routing/retry policy.
-export function parseRelayRetryAdvice (reason, extra, { now = Date.now() } = {}) {
+export function parseRelayRetryAdvice (reason, params, { now = Date.now() } = {}) {
   if (typeof reason !== 'string' || !reason.startsWith('rate-limited:') ||
-      !extra || typeof extra !== 'object' || Array.isArray(extra) || !Number.isFinite(now)) return null
+      typeof params !== 'string' || params.match(/^@?[1-9]\d*$/)?.[0] !== params || !Number.isFinite(now)) return null
 
-  const after = extra.retry_after
-  const retryAfterMs = typeof after === 'number' && Number.isFinite(after) && after > 0
-    ? Math.min(after, 300) * 1000
-    : undefined
-  const at = extra.retry_at
-  const absolute = typeof at === 'number' && Number.isFinite(at) && at > 0 && Number.isFinite(at * 1000)
-    ? Math.min(at * 1000, now + 300000)
-    : undefined
-  const retryAt = absolute ?? (retryAfterMs === undefined ? undefined : now + retryAfterMs)
-  if (retryAt === undefined) return null
-  return { ...(retryAfterMs === undefined ? {} : { retryAfterMs }), retryAt }
+  const absolute = params.startsWith('@')
+  const value = Number(absolute ? params.slice(1) : params)
+  if (!Number.isSafeInteger(value)) return null
+  if (absolute) return { retryAt: Math.min(value, now + 300000) }
+  const retryAfterMs = Math.min(value, 300000)
+  return { retryAfterMs, retryAt: now + retryAfterMs }
 }

package/relay/services/relay-connection.js

@@ -50,7 +50,7 @@ export class RelayConnection {
   #publishes = new Map()
   #authentications = new Map()
   #counts = new Map()
-  #retryAt = 0
+  #retryAtByType = new Map()
 
   constructor (url, { WebSocket: WebSocketImpl = globalThis.WebSocket } = {}) {
     this.url = url
@@ -124,12 +124,12 @@ export class RelayConnection {
 
   // New work respects relay cooldowns; cleanup uses send() directly. These
   // waits stay within the caller's existing deadline and are cancellable.
-  #dispatchWork (send, fail) {
+  #dispatchWork (type, send, fail) {
     let timer = null
     let cancelled = false
     const dispatch = () => {
       if (cancelled) return
-      const remaining = this.#retryAt - Date.now()
+      const remaining = (this.#retryAtByType.get(type) ?? 0) - Date.now()
       if (remaining > 0) {
         timer = maybeUnref(setTimeout(dispatch, remaining))
         return
@@ -140,9 +140,9 @@ export class RelayConnection {
     return () => { cancelled = true; clearTimeout(timer) }
   }
 
-  #rejection (reason, extra, fallback) {
-    const error = relayRejectionError(reason, extra, fallback)
-    this.#retryAt = Math.max(this.#retryAt, error.retryAt || 0)
+  #rejection (type, reason, params, fallback) {
+    const error = relayRejectionError(reason, params, fallback)
+    if (error.retryAt !== undefined) this.#retryAtByType.set(type, Math.max(this.#retryAtByType.get(type) ?? 0, error.retryAt))
     return error
   }
 
@@ -163,7 +163,7 @@ export class RelayConnection {
     }
     const subscription = { filters, handlers, close, cancelSend: null }
     this.#subscriptions.set(id, subscription)
-    subscription.cancelSend = this.#dispatchWork(() => {
+    subscription.cancelSend = this.#dispatchWork('REQ', () => {
       this.send(JSON.stringify(['REQ', id, ...filters]))
       sent = true
     }, error => {
@@ -209,7 +209,7 @@ export class RelayConnection {
     pending.waiters.add(waiter)
     signal?.addEventListener('abort', onAbort, { once: true })
     if (created) {
-      pending.cancelSend = this.#dispatchWork(() => {
+      pending.cancelSend = this.#dispatchWork(type, () => {
         this.send(JSON.stringify([type, event]))
       }, error => this.#settleEvent(map, event.id, error))
     }
@@ -224,7 +224,7 @@ export class RelayConnection {
     const pending = { ...deferred, signal, onAbort, cancelSend: null }
     this.#counts.set(id, pending)
     signal?.addEventListener('abort', onAbort, { once: true })
-    pending.cancelSend = this.#dispatchWork(() => this.send(JSON.stringify(['COUNT', id, ...filters])), error => {
+    pending.cancelSend = this.#dispatchWork('COUNT', () => this.send(JSON.stringify(['COUNT', id, ...filters])), error => {
       this.#settleCount(id, null, error)
     })
     return deferred.promise
@@ -277,7 +277,8 @@ export class RelayConnection {
     if (data[0] === 'CLOSED') {
       const id = data[1]
       const subscription = this.#subscriptions.get(id)
-      const reason = this.#rejection(data[2], data[3], subscription ? 'SUBSCRIPTION_CLOSED' : 'COUNT_CLOSED')
+      if (!subscription && !this.#counts.has(id)) return
+      const reason = this.#rejection(subscription ? 'REQ' : 'COUNT', data[2], data[3], subscription ? 'SUBSCRIPTION_CLOSED' : 'COUNT_CLOSED')
       if (subscription) {
         this.#subscriptions.delete(id)
         subscription.cancelSend?.()
@@ -286,9 +287,11 @@ export class RelayConnection {
       return
     }
     if (data[0] === 'OK') {
-      const reason = data[2] === true ? null : this.#rejection(data[3], data[4], 'EVENT_REJECTED')
-      this.#settleEvent(this.#publishes, data[1], reason, data[3])
-      this.#settleEvent(this.#authentications, data[1], reason, data[3])
+      for (const [type, pending] of [['EVENT', this.#publishes], ['AUTH', this.#authentications]]) {
+        if (!pending.has(data[1])) continue
+        const reason = data[2] === true ? null : this.#rejection(type, data[3], data[4], 'EVENT_REJECTED')
+        this.#settleEvent(pending, data[1], reason, data[3])
+      }
       return
     }
     if (data[0] === 'AUTH' && typeof data[1] === 'string') {