nappup 1.0.9 → 1.0.12

package/src/services/nostr-relays.js

@@ -10,10 +10,10 @@ export const seedRelays = [
   'wss://indexer.coracle.social'
 ]
 export const freeRelays = [
-  'wss://relay.damus.io',
-  'wss://relay.nostr.band',
+  'wss://relay.primal.net',
   'wss://nos.lol',
-  'wss://relay.primal.net'
+  'wss://relay.damus.io',
+  'wss://relay.nostr.band'
 ]
 
 // Interacts with Nostr relays.
@@ -27,7 +27,10 @@ export class NostrRelays {
     if (this.#relays.has(url)) {
       clearTimeout(this.#relayTimeouts.get(url))
       this.#relayTimeouts.set(url, maybeUnref(setTimeout(() => this.disconnect(url), this.#timeout)))
-      return this.#relays.get(url)
+      const relay = this.#relays.get(url)
+      // reconnect if needed to avoid SendingOnClosedConnection errors
+      await relay.connect()
+      return relay
     }
 
     const relay = new Relay(url)
@@ -61,55 +64,84 @@ export class NostrRelays {
   // Get events from a list of relays
   async getEvents (filter, relays, timeout = 5000) {
     const events = []
+    const resolveOrReject = (resolve, reject, err) => {
+      err ? reject(err) : resolve()
+    }
     const promises = relays.map(async (url) => {
+      let sub
+      let isClosed = false
+      const p = Promise.withResolvers()
+      const timer = maybeUnref(setTimeout(() => {
+        sub?.close()
+        isClosed = true
+        resolveOrReject(p.resolve, p.reject, new Error(`timeout: ${url}`))
+      }, timeout))
       try {
         const relay = await this.#getRelay(url)
-        return new Promise((resolve) => {
-          const sub = relay.subscribe([filter], {
-            onevent: (event) => {
-              events.push(event)
-            },
-            onclose: () => {
-              clearTimeout(timer)
-              resolve()
-            },
-            oneose: () => {
-              clearTimeout(timer)
-              resolve()
-            }
-          })
-          const timer = maybeUnref(setTimeout(() => {
+        sub = relay.subscribe([filter], {
+          onevent: (event) => {
+            events.push(event)
+          },
+          onclose: err => {
+            clearTimeout(timer)
+            if (isClosed) return
+            resolveOrReject(p.resolve, p.reject, err /* may be empty (closed normally) */)
+          },
+          oneose: () => {
+            clearTimeout(timer)
+            isClosed = true
             sub.close()
-            resolve()
-          }, timeout))
+            p.resolve()
+          }
         })
-      } catch (error) {
-        console.error(`Failed to get events from ${url}`, error)
+
+        await p.promise
+      } catch (err) {
+        clearTimeout(timer)
+        p.reject(err)
       }
     })
 
     const results = await Promise.allSettled(promises)
-    if (results.some(v => v.status === 'rejected')) throw new Error(results[0].reason)
-    return events
+    const rejectedResults = results.filter(v => v.status === 'rejected')
+
+    return {
+      result: events,
+      errors: rejectedResults.map(v => ({ reason: v.reason, relay: relays[results.indexOf(v)] })),
+      success: events.length > 0 || results.length !== rejectedResults.length
+    }
   }
 
   // Send an event to a list of relays.
   async sendEvent (event, relays, timeout = 3000) {
     const promises = relays.map(async (url) => {
+      let timer
       try {
-        const relay = await this.#getRelay(url)
-        const timer = maybeUnref(setTimeout(() => {
-          throw new Error(`Timeout sending event to ${url}`)
+        timer = maybeUnref(setTimeout(() => {
+          throw new Error(`timeout: ${url}`)
         }, timeout))
+        const relay = await this.#getRelay(url)
         await relay.publish(event)
+      } catch (err) {
+        if (err.message?.startsWith('duplicate:')) return
+        if (err.message?.startsWith('mute:')) {
+          console.info(`${url} - ${err.message}`)
+          return
+        }
+        throw err
+      } finally {
         clearTimeout(timer)
-      } catch (error) {
-        console.error(`Failed to send event to ${url}`, error)
       }
     })
 
     const results = await Promise.allSettled(promises)
-    if (results.some(v => v.status === 'rejected')) throw new Error(results[0].reason)
+    const rejectedResults = results.filter(v => v.status === 'rejected')
+
+    return {
+      result: null,
+      errors: rejectedResults.map(v => ({ reason: v.reason, relay: relays[results.indexOf(v)] })),
+      success: results.length !== rejectedResults.length
+    }
   }
 }
 // Share same connection.

package/src/services/nostr-signer.js

@@ -2,10 +2,11 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import * as dotenv from 'dotenv'
-import { getPublicKey, finalizeEvent } from 'nostr-tools/pure'
+import { getPublicKey } from 'nostr-tools/pure'
 import { getConversationKey, encrypt, decrypt } from 'nostr-tools/nip44'
 import nostrRelays, { seedRelays, freeRelays } from '#services/nostr-relays.js'
 import { bytesToBase16, base16ToBytes } from '#helpers/base16.js'
+import { finalizeEvent } from '#helpers/nip01.js'
 const __dirname = fileURLToPath(new URL('.', import.meta.url))
 
 const dotenvPath = process.env.DOTENV_CONFIG_PATH ?? `${__dirname}/../../.env`
@@ -54,7 +55,7 @@ export default class NostrSigner {
   async getRelays () {
     if (this.relays) return this.relays
 
-    const relayLists = await nostrRelays.getEvents({ authors: [await this.getPublicKey()], kinds: [10002], limit: 1 }, seedRelays)
+    const relayLists = (await nostrRelays.getEvents({ authors: [await this.getPublicKey()], kinds: [10002], limit: 1 }, seedRelays)).result
     const relayList = relayLists.sort((a, b) => b.created_at - a.created_at)[0]
     const rTags = (relayList?.tags ?? []).filter(v => v[0] === 'r' && /^wss?:\/\//.test(v[1]))
     if (rTags.length === 0) return (this.relays = await this.#initRelays())

package/lib/GEMINI.md

@@ -1,4 +0,0 @@
-# lib folder
-
-This is the place to add third-party libraries that don't have a
-published npm package.

package/lib/base122.js

@@ -1,171 +0,0 @@
-// https://github.com/kevinAlbs/Base122/commit/b62945c2733fa4da8792a1071e40a8b326e8dd1b
-// Provides functions for encoding/decoding data to and from base-122.
-
-const kString = 0
-const kUint8Array = 1
-const kDebug = false
-const kIllegals = [
-  0, // null
-  10, // newline
-  13, // carriage return
-  34, // double quote
-  38, // ampersand
-  92 // backslash
-]
-const kShortened = 0b111 // Uses the illegal index to signify the last two-byte char encodes <= 7 bits.
-
-/**
- * Encodes raw data into base-122.
- * @param {Uint8Array|Buffer|Array|String} rawData - The data to be encoded. This can be an array
- * or Buffer with raw data bytes or a string of bytes (i.e. the type of argument to btoa())
- * @returns {Array} The base-122 encoded data as a regular array of UTF-8 character byte values.
- */
-function encode (rawData) {
-  const dataType = typeof (rawData) === 'string' ? kString : kUint8Array
-  let curIndex = 0
-  let curBit = 0 // Points to current bit needed
-  // const curMask = 0b10000000
-  const outData = []
-  let getByte = i => rawData[i]
-
-  if (dataType === kString) {
-    getByte = (i) => {
-      const val = rawData.codePointAt(i)
-      if (val > 255) {
-        throw new Error('Unexpected code point at position: ' + i + '. Expected value [0,255]. Got: ' + val)
-      }
-      return val
-    }
-  }
-
-  // Get seven bits of input data. Returns false if there is no input left.
-  function get7 () {
-    if (curIndex >= rawData.length) return false
-    // Shift, mask, unshift to get first part.
-    const firstByte = getByte(curIndex)
-    let firstPart = ((0b11111110 >>> curBit) & firstByte) << curBit
-    // Align it to a seven bit chunk.
-    firstPart >>= 1
-    // Check if we need to go to the next byte for more bits.
-    curBit += 7
-    if (curBit < 8) return firstPart // Do not need next byte.
-    curBit -= 8
-    curIndex++
-    // Now we want bits [0..curBit] of the next byte if it exists.
-    if (curIndex >= rawData.length) return firstPart
-    const secondByte = getByte(curIndex)
-    let secondPart = ((0xFF00 >>> curBit) & secondByte) & 0xFF
-    // Align it.
-    secondPart >>= 8 - curBit
-    return firstPart | secondPart
-  }
-
-  while (true) {
-    // Grab 7 bits.
-    const bits = get7()
-    if (bits === false) break
-    debugLog('Seven input bits', print7Bits(bits), bits)
-
-    const illegalIndex = kIllegals.indexOf(bits)
-    if (illegalIndex !== -1) {
-      // Since this will be a two-byte character, get the next chunk of seven bits.
-      let nextBits = get7()
-      debugLog('Handle illegal sequence', print7Bits(bits), print7Bits(nextBits))
-
-      let b1 = 0b11000010; let b2 = 0b10000000
-      if (nextBits === false) {
-        debugLog('Last seven bits are an illegal sequence.')
-        b1 |= (0b111 & kShortened) << 2
-        nextBits = bits // Encode these bits after the shortened signifier.
-      } else {
-        b1 |= (0b111 & illegalIndex) << 2
-      }
-
-      // Push first bit onto first byte, remaining 6 onto second.
-      const firstBit = (nextBits & 0b01000000) > 0 ? 1 : 0
-      b1 |= firstBit
-      b2 |= nextBits & 0b00111111
-      outData.push(b1)
-      outData.push(b2)
-    } else {
-      outData.push(bits)
-    }
-  }
-  return outData
-}
-
-/**
- * Decodes base-122 encoded data back to the original data.
- * @param {Uint8Array|Buffer|String} rawData - The data to be decoded. This can be a Uint8Array
- * or Buffer with raw data bytes or a string of bytes (i.e. the type of argument to btoa())
- * @returns {Array} The data in a regular array representing byte values.
- */
-function decode (base122Data) {
-  const strData = typeof (base122Data) === 'string' ? base122Data : utf8DataToString(base122Data)
-  const decoded = []
-  // const decodedIndex = 0
-  let curByte = 0
-  let bitOfByte = 0
-
-  function push7 (byte) {
-    byte <<= 1
-    // Align this byte to offset for current byte.
-    curByte |= (byte >>> bitOfByte)
-    bitOfByte += 7
-    if (bitOfByte >= 8) {
-      decoded.push(curByte)
-      bitOfByte -= 8
-      // Now, take the remainder, left shift by what has been taken.
-      curByte = (byte << (7 - bitOfByte)) & 255
-    }
-  }
-
-  for (let i = 0; i < strData.length; i++) {
-    const c = strData.charCodeAt(i)
-    // Check if this is a two-byte character.
-    if (c > 127) {
-      // Note, the charCodeAt will give the codePoint, thus
-      // 0b110xxxxx 0b10yyyyyy will give => xxxxxyyyyyy
-      const illegalIndex = (c >>> 8) & 7 // 7 = 0b111.
-      // We have to first check if this is a shortened two-byte character, i.e. if it only
-      // encodes <= 7 bits.
-      if (illegalIndex !== kShortened) push7(kIllegals[illegalIndex])
-      // Always push the rest.
-      push7(c & 127)
-    } else {
-      // One byte characters can be pushed directly.
-      push7(c)
-    }
-  }
-  return decoded
-}
-
-/**
- * Converts a sequence of UTF-8 bytes to a string.
- * @param {Uint8Array|Buffer} data - The UTF-8 data.
- * @returns {String} A string with each character representing a code point.
- */
-function utf8DataToString (data) {
-  return Buffer.from(data).toString('utf-8')
-}
-
-// For debugging.
-function debugLog () {
-  if (kDebug) console.log(...arguments)
-}
-
-// For debugging.
-function print7Bits (num) {
-  return '0000000'.substring(num.toString(2).length) + num.toString(2)
-}
-
-// For debugging.
-// eslint-disable-next-line no-unused-vars
-function print8Bits (num) {
-  return '00000000'.substring(num.toString(2).length) + num.toString(2)
-}
-
-export {
-  encode,
-  decode
-}

package/src/services/base122-decoder.js

@@ -1,56 +0,0 @@
-import { decode } from '#lib/base122.js'
-
-// Decodes data from base122.
-export default class Base122Decoder {
-  textEncoder = new TextEncoder()
-
-  constructor (source, { mimeType = '' } = {}) {
-    this.sourceIterator = source?.[Symbol.iterator]?.() || source?.[Symbol.asyncIterator]?.() || source()
-    this.isText = mimeType.startsWith('text/')
-    if (this.isText) this.textDecoder = new TextDecoder()
-  }
-
-  // decoder generator
-  * [Symbol.iterator] (base122String) {
-    let bytes
-    if (this.isText) {
-      while (base122String) {
-        bytes = this.textEncoder.encode(base122String) // from string to UInt8Array
-        // stream=true avoids cutting a multi-byte character
-        base122String = yield this.textDecoder.decode(new Uint8Array(decode(bytes)), { stream: true })
-      }
-    } else {
-      while (base122String) {
-        bytes = this.textEncoder.encode(base122String)
-        base122String = yield new Uint8Array(decode(bytes))
-      }
-    }
-  }
-
-  // Gets the decoded data.
-  getDecoded () { return iteratorToStream(this, this.sourceIterator) }
-}
-
-function iteratorToStream (decoder, sourceIterator) {
-  return new ReadableStream({
-    decoderIterator: null,
-    async start (controller) {
-      const { value: chunk, done } = await sourceIterator.next()
-      if (done) return controller.close()
-
-      // Pass first chunk when instantiating the decoder generator
-      this.decoderIterator = decoder[Symbol.iterator](chunk)
-      const { value } = this.decoderIterator.next()
-      if (value) controller.enqueue(value)
-    },
-    async pull (controller) {
-      if (!this.decoderIterator) return
-
-      const { value: chunk, done: sourceDone } = await sourceIterator.next()
-      const { value, done } = this.decoderIterator.next(chunk)
-
-      if (value) controller.enqueue(value)
-      if (done || sourceDone) controller.close()
-    }
-  })
-}

package/src/services/base122-encoder.js

@@ -1,19 +0,0 @@
-import { encode } from '#lib/base122.js'
-
-// Encodes data using base122.
-export default class Base122Encoder {
-  textDecoder = new TextDecoder()
-  // The encoded data.
-  encoded = ''
-
-  // Updates the encoded data with the given bytes.
-  update (bytes) {
-    this.encoded += this.textDecoder.decode(new Uint8Array(encode(bytes)))
-    return this
-  }
-
-  // Gets the encoded data.
-  getEncoded () {
-    return this.encoded
-  }
-}