nappup 1.0.8 → 1.0.11

package/bin/nappup/helpers.js

@@ -10,6 +10,7 @@ export function parseArgs (args) {
   let sk = null
   let dTag = null
   let channel = null
+  let shouldReupload = false
 
   for (let i = 0; i < args.length; i++) {
     if (args[i] === '-s' && args[i + 1]) {
@@ -24,6 +25,8 @@ export function parseArgs (args) {
       channel = 'next'
     } else if (args[i] === '--draft' && channel === null) {
       channel = 'draft'
+    } else if (args[i] === '-r') {
+      shouldReupload = true
     } else if (!args[i].startsWith('-') && dir === null) {
       dir = args[i]
     }
@@ -33,7 +36,8 @@ export function parseArgs (args) {
     dir: path.resolve(dir ?? '.'),
     sk,
     dTag,
-    channel: channel || 'main'
+    channel: channel || 'main',
+    shouldReupload
   }
 }
 

package/bin/nappup/index.js

@@ -11,7 +11,7 @@ import toApp from '#index.js'
 const args = parseArgs(process.argv.slice(2))
 await confirmArgs(args)
 
-const { dir, sk, dTag, channel } = args
+const { dir, sk, dTag, channel, shouldReupload } = args
 const fileList = await toFileList(getFiles(dir), dir)
 
-await toApp(fileList, await NostrSigner.create(sk), { log: console.log.bind(console), dTag, channel })
+await toApp(fileList, await NostrSigner.create(sk), { log: console.log.bind(console), dTag, channel, shouldReupload })

package/package.json

@@ -6,7 +6,7 @@
     "url": "git+https://github.com/44billion/nappup.git"
   },
   "license": "GPL-3.0-or-later",
-  "version": "1.0.8",
+  "version": "1.0.11",
   "description": "Nostr App Uploader",
   "type": "module",
   "scripts": {
@@ -17,10 +17,12 @@
     "nappup": "bin/nappup/index.js"
   },
   "dependencies": {
+    "@noble/curves": "^2.0.0",
+    "@noble/hashes": "^2.0.0",
     "dotenv": "^17.2.0",
     "file-type": "^21.0.0",
     "mime-types": "^3.0.1",
-    "nmmr": "^1.0.4",
+    "nmmr": "^1.0.9",
     "nostr-tools": "^2.15.0"
   },
   "devDependencies": {

package/src/helpers/app.js

@@ -1,4 +1,4 @@
-import { bytesToBase36 } from '#helpers/base36.js'
+import { bytesToBase36, isBase36 } from '#helpers/base36.js'
 
 // 63 - (1<channel> + 5<b36loggeduserpkslug> 50<b36pk>)
 // <b36loggeduserpkslug> pk chars at positions [7][17][27][37][47]
@@ -6,10 +6,10 @@ import { bytesToBase36 } from '#helpers/base36.js'
 export const NOSTR_APP_D_TAG_MAX_LENGTH = 7
 
 export function isNostrAppDTagSafe (string) {
-  return isSubdomainSafe(string) && string.length <= NOSTR_APP_D_TAG_MAX_LENGTH
+  return string.length > 0 && string.length <= NOSTR_APP_D_TAG_MAX_LENGTH && isBase36(string)
 }
 
-function isSubdomainSafe (string) {
+export function isSubdomainSafe (string) {
   return /(?:^[a-z0-9]$)|(?:^(?!.*--)[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$)/.test(string)
 }
 

package/src/helpers/base36.js

@@ -5,6 +5,12 @@ export const BASE36_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz'
 const BASE = BigInt(BASE36_ALPHABET.length)
 const LEADER = BASE36_ALPHABET[0]
 const CHAR_MAP = new Map([...BASE36_ALPHABET].map((char, index) => [char, BigInt(index)]))
+const BASE36_REGEX = /^[0-9a-z]+$/
+
+export function isBase36 (str) {
+  if (typeof str !== 'string') return false
+  return BASE36_REGEX.test(str)
+}
 
 export function bytesToBase36 (bytes, padLength = 0) {
   return base16ToBase36(bytesToBase16(bytes), padLength)

package/src/helpers/base62.js

@@ -1,7 +1,7 @@
-export const ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
-const BASE = BigInt(ALPHABET.length)
-const LEADER = ALPHABET[0]
-const CHAR_MAP = new Map([...ALPHABET].map((char, index) => [char, BigInt(index)]))
+export const BASE62_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+const BASE = BigInt(BASE62_ALPHABET.length)
+const LEADER = BASE62_ALPHABET[0]
+const CHAR_MAP = new Map([...BASE62_ALPHABET].map((char, index) => [char, BigInt(index)]))
 
 export function bytesToBase62 (bytes, padLength = 0) {
   if (bytes.length === 0) return ''.padStart(padLength, LEADER)
@@ -16,7 +16,7 @@ export function bytesToBase62 (bytes, padLength = 0) {
 
   while (num > 0n) {
     const remainder = num % BASE
-    result = ALPHABET[Number(remainder)] + result
+    result = BASE62_ALPHABET[Number(remainder)] + result
     num = num / BASE
   }
 

package/src/helpers/nip01.js

@@ -0,0 +1,32 @@
+import { schnorr } from '@noble/curves/secp256k1.js'
+import { sha256 } from '@noble/hashes/sha2.js'
+import { bytesToBase16, base16ToBytes } from '#helpers/base16.js'
+import { getPublicKey } from 'nostr-tools/pure'
+
+function serializeEvent (event) {
+  return JSON.stringify([
+    0,
+    event.pubkey,
+    event.created_at,
+    event.kind,
+    event.tags,
+    event.content
+  ])
+}
+
+function getEventHash (event) {
+  return sha256(new TextEncoder().encode(serializeEvent(event)))
+}
+
+function getSignature (eventHash, privkey) {
+  return bytesToBase16(schnorr.sign(eventHash, privkey))
+}
+
+export function finalizeEvent (event, privkey, withSig = true) {
+  event.pubkey ??= getPublicKey(privkey)
+  const eventHash = event.id ? base16ToBytes(event.id) : getEventHash(event)
+  event.id ??= bytesToBase16(eventHash)
+  if (withSig) event.sig ??= getSignature(eventHash, privkey)
+  else delete event.sig
+  return event
+}

package/src/helpers/nip19.js

@@ -1,45 +1,56 @@
 import { bytesToBase16, base16ToBytes } from '#helpers/base16.js'
-import { bytesToBase62, base62ToBytes, ALPHABET as base62Alphabet } from '#helpers/base62.js'
+import { bytesToBase62, base62ToBytes, BASE62_ALPHABET } from '#helpers/base62.js'
 import { isNostrAppDTagSafe } from '#helpers/app.js'
 
 const MAX_SIZE = 5000
-export const BASE62_ENTITY_REGEX = new RegExp(`^app-[${base62Alphabet}]{,${MAX_SIZE}}$`)
-export const kindByChannel = {
+export const NAPP_ENTITY_REGEX = new RegExp(`^\\+{1,3}[${BASE62_ALPHABET}]{48,${MAX_SIZE}}$`)
+const textEncoder = new TextEncoder()
+const textDecoder = new TextDecoder()
+
+const kindByChannel = {
   main: 37448,
   next: 37449,
   draft: 37450
 }
-const channelEnum = Object.keys(kindByChannel)
-const textEncoder = new TextEncoder()
-const textDecoder = new TextDecoder()
-
+const channelByKind = Object.fromEntries(
+  Object.entries(kindByChannel).map(([k, v]) => [v, k])
+)
+const prefixByChannel = {
+  main: '+',
+  next: '++',
+  draft: '+++'
+}
+const channelByPrefix = Object.fromEntries(
+  Object.entries(prefixByChannel).map(([k, v]) => [v, k])
+)
 export function appEncode (ref) {
   if (!isNostrAppDTagSafe(ref.dTag)) { throw new Error('Invalid deduplication tag') }
-  const channelIndex = Object.entries(kindByChannel)
-    .findIndex(([k, v]) => ref.channel ? k === ref.channel : v === ref.kind)
-  if (channelIndex === -1) throw new Error('Wrong channel')
+  const channel = ref.channel ? (prefixByChannel[ref.channel] && ref.channel) : channelByKind[ref.kind]
+  if (!channel) throw new Error('Wrong channel')
   const tlv = toTlv([
     [textEncoder.encode(ref.dTag)], // type 0 (the array index)
     (ref.relays || []).map(url => textEncoder.encode(url)), // type 1
-    [base16ToBytes(ref.pubkey)], // type 2
-    [uintToBytes(channelIndex)] // type 3
+    [base16ToBytes(ref.pubkey)] // type 2
   ])
   const base62 = bytesToBase62(tlv)
-  return `app-${base62}`
+  const prefix = prefixByChannel[channel]
+  return `${prefix}${base62}`
 }
 
 export function appDecode (entity) {
-  const [, base62] = entity.split('-')
+  const prefix = entity.match(/^\+*/)[0]
+  const channel = channelByPrefix[prefix]
+  if (!channel) throw new Error('Invalid channel')
+  const base62 = entity.slice(prefix.length)
   const tlv = tlvToObj(base62ToBytes(base62))
   if (!tlv[0]?.[0]) throw new Error('Missing deduplication tag')
   if (!tlv[2]?.[0]) throw new Error('Missing author pubkey')
   if (tlv[2][0].length !== 32) throw new Error('Author pubkey should be 32 bytes')
-  if (!tlv[3]?.[0]) throw new Error('Missing channel enum')
-  if (tlv[3][0].length !== 1) throw new Error('Channel enum should be 1 byte')
+  const dTag = textDecoder.decode(tlv[0][0])
+  if (!isNostrAppDTagSafe(dTag)) { throw new Error('Invalid deduplication tag') }
 
-  const channel = channelEnum[parseInt(tlv[3][0])]
   return {
-    dTag: textDecoder.decode(tlv[0][0]),
+    dTag,
     pubkey: bytesToBase16(tlv[2][0]),
     kind: kindByChannel[channel],
     channel,
@@ -47,12 +58,6 @@ export function appDecode (entity) {
   }
 }
 
-// Return shortest uint8Array size (not fixed size)
-function uintToBytes (n, bytes = []) {
-  do { bytes.unshift(n & 255) } while ((n >>= 8) > 0)
-  return new Uint8Array(bytes)
-}
-
 function toTlv (tlvConfig) {
   const arrays = []
   tlvConfig

package/src/index.js

@@ -1,6 +1,6 @@
 import NMMR from 'nmmr'
 import { appEncode } from '#helpers/nip19.js'
-import Base122Encoder from '#services/base122-encoder.js'
+import Base93Encoder from '#services/base93-encoder.js'
 import nostrRelays from '#services/nostr-relays.js'
 import NostrSigner from '#services/nostr-signer.js'
 import { streamToChunks } from '#helpers/stream.js'
@@ -14,37 +14,41 @@ export default async function (...args) {
   }
 }
 
-export async function toApp (fileList, nostrSigner, { log = () => {}, dTag, channel = 'main' } = {}) {
+export async function toApp (fileList, nostrSigner, { log = () => {}, dTag, channel = 'main', shouldReupload = false } = {}) {
   if (!nostrSigner && typeof window !== 'undefined') nostrSigner = window.nostr
   if (!nostrSigner) throw new Error('No Nostr signer found')
   if (typeof window !== 'undefined' && nostrSigner === window.nostr) {
     nostrSigner.getRelays = NostrSigner.prototype.getRelays
   }
+  const writeRelays = (await nostrSigner.getRelays()).write
+  log(`Found ${writeRelays.length} outbox relays for pubkey ${nostrSigner.getPublicKey()}:\n${writeRelays.join(', ')}`)
+  if (writeRelays.length === 0) throw new Error('No outbox relays found')
 
   if (typeof dTag === 'string') {
     if (!isNostrAppDTagSafe(dTag)) throw new Error('dTag should be [A-Za-z0-9] with length ranging from 1 to 19')
   } else {
     dTag = fileList[0].webkitRelativePath.split('/')[0].trim()
-    if (!isNostrAppDTagSafe(dTag)) dTag = deriveNostrAppDTag(dTag || Math.random().toString(36))
+    if (!isNostrAppDTagSafe(dTag)) dTag = await deriveNostrAppDTag(dTag || Math.random().toString(36))
   }
   let nmmr
   const fileMetadata = []
 
   log(`Processing ${fileList.length} files`)
+  let pause = 1000
   for (const file of fileList) {
     nmmr = new NMMR()
     const stream = file.stream()
 
     let chunkLength = 0
-    for await (const chunk of streamToChunks(stream, 54600)) {
+    for await (const chunk of streamToChunks(stream, 51000)) {
       chunkLength++
-      nmmr.append(chunk)
+      await nmmr.append(chunk)
     }
     if (chunkLength) {
       // remove root dir
       const filename = file.webkitRelativePath.split('/').slice(1).join('/')
       log(`Uploading ${chunkLength} file parts of ${filename}`)
-      await uploadBinaryDataChunks(nmmr, nostrSigner, { mimeType: file.type || 'application/octet-stream' })
+      ;({ pause } = (await uploadBinaryDataChunks({ nmmr, signer: nostrSigner, filename, chunkLength, log, pause, mimeType: file.type || 'application/octet-stream', shouldReupload })))
       fileMetadata.push({
         rootHash: nmmr.getRoot(),
         filename,
@@ -54,7 +58,7 @@ export async function toApp (fileList, nostrSigner, { log = () => {}, dTag, chan
   }
 
   log(`Uploading bundle #${dTag}`)
-  const bundle = await uploadBundle(dTag, channel, fileMetadata, nostrSigner)
+  const bundle = await uploadBundle({ dTag, channel, fileMetadata, signer: nostrSigner, pause })
 
   const appEntity = appEncode({
     dTag: bundle.tags.find(v => v[0] === 'd')[1],
@@ -65,43 +69,105 @@ export async function toApp (fileList, nostrSigner, { log = () => {}, dTag, chan
   log(`Visit at https://44billion.net/${appEntity}`)
 }
 
-async function uploadBinaryDataChunks (nmmr, signer, { mimeType } = {}) {
+async function uploadBinaryDataChunks ({ nmmr, signer, filename, chunkLength, log, pause = 0, mimeType, shouldReupload = false }) {
   const writeRelays = (await signer.getRelays()).write
+  let chunkIndex = 0
   for await (const chunk of nmmr.getChunks()) {
     const dTag = chunk.x
     const currentCtag = `${chunk.rootX}:${chunk.index}`
-    const prevCTags = await getPreviousCtags(dTag, currentCtag, writeRelays, signer)
+    const { otherCtags, hasCurrentCtag } = await getPreviousCtags(dTag, currentCtag, writeRelays, signer)
+    if (!shouldReupload && hasCurrentCtag) {
+      log(`${filename}: Skipping chunk ${++chunkIndex} of ${chunkLength} (already uploaded)`)
+      continue
+    }
     const binaryDataChunk = {
       kind: 34600,
       tags: [
         ['d', dTag],
-        ...prevCTags,
+        ...otherCtags,
         ['c', currentCtag, chunk.length, ...chunk.proof],
         ...(mimeType ? [['m', mimeType]] : [])
       ],
-      // These chunks already have the expected size of 54600 bytes
-      content: new Base122Encoder().update(chunk.contentBytes).getEncoded(),
+      // These chunks already have the expected size of 51000 bytes
+      content: new Base93Encoder().update(chunk.contentBytes).getEncoded(),
       created_at: Math.floor(Date.now() / 1000)
     }
 
     const event = await signer.signEvent(binaryDataChunk)
-    await nostrRelays.sendEvent(event, writeRelays)
+    log(`${filename}: Uploading file part ${++chunkIndex} of ${chunkLength} to ${writeRelays.length} relays`)
+    ;({ pause } = (await throttledSendEvent(event, writeRelays, { pause, log, trailingPause: true })))
   }
+  return { pause }
+}
+
+async function throttledSendEvent (event, relays, {
+  pause, log,
+  retries = 0, maxRetries = 10,
+  minSuccessfulRelays = 1,
+  leadingPause = false, trailingPause = false
+}) {
+  if (pause && leadingPause) await new Promise(resolve => setTimeout(resolve, pause))
+  if (retries > 0) log(`Retrying upload to ${relays.length} relays: ${relays.join(', ')}`)
+
+  const { errors } = (await nostrRelays.sendEvent(event, relays, 15000))
+  if (errors.length === 0) {
+    if (pause && trailingPause) await new Promise(resolve => setTimeout(resolve, pause))
+    return { pause }
+  }
+
+  const [rateLimitErrors, unretryableErrors] =
+    errors.reduce((r, v) => {
+      if ((v.reason?.message ?? '').startsWith('rate-limited:')) r[0].push(v)
+      else r[1].push(v)
+      return r
+    }, [[], []])
+  log(`${unretryableErrors.length} Unretryable errors\n: ${unretryableErrors.map(v => `${v.relay}: ${v.reason.message}`).join('; ')}`)
+  const unretryableErrorsLength = errors.length - rateLimitErrors.length
+  const maybeSuccessfulRelays = relays.length - unretryableErrorsLength
+  const hasReachedMaxRetries = retries > maxRetries
+  if (
+    hasReachedMaxRetries ||
+    maybeSuccessfulRelays < minSuccessfulRelays
+  ) throw new Error(errors.map(v => `\n${v.relay}: ${v.reason}`).join('\n'))
+
+  if (rateLimitErrors.length === 0) {
+    if (pause && trailingPause) await new Promise(resolve => setTimeout(resolve, pause))
+    return { pause }
+  }
+
+  const erroedRelays = rateLimitErrors.map(v => v.relay)
+  log(`Rate limited by ${erroedRelays.length} relays, pausing for ${pause + 2000} ms`)
+  await new Promise(resolve => setTimeout(resolve, (pause += 2000)))
+
+  minSuccessfulRelays = Math.max(0, minSuccessfulRelays - (relays.length - erroedRelays.length))
+  return await throttledSendEvent(event, erroedRelays, {
+    pause, log, retries: ++retries, maxRetries, minSuccessfulRelays, leadingPause: false, trailingPause
+  })
 }
 
 async function getPreviousCtags (dTagValue, currentCtagValue, writeRelays, signer) {
-  const storedEvents = await nostrRelays.getEvents({
+  const storedEvents = (await nostrRelays.getEvents({
     kinds: [34600],
     authors: [await signer.getPublicKey()],
     '#d': [dTagValue],
     limit: 1
-  }, writeRelays)
-  if (storedEvents.length === 0) return []
+  }, writeRelays)).result
+
+  let hasCurrentCtag = false
+  const hasEvent = storedEvents.length > 0
+  if (!hasEvent) return { otherCtags: [], hasEvent, hasCurrentCtag }
 
   const cTagValues = { [currentCtagValue]: true }
   const prevTags = storedEvents.sort((a, b) => b.created_at - a.created_at)[0].tags
-  if (!Array.isArray(prevTags)) return []
-  return prevTags
+  if (!Array.isArray(prevTags)) return { otherCtags: [], hasEvent, hasCurrentCtag }
+
+  hasCurrentCtag = prevTags.some(tag =>
+    Array.isArray(tag) &&
+    tag[0] === 'c' &&
+    tag[1] === currentCtagValue
+  )
+
+  const otherCtags = prevTags
     .filter(v => {
       const isCTag =
         Array.isArray(v) &&
@@ -114,9 +180,11 @@ async function getPreviousCtags (dTagValue, currentCtagValue, writeRelays, signe
       cTagValues[v[1]] = true
       return isCTag && isntDuplicate
     })
+
+  return { otherCtags, hasEvent, hasCurrentCtag }
 }
 
-async function uploadBundle (dTag, channel, fileMetadata, signer) {
+async function uploadBundle ({ dTag, channel, fileMetadata, signer, pause = 0 }) {
   const kind = {
     main: 37448, // stable
     next: 37449, // insider
@@ -132,6 +200,6 @@ async function uploadBundle (dTag, channel, fileMetadata, signer) {
     created_at: Math.floor(Date.now() / 1000)
   }
   const event = await signer.signEvent(appBundle)
-  await nostrRelays.sendEvent(event, (await signer.getRelays()).write)
+  await throttledSendEvent(event, (await signer.getRelays()).write, { pause, trailingPause: true })
   return event
 }

package/src/services/base93-decoder.js

@@ -0,0 +1,107 @@
+// https://github.com/ticlo/arrow-code/blob/master/src/base93.ts
+// https://github.com/ticlo/arrow-code/blob/master/LICENSE - Apache 2.0
+
+// JSON-safe (space included; " and \ excluded)
+const BASE93_ALPHABET =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&'()*+,-./:;<=>?@[]^_`{|}~ "
+
+const DECODING_TABLE = (() => {
+  const out = new Int16Array(128)
+  out.fill(93) // sentinel = invalid
+  for (let i = 0; i < 93; i++) out[BASE93_ALPHABET.charCodeAt(i)] = i
+  return out
+})()
+
+/**
+ * Decode Base93 string to Uint8Array
+ * @param {string} str - The Base93 encoded string to decode
+ * @param {number} [offset=0] - The starting position in the string
+ * @param {number} [length=-1] - The number of characters to decode, or -1 for all remaining
+ * @returns {Uint8Array} The decoded bytes
+ */
+export function decode (str, offset = 0, length = -1) {
+  let end = offset + length
+  if (length < 0 || end > str.length) end = str.length
+
+  // Over-allocate; we’ll trim at the end
+  const out = new Uint8Array(Math.ceil((end - offset) * 7 / 8))
+
+  let dbq = 0
+  let dn = 0
+  let dv = -1
+  let pos = 0
+
+  for (let i = offset; i < end; i++) {
+    const code = str.charCodeAt(i)
+    if (code > 126) continue // ignore non-ASCII
+    const v = DECODING_TABLE[code]
+    if (v === 93) continue // ignore invalids
+    if (dv === -1) {
+      dv = v
+    } else {
+      const t = dv + v * 93
+      dv = -1
+      dbq |= t << dn
+      dn += ((t & 0x1fff) > 456 ? 13 : 14)
+      while (dn > 7) {
+        out[pos++] = dbq & 0xff
+        dbq >>>= 8
+        dn -= 8
+      }
+    }
+  }
+
+  if (dv !== -1) {
+    out[pos++] = (dbq | (dv << dn)) & 0xff
+  }
+  return out.subarray(0, pos)
+}
+
+export default class Base93Decoder {
+  constructor (source, { mimeType = '', preferTextStreamDecoding = false } = {}) {
+    this.sourceIterator = source?.[Symbol.iterator]?.() || source?.[Symbol.asyncIterator]?.() || source()
+    this.asTextStream = preferTextStreamDecoding && mimeType.startsWith('text/')
+    if (this.asTextStream) this.textDecoder = new TextDecoder()
+  }
+
+  // decoder generator
+  * [Symbol.iterator] (base93String) {
+    if (this.asTextStream) {
+      while (base93String) {
+        // stream=true avoids cutting a multi-byte character
+        base93String = yield this.textDecoder.decode(decode(base93String), { stream: true })
+      }
+    } else {
+      while (base93String) {
+        base93String = yield decode(base93String)
+      }
+    }
+  }
+
+  // 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/base93-encoder.js

@@ -0,0 +1,96 @@
+// https://github.com/ticlo/arrow-code/blob/master/src/base93.ts
+// https://github.com/ticlo/arrow-code/blob/master/LICENSE - Apache 2.0
+
+// JSON-safe (space included; " and \ excluded)
+const BASE93_ALPHABET =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&'()*+,-./:;<=>?@[]^_`{|}~ "
+const ENCODING_TABLE = (() => {
+  const out = new Uint16Array(93)
+  for (let i = 0; i < 93; i++) out[i] = BASE93_ALPHABET.charCodeAt(i)
+  return out
+})()
+
+function codesToString (codes, len) {
+  const CHUNK = 16384 // 16k chars per slice
+  let s = ''
+  for (let i = 0; i < len; i += CHUNK) {
+    const end = i + CHUNK < len ? i + CHUNK : len
+    s += String.fromCharCode.apply(
+      null,
+      Array.prototype.slice.call(codes, i, end)
+    )
+  }
+  return s
+}
+
+export default class Base93Encoder {
+  constructor (prefix = '') {
+    // bit reservoir
+    this._ebq = 0 // queued bits
+    this._en = 0  // number of bits in ebq
+
+    // output parts
+    this._parts = []
+    this._finished = false
+
+    if (prefix) this._parts.push(prefix)
+  }
+
+  // Stream bytes; keeps reservoir across calls.
+  update (bytes) {
+    if (this._finished) throw new Error('Encoder already finalized.')
+    const src = bytes instanceof Uint8Array ? bytes : Uint8Array.from(bytes)
+
+    // Over-allocate for this update; we’ll trim to 'pos'
+    const outCodes = new Uint16Array(Math.ceil(src.length * 8 / 6.5) + 4)
+    let pos = 0
+
+    let ebq = this._ebq
+    let en = this._en
+    let ev = 0
+
+    for (let i = 0; i < src.length; i++) {
+      ebq |= (src[i] & 0xff) << en
+      en += 8
+      if (en > 13) {
+        ev = ebq & 0x1fff
+        if (ev > 456) {
+          ebq >>>= 13
+          en -= 13
+        } else {
+          ev = ebq & 0x3fff
+          ebq >>>= 14
+          en -= 14
+        }
+        outCodes[pos++] = ENCODING_TABLE[ev % 93]
+        outCodes[pos++] = ENCODING_TABLE[(ev / 93) | 0]
+      }
+    }
+
+    // persist reservoir
+    this._ebq = ebq
+    this._en = en
+
+    if (pos) this._parts.push(codesToString(outCodes, pos))
+    return this
+  }
+
+  // Finalize on first call: flush trailing partial block, join, lock.
+  getEncoded () {
+    if (!this._finished) {
+      if (this._en > 0) {
+        const outCodes = new Uint16Array(2)
+        let pos = 0
+        outCodes[pos++] = ENCODING_TABLE[this._ebq % 93]
+        if (this._en > 7 || this._ebq > 92) {
+          outCodes[pos++] = ENCODING_TABLE[(this._ebq / 93) | 0]
+        }
+        this._parts.push(codesToString(outCodes, pos))
+      }
+      this._finished = true
+      this._ebq = 0
+      this._en = 0
+    }
+    return this._parts.join('')
+  }
+}

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)
@@ -44,7 +47,7 @@ export class NostrRelays {
   async disconnect (url) {
     if (this.#relays.has(url)) {
       const relay = this.#relays.get(url)
-      if (relay.ws.readyState < 2) await relay.close().catch(console.log)
+      if (relay.ws.readyState < 2) await relay.close()?.catch(console.log)
       this.#relays.delete(url)
       clearTimeout(this.#relayTimeouts.get(url))
       this.#relayTimeouts.delete(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
-  }
-}