fix classifyKind() test.

fix normalizeUrl to make websocket urls out of http urls.
kinds: more reliable regular/replaceable kind figuring.
2025-12-08 16:28:49 +00:00 · 2025-11-25 22:21:46 -03:00 · 2025-11-25 22:20:38 -03:00 · 2025-11-24 20:08:15 -03:00 · 2025-11-22 22:23:03 -03:00 · 2025-11-22 20:36:04 -03:00
27 changed files with 1923 additions and 296 deletions
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -138,6 +138,7 @@
    "valid-typeof": 2,
    "wrap-iife": [2, "any"],
    "yield-star-spacing": [2, "both"],
-    "yoda": [0]
+    "yoda": [0],
+    "no-labels": [0]
  }
 }
--- a/README.md
+++ b/README.md
@@ -133,6 +133,44 @@ import WebSocket from 'ws'
 useWebSocketImplementation(WebSocket)
 ```

+#### enablePing
+
+You can enable regular pings of connected relays with the `enablePing` option. This will set up a heartbeat that closes the websocket if it doesn't receive a response in time. Some platforms, like Node.js, don't report websocket disconnections due to network issues, and enabling this can increase the reliability of the `onclose` event.
+
+```js
+import { SimplePool } from 'nostr-tools/pool'
+
+const pool = new SimplePool({ enablePing: true })
+```
+
+#### enableReconnect
+
+You can also enable automatic reconnection with the `enableReconnect` option. This will make the pool try to reconnect to relays with an exponential backoff delay if the connection is lost unexpectedly.
+
+```js
+import { SimplePool } from 'nostr-tools/pool'
+
+const pool = new SimplePool({ enableReconnect: true })
+```
+
+Using both `enablePing: true` and `enableReconnect: true` is recommended as it will improve the reliability and timeliness of the reconnection (at the expense of slighly higher bandwidth due to the ping messages).
+
+```js
+// on Node.js
+const pool = new SimplePool({ enablePing: true, enableReconnect: true })
+```
+
+The `enableReconnect` option can also be a callback function which will receive the current subscription filters and should return a new set of filters. This is useful if you want to modify the subscription on reconnect, for example, to update the `since` parameter to fetch only new events.
+
+```js
+const pool = new SimplePool({
+  enableReconnect: (filters) => {
+    const newSince = Math.floor(Date.now() / 1000)
+    return filters.map(filter => ({ ...filter, since: newSince }))
+  }
+})
+```
+
 ### Parsing references (mentions) from a content based on NIP-27

 ```js
@@ -161,8 +199,10 @@ for (let block of nip27.parse(evt.content)) {
    case 'video':
    case 'audio':
      console.log("it's a media url:", block.url)
+      break
    case 'relay':
      console.log("it's a websocket url, probably a relay address:", block.url)
+      break
    default:
      break
  }
@@ -171,14 +211,24 @@ for (let block of nip27.parse(evt.content)) {

 ### Connecting to a bunker using NIP-46

+`BunkerSigner` allows your application to request signatures and other actions from a remote NIP-46 signer, often called a "bunker". There are two primary ways to establish a connection, depending on whether the client or the bunker initiates the connection.
+
+A local secret key is required for the client to communicate securely with the bunker. This key should generally be persisted for the user's session.
+
+```js
+import { generateSecretKey } from '@nostr/tools/pure'
+
+const localSecretKey = generateSecretKey()
+```
+
+### Method 1: Using a Bunker URI (`bunker://`)
+
+This is the bunker-initiated flow. Your client receives a `bunker://` string or a NIP-05 identifier from the user. You use `BunkerSigner.fromBunker()` to create an instance, which returns immediately. For the **initial connection** with a new bunker, you must explicitly call `await bunker.connect()` to establish the connection and receive authorization.
+
 ```js
-import { generateSecretKey, getPublicKey } from '@nostr/tools/pure'
 import { BunkerSigner, parseBunkerInput } from '@nostr/tools/nip46'
 import { SimplePool } from '@nostr/tools/pool'

-// the client needs a local secret key (which is generally persisted) for communicating with the bunker
-const localSecretKey = generateSecretKey()
-
 // parse a bunker URI
 const bunkerPointer = await parseBunkerInput('bunker://abcd...?relay=wss://relay.example.com')
 if (!bunkerPointer) {
@@ -187,7 +237,7 @@ if (!bunkerPointer) {

 // create the bunker instance
 const pool = new SimplePool()
-const bunker = new BunkerSigner(localSecretKey, bunkerPointer, { pool })
+const bunker = BunkerSigner.fromBunker(localSecretKey, bunkerPointer, { pool })
 await bunker.connect()

 // and use it
@@ -203,6 +253,47 @@ const event = await bunker.signEvent({
 await signer.close()
 pool.close([])
 ```
+> **Note on Reconnecting:** Once a connection has been successfully established and the `BunkerPointer` is stored, you do **not** need to call `await bunker.connect()` on subsequent sessions. 
+
+### Method 2: Using a Client-generated URI (`nostrconnect://`)
+
+This is the client-initiated flow, which generally provides a better user experience for first-time connections (e.g., via QR code). Your client generates a `nostrconnect://` URI and waits for the bunker to connect to it.
+
+`BunkerSigner.fromURI()` is an **asynchronous** method. It returns a `Promise` that resolves only after the bunker has successfully connected. Therefore, the returned signer instance is already fully connected and ready to use, so you **do not** need to call `.connect()` on it.
+
+```js
+import { getPublicKey } from '@nostr/tools/pure'
+import { BunkerSigner, createNostrConnectURI } from '@nostr/tools/nip46'
+import { SimplePool } from '@nostr/tools/pool'
+
+const clientPubkey = getPublicKey(localSecretKey)
+
+// generate a connection URI for the bunker to scan
+const connectionUri = createNostrConnectURI({
+  clientPubkey,
+  relays: ['wss://relay.damus.io', 'wss://relay.primal.net'],
+  secret: 'a-random-secret-string', // A secret to verify the bunker's response
+  name: 'My Awesome App'
+})
+
+// wait for the bunker to connect
+const pool = new SimplePool()
+const signer = await BunkerSigner.fromURI(localSecretKey, connectionUri, { pool })
+
+// and use it
+const pubkey = await signer.getPublicKey()
+const event = await signer.signEvent({
+  kind: 1,
+  created_at: Math.floor(Date.now() / 1000),
+  tags: [],
+  content: 'Hello from a client-initiated connection!'
+})
+
+// cleanup
+await signer.close()
+pool.close([])
+```
+> **Note on Persistence:** This method is ideal for the initial sign-in. To allow users to stay logged in across sessions, you should store the connection details and use `Method 1` for subsequent reconnections. 

 ### Parsing thread from any note based on NIP-10

--- a/abstract-pool.ts
+++ b/abstract-pool.ts
@@ -32,6 +32,8 @@ export class AbstractSimplePool {
  public trackRelays: boolean = false

  public verifyEvent: Nostr['verifyEvent']
+  public enablePing: boolean | undefined
+  public enableReconnect: boolean | ((filters: Filter[]) => Filter[]) | undefined
  public trustedRelayURLs: Set<string> = new Set()

  private _WebSocket?: typeof WebSocket
@@ -39,6 +41,8 @@ export class AbstractSimplePool {
  constructor(opts: AbstractPoolConstructorOptions) {
    this.verifyEvent = opts.verifyEvent
    this._WebSocket = opts.websocketImplementation
+    this.enablePing = opts.enablePing
+    this.enableReconnect = opts.enableReconnect
  }

  async ensureRelay(url: string, params?: { connectionTimeout?: number }): Promise<AbstractRelay> {
@@ -49,9 +53,13 @@ export class AbstractSimplePool {
      relay = new AbstractRelay(url, {
        verifyEvent: this.trustedRelayURLs.has(url) ? alwaysTrue : this.verifyEvent,
        websocketImplementation: this._WebSocket,
+        enablePing: this.enablePing,
+        enableReconnect: this.enableReconnect,
      })
      relay.onclose = () => {
-        this.relays.delete(url)
+        if (relay && !relay.enableReconnect) {
+          this.relays.delete(url)
+        }
      }
      if (params?.connectionTimeout) relay.connectionTimeout = params.connectionTimeout
      this.relays.set(url, relay)
@@ -71,24 +79,44 @@ export class AbstractSimplePool {
  subscribe(relays: string[], filter: Filter, params: SubscribeManyParams): SubCloser {
    params.onauth = params.onauth || params.doauth

-    return this.subscribeMap(
-      relays.map(url => ({ url, filter })),
-      params,
-    )
+    const request: { url: string; filter: Filter }[] = []
+    for (let i = 0; i < relays.length; i++) {
+      const url = normalizeURL(relays[i])
+      if (!request.find(r => r.url === url)) {
+        request.push({ url, filter: filter })
+      }
+    }
+
+    return this.subscribeMap(request, params)
  }

-  subscribeMany(relays: string[], filters: Filter[], params: SubscribeManyParams): SubCloser {
+  subscribeMany(relays: string[], filter: Filter, params: SubscribeManyParams): SubCloser {
    params.onauth = params.onauth || params.doauth

-    return this.subscribeMap(
-      relays.flatMap(url => filters.map(filter => ({ url, filter }))),
-      params,
-    )
+    const request: { url: string; filter: Filter }[] = []
+    const uniqUrls: string[] = []
+    for (let i = 0; i < relays.length; i++) {
+      const url = normalizeURL(relays[i])
+      if (uniqUrls.indexOf(url) === -1) {
+        uniqUrls.push(url)
+        request.push({ url, filter: filter })
+      }
+    }
+
+    return this.subscribeMap(request, params)
  }

  subscribeMap(requests: { url: string; filter: Filter }[], params: SubscribeManyParams): SubCloser {
    params.onauth = params.onauth || params.doauth

+    const grouped = new Map<string, Filter[]>()
+    for (const req of requests) {
+      const { url, filter } = req
+      if (!grouped.has(url)) grouped.set(url, [])
+      grouped.get(url)!.push(filter)
+    }
+    const groupedRequests = Array.from(grouped.entries()).map(([url, filters]) => ({ url, filters }))
+
    if (this.trackRelays) {
      params.receivedEvent = (relay: AbstractRelay, id: string) => {
        let set = this.seenOn.get(id)
@@ -108,7 +136,7 @@ export class AbstractSimplePool {
    let handleEose = (i: number) => {
      if (eosesReceived[i]) return // do not act twice for the same relay
      eosesReceived[i] = true
-      if (eosesReceived.filter(a => a).length === requests.length) {
+      if (eosesReceived.filter(a => a).length === groupedRequests.length) {
        params.oneose?.()
        handleEose = () => {}
      }
@@ -119,7 +147,7 @@ export class AbstractSimplePool {
      if (closesReceived[i]) return // do not act twice for the same relay
      handleEose(i)
      closesReceived[i] = reason
-      if (closesReceived.filter(a => a).length === requests.length) {
+      if (closesReceived.filter(a => a).length === groupedRequests.length) {
        params.onclose?.(closesReceived)
        handleClose = () => {}
      }
@@ -136,9 +164,7 @@ export class AbstractSimplePool {

    // open a subscription in all given relays
    const allOpened = Promise.all(
-      requests.map(async ({ url, filter }, i) => {
-        url = normalizeURL(url)
-
+      groupedRequests.map(async ({ url, filters }, i) => {
        let relay: AbstractRelay
        try {
          relay = await this.ensureRelay(url, {
@@ -149,7 +175,7 @@ export class AbstractSimplePool {
          return
        }

-        let subscription = relay.subscribe([filter], {
+        let subscription = relay.subscribe(filters, {
          ...params,
          oneose: () => handleEose(i),
          onclose: reason => {
@@ -157,7 +183,7 @@ export class AbstractSimplePool {
              relay
                .auth(params.onauth)
                .then(() => {
-                  relay.subscribe([filter], {
+                  relay.subscribe(filters, {
                    ...params,
                    oneose: () => handleEose(i),
                    onclose: reason => {
@@ -210,12 +236,12 @@ export class AbstractSimplePool {

  subscribeManyEose(
    relays: string[],
-    filters: Filter[],
+    filter: Filter,
    params: Pick<SubscribeManyParams, 'label' | 'id' | 'onevent' | 'onclose' | 'maxWait' | 'onauth' | 'doauth'>,
  ): SubCloser {
    params.onauth = params.onauth || params.doauth

-    const subcloser = this.subscribeMany(relays, filters, {
+    const subcloser = this.subscribeMany(relays, filter, {
      ...params,
      oneose() {
        subcloser.close('closed automatically on eose')
--- a/abstract-relay.ts
+++ b/abstract-relay.ts
@@ -7,9 +7,16 @@ import { Queue, normalizeURL } from './utils.ts'
 import { makeAuthEvent } from './nip42.ts'
 import { yieldThread } from './helpers.ts'

+type RelayWebSocket = WebSocket & {
+  ping?(): void
+  on?(event: 'pong', listener: () => void): any
+}
+
 export type AbstractRelayConstructorOptions = {
  verifyEvent: Nostr['verifyEvent']
  websocketImplementation?: typeof WebSocket
+  enablePing?: boolean
+  enableReconnect?: boolean | ((filters: Filter[]) => Filter[])
 }

 export class SendingOnClosedConnection extends Error {
@@ -29,13 +36,22 @@ export class AbstractRelay {
  public baseEoseTimeout: number = 4400
  public connectionTimeout: number = 4400
  public publishTimeout: number = 4400
+  public pingFrequency: number = 20000
+  public pingTimeout: number = 20000
+  public resubscribeBackoff: number[] = [10000, 10000, 10000, 20000, 20000, 30000, 60000]
  public openSubs: Map<string, Subscription> = new Map()
+  public enablePing: boolean | undefined
+  public enableReconnect: boolean | ((filters: Filter[]) => Filter[])
  private connectionTimeoutHandle: ReturnType<typeof setTimeout> | undefined
+  private reconnectTimeoutHandle: ReturnType<typeof setTimeout> | undefined
+  private pingTimeoutHandle: ReturnType<typeof setTimeout> | undefined
+  private reconnectAttempts: number = 0
+  private closedIntentionally: boolean = false

  private connectionPromise: Promise<void> | undefined
  private openCountRequests = new Map<string, CountResolver>()
  private openEventPublishes = new Map<string, EventPublishResolver>()
-  private ws: WebSocket | undefined
+  private ws: RelayWebSocket | undefined
  private incomingMessageQueue = new Queue<string>()
  private queueRunning = false
  private challenge: string | undefined
@@ -49,6 +65,8 @@ export class AbstractRelay {
    this.url = normalizeURL(url)
    this.verifyEvent = opts.verifyEvent
    this._WebSocket = opts.websocketImplementation || WebSocket
+    this.enablePing = opts.enablePing
+    this.enableReconnect = opts.enableReconnect || false
  }

  static async connect(url: string, opts: AbstractRelayConstructorOptions): Promise<AbstractRelay> {
@@ -78,6 +96,40 @@ export class AbstractRelay {
    return this._connected
  }

+  private async reconnect(): Promise<void> {
+    const backoff = this.resubscribeBackoff[Math.min(this.reconnectAttempts, this.resubscribeBackoff.length - 1)]
+    this.reconnectAttempts++
+
+    this.reconnectTimeoutHandle = setTimeout(async () => {
+      try {
+        await this.connect()
+      } catch (err) {
+        // this will be called again through onclose/onerror
+      }
+    }, backoff)
+  }
+
+  private handleHardClose(reason: string) {
+    if (this.pingTimeoutHandle) {
+      clearTimeout(this.pingTimeoutHandle)
+      this.pingTimeoutHandle = undefined
+    }
+
+    this._connected = false
+    this.connectionPromise = undefined
+
+    const wasIntentional = this.closedIntentionally
+    this.closedIntentionally = false // reset for next time
+
+    this.onclose?.()
+
+    if (this.enableReconnect && !wasIntentional) {
+      this.reconnect()
+    } else {
+      this.closeAllSubscriptions(reason)
+    }
+  }
+
  public async connect(): Promise<void> {
    if (this.connectionPromise) return this.connectionPromise

@@ -100,31 +152,39 @@ export class AbstractRelay {
      }

      this.ws.onopen = () => {
+        if (this.reconnectTimeoutHandle) {
+          clearTimeout(this.reconnectTimeoutHandle)
+          this.reconnectTimeoutHandle = undefined
+        }
        clearTimeout(this.connectionTimeoutHandle)
        this._connected = true
+        this.reconnectAttempts = 0
+
+        // resubscribe to all open subscriptions
+        for (const sub of this.openSubs.values()) {
+          sub.eosed = false
+          if (typeof this.enableReconnect === 'function') {
+            sub.filters = this.enableReconnect(sub.filters)
+          }
+          sub.fire()
+        }
+
+        if (this.enablePing) {
+          this.pingpong()
+        }
        resolve()
      }

      this.ws.onerror = ev => {
        clearTimeout(this.connectionTimeoutHandle)
        reject((ev as any).message || 'websocket error')
-        if (this._connected) {
-          this._connected = false
-          this.connectionPromise = undefined
-          this.onclose?.()
-          this.closeAllSubscriptions('relay connection errored')
-        }
+        this.handleHardClose('relay connection errored')
      }

      this.ws.onclose = ev => {
        clearTimeout(this.connectionTimeoutHandle)
        reject((ev as any).message || 'websocket closed')
-        if (this._connected) {
-          this._connected = false
-          this.connectionPromise = undefined
-          this.onclose?.()
-          this.closeAllSubscriptions('relay connection closed')
-        }
+        this.handleHardClose('relay connection closed')
      }

      this.ws.onmessage = this._onmessage.bind(this)
@@ -133,6 +193,52 @@ export class AbstractRelay {
    return this.connectionPromise
  }

+  private waitForPingPong() {
+    return new Promise(resolve => {
+      // listen for pong
+      ;(this.ws as any).once('pong', () => resolve(true))
+      // send a ping
+      this.ws!.ping!()
+    })
+  }
+
+  private async waitForDummyReq() {
+    return new Promise((resolve, _) => {
+      // make a dummy request with expected empty eose reply
+      // ["REQ", "_", {"ids":["aaaa...aaaa"]}]
+      const sub = this.subscribe([{ ids: ['a'.repeat(64)] }], {
+        oneose: () => {
+          sub.close()
+          resolve(true)
+        },
+        eoseTimeout: this.pingTimeout + 1000,
+      })
+    })
+  }
+
+  // nodejs requires this magic here to ensure connections are closed when internet goes off and stuff
+  // in browsers it's done automatically. see https://github.com/nbd-wtf/nostr-tools/issues/491
+  private async pingpong() {
+    // if the websocket is connected
+    if (this.ws?.readyState === 1) {
+      // wait for either a ping-pong reply or a timeout
+      const result = await Promise.any([
+        // browsers don't have ping so use a dummy req
+        this.ws && this.ws.ping && (this.ws as any).once ? this.waitForPingPong() : this.waitForDummyReq(),
+        new Promise(res => setTimeout(() => res(false), this.pingTimeout)),
+      ])
+      if (result) {
+        // schedule another pingpong
+        this.pingTimeoutHandle = setTimeout(() => this.pingpong(), this.pingFrequency)
+      } else {
+        // pingpong closing socket
+        if (this.ws?.readyState === this._WebSocket.OPEN) {
+          this.ws?.close()
+        }
+      }
+    }
+  }
+
  private async runQueue() {
    this.queueRunning = true
    while (true) {
@@ -150,6 +256,7 @@ export class AbstractRelay {
      return false
    }

+    // shortcut EVENT sub
    const subid = getSubscriptionId(json)
    if (subid) {
      const so = this.openSubs.get(subid as string)
@@ -225,13 +332,19 @@ export class AbstractRelay {
          so.close(data[2] as string)
          return
        }
-        case 'NOTICE':
+        case 'NOTICE': {
          this.onnotice(data[1] as string)
          return
+        }
        case 'AUTH': {
          this.challenge = data[1] as string
          return
        }
+        default: {
+          const so = this.openSubs.get(data[1])
+          so?.oncustom?.(data)
+          return
+        }
      }
    } catch (err) {
      return
@@ -299,9 +412,9 @@ export class AbstractRelay {
    filters: Filter[],
    params: Partial<SubscriptionParams> & { label?: string; id?: string },
  ): Subscription {
-    const subscription = this.prepareSubscription(filters, params)
-    subscription.fire()
-    return subscription
+    const sub = this.prepareSubscription(filters, params)
+    sub.fire()
+    return sub
  }

  public prepareSubscription(
@@ -316,10 +429,21 @@ export class AbstractRelay {
  }

  public close() {
+    this.closedIntentionally = true
+    if (this.reconnectTimeoutHandle) {
+      clearTimeout(this.reconnectTimeoutHandle)
+      this.reconnectTimeoutHandle = undefined
+    }
+    if (this.pingTimeoutHandle) {
+      clearTimeout(this.pingTimeoutHandle)
+      this.pingTimeoutHandle = undefined
+    }
    this.closeAllSubscriptions('relay connection closed by us')
    this._connected = false
-    this.ws?.close()
    this.onclose?.()
+    if (this.ws?.readyState === this._WebSocket.OPEN) {
+      this.ws?.close()
+    }
  }

  // this is the function assigned to this.ws.onmessage
@@ -346,10 +470,15 @@ export class Subscription {
  public oneose: (() => void) | undefined
  public onclose: ((reason: string) => void) | undefined

+  // will get any messages that have this subscription id as their second item and are not default standard
+  public oncustom: ((msg: string[]) => void) | undefined
+
  public eoseTimeout: number
  private eoseTimeoutHandle: ReturnType<typeof setTimeout> | undefined

  constructor(relay: AbstractRelay, id: string, filters: Filter[], params: SubscriptionParams) {
+    if (filters.length === 0) throw new Error("subscription can't be created with zero filters")
+
    this.relay = relay
    this.filters = filters
    this.id = id
--- a/build.js
+++ b/build.js
@@ -7,7 +7,6 @@ const entryPoints = fs
  .filter(
    file =>
      file.endsWith('.ts') &&
-      file !== 'core.ts' &&
      file !== 'test-helpers.ts' &&
      file !== 'helpers.ts' &&
      file !== 'benchmarks.ts' &&
--- a/helpers.ts
+++ b/helpers.ts
@@ -1,17 +1,34 @@
 import { verifiedSymbol, type Event, type Nostr, VerifiedEvent } from './core.ts'

 export async function yieldThread() {
-  return new Promise<void>(resolve => {
-    const ch = new MessageChannel()
-    const handler = () => {
-      // @ts-ignore (typescript thinks this property should be called `removeListener`, but in fact it's `removeEventListener`)
-      ch.port1.removeEventListener('message', handler)
-      resolve()
+  return new Promise<void>((resolve, reject) => {
+    try {
+      // Check if MessageChannel is available
+      if (typeof MessageChannel !== 'undefined') {
+        const ch = new MessageChannel()
+        const handler = () => {
+          // @ts-ignore (typescript thinks this property should be called `removeListener`, but in fact it's `removeEventListener`)
+          ch.port1.removeEventListener('message', handler)
+          resolve()
+        }
+        // @ts-ignore (typescript thinks this property should be called `addListener`, but in fact it's `addEventListener`)
+        ch.port1.addEventListener('message', handler)
+        ch.port2.postMessage(0)
+        ch.port1.start()
+      } else {
+        if (typeof setImmediate !== 'undefined') {
+          setImmediate(resolve)
+        } else if (typeof setTimeout !== 'undefined') {
+          setTimeout(resolve, 0)
+        } else {
+          // Last resort - resolve immediately
+          resolve()
+        }
+      }
+    } catch (e) {
+      console.error('during yield: ', e)
+      reject(e)
    }
-    // @ts-ignore (typescript thinks this property should be called `addListener`, but in fact it's `addEventListener`)
-    ch.port1.addEventListener('message', handler)
-    ch.port2.postMessage(0)
-    ch.port1.start()
  })
 }

--- a/index.ts
+++ b/index.ts
@@ -24,6 +24,7 @@ export * as nip47 from './nip47.ts'
 export * as nip54 from './nip54.ts'
 export * as nip57 from './nip57.ts'
 export * as nip59 from './nip59.ts'
+export * as nip77 from './nip77.ts'
 export * as nip98 from './nip98.ts'

 export * as kinds from './kinds.ts'
--- a/jsr.json
+++ b/jsr.json
@@ -1,6 +1,6 @@
 {
  "name": "@nostr/tools",
-  "version": "2.15.1",
+  "version": "2.18.2",
  "exports": {
    ".": "./index.ts",
    "./core": "./core.ts",
@@ -44,7 +44,7 @@
    "./nip99": "./nip99.ts",
    "./nipb7": "./nipb7.ts",
    "./fakejson": "./fakejson.ts",
-    "./utils": "./utils.ts"
+    "./utils": "./utils.ts",
    "./signer": "./signer.ts"
  }
 }
--- a/kinds.test.ts
+++ b/kinds.test.ts
@@ -18,7 +18,7 @@ test('kind classification', () => {
  expect(classifyKind(30000)).toBe('parameterized')
  expect(classifyKind(39999)).toBe('parameterized')
  expect(classifyKind(40000)).toBe('unknown')
-  expect(classifyKind(255)).toBe('unknown')
+  expect(classifyKind(255)).toBe('regular')
 })

 test('kind type guard', () => {
--- a/kinds.ts
+++ b/kinds.ts
@@ -2,12 +2,12 @@ import { NostrEvent, validateEvent } from './pure.ts'

 /** Events are **regular**, which means they're all expected to be stored by relays. */
 export function isRegularKind(kind: number): boolean {
-  return (1000 <= kind && kind < 10000) || [1, 2, 4, 5, 6, 7, 8, 16, 40, 41, 42, 43, 44].includes(kind)
+  return kind < 10000 && kind !== 0 && kind !== 3
 }

 /** Events are **replaceable**, which means that, for each combination of `pubkey` and `kind`, only the latest event is expected to (SHOULD) be stored by relays, older versions are expected to be discarded. */
 export function isReplaceableKind(kind: number): boolean {
-  return [0, 3].includes(kind) || (10000 <= kind && kind < 20000)
+  return kind === 0 || kind === 3 || (10000 <= kind && kind < 20000)
 }

 /** Events are **ephemeral**, which means they are not expected to be stored by relays. */
--- a/nip19.test.ts
+++ b/nip19.test.ts
@@ -1,4 +1,5 @@
 import { describe, expect, test } from 'bun:test'
+// prettier-ignore
 import {
  decode,
  naddrEncode,
--- a/nip27.test.ts
+++ b/nip27.test.ts
@@ -1,5 +1,6 @@
 import { test, expect } from 'bun:test'
 import { parse } from './nip27.ts'
+import { NostrEvent } from './core.ts'

 test('first: parse simple content with 1 url and 1 nostr uri', () => {
  const content = `nostr:npub1hpslpc8c5sp3e2nhm2fr7swsfqpys5vyjar5dwpn7e7decps6r8qkcln63 check out my profile:nostr:npub1xtscya34g58tk0z605fvr788k263gsu6cy9x0mhnm87echrgufzsevkk5s; and this cool image https://images.com/image.jpg`
@@ -75,3 +76,40 @@ test('third: parse complex content with 4 nostr uris and 3 urls', () => {
    { type: 'url', url: 'https://example.com/docs' },
  ])
 })
+
+test('parse content with hashtags and emoji shortcodes', () => {
+  const event: NostrEvent = {
+    kind: 1,
+    tags: [
+      ['emoji', 'star', 'https://example.com/star.png'],
+      ['emoji', 'alpaca', 'https://example.com/alpaca.png'],
+    ],
+    content:
+      'hey nostr:npub1hpslpc8c5sp3e2nhm2fr7swsfqpys5vyjar5dwpn7e7decps6r8qkcln63 check out :alpaca::alpaca: #alpaca at wss://alpaca.com! :star:',
+    created_at: 1234567890,
+    pubkey: 'dummy',
+    id: 'dummy',
+    sig: 'dummy',
+  }
+  const blocks = Array.from(parse(event))
+
+  expect(blocks).toEqual([
+    { type: 'text', text: 'hey ' },
+    { type: 'reference', pointer: { pubkey: 'b861f0e0f8a4031caa77da923f41d04802485184974746b833f67cdce030d0ce' } },
+    { type: 'text', text: ' check out ' },
+    { type: 'emoji', shortcode: 'alpaca', url: 'https://example.com/alpaca.png' },
+    { type: 'emoji', shortcode: 'alpaca', url: 'https://example.com/alpaca.png' },
+    { type: 'text', text: ' ' },
+    { type: 'hashtag', value: 'alpaca' },
+    { type: 'text', text: ' at ' },
+    { type: 'relay', url: 'wss://alpaca.com/' },
+    { type: 'text', text: '! ' },
+    { type: 'emoji', shortcode: 'star', url: 'https://example.com/star.png' },
+  ])
+})
+
+test('emoji shortcodes are treated as text if no event tags', () => {
+  const blocks = Array.from(parse('hello :alpaca:'))
+
+  expect(blocks).toEqual([{ type: 'text', text: 'hello :alpaca:' }])
+})
--- a/nip27.ts
+++ b/nip27.ts
@@ -1,3 +1,4 @@
+import { NostrEvent } from './core.ts'
 import { AddressPointer, EventPointer, ProfilePointer, decode } from './nip19.ts'

 export type Block =
@@ -29,27 +30,67 @@ export type Block =
      type: 'audio'
      url: string
    }
+  | {
+      type: 'emoji'
+      shortcode: string
+      url: string
+    }
+  | {
+      type: 'hashtag'
+      value: string
+    }

 const noCharacter = /\W/m
 const noURLCharacter = /\W |\W$|$|,| /m
+const MAX_HASHTAG_LENGTH = 42
+
+export function* parse(content: string | NostrEvent): Iterable<Block> {
+  let emojis: { type: 'emoji'; shortcode: string; url: string }[] = []
+  if (typeof content !== 'string') {
+    for (let i = 0; i < content.tags.length; i++) {
+      const tag = content.tags[i]
+      if (tag[0] === 'emoji' && tag.length >= 3) {
+        emojis.push({ type: 'emoji', shortcode: tag[1], url: tag[2] })
+      }
+    }
+    content = content.content
+  }

-export function* parse(content: string): Iterable<Block> {
  const max = content.length
  let prevIndex = 0
  let index = 0
-  while (index < max) {
-    let u = content.indexOf(':', index)
-    if (u === -1) {
+  mainloop: while (index < max) {
+    const u = content.indexOf(':', index)
+    const h = content.indexOf('#', index)
+    if (u === -1 && h === -1) {
      // reached end
-      break
+      break mainloop
    }

-    if (content.substring(u - 5, u) === 'nostr') {
-      const m = content.substring(u + 60).match(noCharacter)
+    if (u === -1 || (h >= 0 && h < u)) {
+      // parse hashtag
+      if (h === 0 || content[h - 1] === ' ') {
+        const m = content.slice(h + 1, h + MAX_HASHTAG_LENGTH).match(noCharacter)
+        const end = m ? h + 1 + m.index! : max
+        yield { type: 'text', text: content.slice(prevIndex, h) }
+        yield { type: 'hashtag', value: content.slice(h + 1, end) }
+        index = end
+        prevIndex = index
+        continue mainloop
+      }
+
+      // ignore this, it is nothing
+      index = h + 1
+      continue mainloop
+    }
+
+    // otherwise parse things that have an ":"
+    if (content.slice(u - 5, u) === 'nostr') {
+      const m = content.slice(u + 60).match(noCharacter)
      const end = m ? u + 60 + m.index! : max
      try {
        let pointer: ProfilePointer | AddressPointer | EventPointer
-        let { data, type } = decode(content.substring(u + 1, end))
+        let { data, type } = decode(content.slice(u + 1, end))

        switch (type) {
          case 'npub':
@@ -65,105 +106,107 @@ export function* parse(content: string): Iterable<Block> {
        }

        if (prevIndex !== u - 5) {
-          yield { type: 'text', text: content.substring(prevIndex, u - 5) }
+          yield { type: 'text', text: content.slice(prevIndex, u - 5) }
        }
        yield { type: 'reference', pointer }
        index = end
        prevIndex = index
-        continue
+        continue mainloop
      } catch (_err) {
        // ignore this, not a valid nostr uri
        index = u + 1
-        continue
+        continue mainloop
      }
-    } else if (content.substring(u - 5, u) === 'https' || content.substring(u - 4, u) === 'http') {
-      const m = content.substring(u + 4).match(noURLCharacter)
+    } else if (content.slice(u - 5, u) === 'https' || content.slice(u - 4, u) === 'http') {
+      const m = content.slice(u + 4).match(noURLCharacter)
      const end = m ? u + 4 + m.index! : max
      const prefixLen = content[u - 1] === 's' ? 5 : 4
      try {
-        let url = new URL(content.substring(u - prefixLen, end))
+        let url = new URL(content.slice(u - prefixLen, end))
        if (url.hostname.indexOf('.') === -1) {
          throw new Error('invalid url')
        }

        if (prevIndex !== u - prefixLen) {
-          yield { type: 'text', text: content.substring(prevIndex, u - prefixLen) }
+          yield { type: 'text', text: content.slice(prevIndex, u - prefixLen) }
        }

-        if (
-          url.pathname.endsWith('.png') ||
-          url.pathname.endsWith('.jpg') ||
-          url.pathname.endsWith('.jpeg') ||
-          url.pathname.endsWith('.gif') ||
-          url.pathname.endsWith('.webp')
-        ) {
+        if (/\.(png|jpe?g|gif|webp|heic|svg)$/i.test(url.pathname)) {
          yield { type: 'image', url: url.toString() }
          index = end
          prevIndex = index
-          continue
+          continue mainloop
        }
-        if (
-          url.pathname.endsWith('.mp4') ||
-          url.pathname.endsWith('.avi') ||
-          url.pathname.endsWith('.webm') ||
-          url.pathname.endsWith('.mkv')
-        ) {
+        if (/\.(mp4|avi|webm|mkv|mov)$/i.test(url.pathname)) {
          yield { type: 'video', url: url.toString() }
          index = end
          prevIndex = index
-          continue
+          continue mainloop
        }
-        if (
-          url.pathname.endsWith('.mp3') ||
-          url.pathname.endsWith('.aac') ||
-          url.pathname.endsWith('.ogg') ||
-          url.pathname.endsWith('.opus')
-        ) {
+        if (/\.(mp3|aac|ogg|opus|wav|flac)$/i.test(url.pathname)) {
          yield { type: 'audio', url: url.toString() }
          index = end
          prevIndex = index
-          continue
+          continue mainloop
        }

        yield { type: 'url', url: url.toString() }
        index = end
        prevIndex = index
-        continue
+        continue mainloop
      } catch (_err) {
        // ignore this, not a valid url
        index = end + 1
-        continue
+        continue mainloop
      }
-    } else if (content.substring(u - 3, u) === 'wss' || content.substring(u - 2, u) === 'ws') {
-      const m = content.substring(u + 4).match(noURLCharacter)
+    } else if (content.slice(u - 3, u) === 'wss' || content.slice(u - 2, u) === 'ws') {
+      const m = content.slice(u + 4).match(noURLCharacter)
      const end = m ? u + 4 + m.index! : max
      const prefixLen = content[u - 1] === 's' ? 3 : 2
      try {
-        let url = new URL(content.substring(u - prefixLen, end))
+        let url = new URL(content.slice(u - prefixLen, end))
        if (url.hostname.indexOf('.') === -1) {
          throw new Error('invalid ws url')
        }

        if (prevIndex !== u - prefixLen) {
-          yield { type: 'text', text: content.substring(prevIndex, u - prefixLen) }
+          yield { type: 'text', text: content.slice(prevIndex, u - prefixLen) }
        }
        yield { type: 'relay', url: url.toString() }
        index = end
        prevIndex = index
-        continue
+        continue mainloop
      } catch (_err) {
        // ignore this, not a valid url
        index = end + 1
-        continue
+        continue mainloop
      }
    } else {
+      // try to parse an emoji shortcode
+      for (let e = 0; e < emojis.length; e++) {
+        const emoji = emojis[e]
+        if (
+          content[u + emoji.shortcode.length + 1] === ':' &&
+          content.slice(u + 1, u + emoji.shortcode.length + 1) === emoji.shortcode
+        ) {
+          // found an emoji
+          if (prevIndex !== u) {
+            yield { type: 'text', text: content.slice(prevIndex, u) }
+          }
+          yield emoji
+          index = u + emoji.shortcode.length + 2
+          prevIndex = index
+          continue mainloop
+        }
+      }
+
      // ignore this, it is nothing
      index = u + 1
-      continue
+      continue mainloop
    }
  }

  if (prevIndex !== max) {
-    yield { type: 'text', text: content.substring(prevIndex) }
+    yield { type: 'text', text: content.slice(prevIndex) }
  }
 }
--- a/nip29.ts
+++ b/nip29.ts
@@ -2,7 +2,7 @@ import { AbstractSimplePool } from './abstract-pool.ts'
 import { Subscription } from './abstract-relay.ts'
 import type { Event, EventTemplate } from './core.ts'
 import { fetchRelayInformation, RelayInformation } from './nip11.ts'
-import { AddressPointer, decode, NostrTypeGuard } from './nip19.ts'
+import { decode, NostrTypeGuard } from './nip19.ts'
 import { normalizeURL } from './utils.ts'

 /**
--- a/nip46.ts
+++ b/nip46.ts
@@ -5,7 +5,6 @@ import { getConversationKey, decrypt, encrypt } from './nip44.ts'
 import { NIP05_REGEX } from './nip05.ts'
 import { SimplePool } from './pool.ts'
 import { Handlerinformation, NostrConnect } from './kinds.ts'
-import type { RelayRecord } from './relay.ts'
 import { Signer } from './signer.ts'

 var _fetch: any
@@ -78,6 +77,114 @@ export async function queryBunkerProfile(nip05: string): Promise<BunkerPointer |
  }
 }

+export type NostrConnectParams = {
+  clientPubkey: string
+  relays: string[]
+  secret: string
+  perms?: string[]
+  name?: string
+  url?: string
+  image?: string
+}
+
+export type ParsedNostrConnectURI = {
+  protocol: 'nostrconnect'
+  clientPubkey: string
+  params: {
+    relays: string[]
+    secret: string
+    perms?: string[]
+    name?: string
+    url?: string
+    image?: string
+  }
+  originalString: string
+}
+
+export function createNostrConnectURI(params: NostrConnectParams): string {
+  if (!params.clientPubkey) {
+    throw new Error('clientPubkey is required.')
+  }
+  if (!params.relays || params.relays.length === 0) {
+    throw new Error('At least one relay is required.')
+  }
+  if (!params.secret) {
+    throw new Error('secret is required.')
+  }
+
+  const queryParams = new URLSearchParams()
+
+  params.relays.forEach(relay => {
+    queryParams.append('relay', relay)
+  })
+
+  queryParams.append('secret', params.secret)
+
+  if (params.perms && params.perms.length > 0) {
+    queryParams.append('perms', params.perms.join(','))
+  }
+  if (params.name) {
+    queryParams.append('name', params.name)
+  }
+  if (params.url) {
+    queryParams.append('url', params.url)
+  }
+  if (params.image) {
+    queryParams.append('image', params.image)
+  }
+
+  return `nostrconnect://${params.clientPubkey}?${queryParams.toString()}`
+}
+
+export function parseNostrConnectURI(uri: string): ParsedNostrConnectURI {
+  if (!uri.startsWith('nostrconnect://')) {
+    throw new Error('Invalid nostrconnect URI: Must start with "nostrconnect://".')
+  }
+
+  const [protocolAndPubkey, queryString] = uri.split('?')
+  if (!protocolAndPubkey || !queryString) {
+    throw new Error('Invalid nostrconnect URI: Missing query string.')
+  }
+
+  const clientPubkey = protocolAndPubkey.substring('nostrconnect://'.length)
+  if (!clientPubkey) {
+    throw new Error('Invalid nostrconnect URI: Missing client-pubkey.')
+  }
+
+  const queryParams = new URLSearchParams(queryString)
+
+  const relays = queryParams.getAll('relay')
+  if (relays.length === 0) {
+    throw new Error('Invalid nostrconnect URI: Missing "relay" parameter.')
+  }
+
+  const secret = queryParams.get('secret')
+  if (!secret) {
+    throw new Error('Invalid nostrconnect URI: Missing "secret" parameter.')
+  }
+
+  const permsString = queryParams.get('perms')
+  const perms = permsString ? permsString.split(',') : undefined
+
+  const name = queryParams.get('name') || undefined
+  const url = queryParams.get('url') || undefined
+  const image = queryParams.get('image') || undefined
+
+  return {
+    protocol: 'nostrconnect',
+    clientPubkey,
+    params: {
+      relays,
+      secret,
+      perms,
+      name,
+      url,
+      image,
+    },
+    originalString: uri,
+  }
+}
+
 export type BunkerSignerParams = {
  pool?: AbstractSimplePool
  onauth?: (url: string) => void
@@ -98,8 +205,9 @@ export class BunkerSigner implements Signer {
  }
  private waitingForAuth: { [id: string]: boolean }
  private secretKey: Uint8Array
-  private conversationKey: Uint8Array
-  public bp: BunkerPointer
+  // If the client initiates the connection, the two variables below can be filled in later.
+  private conversationKey!: Uint8Array
+  public bp!: BunkerPointer

  private cachedPubKey: string | undefined

@@ -109,23 +217,95 @@ export class BunkerSigner implements Signer {
   * @param remotePubkey - An optional remote public key. This is the key you want to sign as.
   * @param secretKey - An optional key pair.
   */
-  public constructor(clientSecretKey: Uint8Array, bp: BunkerPointer, params: BunkerSignerParams = {}) {
-    if (bp.relays.length === 0) {
-      throw new Error('no relays are specified for this bunker')
-    }
-
+  private constructor(clientSecretKey: Uint8Array, params: BunkerSignerParams) {
    this.params = params
    this.pool = params.pool || new SimplePool()
    this.secretKey = clientSecretKey
-    this.conversationKey = getConversationKey(clientSecretKey, bp.pubkey)
-    this.bp = bp
    this.isOpen = false
    this.idPrefix = Math.random().toString(36).substring(7)
    this.serial = 0
    this.listeners = {}
    this.waitingForAuth = {}
+  }

-    this.setupSubscription(params)
+  /**
+   * [Factory Method 1] Creates a Signer using bunker information (bunker:// URL or NIP-05).
+   * This method is used when the public key of the bunker is known in advance.
+   */
+  public static fromBunker(
+    clientSecretKey: Uint8Array,
+    bp: BunkerPointer,
+    params: BunkerSignerParams = {},
+  ): BunkerSigner {
+    if (bp.relays.length === 0) {
+      throw new Error('No relays specified for this bunker')
+    }
+
+    const signer = new BunkerSigner(clientSecretKey, params)
+
+    signer.conversationKey = getConversationKey(clientSecretKey, bp.pubkey)
+    signer.bp = bp
+
+    signer.setupSubscription(params)
+    return signer
+  }
+
+  /**
+   * [Factory Method 2] Creates a Signer using a nostrconnect:// URI generated by the client.
+   * In this method, the bunker initiates the connection by scanning the URI.
+   */
+  public static async fromURI(
+    clientSecretKey: Uint8Array,
+    connectionURI: string,
+    params: BunkerSignerParams = {},
+    maxWait: number = 300_000,
+  ): Promise<BunkerSigner> {
+    const signer = new BunkerSigner(clientSecretKey, params)
+    const parsedURI = parseNostrConnectURI(connectionURI)
+    const clientPubkey = getPublicKey(clientSecretKey)
+
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        sub.close()
+        reject(new Error(`Connection timed out after ${maxWait / 1000} seconds`))
+      }, maxWait)
+
+      const sub = signer.pool.subscribe(
+        parsedURI.params.relays,
+        { kinds: [NostrConnect], '#p': [clientPubkey] },
+        {
+          onevent: async (event: NostrEvent) => {
+            try {
+              const tempConvKey = getConversationKey(clientSecretKey, event.pubkey)
+              const decryptedContent = decrypt(event.content, tempConvKey)
+
+              const response = JSON.parse(decryptedContent)
+
+              if (response.result === parsedURI.params.secret) {
+                clearTimeout(timer)
+                sub.close()
+
+                signer.bp = {
+                  pubkey: event.pubkey,
+                  relays: parsedURI.params.relays,
+                  secret: parsedURI.params.secret,
+                }
+                signer.conversationKey = getConversationKey(clientSecretKey, event.pubkey)
+                signer.setupSubscription(params)
+                resolve(signer)
+              }
+            } catch (e) {
+              console.warn('Failed to process potential connection event', e)
+            }
+          },
+          onclose: () => {
+            clearTimeout(timer)
+            reject(new Error('Subscription closed before connection was established.'))
+          },
+          maxWait,
+        },
+      )
+    })
  }

  private setupSubscription(params: BunkerSignerParams) {
@@ -238,13 +418,6 @@ export class BunkerSigner implements Signer {
    return this.cachedPubKey
  }

-  /**
-   * @deprecated removed from NIP
-   */
-  async getRelays(): Promise<RelayRecord> {
-    return JSON.parse(await this.sendRequest('get_relays', []))
-  }
-
  /**
   * Signs an event using the remote private key.
   * @param event - The event to sign.
@@ -298,7 +471,7 @@ export async function createAccount(
 ): Promise<BunkerSigner> {
  if (email && !EMAIL_REGEX.test(email)) throw new Error('Invalid email')

-  let rpc = new BunkerSigner(localSecretKey, bunker.bunkerPointer, params)
+  let rpc = BunkerSigner.fromBunker(localSecretKey, bunker.bunkerPointer, params)

  let pubkey = await rpc.sendRequest('create_account', [username, domain, email || ''])

--- a/nip57.test.ts
+++ b/nip57.test.ts
@@ -1,112 +1,7 @@
-import { describe, test, expect, mock } from 'bun:test'
+import { describe, test, expect } from 'bun:test'
 import { finalizeEvent } from './pure.ts'
 import { getPublicKey, generateSecretKey } from './pure.ts'
-import {
-  getSatoshisAmountFromBolt11,
-  getZapEndpoint,
-  makeZapReceipt,
-  makeZapRequest,
-  useFetchImplementation,
-  validateZapRequest,
-} from './nip57.ts'
-import { buildEvent } from './test-helpers.ts'
-
-describe('getZapEndpoint', () => {
-  test('returns null if neither lud06 nor lud16 is present', async () => {
-    const metadata = buildEvent({ kind: 0, content: '{}' })
-    const result = await getZapEndpoint(metadata)
-
-    expect(result).toBeNull()
-  })
-
-  test('returns null if fetch fails', async () => {
-    const fetchImplementation = mock(() => Promise.reject(new Error()))
-    useFetchImplementation(fetchImplementation)
-
-    const metadata = buildEvent({ kind: 0, content: '{"lud16": "name@domain"}' })
-    const result = await getZapEndpoint(metadata)
-
-    expect(result).toBeNull()
-    expect(fetchImplementation).toHaveBeenCalledWith('https://domain/.well-known/lnurlp/name')
-  })
-
-  test('returns null if the response does not allow Nostr payments', async () => {
-    const fetchImplementation = mock(() => Promise.resolve({ json: () => ({ allowsNostr: false }) }))
-    useFetchImplementation(fetchImplementation)
-
-    const metadata = buildEvent({ kind: 0, content: '{"lud16": "name@domain"}' })
-    const result = await getZapEndpoint(metadata)
-
-    expect(result).toBeNull()
-    expect(fetchImplementation).toHaveBeenCalledWith('https://domain/.well-known/lnurlp/name')
-  })
-
-  test('returns the callback URL if the response allows Nostr payments', async () => {
-    const fetchImplementation = mock(() =>
-      Promise.resolve({
-        json: () => ({
-          allowsNostr: true,
-          nostrPubkey: 'pubkey',
-          callback: 'callback',
-        }),
-      }),
-    )
-    useFetchImplementation(fetchImplementation)
-
-    const metadata = buildEvent({ kind: 0, content: '{"lud16": "name@domain"}' })
-    const result = await getZapEndpoint(metadata)
-
-    expect(result).toBe('callback')
-    expect(fetchImplementation).toHaveBeenCalledWith('https://domain/.well-known/lnurlp/name')
-  })
-})
-
-describe('makeZapRequest', () => {
-  test('throws an error if amount is not given', () => {
-    expect(() =>
-      // @ts-expect-error
-      makeZapRequest({
-        profile: 'profile',
-        event: null,
-        relays: [],
-        comment: '',
-      }),
-    ).toThrow()
-  })
-
-  test('throws an error if profile is not given', () => {
-    expect(() =>
-      // @ts-expect-error
-      makeZapRequest({
-        event: null,
-        amount: 100,
-        relays: [],
-        comment: '',
-      }),
-    ).toThrow()
-  })
-
-  test('returns a valid Zap request', () => {
-    const result = makeZapRequest({
-      profile: 'profile',
-      event: 'event',
-      amount: 100,
-      relays: ['relay1', 'relay2'],
-      comment: 'comment',
-    })
-    expect(result.kind).toBe(9734)
-    expect(result.created_at).toBeCloseTo(Date.now() / 1000, 0)
-    expect(result.content).toBe('comment')
-    expect(result.tags).toEqual(
-      expect.arrayContaining([
-        ['p', 'profile'],
-        ['amount', '100'],
-        ['relays', 'relay1', 'relay2'],
-        ['e', 'event'],
-      ]),
-    )
-  })
-})
+import { getSatoshisAmountFromBolt11, makeZapReceipt, validateZapRequest } from './nip57.ts'

 describe('validateZapRequest', () => {
  test('returns an error message for invalid JSON', () => {
--- a/nip57.ts
+++ b/nip57.ts
@@ -1,6 +1,6 @@
 import { bech32 } from '@scure/base'

-import { validateEvent, verifyEvent, type Event, type EventTemplate } from './pure.ts'
+import { NostrEvent, validateEvent, verifyEvent, type Event, type EventTemplate } from './pure.ts'
 import { utf8Decoder } from './utils.ts'
 import { isReplaceableKind, isAddressableKind } from './kinds.ts'

@@ -18,13 +18,13 @@ export async function getZapEndpoint(metadata: Event): Promise<null | string> {
  try {
    let lnurl: string = ''
    let { lud06, lud16 } = JSON.parse(metadata.content)
-    if (lud06) {
+    if (lud16) {
+      let [name, domain] = lud16.split('@')
+      lnurl = new URL(`/.well-known/lnurlp/${name}`, `https://${domain}`).toString()
+    } else if (lud06) {
      let { words } = bech32.decode(lud06, 1000)
      let data = bech32.fromWords(words)
      lnurl = utf8Decoder.decode(data)
-    } else if (lud16) {
-      let [name, domain] = lud16.split('@')
-      lnurl = new URL(`/.well-known/lnurlp/${name}`, `https://${domain}`).toString()
    } else {
      return null
    }
@@ -42,48 +42,44 @@ export async function getZapEndpoint(metadata: Event): Promise<null | string> {
  return null
 }

-export function makeZapRequest({
-  profile,
-  event,
-  amount,
-  relays,
-  comment = '',
-}: {
-  profile: string
-  event: string | Event | null
+type ProfileZap = {
+  pubkey: string
  amount: number
-  comment: string
+  comment?: string
  relays: string[]
-}): EventTemplate {
-  if (!amount) throw new Error('amount not given')
-  if (!profile) throw new Error('profile not given')
+}

+type EventZap = {
+  event: NostrEvent
+  amount: number
+  comment?: string
+  relays: string[]
+}
+
+export function makeZapRequest(params: ProfileZap | EventZap): EventTemplate {
  let zr: EventTemplate = {
    kind: 9734,
    created_at: Math.round(Date.now() / 1000),
-    content: comment,
+    content: params.comment || '',
    tags: [
-      ['p', profile],
-      ['amount', amount.toString()],
-      ['relays', ...relays],
+      ['p', 'pubkey' in params ? params.pubkey : params.event.pubkey],
+      ['amount', params.amount.toString()],
+      ['relays', ...params.relays],
    ],
  }

-  if (event && typeof event === 'string') {
-    zr.tags.push(['e', event])
-  }
-  if (event && typeof event === 'object') {
-    // replacable event
-    if (isReplaceableKind(event.kind)) {
-      const a = ['a', `${event.kind}:${event.pubkey}:`]
+  if ('event' in params) {
+    zr.tags.push(['e', params.event.id])
+    if (isReplaceableKind(params.event.kind)) {
+      const a = ['a', `${params.event.kind}:${params.event.pubkey}:`]
      zr.tags.push(a)
-      // addressable event
-    } else if (isAddressableKind(event.kind)) {
-      let d = event.tags.find(([t, v]) => t === 'd' && v)
+    } else if (isAddressableKind(params.event.kind)) {
+      let d = params.event.tags.find(([t, v]) => t === 'd' && v)
      if (!d) throw new Error('d tag not found or is empty')
-      const a = ['a', `${event.kind}:${event.pubkey}:${d[1]}`]
+      const a = ['a', `${params.event.kind}:${params.event.pubkey}:${d[1]}`]
      zr.tags.push(a)
    }
+    zr.tags.push(['k', params.event.kind.toString()])
  }

  return zr
--- a/nip77.test.ts
+++ b/nip77.test.ts
@@ -0,0 +1,114 @@
+import { describe, test, expect } from 'bun:test'
+import { NegentropySync, NegentropyStorageVector } from './nip77.ts'
+import { Relay } from './relay.ts'
+import { NostrEvent } from './core.ts'
+
+// const RELAY = 'ws://127.0.0.1:10547'
+const RELAY = 'wss://relay.damus.io'
+
+describe('NegentropySync', () => {
+  test('syncs events from ' + RELAY, async () => {
+    const relay = await Relay.connect(RELAY)
+
+    const storage = new NegentropyStorageVector()
+    storage.seal()
+    const filter = {
+      authors: ['3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d'],
+      kinds: [30617, 30618],
+    }
+
+    let ids1: string[] = []
+    const done1 = Promise.withResolvers<void>()
+    const sync1 = new NegentropySync(relay, storage, filter, {
+      onneed: (id: string) => {
+        ids1.push(id)
+      },
+      onclose: err => {
+        expect(err).toBeUndefined()
+        done1.resolve()
+      },
+    })
+
+    await sync1.start()
+    await done1.promise
+
+    expect(ids1.length).toBeGreaterThan(10)
+
+    sync1.close()
+
+    // fetch events
+    const events1: NostrEvent[] = []
+    const fetched = Promise.withResolvers()
+    const sub = relay.subscribe([{ ids: ids1 }], {
+      onevent(evt) {
+        events1.push(evt)
+      },
+      oneose() {
+        sub.close()
+        fetched.resolve()
+      },
+    })
+    await fetched.promise
+    expect(events1.map(evt => evt.id).sort()).toEqual(ids1.sort())
+
+    // Second sync with local events
+    await relay.connect()
+
+    const storage2 = new NegentropyStorageVector()
+    for (const evt of events1) {
+      storage2.insert(evt.created_at, evt.id)
+    }
+    storage2.seal()
+
+    let ids2: string[] = []
+    let done2 = Promise.withResolvers()
+    const sync2 = new NegentropySync(relay, storage2, filter, {
+      onneed: (id: string) => {
+        ids2.push(id)
+      },
+      onclose: err => {
+        expect(err).toBeUndefined()
+        done2.resolve()
+      },
+    })
+
+    await sync2.start()
+    await done2.promise
+
+    expect(ids2.length).toBe(0)
+
+    sync2.close()
+
+    // third sync with 4 events removed
+    const storage3 = new NegentropyStorageVector()
+
+    // shuffle
+    ids1.sort(() => Math.random() - 0.5)
+    const removedEvents = ids1.slice(0, 1 + Math.floor(Math.random() * ids1.length - 1))
+    for (const evt of events1) {
+      if (!removedEvents.includes(evt.id)) {
+        storage3.insert(evt.created_at, evt.id)
+      }
+    }
+    storage3.seal()
+
+    let ids3: string[] = []
+    const done3 = Promise.withResolvers()
+    const sync3 = new NegentropySync(relay, storage3, filter, {
+      onneed: (id: string) => {
+        ids3.push(id)
+      },
+      onclose: err => {
+        expect(err).toBeUndefined()
+        done3.resolve()
+      },
+    })
+
+    await sync3.start()
+    await done3.promise
+
+    expect(ids3.sort()).toEqual(removedEvents.sort())
+
+    sync3.close()
+  })
+})
--- a/nip77.ts
+++ b/nip77.ts
@@ -0,0 +1,607 @@
+import { bytesToHex, hexToBytes } from '@noble/ciphers/utils'
+import { Filter } from './filter.ts'
+import { AbstractRelay, Subscription } from './relay.ts'
+import { sha256 } from '@noble/hashes/sha256'
+
+// Negentropy implementation by Doug Hoyte
+const PROTOCOL_VERSION = 0x61 // Version 1
+const ID_SIZE = 32
+const FINGERPRINT_SIZE = 16
+
+const Mode = {
+  Skip: 0,
+  Fingerprint: 1,
+  IdList: 2,
+}
+
+class WrappedBuffer {
+  _raw: Uint8Array
+  length: number
+
+  constructor(buffer?: Uint8Array | number) {
+    if (typeof buffer === 'number') {
+      this._raw = new Uint8Array(buffer)
+      this.length = 0
+    } else if (buffer instanceof Uint8Array) {
+      this._raw = new Uint8Array(buffer)
+      this.length = buffer.length
+    } else {
+      this._raw = new Uint8Array(512)
+      this.length = 0
+    }
+  }
+
+  unwrap(): Uint8Array {
+    return this._raw.subarray(0, this.length)
+  }
+
+  get capacity(): number {
+    return this._raw.byteLength
+  }
+
+  extend(buf: Uint8Array | WrappedBuffer): void {
+    if (buf instanceof WrappedBuffer) buf = buf.unwrap()
+    if (typeof buf.length !== 'number') throw Error('bad length')
+    const targetSize = buf.length + this.length
+    if (this.capacity < targetSize) {
+      const oldRaw = this._raw
+      const newCapacity = Math.max(this.capacity * 2, targetSize)
+      this._raw = new Uint8Array(newCapacity)
+      this._raw.set(oldRaw)
+    }
+
+    this._raw.set(buf, this.length)
+    this.length += buf.length
+  }
+
+  shift(): number {
+    const first = this._raw[0]
+    this._raw = this._raw.subarray(1)
+    this.length--
+    return first
+  }
+
+  shiftN(n: number = 1): Uint8Array {
+    const firstSubarray = this._raw.subarray(0, n)
+    this._raw = this._raw.subarray(n)
+    this.length -= n
+    return firstSubarray
+  }
+}
+
+function decodeVarInt(buf: WrappedBuffer): number {
+  let res = 0
+
+  while (1) {
+    if (buf.length === 0) throw Error('parse ends prematurely')
+    let byte = buf.shift()
+    res = (res << 7) | (byte & 127)
+    if ((byte & 128) === 0) break
+  }
+
+  return res
+}
+
+function encodeVarInt(n: number): WrappedBuffer {
+  if (n === 0) return new WrappedBuffer(new Uint8Array([0]))
+
+  let o: number[] = []
+
+  while (n !== 0) {
+    o.push(n & 127)
+    n >>>= 7
+  }
+
+  o.reverse()
+
+  for (let i = 0; i < o.length - 1; i++) o[i] |= 128
+
+  return new WrappedBuffer(new Uint8Array(o))
+}
+
+function getByte(buf: WrappedBuffer): number {
+  return getBytes(buf, 1)[0]
+}
+
+function getBytes(buf: WrappedBuffer, n: number): Uint8Array {
+  if (buf.length < n) throw Error('parse ends prematurely')
+  return buf.shiftN(n)
+}
+
+class Accumulator {
+  buf!: Uint8Array
+
+  constructor() {
+    this.setToZero()
+  }
+
+  setToZero(): void {
+    this.buf = new Uint8Array(ID_SIZE)
+  }
+
+  add(otherBuf: Uint8Array): void {
+    let currCarry = 0,
+      nextCarry = 0
+    let p = new DataView(this.buf.buffer)
+    let po = new DataView(otherBuf.buffer)
+
+    for (let i = 0; i < 8; i++) {
+      let offset = i * 4
+      let orig = p.getUint32(offset, true)
+      let otherV = po.getUint32(offset, true)
+
+      let next = orig
+
+      next += currCarry
+      next += otherV
+      if (next > 0xffffffff) nextCarry = 1
+
+      p.setUint32(offset, next & 0xffffffff, true)
+      currCarry = nextCarry
+      nextCarry = 0
+    }
+  }
+
+  negate(): void {
+    let p = new DataView(this.buf.buffer)
+
+    for (let i = 0; i < 8; i++) {
+      let offset = i * 4
+      p.setUint32(offset, ~p.getUint32(offset, true))
+    }
+
+    let one = new Uint8Array(ID_SIZE)
+    one[0] = 1
+    this.add(one)
+  }
+
+  getFingerprint(n: number): Uint8Array {
+    let input = new WrappedBuffer()
+    input.extend(this.buf)
+    input.extend(encodeVarInt(n))
+
+    let hash = sha256(input.unwrap())
+    return hash.subarray(0, FINGERPRINT_SIZE)
+  }
+}
+
+export class NegentropyStorageVector {
+  items: { timestamp: number; id: Uint8Array }[]
+  sealed: boolean
+
+  constructor() {
+    this.items = []
+    this.sealed = false
+  }
+
+  insert(timestamp: number, id: string): void {
+    if (this.sealed) throw Error('already sealed')
+    const idb = hexToBytes(id)
+    if (idb.byteLength !== ID_SIZE) throw Error('bad id size for added item')
+    this.items.push({ timestamp, id: idb })
+  }
+
+  seal(): void {
+    if (this.sealed) throw Error('already sealed')
+    this.sealed = true
+
+    this.items.sort(itemCompare)
+
+    for (let i = 1; i < this.items.length; i++) {
+      if (itemCompare(this.items[i - 1], this.items[i]) === 0) throw Error('duplicate item inserted')
+    }
+  }
+
+  unseal(): void {
+    this.sealed = false
+  }
+
+  size(): number {
+    this._checkSealed()
+    return this.items.length
+  }
+
+  getItem(i: number): { timestamp: number; id: Uint8Array } {
+    this._checkSealed()
+    if (i >= this.items.length) throw Error('out of range')
+    return this.items[i]
+  }
+
+  iterate(begin: number, end: number, cb: (item: { timestamp: number; id: Uint8Array }, i: number) => boolean): void {
+    this._checkSealed()
+    this._checkBounds(begin, end)
+
+    for (let i = begin; i < end; ++i) {
+      if (!cb(this.items[i], i)) break
+    }
+  }
+
+  findLowerBound(begin: number, end: number, bound: { timestamp: number; id: Uint8Array }): number {
+    this._checkSealed()
+    this._checkBounds(begin, end)
+
+    return this._binarySearch(this.items, begin, end, a => itemCompare(a, bound) < 0)
+  }
+
+  fingerprint(begin: number, end: number): Uint8Array {
+    let out = new Accumulator()
+    out.setToZero()
+
+    this.iterate(begin, end, item => {
+      out.add(item.id)
+      return true
+    })
+
+    return out.getFingerprint(end - begin)
+  }
+
+  _checkSealed(): void {
+    if (!this.sealed) throw Error('not sealed')
+  }
+
+  _checkBounds(begin: number, end: number): void {
+    if (begin > end || end > this.items.length) throw Error('bad range')
+  }
+
+  _binarySearch(
+    arr: { timestamp: number; id: Uint8Array }[],
+    first: number,
+    last: number,
+    cmp: (a: { timestamp: number; id: Uint8Array }) => boolean,
+  ): number {
+    let count = last - first
+
+    while (count > 0) {
+      let it = first
+      let step = Math.floor(count / 2)
+      it += step
+
+      if (cmp(arr[it])) {
+        first = ++it
+        count -= step + 1
+      } else {
+        count = step
+      }
+    }
+
+    return first
+  }
+}
+
+export class Negentropy {
+  storage: NegentropyStorageVector
+  frameSizeLimit: number
+  lastTimestampIn: number
+  lastTimestampOut: number
+
+  constructor(storage: NegentropyStorageVector, frameSizeLimit: number = 60_000) {
+    if (frameSizeLimit < 4096) throw Error('frameSizeLimit too small')
+
+    this.storage = storage
+    this.frameSizeLimit = frameSizeLimit
+
+    this.lastTimestampIn = 0
+    this.lastTimestampOut = 0
+  }
+
+  _bound(timestamp: number, id?: Uint8Array): { timestamp: number; id: Uint8Array } {
+    return { timestamp, id: id || new Uint8Array(0) }
+  }
+
+  initiate(): string {
+    let output = new WrappedBuffer()
+    output.extend(new Uint8Array([PROTOCOL_VERSION]))
+    this.splitRange(0, this.storage.size(), this._bound(Number.MAX_VALUE), output)
+    return bytesToHex(output.unwrap())
+  }
+
+  reconcile(queryMsg: string, onhave?: (id: string) => void, onneed?: (id: string) => void): string | null {
+    const query = new WrappedBuffer(hexToBytes(queryMsg))
+
+    this.lastTimestampIn = this.lastTimestampOut = 0 // reset for each message
+
+    let fullOutput = new WrappedBuffer()
+    fullOutput.extend(new Uint8Array([PROTOCOL_VERSION]))
+
+    let protocolVersion = getByte(query)
+    if (protocolVersion < 0x60 || protocolVersion > 0x6f) throw Error('invalid negentropy protocol version byte')
+    if (protocolVersion !== PROTOCOL_VERSION) {
+      throw Error('unsupported negentropy protocol version requested: ' + (protocolVersion - 0x60))
+    }
+
+    let storageSize = this.storage.size()
+    let prevBound = this._bound(0)
+    let prevIndex = 0
+    let skip = false
+
+    while (query.length !== 0) {
+      let o = new WrappedBuffer()
+
+      let doSkip = () => {
+        if (skip) {
+          skip = false
+          o.extend(this.encodeBound(prevBound))
+          o.extend(encodeVarInt(Mode.Skip))
+        }
+      }
+
+      let currBound = this.decodeBound(query)
+      let mode = decodeVarInt(query)
+
+      let lower = prevIndex
+      let upper = this.storage.findLowerBound(prevIndex, storageSize, currBound)
+
+      if (mode === Mode.Skip) {
+        skip = true
+      } else if (mode === Mode.Fingerprint) {
+        let theirFingerprint = getBytes(query, FINGERPRINT_SIZE)
+        let ourFingerprint = this.storage.fingerprint(lower, upper)
+
+        if (compareUint8Array(theirFingerprint, ourFingerprint) !== 0) {
+          doSkip()
+          this.splitRange(lower, upper, currBound, o)
+        } else {
+          skip = true
+        }
+      } else if (mode === Mode.IdList) {
+        let numIds = decodeVarInt(query)
+
+        let theirElems: { [key: string]: Uint8Array } = {} // stringified Uint8Array -> original Uint8Array (or hex)
+        for (let i = 0; i < numIds; i++) {
+          let e = getBytes(query, ID_SIZE)
+          theirElems[bytesToHex(e)] = e
+        }
+
+        skip = true
+        this.storage.iterate(lower, upper, item => {
+          let k = item.id
+          const id = bytesToHex(k)
+
+          if (!theirElems[id]) {
+            // ID exists on our side, but not their side
+            onhave?.(id)
+          } else {
+            // ID exists on both sides
+            delete theirElems[bytesToHex(k)]
+          }
+
+          return true
+        })
+
+        if (onneed) {
+          for (let v of Object.values(theirElems)) {
+            // ID exists on their side, but not our side
+            onneed(bytesToHex(v))
+          }
+        }
+      } else {
+        throw Error('unexpected mode')
+      }
+
+      if (this.exceededFrameSizeLimit(fullOutput.length + o.length)) {
+        // frameSizeLimit exceeded: stop range processing and return a fingerprint for the remaining range
+        let remainingFingerprint = this.storage.fingerprint(upper, storageSize)
+
+        fullOutput.extend(this.encodeBound(this._bound(Number.MAX_VALUE)))
+        fullOutput.extend(encodeVarInt(Mode.Fingerprint))
+        fullOutput.extend(remainingFingerprint)
+        break
+      } else {
+        fullOutput.extend(o)
+      }
+
+      prevIndex = upper
+      prevBound = currBound
+    }
+
+    return fullOutput.length === 1 ? null : bytesToHex(fullOutput.unwrap())
+  }
+
+  splitRange(lower: number, upper: number, upperBound: { timestamp: number; id: Uint8Array }, o: WrappedBuffer) {
+    let numElems = upper - lower
+    let buckets = 16
+
+    if (numElems < buckets * 2) {
+      o.extend(this.encodeBound(upperBound))
+      o.extend(encodeVarInt(Mode.IdList))
+
+      o.extend(encodeVarInt(numElems))
+      this.storage.iterate(lower, upper, item => {
+        o.extend(item.id)
+        return true
+      })
+    } else {
+      let itemsPerBucket = Math.floor(numElems / buckets)
+      let bucketsWithExtra = numElems % buckets
+      let curr = lower
+
+      for (let i = 0; i < buckets; i++) {
+        let bucketSize = itemsPerBucket + (i < bucketsWithExtra ? 1 : 0)
+        let ourFingerprint = this.storage.fingerprint(curr, curr + bucketSize)
+        curr += bucketSize
+
+        let nextBound: { timestamp: number; id: Uint8Array }
+
+        if (curr === upper) {
+          nextBound = upperBound
+        } else {
+          let prevItem: { timestamp: number; id: Uint8Array } | undefined
+          let currItem: { timestamp: number; id: Uint8Array } | undefined
+
+          this.storage.iterate(curr - 1, curr + 1, (item, index) => {
+            if (index === curr - 1) prevItem = item
+            else currItem = item
+            return true
+          })
+
+          nextBound = this.getMinimalBound(prevItem!, currItem!)
+        }
+
+        o.extend(this.encodeBound(nextBound))
+        o.extend(encodeVarInt(Mode.Fingerprint))
+        o.extend(ourFingerprint)
+      }
+    }
+  }
+
+  exceededFrameSizeLimit(n: number): boolean {
+    return n > this.frameSizeLimit - 200
+  }
+
+  // Decoding
+  decodeTimestampIn(encoded: WrappedBuffer): number {
+    let timestamp = decodeVarInt(encoded)
+    timestamp = timestamp === 0 ? Number.MAX_VALUE : timestamp - 1
+    if (this.lastTimestampIn === Number.MAX_VALUE || timestamp === Number.MAX_VALUE) {
+      this.lastTimestampIn = Number.MAX_VALUE
+      return Number.MAX_VALUE
+    }
+    timestamp += this.lastTimestampIn
+    this.lastTimestampIn = timestamp
+    return timestamp
+  }
+
+  decodeBound(encoded: WrappedBuffer): { timestamp: number; id: Uint8Array } {
+    let timestamp = this.decodeTimestampIn(encoded)
+    let len = decodeVarInt(encoded)
+    if (len > ID_SIZE) throw Error('bound key too long')
+    let id = getBytes(encoded, len)
+    return { timestamp, id }
+  }
+
+  // Encoding
+  encodeTimestampOut(timestamp: number): WrappedBuffer {
+    if (timestamp === Number.MAX_VALUE) {
+      this.lastTimestampOut = Number.MAX_VALUE
+      return encodeVarInt(0)
+    }
+
+    let temp = timestamp
+    timestamp -= this.lastTimestampOut
+    this.lastTimestampOut = temp
+    return encodeVarInt(timestamp + 1)
+  }
+
+  encodeBound(key: { timestamp: number; id: Uint8Array }): WrappedBuffer {
+    let output = new WrappedBuffer()
+
+    output.extend(this.encodeTimestampOut(key.timestamp))
+    output.extend(encodeVarInt(key.id.length))
+    output.extend(key.id)
+
+    return output
+  }
+
+  getMinimalBound(
+    prev: { timestamp: number; id: Uint8Array },
+    curr: { timestamp: number; id: Uint8Array },
+  ): { timestamp: number; id: Uint8Array } {
+    if (curr.timestamp !== prev.timestamp) {
+      return this._bound(curr.timestamp)
+    } else {
+      let sharedPrefixBytes = 0
+      let currKey = curr.id
+      let prevKey = prev.id
+
+      for (let i = 0; i < ID_SIZE; i++) {
+        if (currKey[i] !== prevKey[i]) break
+        sharedPrefixBytes++
+      }
+
+      return this._bound(curr.timestamp, curr.id.subarray(0, sharedPrefixBytes + 1))
+    }
+  }
+}
+
+function compareUint8Array(a: Uint8Array, b: Uint8Array): number {
+  for (let i = 0; i < a.byteLength; i++) {
+    if (a[i] < b[i]) return -1
+    if (a[i] > b[i]) return 1
+  }
+
+  if (a.byteLength > b.byteLength) return 1
+  if (a.byteLength < b.byteLength) return -1
+
+  return 0
+}
+
+function itemCompare(a: { timestamp: number; id: Uint8Array }, b: { timestamp: number; id: Uint8Array }): number {
+  if (a.timestamp === b.timestamp) {
+    return compareUint8Array(a.id, b.id)
+  }
+
+  return a.timestamp - b.timestamp
+}
+
+export class NegentropySync {
+  relay: AbstractRelay
+  storage: NegentropyStorageVector
+  private neg: Negentropy
+  private filter: Filter
+  private subscription: Subscription
+  private onhave?: (id: string) => void
+  private onneed?: (id: string) => void
+
+  constructor(
+    relay: AbstractRelay,
+    storage: NegentropyStorageVector,
+    filter: Filter,
+    params: {
+      label?: string
+      onhave?: (id: string) => void
+      onneed?: (id: string) => void
+      onclose?: (errReason?: string) => void
+    } = {},
+  ) {
+    this.relay = relay
+    this.storage = storage
+    this.neg = new Negentropy(storage)
+    this.onhave = params.onhave
+    this.onneed = params.onneed
+    this.filter = filter
+
+    // we prepare a subscription with an empty filter, but it will not be used
+    this.subscription = this.relay.prepareSubscription([{}], { label: params.label || 'negentropy' })
+    this.subscription.oncustom = (data: string[]) => {
+      switch (data[0]) {
+        case 'NEG-MSG': {
+          if (data.length < 3) {
+            console.warn(`got invalid NEG-MSG from ${this.relay.url}: ${data}`)
+          }
+          try {
+            const response = this.neg.reconcile(data[2], this.onhave, this.onneed)
+            if (response) {
+              this.relay.send(`["NEG-MSG", "${this.subscription.id}", "${response}"]`)
+            } else {
+              this.close()
+              params.onclose?.()
+            }
+          } catch (error) {
+            console.error('negentropy reconcile error:', error)
+            params?.onclose?.(`reconcile error: ${error}`)
+          }
+          break
+        }
+        case 'NEG-CLOSE': {
+          const reason = data[2]
+          console.warn('negentropy error:', reason)
+          params.onclose?.(reason)
+          break
+        }
+        case 'NEG-ERR': {
+          params.onclose?.()
+        }
+      }
+    }
+  }
+
+  async start(): Promise<void> {
+    const initMsg = this.neg.initiate()
+    this.relay.send(`["NEG-OPEN","${this.subscription.id}",${JSON.stringify(this.filter)},"${initMsg}"]`)
+  }
+
+  close(): void {
+    this.relay.send(`["NEG-CLOSE","${this.subscription.id}"]`)
+    this.subscription.close()
+  }
+}
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
  "type": "module",
  "name": "nostr-tools",
-  "version": "2.15.0",
+  "version": "2.18.2",
  "description": "Tools for making a Nostr client.",
  "repository": {
    "type": "git",
--- a/pool.test.ts
+++ b/pool.test.ts
@@ -35,14 +35,18 @@ test('removing duplicates when subscribing', async () => {
    priv,
  )

-  pool.subscribeMany(relayURLs, [{ authors: [pub] }], {
-    onevent(event: Event) {
-      // this should be called only once even though we're listening
-      // to multiple relays because the events will be caught and
-      // deduplicated efficiently (without even being parsed)
-      received.push(event)
+  pool.subscribeMany(
+    relayURLs,
+    { authors: [pub] },
+    {
+      onevent(event: Event) {
+        // this should be called only once even though we're listening
+        // to multiple relays because the events will be caught and
+        // deduplicated efficiently (without even being parsed)
+        received.push(event)
+      },
    },
-  })
+  )

  await Promise.any(pool.publish(relayURLs, event))
  await new Promise(resolve => setTimeout(resolve, 200)) // wait for the new published event to be received
@@ -55,16 +59,24 @@ test('same with double subs', async () => {
  let priv = generateSecretKey()
  let pub = getPublicKey(priv)

-  pool.subscribeMany(relayURLs, [{ authors: [pub] }], {
-    onevent(event) {
-      received.push(event)
+  pool.subscribeMany(
+    relayURLs,
+    { authors: [pub] },
+    {
+      onevent(event) {
+        received.push(event)
+      },
    },
-  })
-  pool.subscribeMany(relayURLs, [{ authors: [pub] }], {
-    onevent(event) {
-      received.push(event)
+  )
+  pool.subscribeMany(
+    relayURLs,
+    { authors: [pub] },
+    {
+      onevent(event) {
+        received.push(event)
+      },
    },
-  })
+  )

  let received: Event[] = []

@@ -168,12 +180,16 @@ test('query a bunch of events and cancel on eose', async () => {
  let events = new Set<string>()

  await new Promise<void>(resolve => {
-    pool.subscribeManyEose(relayURLs, [{ kinds: [0, 1, 2, 3, 4, 5, 6], limit: 40 }], {
-      onevent(event) {
-        events.add(event.id)
+    pool.subscribeManyEose(
+      relayURLs,
+      { kinds: [0, 1, 2, 3, 4, 5, 6], limit: 40 },
+      {
+        onevent(event) {
+          events.add(event.id)
+        },
+        onclose: resolve as any,
      },
-      onclose: resolve as any,
-    })
+    )
  })

  expect(events.size).toBeGreaterThan(50)
@@ -206,6 +222,151 @@ test('get()', async () => {
  expect(event).toHaveProperty('id', ids[0])
 })

+test('ping-pong timeout in pool', async () => {
+  const mockRelay = mockRelays[0]
+  pool = new SimplePool({ enablePing: true })
+  const relay = await pool.ensureRelay(mockRelay.url)
+  relay.pingTimeout = 50
+  relay.pingFrequency = 50
+
+  let closed = false
+  const closedPromise = new Promise<void>(resolve => {
+    relay.onclose = () => {
+      closed = true
+      resolve()
+    }
+  })
+
+  expect(relay.connected).toBeTrue()
+
+  // wait for the first ping to succeed
+  await new Promise(resolve => setTimeout(resolve, 75))
+  expect(closed).toBeFalse()
+
+  // now make it unresponsive
+  mockRelay.unresponsive = true
+
+  // wait for the second ping to fail
+  await closedPromise
+
+  expect(relay.connected).toBeFalse()
+  expect(closed).toBeTrue()
+})
+
+test('reconnect on disconnect in pool', async () => {
+  const mockRelay = mockRelays[0]
+  pool = new SimplePool({ enablePing: true, enableReconnect: true })
+  const relay = await pool.ensureRelay(mockRelay.url)
+  relay.pingTimeout = 50
+  relay.pingFrequency = 50
+  relay.resubscribeBackoff = [50, 100]
+
+  let closes = 0
+  relay.onclose = () => {
+    closes++
+  }
+
+  expect(relay.connected).toBeTrue()
+
+  // wait for the first ping to succeed
+  await new Promise(resolve => setTimeout(resolve, 75))
+  expect(closes).toBe(0)
+
+  // now make it unresponsive
+  mockRelay.unresponsive = true
+
+  // wait for the second ping to fail, which will trigger a close
+  await new Promise(resolve => {
+    const interval = setInterval(() => {
+      if (closes > 0) {
+        clearInterval(interval)
+        resolve(null)
+      }
+    }, 10)
+  })
+  expect(closes).toBe(1)
+  expect(relay.connected).toBeFalse()
+
+  // now make it responsive again
+  mockRelay.unresponsive = false
+
+  // wait for reconnect
+  await new Promise(resolve => {
+    const interval = setInterval(() => {
+      if (relay.connected) {
+        clearInterval(interval)
+        resolve(null)
+      }
+    }, 10)
+  })
+
+  expect(relay.connected).toBeTrue()
+  expect(closes).toBe(1)
+})
+
+test('reconnect with filter update in pool', async () => {
+  const mockRelay = mockRelays[0]
+  const newSince = Math.floor(Date.now() / 1000)
+  pool = new SimplePool({
+    enablePing: true,
+    enableReconnect: filters => {
+      return filters.map(f => ({ ...f, since: newSince }))
+    },
+  })
+  const relay = await pool.ensureRelay(mockRelay.url)
+  relay.pingTimeout = 50
+  relay.pingFrequency = 50
+  relay.resubscribeBackoff = [50, 100]
+
+  let closes = 0
+  relay.onclose = () => {
+    closes++
+  }
+
+  expect(relay.connected).toBeTrue()
+
+  const sub = relay.subscribe([{ kinds: [1], since: 0 }], { onevent: () => {} })
+  expect(sub.filters[0].since).toBe(0)
+
+  // wait for the first ping to succeed
+  await new Promise(resolve => setTimeout(resolve, 75))
+  expect(closes).toBe(0)
+
+  // now make it unresponsive
+  mockRelay.unresponsive = true
+
+  // wait for the second ping to fail, which will trigger a close
+  await new Promise(resolve => {
+    const interval = setInterval(() => {
+      if (closes > 0) {
+        clearInterval(interval)
+        resolve(null)
+      }
+    }, 10)
+  })
+  expect(closes).toBe(1)
+  expect(relay.connected).toBeFalse()
+
+  // now make it responsive again
+  mockRelay.unresponsive = false
+
+  // wait for reconnect
+  await new Promise(resolve => {
+    const interval = setInterval(() => {
+      if (relay.connected) {
+        clearInterval(interval)
+        resolve(null)
+      }
+    }, 10)
+  })
+
+  expect(relay.connected).toBeTrue()
+  expect(closes).toBe(1)
+
+  // check if filter was updated
+  expect(sub.filters[0].since).toBe(newSince)
+})
+
 test('track relays when publishing', async () => {
  let event1 = finalizeEvent(
    {
--- a/pool.ts
+++ b/pool.ts
@@ -1,7 +1,7 @@
 /* global WebSocket */

 import { verifyEvent } from './pure.ts'
-import { AbstractSimplePool } from './abstract-pool.ts'
+import { AbstractSimplePool, type AbstractPoolConstructorOptions } from './abstract-pool.ts'

 var _WebSocket: typeof WebSocket

@@ -14,8 +14,8 @@ export function useWebSocketImplementation(websocketImplementation: any) {
 }

 export class SimplePool extends AbstractSimplePool {
-  constructor() {
-    super({ verifyEvent, websocketImplementation: _WebSocket })
+  constructor(options?: Pick<AbstractPoolConstructorOptions, 'enablePing' | 'enableReconnect'>) {
+    super({ verifyEvent, websocketImplementation: _WebSocket, ...options })
  }
 }

--- a/relay.test.ts
+++ b/relay.test.ts
@@ -117,3 +117,285 @@ test('publish timeout', async () => {
    ),
  ).rejects.toThrow('publish timed out')
 })
+
+test('ping-pong timeout (with native ping)', async () => {
+  const mockRelay = new MockRelay()
+  let pingCalled = false
+
+  // mock a native ping/pong mechanism
+  ;(MockWebSocketClient.prototype as any).ping = function (this: any) {
+    pingCalled = true
+    if (!mockRelay.unresponsive) {
+      this.dispatchEvent(new Event('pong'))
+    }
+  }
+  ;(MockWebSocketClient.prototype as any).once = function (
+    this: any,
+    event: string,
+    listener: (...args: any[]) => void,
+  ) {
+    if (event === 'pong') {
+      const onceListener = (...args: any[]) => {
+        this.removeEventListener(event, onceListener)
+        listener.apply(this, args)
+      }
+      this.addEventListener('pong', onceListener)
+    }
+  }
+
+  try {
+    const relay = new Relay(mockRelay.url, { enablePing: true })
+    relay.pingTimeout = 50
+    relay.pingFrequency = 50
+
+    let closed = false
+    const closedPromise = new Promise<void>(resolve => {
+      relay.onclose = () => {
+        closed = true
+        resolve()
+      }
+    })
+
+    await relay.connect()
+    expect(relay.connected).toBeTrue()
+
+    // wait for the first ping to succeed
+    await new Promise(resolve => setTimeout(resolve, 75))
+    expect(pingCalled).toBeTrue()
+    expect(closed).toBeFalse()
+
+    // now make it unresponsive
+    mockRelay.unresponsive = true
+
+    // wait for the second ping to fail
+    await closedPromise
+
+    expect(relay.connected).toBeFalse()
+    expect(closed).toBeTrue()
+  } finally {
+    delete (MockWebSocketClient.prototype as any).ping
+    delete (MockWebSocketClient.prototype as any).once
+  }
+})
+
+test('ping-pong timeout (no-ping browser environment)', async () => {
+  // spy on send to ensure the fallback dummy REQ is used, since MockWebSocketClient has no ping
+  const originalSend = MockWebSocketClient.prototype.send
+  let dummyReqSent = false
+
+  try {
+    MockWebSocketClient.prototype.send = function (message: string) {
+      if (message.includes('REQ') && message.includes('a'.repeat(64))) {
+        dummyReqSent = true
+      }
+      originalSend.call(this, message)
+    }
+
+    const mockRelay = new MockRelay()
+    const relay = new Relay(mockRelay.url, { enablePing: true })
+    relay.pingTimeout = 50
+    relay.pingFrequency = 50
+
+    let closed = false
+    const closedPromise = new Promise<void>(resolve => {
+      relay.onclose = () => {
+        closed = true
+        resolve()
+      }
+    })
+
+    await relay.connect()
+    expect(relay.connected).toBeTrue()
+
+    // wait for the first ping to succeed
+    await new Promise(resolve => setTimeout(resolve, 75))
+    expect(dummyReqSent).toBeTrue()
+    expect(closed).toBeFalse()
+
+    // now make it unresponsive
+    mockRelay.unresponsive = true
+
+    // wait for the second ping to fail
+    await closedPromise
+
+    expect(relay.connected).toBeFalse()
+    expect(closed).toBeTrue()
+  } finally {
+    MockWebSocketClient.prototype.send = originalSend
+  }
+})
+
+test('ping-pong listeners are cleaned up', async () => {
+  const mockRelay = new MockRelay()
+  let listenerCount = 0
+
+  // mock a native ping/pong mechanism
+  ;(MockWebSocketClient.prototype as any).ping = function (this: any) {
+    if (!mockRelay.unresponsive) {
+      this.dispatchEvent(new Event('pong'))
+    }
+  }
+
+  const originalAddEventListener = MockWebSocketClient.prototype.addEventListener
+  MockWebSocketClient.prototype.addEventListener = function (event, listener, options) {
+    if (event === 'pong') {
+      listenerCount++
+    }
+    // @ts-ignore
+    return originalAddEventListener.call(this, event, listener, options)
+  }
+
+  const originalRemoveEventListener = MockWebSocketClient.prototype.removeEventListener
+  MockWebSocketClient.prototype.removeEventListener = function (event, listener) {
+    if (event === 'pong') {
+      listenerCount--
+    }
+    // @ts-ignore
+    return originalRemoveEventListener.call(this, event, listener)
+  }
+
+  // the check in pingpong() is for .once() so we must mock it
+  ;(MockWebSocketClient.prototype as any).once = function (
+    this: any,
+    event: string,
+    listener: (...args: any[]) => void,
+  ) {
+    const onceListener = (...args: any[]) => {
+      this.removeEventListener(event, onceListener)
+      listener.apply(this, args)
+    }
+    this.addEventListener(event, onceListener)
+  }
+
+  try {
+    const relay = new Relay(mockRelay.url, { enablePing: true })
+    relay.pingTimeout = 50
+    relay.pingFrequency = 50
+
+    await relay.connect()
+    await new Promise(resolve => setTimeout(resolve, 175))
+
+    expect(listenerCount).toBeLessThan(2)
+
+    relay.close()
+  } finally {
+    delete (MockWebSocketClient.prototype as any).ping
+    delete (MockWebSocketClient.prototype as any).once
+    MockWebSocketClient.prototype.addEventListener = originalAddEventListener
+    MockWebSocketClient.prototype.removeEventListener = originalRemoveEventListener
+  }
+})
+
+test('reconnect on disconnect', async () => {
+  const mockRelay = new MockRelay()
+  const relay = new Relay(mockRelay.url, { enablePing: true, enableReconnect: true })
+  relay.pingTimeout = 50
+  relay.pingFrequency = 50
+  relay.resubscribeBackoff = [50, 100] // short backoff for testing
+
+  let closes = 0
+  relay.onclose = () => {
+    closes++
+  }
+
+  await relay.connect()
+  expect(relay.connected).toBeTrue()
+
+  // wait for the first ping to succeed
+  await new Promise(resolve => setTimeout(resolve, 75))
+  expect(closes).toBe(0)
+
+  // now make it unresponsive
+  mockRelay.unresponsive = true
+
+  // wait for the second ping to fail, which will trigger a close
+  await new Promise(resolve => {
+    const interval = setInterval(() => {
+      if (closes > 0) {
+        clearInterval(interval)
+        resolve(null)
+      }
+    }, 10)
+  })
+  expect(closes).toBe(1)
+  expect(relay.connected).toBeFalse()
+
+  // now make it responsive again
+  mockRelay.unresponsive = false
+
+  // wait for reconnect
+  await new Promise(resolve => {
+    const interval = setInterval(() => {
+      if (relay.connected) {
+        clearInterval(interval)
+        resolve(null)
+      }
+    }, 10)
+  })
+
+  expect(relay.connected).toBeTrue()
+  expect(closes).toBe(1) // should not have closed again
+})
+
+test('reconnect with filter update', async () => {
+  const mockRelay = new MockRelay()
+  const newSince = Math.floor(Date.now() / 1000)
+  const relay = new Relay(mockRelay.url, {
+    enablePing: true,
+    enableReconnect: filters => {
+      return filters.map(f => ({ ...f, since: newSince }))
+    },
+  })
+  relay.pingTimeout = 50
+  relay.pingFrequency = 50
+  relay.resubscribeBackoff = [50, 100]
+
+  let closes = 0
+  relay.onclose = () => {
+    closes++
+  }
+
+  await relay.connect()
+  expect(relay.connected).toBeTrue()
+
+  const sub = relay.subscribe([{ kinds: [1], since: 0 }], { onevent: () => {} })
+  expect(sub.filters[0].since).toBe(0)
+
+  // wait for the first ping to succeed
+  await new Promise(resolve => setTimeout(resolve, 75))
+  expect(closes).toBe(0)
+
+  // now make it unresponsive
+  mockRelay.unresponsive = true
+
+  // wait for the second ping to fail, which will trigger a close
+  await new Promise(resolve => {
+    const interval = setInterval(() => {
+      if (closes > 0) {
+        clearInterval(interval)
+        resolve(null)
+      }
+    }, 10)
+  })
+  expect(closes).toBe(1)
+  expect(relay.connected).toBeFalse()
+
+  // now make it responsive again
+  mockRelay.unresponsive = false
+
+  // wait for reconnect
+  await new Promise(resolve => {
+    const interval = setInterval(() => {
+      if (relay.connected) {
+        clearInterval(interval)
+        resolve(null)
+      }
+    }, 10)
+  })
+
+  expect(relay.connected).toBeTrue()
+  expect(closes).toBe(1)
+
+  // check if filter was updated
+  expect(sub.filters[0].since).toBe(newSince)
+})
--- a/relay.ts
+++ b/relay.ts
@@ -1,7 +1,7 @@
 /* global WebSocket */

 import { verifyEvent } from './pure.ts'
-import { AbstractRelay } from './abstract-relay.ts'
+import { AbstractRelay, type AbstractRelayConstructorOptions } from './abstract-relay.ts'

 var _WebSocket: typeof WebSocket

@@ -14,12 +14,15 @@ export function useWebSocketImplementation(websocketImplementation: any) {
 }

 export class Relay extends AbstractRelay {
-  constructor(url: string) {
-    super(url, { verifyEvent, websocketImplementation: _WebSocket })
+  constructor(url: string, options?: Pick<AbstractRelayConstructorOptions, 'enablePing' | 'enableReconnect'>) {
+    super(url, { verifyEvent, websocketImplementation: _WebSocket, ...options })
  }

-  static async connect(url: string): Promise<Relay> {
-    const relay = new Relay(url)
+  static async connect(
+    url: string,
+    options?: Pick<AbstractRelayConstructorOptions, 'enablePing' | 'enableReconnect'>,
+  ): Promise<Relay> {
+    const relay = new Relay(url, options)
    await relay.connect()
    return relay
  }
--- a/test-helpers.ts
+++ b/test-helpers.ts
@@ -26,6 +26,7 @@ export class MockRelay {
  public url: string
  public secretKeys: Uint8Array[]
  public preloadedEvents: Event[]
+  public unresponsive: boolean = false

  constructor(url?: string | undefined) {
    serial++
@@ -48,6 +49,7 @@ export class MockRelay {
      let subs: { [subId: string]: { conn: any; filters: Filter[] } } = {}

      conn.on('message', (message: string) => {
+        if (this.unresponsive) return
        const data = JSON.parse(message)

        switch (data[0]) {
--- a/utils.test.ts
+++ b/utils.test.ts
@@ -1,6 +1,12 @@
 import { describe, test, expect } from 'bun:test'
 import { buildEvent } from './test-helpers.ts'
-import { Queue, insertEventIntoAscendingList, insertEventIntoDescendingList, binarySearch } from './utils.ts'
+import {
+  Queue,
+  insertEventIntoAscendingList,
+  insertEventIntoDescendingList,
+  binarySearch,
+  normalizeURL,
+} from './utils.ts'

 import type { Event } from './core.ts'

@@ -263,3 +269,43 @@ test('binary search', () => {
  expect(binarySearch(['a', 'b', 'd', 'e'], b => ('a' < b ? -1 : 'a' === b ? 0 : 1))).toEqual([0, true])
  expect(binarySearch(['a', 'b', 'd', 'e'], b => ('[' < b ? -1 : '[' === b ? 0 : 1))).toEqual([0, false])
 })
+
+describe('normalizeURL', () => {
+  test('normalizes wss:// URLs', () => {
+    expect(normalizeURL('wss://example.com')).toBe('wss://example.com/')
+    expect(normalizeURL('wss://example.com/')).toBe('wss://example.com/')
+    expect(normalizeURL('wss://example.com//path')).toBe('wss://example.com/path')
+    expect(normalizeURL('wss://example.com:443')).toBe('wss://example.com/')
+  })
+
+  test('normalizes https:// URLs', () => {
+    expect(normalizeURL('https://example.com')).toBe('wss://example.com/')
+    expect(normalizeURL('https://example.com/')).toBe('wss://example.com/')
+    expect(normalizeURL('http://example.com//path')).toBe('ws://example.com/path')
+  })
+
+  test('normalizes ws:// URLs', () => {
+    expect(normalizeURL('ws://example.com')).toBe('ws://example.com/')
+    expect(normalizeURL('ws://example.com/')).toBe('ws://example.com/')
+    expect(normalizeURL('ws://example.com//path')).toBe('ws://example.com/path')
+    expect(normalizeURL('ws://example.com:80')).toBe('ws://example.com/')
+  })
+
+  test('adds wss:// to URLs without scheme', () => {
+    expect(normalizeURL('example.com')).toBe('wss://example.com/')
+    expect(normalizeURL('example.com/')).toBe('wss://example.com/')
+    expect(normalizeURL('example.com//path')).toBe('wss://example.com/path')
+  })
+
+  test('handles query parameters', () => {
+    expect(normalizeURL('wss://example.com?z=1&a=2')).toBe('wss://example.com/?a=2&z=1')
+  })
+
+  test('removes hash', () => {
+    expect(normalizeURL('wss://example.com#hash')).toBe('wss://example.com/')
+  })
+
+  test('throws on invalid URL', () => {
+    expect(() => normalizeURL('http://')).toThrow('Invalid URL: http://')
+  })
+})
--- a/utils.ts
+++ b/utils.ts
@@ -9,6 +9,8 @@ export function normalizeURL(url: string): string {
  try {
    if (url.indexOf('://') === -1) url = 'wss://' + url
    let p = new URL(url)
+    if (p.protocol === 'http:') p.protocol = 'ws:'
+    else if (p.protocol === 'https:') p.protocol = 'wss:'
    p.pathname = p.pathname.replace(/\/+/g, '/')
    if (p.pathname.endsWith('/')) p.pathname = p.pathname.slice(0, -1)
    if ((p.port === '80' && p.protocol === 'ws:') || (p.port === '443' && p.protocol === 'wss:')) p.port = ''
Author	SHA1	Message	Date
fiatjaf	e959409c14	fix classifyKind() test.	2025-11-25 22:21:46 -03:00
fiatjaf	8a76c4e329	fix normalizeUrl to make websocket urls out of http urls.	2025-11-25 22:20:38 -03:00
fiatjaf	34a1d8db47	kinds: more reliable regular/replaceable kind figuring.	2025-11-24 20:08:15 -03:00
fiatjaf	d3ddd490c2	nip27: test emoji behavior when no tags.	2025-11-22 22:23:03 -03:00
fiatjaf	7730e321a5	nip27: support more image, audio and video extensions.	2025-11-22 20:36:04 -03:00
fiatjaf	400d132612	nip77: negentropy tests and small fixes.	2025-11-21 19:51:55 -03:00
fiatjaf	01880b6fb5	nip27: parse emoji shortcodes and hashtags too.	2025-11-21 00:37:40 -03:00
fiatjaf	e87ffc433c	build "core" although we shouldn't.	2025-11-21 00:37:40 -03:00
fiatjaf	c45e861493	fire subscriptions. this was broken during the negentropy stuff. fixes https://github.com/nbd-wtf/nostr-tools/issues/517	2025-11-19 14:53:24 -03:00
fiatjaf	66cc55c7f0	nip77: negentropy implementation and nip77 interface. supersedes https://github.com/nbd-wtf/nostr-tools/pull/516	2025-11-18 09:33:11 -03:00
fiatjaf	5841b0936b	throw when subscription is created without filters. fixes https://github.com/nbd-wtf/nostr-tools/pull/497	2025-11-18 08:09:45 -03:00
max-gy	f5d0c0eb0f	fix prettier checks on nip77 related *ts files	2025-11-18 08:06:26 -03:00
max-gy	e19db61bec	nip77: adds wrapper for negentropy and fallback for yieldThread MessageChannel	2025-11-18 08:06:26 -03:00
Chris McCormick	1e0f393268	Fix subscribeMap EOSE grouping. Fixes #514	2025-10-29 08:18:49 -03:00
Chris McCormick	1bec9fa365	Ping pong memory leak fix for #511 (#512 ) * New test for pingpong memory leak (failing). * Shim once in relay ping mem test. * Fix pong memory leak with .once. Fixes #511. * Fix missing global WebSocket on Node. * Lint fix. * Remove overkill WebSocket impl check.	2025-10-26 23:33:38 -03:00
雪猫	e8927d78e6	nip57: lud16 must take precedence over lud06	2025-10-12 11:01:25 -03:00
Chris McCormick	bc1294e4e6	Reconnect with exponential backoff flag: `enableReconnect` (#507 ) https://github.com/nbd-wtf/nostr-tools/pull/507	2025-09-30 10:01:07 -03:00
Chris McCormick	226d7d07e2	Improvements to enablePing() & tests (#506 ) https://github.com/nbd-wtf/nostr-tools/pull/506	2025-09-29 10:41:40 -03:00
fiatjaf	c9ff51e278	subscribeMap() now sends multiple filters to the same relay in the same REQ. because the initiative to get rid of multiple filters went down.	2025-09-20 16:54:12 -03:00
Anderson Juhasc	23aebbd341	update NIP-27 example in README	2025-08-27 10:32:45 -03:00
Anderson Juhasc	a3fcd79545	ensures consistency for .jpg/.JPG, .mp4/.MP4, etc	2025-08-27 10:32:45 -03:00
tajava2006	0e6e7af934	chore: Bump version and document NIP-46 usage	2025-08-25 11:00:06 -03:00
codytseng	8866042edf	relay: ensure onclose callback is triggered	2025-08-24 22:22:38 -03:00
hoppe	ebe7df7b9e	feat(nip46): Add support for client-initiated connections in BunkerSigner (#502 ) * add: nostrconnect * fix: typo	2025-08-24 15:53:01 -03:00
fiatjaf	86235314c4	deduplicate relay URLs in pool.subscribe() and pool.subscribeMany()	2025-08-06 10:37:36 -03:00
Don	b39dac3551	nip57: include "e" tag.	2025-08-04 15:23:29 -03:00
fiatjaf	929d62bbbb	nip57: cleanup useless tests.	2025-08-01 20:28:49 -03:00
fiatjaf	b575e47844	nip57: include "k" tag.	2025-08-01 19:38:03 -03:00
fiatjaf	b076c34a2f	tag new minor because of the pingpong stuff.	2025-08-01 14:12:53 -03:00
fiatjaf	4bb3eb2d40	remove unnecessary normalizeURL() call that can throw sometimes.	2025-08-01 14:11:44 -03:00
Chris McCormick	87f2c74bb3	Get pingpong working in the browser with dummy REQ (#499 )	2025-07-24 11:22:15 -03:00
fiatjaf	4b6cc19b9c	cleanup.	2025-07-23 16:22:25 -03:00
fiatjaf	b2f3a01439	nip46: remove deprecated getRelays()	2025-07-23 16:22:16 -03:00
Chris McCormick	6ec19b618c	WIP: pingpong with logging.	2025-07-23 16:16:12 -03:00
Chris McCormick	b3cc9f50e5	WIP: hack in pingpong #495 TypeScript does not like the duck typing of .on and .ping (only valid on Node ws).	2025-07-23 16:16:12 -03:00
vornis101	de1cf0ed60	Fix JSON syntax of jsr.json	2025-07-19 08:58:05 -03:00