something

README.md

@@ -133,14 +133,6 @@ import WebSocket from 'ws'
 useWebSocketImplementation(WebSocket)
 ```
 
-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 don't report websocket disconnections due to network issues, and enabling this can increase reliability.
-
-```js
-import { SimplePool } from 'nostr-tools/pool'
-
-const pool = new SimplePool({ enablePing: true })
-```
-
 ### Parsing references (mentions) from a content based on NIP-27
 
 ```js

abstract-pool.ts

@@ -32,7 +32,6 @@ export class AbstractSimplePool {
   public trackRelays: boolean = false
 
   public verifyEvent: Nostr['verifyEvent']
-  public enablePing: boolean | undefined
   public trustedRelayURLs: Set<string> = new Set()
 
   private _WebSocket?: typeof WebSocket
@@ -40,7 +39,6 @@ export class AbstractSimplePool {
   constructor(opts: AbstractPoolConstructorOptions) {
     this.verifyEvent = opts.verifyEvent
     this._WebSocket = opts.websocketImplementation
-    this.enablePing = opts.enablePing
   }
 
   async ensureRelay(url: string, params?: { connectionTimeout?: number }): Promise<AbstractRelay> {
@@ -51,7 +49,6 @@ export class AbstractSimplePool {
       relay = new AbstractRelay(url, {
         verifyEvent: this.trustedRelayURLs.has(url) ? alwaysTrue : this.verifyEvent,
         websocketImplementation: this._WebSocket,
-        enablePing: this.enablePing,
       })
       relay.onclose = () => {
         this.relays.delete(url)
@@ -140,6 +137,8 @@ export class AbstractSimplePool {
     // open a subscription in all given relays
     const allOpened = Promise.all(
       requests.map(async ({ url, filter }, i) => {
+        url = normalizeURL(url)
+
         let relay: AbstractRelay
         try {
           relay = await this.ensureRelay(url, {

abstract-relay.ts

@@ -7,15 +7,22 @@ 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 RelayRecord = Record<string, { read: boolean; write: boolean }>
+
+export interface WebSocketBase {
+  new (url: string | URL, protocols?: string | string[] | undefined): WebSocketBaseConn
+}
+
+export interface WebSocketBaseConn {
+  onopen: ((this: WebSocketBaseConn, ev: Event) => any) | null
+  onclose: ((this: WebSocketBaseConn) => void) | null
+  onerror: ((this: WebSocketBaseConn, _: MessageEvent<any>) => void) | null
+  onmessage: ((_: MessageEvent<any>) => void) | null
 }
 
 export type AbstractRelayConstructorOptions = {
   verifyEvent: Nostr['verifyEvent']
-  websocketImplementation?: typeof WebSocket
-  enablePing?: boolean
+  websocketImplementation?: WebSocketBase
 }
 
 export class SendingOnClosedConnection extends Error {
@@ -35,16 +42,13 @@ export class AbstractRelay {
   public baseEoseTimeout: number = 4400
   public connectionTimeout: number = 4400
   public publishTimeout: number = 4400
-  public pingFrequency: number = 20000
-  public pingTimeout: number = 20000
   public openSubs: Map<string, Subscription> = new Map()
-  public enablePing: boolean | undefined
   private connectionTimeoutHandle: ReturnType<typeof setTimeout> | undefined
 
   private connectionPromise: Promise<void> | undefined
   private openCountRequests = new Map<string, CountResolver>()
   private openEventPublishes = new Map<string, EventPublishResolver>()
-  private ws: RelayWebSocket | undefined
+  private ws: WebSocket | undefined
   private incomingMessageQueue = new Queue<string>()
   private queueRunning = false
   private challenge: string | undefined
@@ -52,13 +56,12 @@ export class AbstractRelay {
   private serial: number = 0
   private verifyEvent: Nostr['verifyEvent']
 
-  private _WebSocket: typeof WebSocket
+  private _WebSocket: WebSocketBase
 
   constructor(url: string, opts: AbstractRelayConstructorOptions) {
     this.url = normalizeURL(url)
     this.verifyEvent = opts.verifyEvent
     this._WebSocket = opts.websocketImplementation || WebSocket
-    this.enablePing = opts.enablePing
   }
 
   static async connect(url: string, opts: AbstractRelayConstructorOptions): Promise<AbstractRelay> {
@@ -112,9 +115,6 @@ export class AbstractRelay {
       this.ws.onopen = () => {
         clearTimeout(this.connectionTimeoutHandle)
         this._connected = true
-        if (this.enablePing) {
-          this.pingpong()
-        }
         resolve()
       }
 
@@ -146,53 +146,6 @@ export class AbstractRelay {
     return this.connectionPromise
   }
 
-  private async waitForPingPong() {
-    return new Promise((res, err) => {
-      // listen for pong
-      ;(this.ws && this.ws.on && this.ws.on('pong', () => res(true))) || err("ws can't listen for pong")
-      // send a ping
-      this.ws && this.ws.ping && this.ws.ping()
-    })
-  }
-
-  private async waitForDummyReq() {
-    return new Promise((res, err) => {
-      // make a dummy request with expected empty eose reply
-      // ["REQ", "_", {"ids":["aaaa...aaaa"]}]
-      const sub = this.subscribe([{ ids: ['a'.repeat(64)] }], {
-        oneose: () => {
-          sub.close()
-          res(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.on ? this.waitForPingPong() : this.waitForDummyReq(),
-        new Promise(res => setTimeout(() => res(false), this.pingTimeout)),
-      ])
-      if (result) {
-        // schedule another pingpong
-        setTimeout(() => this.pingpong(), this.pingFrequency)
-      } else {
-        // pingpong closing socket
-        this.closeAllSubscriptions('pingpong timed out')
-        this._connected = false
-        this.ws?.close()
-        this.onclose?.()
-      }
-    }
-  }
-
   private async runQueue() {
     this.queueRunning = true
     while (true) {

jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@nostr/tools",
-  "version": "2.16.1",
+  "version": "2.15.1",
   "exports": {
     ".": "./index.ts",
     "./core": "./core.ts",

justfile

@@ -13,7 +13,7 @@ test-only file:
 
 publish: build
   # publish to jsr first because it is more strict and will catch some errors
-  perl -i -0pe "s/},\n  \"optionalDependencies\": {\n/,/" package.json
+  jq 'delete(.optionalDependencies)' package.json | sponge package.json
   jsr publish --allow-dirty
   git checkout -- package.json
 

nip19.test.ts

@@ -1,5 +1,4 @@
 import { describe, expect, test } from 'bun:test'
-// prettier-ignore
 import {
   decode,
   naddrEncode,

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 { decode, NostrTypeGuard } from './nip19.ts'
+import { AddressPointer, decode, NostrTypeGuard } from './nip19.ts'
 import { normalizeURL } from './utils.ts'
 
 /**

nip46.ts

@@ -5,6 +5,7 @@ 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
@@ -237,6 +238,13 @@ 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.

nip57.test.ts

@@ -1,7 +1,112 @@
-import { describe, test, expect } from 'bun:test'
+import { describe, test, expect, mock } from 'bun:test'
 import { finalizeEvent } from './pure.ts'
 import { getPublicKey, generateSecretKey } from './pure.ts'
-import { getSatoshisAmountFromBolt11, makeZapReceipt, validateZapRequest } from './nip57.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'],
+      ]),
+    )
+  })
+})
 
 describe('validateZapRequest', () => {
   test('returns an error message for invalid JSON', () => {

nip57.ts

@@ -1,6 +1,6 @@
 import { bech32 } from '@scure/base'
 
-import { NostrEvent, validateEvent, verifyEvent, type Event, type EventTemplate } from './pure.ts'
+import { validateEvent, verifyEvent, type Event, type EventTemplate } from './pure.ts'
 import { utf8Decoder } from './utils.ts'
 import { isReplaceableKind, isAddressableKind } from './kinds.ts'
 
@@ -42,43 +42,48 @@ export async function getZapEndpoint(metadata: Event): Promise<null | string> {
   return null
 }
 
-type ProfileZap = {
-  pubkey: string
+export function makeZapRequest({
+  profile,
+  event,
+  amount,
+  relays,
+  comment = '',
+}: {
+  profile: string
+  event: string | Event | null
   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: params.comment || '',
+    content: comment,
     tags: [
-      ['p', 'pubkey' in params ? params.pubkey : params.event.pubkey],
-      ['amount', params.amount.toString()],
-      ['relays', ...params.relays],
+      ['p', profile],
+      ['amount', amount.toString()],
+      ['relays', ...relays],
     ],
   }
 
-  if ('event' in params) {
-    if (isReplaceableKind(params.event.kind)) {
-      const a = ['a', `${params.event.kind}:${params.event.pubkey}:`]
+  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}:`]
       zr.tags.push(a)
-    } else if (isAddressableKind(params.event.kind)) {
-      let d = params.event.tags.find(([t, v]) => t === 'd' && v)
+      // addressable event
+    } else if (isAddressableKind(event.kind)) {
+      let d = event.tags.find(([t, v]) => t === 'd' && v)
       if (!d) throw new Error('d tag not found or is empty')
-      const a = ['a', `${params.event.kind}:${params.event.pubkey}:${d[1]}`]
+      const a = ['a', `${event.kind}:${event.pubkey}:${d[1]}`]
       zr.tags.push(a)
     }
-    zr.tags.push(['k', params.event.kind.toString()])
   }
 
   return zr

node-ws-relay.ts

@@ -0,0 +1,29 @@
+import WebSocket from 'ws'
+import { verifyEvent } from './pure.ts'
+import { AbstractRelay, WebSocketBase } from './abstract-relay.ts'
+
+class NodeWs extends WebSocket implements WebSocketBase {
+  constructor(url: string | URL, protocols?: string | string[] | undefined) {
+    super(url, {
+      protocol: Array.isArray(protocols) ? protocols[0] : protocols,
+    })
+
+    setInterval(() => {
+      this.ping()
+    }, 29000)
+  }
+}
+
+export class NodeWsRelay extends AbstractRelay {
+  constructor(url: string) {
+    super(url, { verifyEvent, websocketImplementation: NodeWs })
+  }
+
+  static async connect(url: string): Promise<NodeWsRelay> {
+    const relay = new NodeWsRelay(url)
+    await relay.connect()
+    return relay
+  }
+}
+
+export * from './abstract-relay.ts'

package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "nostr-tools",
-  "version": "2.16.1",
+  "version": "2.15.0",
   "description": "Tools for making a Nostr client.",
   "repository": {
     "type": "git",
@@ -241,12 +241,15 @@
     "@noble/hashes": "1.3.1",
     "@scure/base": "1.1.1",
     "@scure/bip32": "1.3.1",
-    "@scure/bip39": "1.2.1",
-    "nostr-wasm": "0.1.0"
+    "@scure/bip39": "1.2.1"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"
   },
+  "optionalDependencies": {
+    "nostr-wasm": "0.1.0",
+    "ws": "^8.18.3"
+  },
   "peerDependenciesMeta": {
     "typescript": {
       "optional": true

pool.ts

@@ -14,8 +14,8 @@ export function useWebSocketImplementation(websocketImplementation: any) {
 }
 
 export class SimplePool extends AbstractSimplePool {
-  constructor(options?: { enablePing?: boolean }) {
-    super({ verifyEvent, websocketImplementation: _WebSocket, ...options })
+  constructor() {
+    super({ verifyEvent, websocketImplementation: _WebSocket })
   }
 }
 

relay.ts

@@ -1,21 +1,13 @@
 /* global WebSocket */
 
 import { verifyEvent } from './pure.ts'
-import { AbstractRelay } from './abstract-relay.ts'
+import { AbstractRelay, WebSocketBaseConn } from './abstract-relay.ts'
 
-var _WebSocket: typeof WebSocket
-
-try {
-  _WebSocket = WebSocket
-} catch {}
-
-export function useWebSocketImplementation(websocketImplementation: any) {
-  _WebSocket = websocketImplementation
-}
+class BrowserWs extends WebSocket implements WebSocketBase, WebSocketBaseConn {}
 
 export class Relay extends AbstractRelay {
   constructor(url: string) {
-    super(url, { verifyEvent, websocketImplementation: _WebSocket })
+    super(url, { verifyEvent, websocketImplementation: BrowserWs })
   }
 
   static async connect(url: string): Promise<Relay> {
@@ -25,6 +17,4 @@ export class Relay extends AbstractRelay {
   }
 }
 
-export type RelayRecord = Record<string, { read: boolean; write: boolean }>
-
 export * from './abstract-relay.ts'