nappup 2.1.0 → 2.2.0

package/package.json

@@ -6,7 +6,7 @@
     "url": "git+https://github.com/44billion/nappup.git"
   },
   "license": "MIT",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Nostr App Uploader",
   "type": "module",
   "scripts": {
@@ -22,10 +22,9 @@
     "@noble/hashes": "^2.0.0",
     "dotenv": "^17.2.0",
     "file-type": "^21.0.0",
-    "libp2r2p": "^0.3.0",
+    "libp2r2p": "^0.9.0",
     "mime-types": "^3.0.1",
-    "nmmr": "^2.0.0",
-    "nostr-tools": "^2.23.3"
+    "nmmr": "^2.0.0"
   },
   "devDependencies": {
     "eslint": "^9.22.0",

package/src/services/bunker-session-codec.js

@@ -1,4 +1,4 @@
-import { getPublicKey } from 'nostr-tools/pure'
+import { getPublicKey } from 'libp2r2p/key'
 import { base16ToBytes } from 'libp2r2p/base16'
 import { base64UrlToBytes, bytesToBase64Url } from 'libp2r2p/base64'
 

package/src/services/bunker-session.js

@@ -1,4 +1,4 @@
-import { generateSecretKey } from 'nostr-tools/pure'
+import { generateSecretKey } from 'libp2r2p/key'
 import { bytesToBase16 } from 'libp2r2p/base16'
 import { toBunkerUrl } from 'libp2r2p/nip46'
 import {

package/src/services/irfs-upload.js

@@ -1,4 +1,4 @@
-import nostrRelays, { nappRelays } from '#services/nostr-relays.js'
+import nostrRelays, { nappRelays, sendEventReport } from '#services/nostr-relays.js'
 import NMMR from 'nmmr'
 import { decode as base93Decode, encode as base93Encode } from 'libp2r2p/base93'
 import { stringifyEvent } from '#helpers/event.js'
@@ -137,7 +137,7 @@ export async function throttledSendEvent (event, relays, {
   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))
+  const { errors } = await sendEventReport(event, relays, { timeout: 15000, timeoutUntilFirstFulfillment: null })
   if (errors.length === 0) {
     if (pause && trailingPause) await new Promise(resolve => setTimeout(resolve, pause))
     return { pause }
@@ -147,8 +147,7 @@ export async function throttledSendEvent (event, relays, {
     errors.reduce((r, v) => {
       const message = v.reason?.message ?? ''
       if (message.startsWith('rate-limited:')) r[0].push(v)
-      // https://github.com/nbd-wtf/nostr-tools/blob/28f7553187d201088c8a1009365db4ecbe03e568/abstract-relay.ts#L311
-      else if (message === 'publish timed out') r[1].push(v)
+      else if (message === 'PUBLISH_TIMEOUT') r[1].push(v)
       else r[2].push(v)
       return r
     }, [[], [], []])
@@ -158,7 +157,7 @@ export async function throttledSendEvent (event, relays, {
     const timedOutRelays = maybeUnretryableErrors.map(v => v.relay)
     log(`${maybeUnretryableErrors.length} timeout errors, retrying once after ${pause}ms:\n${maybeUnretryableErrors.map(v => `${v.relay}: ${v.reason.message}`).join('; ')}`)
     if (pause) await new Promise(resolve => setTimeout(resolve, pause))
-    const { errors: timeoutRetryErrors } = await nostrRelays.sendEvent(event, timedOutRelays, 15000)
+    const { errors: timeoutRetryErrors } = await sendEventReport(event, timedOutRelays, { timeout: 15000, timeoutUntilFirstFulfillment: null })
     unretryableErrors.push(...timeoutRetryErrors)
   }
 
@@ -204,7 +203,7 @@ export async function getPreviousChunks (dTagValues, relays, signer) {
       authors: [pubkey],
       '#d': batch,
       limit: batch.length
-    }, targetRelays)).result
+    }, targetRelays, { timeoutAfterFirstEose: null })).result
 
     for (const event of storedEvents) {
       const dTag = event.tags?.find(tag => tag[0] === 'd')?.[1]

package/src/services/nostr-relays.js

@@ -1,5 +1,4 @@
-import { Relay } from 'nostr-tools/relay'
-import { maybeUnref } from '#helpers/timer.js'
+import { relayPool } from 'libp2r2p/relay'
 
 export const seedRelays = [
   'wss://relay.44billion.net',
@@ -14,145 +13,13 @@ export const freeRelays = [
   'wss://nos.lol',
   'wss://relay.damus.io'
 ]
-export const nappRelays = [
-  'wss://relay.44billion.net'
-]
-
-// Interacts with Nostr relays
-export class NostrRelays {
-  #relays = new Map()
-  #relayTimeouts = new Map()
-  #timeout = 30000 // 30 seconds
-
-  // Get a relay connection, creating one if it doesn't exist
-  async #getRelay (url) {
-    if (this.#relays.has(url)) {
-      clearTimeout(this.#relayTimeouts.get(url))
-      this.#relayTimeouts.set(url, maybeUnref(setTimeout(() => this.disconnect(url), this.#timeout)))
-      const relay = this.#relays.get(url)
-      // Reconnect if needed to avoid SendingOnClosedConnection errors
-      await relay.connect()
-      return relay
-    }
-
-    const relay = new Relay(url)
-    this.#relays.set(url, relay)
-
-    await relay.connect()
-
-    this.#relayTimeouts.set(url, maybeUnref(setTimeout(() => this.disconnect(url), this.#timeout)))
-
-    return relay
-  }
-
-  // Disconnect from a relay
-  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)
-      this.#relays.delete(url)
-      clearTimeout(this.#relayTimeouts.get(url))
-      this.#relayTimeouts.delete(url)
-    }
-  }
-
-  // Disconnect from all relays
-  async disconnectAll () {
-    for (const url of this.#relays.keys()) {
-      await this.disconnect(url)
-    }
-  }
-
-  // Get events from a list of relays
-  async getEvents (filter, relays, timeout = 5000) {
-    const events = []
-    const promises = relays.map(async (url) => {
-      let sub
-      const p = Promise.withResolvers()
-      const t = Promise.withResolvers()
-      const timer = maybeUnref(setTimeout(() => {
-        sub?.close()
-        t.reject(new Error(`timeout: ${url}`))
-      }, timeout))
-
-      ;(async () => {
-        try {
-          const relay = await this.#getRelay(url)
-          sub = relay.subscribe([filter], {
-            onevent: (event) => {
-              event.meta = { relay: url }
-              events.push(event)
-            },
-            onclose: err => err ? p.reject(err) : p.resolve(),
-            oneose: () => { sub.close(); p.resolve() }
-          })
-        } catch (err) {
-          p.reject(err)
-        }
-      })()
-
-      try {
-        await Promise.race([p.promise, t.promise])
-      } finally {
-        clearTimeout(timer)
-      }
-    })
-
-    const results = await Promise.allSettled(promises)
-    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 eventToSend = event.meta ? { ...event } : event
-    if (eventToSend.meta) delete eventToSend.meta
-
-    const promises = relays.map(async (url) => {
-      const p = Promise.withResolvers()
-      const t = Promise.withResolvers()
-      const timer = maybeUnref(setTimeout(() => {
-        t.reject(new Error(`timeout: ${url}`))
-      }, timeout))
-
-      ;(async () => {
-        try {
-          const relay = await this.#getRelay(url)
-          await relay.publish(eventToSend)
-          p.resolve()
-        } catch (err) {
-          if (err.message?.startsWith('duplicate:')) return p.resolve()
-          if (err.message?.startsWith('mute:')) {
-            console.info(`${url} - ${err.message}`)
-            return p.resolve()
-          }
-          p.reject(err)
-        }
-      })()
-
-      try {
-        await Promise.race([p.promise, t.promise])
-      } finally {
-        clearTimeout(timer)
-      }
-    })
-
-    const results = await Promise.allSettled(promises)
-    const rejectedResults = results.filter(v => v.status === 'rejected')
+export const nappRelays = ['wss://relay.44billion.net']
 
-    return {
-      result: null,
-      errors: rejectedResults.map(v => ({ reason: v.reason, relay: relays[results.indexOf(v)] })),
-      success: results.length !== rejectedResults.length
-    }
-  }
+// sendEvent returns quickly after the first successful publish. Upload flows
+// need the terminal per-relay report so retries and replication stay correct.
+export async function sendEventReport (event, relays, options) {
+  const result = await relayPool.sendEvent(event, relays, options)
+  return await (result?.promise ?? result)
 }
 
-// Share same connection
-// Connections aren't authenticated, thus no need to split by authed user
-export default new NostrRelays()
+export default relayPool

package/src/services/nostr-secret-key.js

@@ -1,4 +1,4 @@
-import { getPublicKey } from 'nostr-tools/pure'
+import { getPublicKey } from 'libp2r2p/key'
 import { base16ToBytes } from 'libp2r2p/base16'
 import { nsecDecode } from 'libp2r2p/nip19'
 import { parseBunkerSessionUrl } from '#services/bunker-url.js'

package/src/services/nostr-signer.js

@@ -1,18 +1,12 @@
-import { getPublicKey } from 'nostr-tools/pure'
-import { getConversationKey, encrypt, decrypt } from 'nostr-tools/nip44'
-import nostrRelays, { seedRelays, freeRelays } from '#services/nostr-relays.js'
+import { finalizeEvent } from 'libp2r2p/event'
+import { generateSecretKey, getPublicKey } from 'libp2r2p/key'
+import * as nip44 from 'libp2r2p/nip44'
+import { seedRelays, freeRelays, sendEventReport } from '#services/nostr-relays.js'
 import { getRelays } from '#helpers/signer.js'
 import { bytesToBase16, base16ToBytes } from '#helpers/base16.js'
-import { finalizeEvent } from '#helpers/nip01.js'
 import { nsecDecode, nsecEncode } from 'libp2r2p/nip19'
 import { ensureDotenvInitialized, setEncryptedDotenvValue } from '#services/dotenv.js'
 
-const nip44 = {
-  getConversationKey,
-  encrypt,
-  decrypt
-}
-
 const createToken = Symbol('createToken')
 
 export default class NostrSigner {
@@ -42,9 +36,8 @@ export default class NostrSigner {
       skBytes = base16ToBytes(envSk)
     } else {
       isNewSk = true
-      sk = generateSecretKey()
-      setEncryptedDotenvValue('NOSTR_SECRET_KEY', nsecEncode(sk))
-      skBytes = base16ToBytes(sk)
+      skBytes = generateSecretKey()
+      setEncryptedDotenvValue('NOSTR_SECRET_KEY', nsecEncode(bytesToBase16(skBytes)))
     }
     const ret = new this(createToken, skBytes)
     if (isNewSk) await ret.#initSk(sk)
@@ -65,7 +58,7 @@ export default class NostrSigner {
       content: '',
       created_at: Math.floor(Date.now() / 1000)
     })
-    await nostrRelays.sendEvent(relayList, [...new Set([...seedRelays, ...relays].map(r => r.trim().replace(/\/$/, '')))])
+    await sendEventReport(relayList, [...new Set([...seedRelays, ...relays].map(r => r.trim().replace(/\/$/, '')))])
 
     const profile = await this.signEvent({
       kind: 0,
@@ -77,7 +70,7 @@ export default class NostrSigner {
       }),
       created_at: Math.floor(Date.now() / 1000)
     })
-    await nostrRelays.sendEvent(profile, relays)
+    await sendEventReport(profile, relays)
   }
 
   // hex
@@ -100,21 +93,11 @@ export default class NostrSigner {
 
   nip44Encrypt (pubkey, plaintext) {
     const conversationKey = nip44.getConversationKey(this.#secretKey, pubkey)
-    return nip44.encrypt(conversationKey, plaintext)
+    return nip44.encrypt(plaintext, conversationKey)
   }
 
   nip44Decrypt (pubkey, ciphertext) {
     const conversationKey = nip44.getConversationKey(this.#secretKey, pubkey)
-    return nip44.decrypt(conversationKey, ciphertext)
+    return nip44.decrypt(ciphertext, conversationKey)
   }
 }
-
-function generateSecretKey () {
-  const randomBytes = crypto.getRandomValues(new Uint8Array(40))
-  const B256 = 2n ** 256n // secp256k1 is short weierstrass curve
-  const N = B256 - 0x14551231950b75fc4402da1732fc9bebfn // curve (group) order
-  const bytesToNumber = b => BigInt('0x' + (bytesToBase16(b) || '0'))
-  const mod = (a, b) => { const r = a % b; return r >= 0n ? r : b + r } // mod division
-  const num = mod(bytesToNumber(randomBytes), N - 1n) + 1n // takes at least n+8 bytes
-  return num.toString(16).padStart(64, '0')
-}

package/src/services/site-manifest.js

@@ -187,7 +187,7 @@ export async function uploadSiteManifest ({
     authors: [await signer.getPublicKey()],
     '#d': [dTag],
     limit: 1
-  }, relays)).result
+  }, relays, { timeoutAfterFirstEose: null })).result
   events.sort(newestFirst)
   const previous = events[0]
   const tags = buildManifestTags({

package/src/helpers/nip01.js

@@ -1,32 +0,0 @@
-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
-}