add onRelayConnectionSuccess to pair with onRelayConnectionFailure.

this was so obvious.

abstract-pool.ts

@@ -22,9 +22,14 @@ export type AbstractPoolConstructorOptions = AbstractRelayConstructorOptions & {
   automaticallyAuth?: (relayURL: string) => null | ((event: EventTemplate) => Promise<VerifiedEvent>)
   // onRelayConnectionFailure is called with the URL of a relay that failed the initial connection
   onRelayConnectionFailure?: (url: string) => void
+  // onRelayConnectionSuccess is called with the URL of a relay that succeeds the initial connection
+  onRelayConnectionSuccess?: (url: string) => void
   // allowConnectingToRelay takes a relay URL and the operation being performed
   // return false to skip connecting to that relay
   allowConnectingToRelay?: (url: string, operation: ['read', Filter[]] | ['write', Event]) => boolean
+  // maxWaitForConnection takes a number in milliseconds that will be given to ensureRelay such that we
+  // don't get stuck forever when attempting to connect to a relay, it is 3000 (3 seconds) by default
+  maxWaitForConnection: number
 }
 
 export type SubscribeManyParams = Omit<SubscriptionParams, 'onclose'> & {
@@ -47,7 +52,9 @@ export class AbstractSimplePool {
   public automaticallyAuth?: (relayURL: string) => null | ((event: EventTemplate) => Promise<VerifiedEvent>)
   public trustedRelayURLs: Set<string> = new Set()
   public onRelayConnectionFailure?: (url: string) => void
+  public onRelayConnectionSuccess?: (url: string) => void
   public allowConnectingToRelay?: (url: string, operation: ['read', Filter[]] | ['write', Event]) => boolean
+  public maxWaitForConnection: number
 
   private _WebSocket?: typeof WebSocket
 
@@ -58,7 +65,9 @@ export class AbstractSimplePool {
     this.enableReconnect = opts.enableReconnect || false
     this.automaticallyAuth = opts.automaticallyAuth
     this.onRelayConnectionFailure = opts.onRelayConnectionFailure
+    this.onRelayConnectionSuccess = opts.onRelayConnectionSuccess
     this.allowConnectingToRelay = opts.allowConnectingToRelay
+    this.maxWaitForConnection = opts.maxWaitForConnection || 3000
   }
 
   async ensureRelay(
@@ -199,7 +208,10 @@ export class AbstractSimplePool {
         let relay: AbstractRelay
         try {
           relay = await this.ensureRelay(url, {
-            connectionTimeout: params.maxWait ? Math.max(params.maxWait * 0.8, params.maxWait - 1000) : undefined,
+            connectionTimeout:
+              this.maxWaitForConnection < (params.maxWait || 0)
+                ? Math.max(params.maxWait! * 0.8, params.maxWait! - 1000)
+                : this.maxWaitForConnection,
             abort: params.abort,
           })
         } catch (err) {
@@ -208,6 +220,8 @@ export class AbstractSimplePool {
           return
         }
 
+        this.onRelayConnectionSuccess?.(url)
+
         let subscription = relay.subscribe(filters, {
           ...params,
           oneose: () => handleEose(i),
@@ -314,7 +328,11 @@ export class AbstractSimplePool {
   publish(
     relays: string[],
     event: Event,
-    options?: { onauth?: (evt: EventTemplate) => Promise<VerifiedEvent> },
+    params?: {
+      onauth?: (evt: EventTemplate) => Promise<VerifiedEvent>
+      maxWait?: number
+      abort?: AbortSignal
+    },
   ): Promise<string>[] {
     return relays.map(normalizeURL).map(async (url, i, arr) => {
       if (arr.indexOf(url) !== i) {
@@ -328,7 +346,13 @@ export class AbstractSimplePool {
 
       let r: Relay
       try {
-        r = await this.ensureRelay(url)
+        r = await this.ensureRelay(url, {
+          connectionTimeout:
+            this.maxWaitForConnection < (params?.maxWait || 0)
+              ? Math.max(params!.maxWait! * 0.8, params!.maxWait! - 1000)
+              : this.maxWaitForConnection,
+          abort: params?.abort,
+        })
       } catch (err) {
         this.onRelayConnectionFailure?.(url)
         return String('connection failure: ' + String(err))
@@ -337,8 +361,8 @@ export class AbstractSimplePool {
       return r
         .publish(event)
         .catch(async err => {
-          if (err instanceof Error && err.message.startsWith('auth-required: ') && options?.onauth) {
+          if (err instanceof Error && err.message.startsWith('auth-required: ') && params?.onauth) {
-            await r.auth(options.onauth)
+            await r.auth(params.onauth)
             return r.publish(event) // retry
           }
           throw err

abstract-relay.ts

@@ -45,7 +45,7 @@ export class AbstractRelay {
   private reconnectTimeoutHandle: ReturnType<typeof setTimeout> | undefined
   private pingIntervalHandle: ReturnType<typeof setInterval> | undefined
   private reconnectAttempts: number = 0
-  private closedIntentionally: boolean = false
+  private skipReconnection: boolean = false
 
   private connectionPromise: Promise<void> | undefined
   private openCountRequests = new Map<string, CountResolver>()
@@ -120,12 +120,9 @@ export class AbstractRelay {
     this._connected = false
     this.connectionPromise = undefined
 
-    const wasIntentional = this.closedIntentionally
-    this.closedIntentionally = false // reset for next time
-
     this.onclose?.()
 
-    if (this.enableReconnect && !wasIntentional) {
+    if (this.enableReconnect && !this.skipReconnection) {
       this.reconnect()
     } else {
       this.closeAllSubscriptions(reason)
@@ -139,11 +136,13 @@ export class AbstractRelay {
 
     this.challenge = undefined
     this.authPromise = undefined
+    this.skipReconnection = false
     this.connectionPromise = new Promise((resolve, reject) => {
       if (opts?.timeout) {
         connectionTimeoutHandle = setTimeout(() => {
           reject('connection timed out')
           this.connectionPromise = undefined
+          this.skipReconnection = true
           this.onclose?.()
           this.handleHardClose('relay connection timed out')
         }, opts.timeout)
@@ -153,17 +152,8 @@ export class AbstractRelay {
         opts.abort.onabort = reject
       }
 
-      const connectionFailed = () => {
-        clearTimeout(connectionTimeoutHandle)
-        reject('connection failed')
-        this.connectionPromise = undefined
-        this.onclose?.()
-        this.handleHardClose('relay connection failed')
-      }
-
       try {
         this.ws = new this._WebSocket(this.url)
-        this.ws.addEventListener('error', connectionFailed)
       } catch (err) {
         clearTimeout(connectionTimeoutHandle)
         reject(err)
@@ -171,8 +161,6 @@ export class AbstractRelay {
       }
 
       this.ws.onopen = () => {
-        this.ws?.removeEventListener('error', connectionFailed)
-
         if (this.reconnectTimeoutHandle) {
           clearTimeout(this.reconnectTimeoutHandle)
           this.reconnectTimeoutHandle = undefined
@@ -202,10 +190,13 @@ export class AbstractRelay {
         resolve()
       }
 
-      this.ws.onerror = ev => {
+      this.ws.onerror = () => {
         clearTimeout(connectionTimeoutHandle)
-        reject((ev as any).message || 'websocket error')
+        reject('connection failed')
-        this.handleHardClose('relay connection errored')
+        this.connectionPromise = undefined
+        this.skipReconnection = true
+        this.onclose?.()
+        this.handleHardClose('relay connection failed')
       }
 
       this.ws.onclose = ev => {
@@ -477,7 +468,7 @@ export class AbstractRelay {
   }
 
   public close() {
-    this.closedIntentionally = true
+    this.skipReconnection = true
     if (this.reconnectTimeoutHandle) {
       clearTimeout(this.reconnectTimeoutHandle)
       this.reconnectTimeoutHandle = undefined

jsr.json

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

package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "nostr-tools",
-  "version": "2.22.1",
+  "version": "2.22.2",
   "description": "Tools for making a Nostr client.",
   "repository": {
     "type": "git",

pool.ts

@@ -15,7 +15,7 @@ export function useWebSocketImplementation(websocketImplementation: any) {
 
 export class SimplePool extends AbstractSimplePool {
   constructor(options?: Pick<AbstractPoolConstructorOptions, 'enablePing' | 'enableReconnect'>) {
-    super({ verifyEvent, websocketImplementation: _WebSocket, ...options })
+    super({ verifyEvent, websocketImplementation: _WebSocket, maxWaitForConnection: 3000, ...options })
   }
 }