nappup 1.4.2 → 1.5.3

package/package.json

@@ -6,7 +6,7 @@
     "url": "git+https://github.com/44billion/nappup.git"
   },
   "license": "MIT",
-  "version": "1.4.2",
+  "version": "1.5.3",
   "description": "Nostr App Uploader",
   "type": "module",
   "scripts": {

package/src/index.js

@@ -1,7 +1,7 @@
 import NMMR from 'nmmr'
 import { appEncode } from '#helpers/nip19.js'
 import Base93Encoder from '#services/base93-encoder.js'
-import nostrRelays from '#services/nostr-relays.js'
+import nostrRelays, { nappRelays } from '#services/nostr-relays.js'
 import NostrSigner from '#services/nostr-signer.js'
 import { streamToChunks, streamToText } from '#helpers/stream.js'
 import { isNostrAppDTagSafe, deriveNostrAppDTag } from '#helpers/app.js'
@@ -151,8 +151,8 @@ export async function toApp (fileList, nostrSigner, { log = () => {}, dTag, dTag
     hashtags: nappJson.hashtag
   })))
 
-  log(`Uploading bundle #${dTag}`)
-  const bundle = await uploadBundle({ dTag, channel, fileMetadata, signer: nostrSigner, pause })
+  log(`Uploading bundle ${dTag}`)
+  const bundle = await uploadBundle({ dTag, channel, fileMetadata, signer: nostrSigner, pause, shouldReupload, log })
 
   const appEntity = appEncode({
     dTag: bundle.tags.find(v => v[0] === 'd')[1],
@@ -165,13 +165,19 @@ export async function toApp (fileList, nostrSigner, { log = () => {}, dTag, dTag
 
 async function uploadBinaryDataChunks ({ nmmr, signer, filename, chunkLength, log, pause = 0, mimeType, shouldReupload = false }) {
   const writeRelays = (await signer.getRelays()).write
+  const relays = [...new Set([...writeRelays, ...nappRelays])]
   let chunkIndex = 0
   for await (const chunk of nmmr.getChunks()) {
     const dTag = chunk.x
     const currentCtag = `${chunk.rootX}:${chunk.index}`
-    const { otherCtags, hasCurrentCtag } = await getPreviousCtags(dTag, currentCtag, writeRelays, signer)
+    const { otherCtags, hasCurrentCtag, foundEvent, missingRelays } = await getPreviousCtags(dTag, currentCtag, relays, signer)
     if (!shouldReupload && hasCurrentCtag) {
-      log(`${filename}: Skipping chunk ${++chunkIndex} of ${chunkLength} (already uploaded)`)
+      if (missingRelays.length === 0) {
+        log(`${filename}: Skipping chunk ${++chunkIndex} of ${chunkLength} (already uploaded)`)
+        continue
+      }
+      log(`${filename}: Re-uploading chunk ${++chunkIndex} of ${chunkLength} to ${missingRelays.length} missing relays (out of ${relays.length})`)
+      ;({ pause } = (await throttledSendEvent(foundEvent, missingRelays, { pause, log, trailingPause: true })))
       continue
     }
     const binaryDataChunk = {
@@ -188,8 +194,9 @@ async function uploadBinaryDataChunks ({ nmmr, signer, filename, chunkLength, lo
     }
 
     const event = await signer.signEvent(binaryDataChunk)
-    log(`${filename}: Uploading file part ${++chunkIndex} of ${chunkLength} to ${writeRelays.length} relays`)
-    ;({ pause } = (await throttledSendEvent(event, writeRelays, { pause, log, trailingPause: true })))
+    const fallbackRelayCount = relays.length - writeRelays.length
+    log(`${filename}: Uploading file part ${++chunkIndex} of ${chunkLength} to ${writeRelays.length} relays${fallbackRelayCount > 0 ? ` (+${fallbackRelayCount} fallback)` : ''}`)
+    ;({ pause } = (await throttledSendEvent(event, relays, { pause, log, trailingPause: true })))
   }
   return { pause }
 }
@@ -239,20 +246,24 @@ async function throttledSendEvent (event, relays, {
   })
 }
 
-async function getPreviousCtags (dTagValue, currentCtagValue, writeRelays, signer) {
+async function getPreviousCtags (dTagValue, currentCtagValue, relays, signer) {
+  const targetRelays = [...new Set([...relays, ...nappRelays])]
   const storedEvents = (await nostrRelays.getEvents({
     kinds: [34600],
     authors: [await signer.getPublicKey()],
     '#d': [dTagValue],
     limit: 1
-  }, writeRelays)).result
+  }, targetRelays)).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
+  storedEvents.sort((a, b) => b.created_at - a.created_at)
+  const bestEvent = storedEvents[0]
+  const prevTags = bestEvent.tags
+
   if (!Array.isArray(prevTags)) return { otherCtags: [], hasEvent, hasCurrentCtag }
 
   hasCurrentCtag = prevTags.some(tag =>
@@ -275,26 +286,78 @@ async function getPreviousCtags (dTagValue, currentCtagValue, writeRelays, signe
       return isCTag && isntDuplicate
     })
 
-  return { otherCtags, hasEvent, hasCurrentCtag }
+  const matchingEvents = storedEvents.filter(e => e.id === bestEvent.id)
+  const coveredRelays = new Set(matchingEvents.map(e => e.meta?.relay).filter(Boolean))
+  const missingRelays = targetRelays.filter(r => !coveredRelays.has(r))
+
+  return { otherCtags, hasEvent, hasCurrentCtag, foundEvent: bestEvent, missingRelays }
 }
 
-async function uploadBundle ({ dTag, channel, fileMetadata, signer, pause = 0 }) {
+async function uploadBundle ({ dTag, channel, fileMetadata, signer, pause = 0, shouldReupload = false, log = () => {} }) {
   const kind = {
     main: 37448, // stable
     next: 37449, // insider
     draft: 37450 // vibe coded preview
   }[channel] ?? 37448
+
+  const fileTags = fileMetadata.map(v => ['file', v.rootHash, v.filename, v.mimeType])
+  const tags = [
+    ['d', dTag],
+    ...fileTags
+  ]
+
+  const writeRelays = [...new Set([...(await signer.getRelays()).write, ...nappRelays])]
+
+  if (!shouldReupload) {
+    const events = (await nostrRelays.getEvents({
+      kinds: [kind],
+      authors: [await signer.getPublicKey()],
+      '#d': [dTag],
+      limit: 1
+    }, writeRelays)).result
+
+    if (events.length > 0) {
+      events.sort((a, b) => {
+        if (b.created_at !== a.created_at) return b.created_at - a.created_at
+        if (a.id < b.id) return -1
+        if (a.id > b.id) return 1
+        return 0
+      })
+
+      const mostRecentEvent = events[0]
+      const recentFileTags = mostRecentEvent.tags.filter(t => t[0] === 'file')
+
+      const isSame = fileTags.length === recentFileTags.length && fileTags.every((t, i) => {
+        const rt = recentFileTags[i]
+        return rt.length >= 4 && rt[1] === t[1] && rt[2] === t[2] && rt[3] === t[3]
+      })
+
+      if (isSame) {
+        log(`Bundle based on ${fileTags.length} files is up-to-date (id: ${mostRecentEvent.id} - created_at: ${new Date(mostRecentEvent.created_at * 1000).toISOString()})`)
+
+        const matchingEvents = events.filter(e => e.id === mostRecentEvent.id)
+        const coveredRelays = new Set(matchingEvents.map(e => e.meta?.relay).filter(Boolean))
+        const missingRelays = writeRelays.filter(r => !coveredRelays.has(r))
+
+        if (missingRelays.length === 0) return mostRecentEvent
+
+        // nostrRelays.getEvents currently doesn't tell us which event came from which relay,
+        // so we re-upload to all relays to ensure consistency
+        log(`Re-uploading existing bundle event to ${missingRelays.length} missing relays (out of ${writeRelays.length})`)
+        await throttledSendEvent(mostRecentEvent, missingRelays, { pause, trailingPause: true, log })
+        return mostRecentEvent
+      }
+    }
+  }
+
   const appBundle = {
     kind,
-    tags: [
-      ['d', dTag],
-      ...fileMetadata.map(v => ['file', v.rootHash, v.filename, v.mimeType])
-    ],
+    tags,
     content: '',
     created_at: Math.floor(Date.now() / 1000)
   }
   const event = await signer.signEvent(appBundle)
-  await throttledSendEvent(event, (await signer.getRelays()).write, { pause, trailingPause: true })
+  await throttledSendEvent(event, writeRelays, { pause, trailingPause: true, log })
   return event
 }
 
@@ -325,13 +388,14 @@ async function maybeUploadStall ({
   const hasMetadata = Boolean(trimmedName) || Boolean(trimmedSummary) || Boolean(iconRootHash) ||
     Boolean(self) || (countries && countries.length > 0) || (categories && categories.length > 0) || (hashtags && hashtags.length > 0)
 
-  const previous = await getPreviousStall(dTag, writeRelays, signer, channel)
+  const relays = [...new Set([...writeRelays, ...nappRelays])]
+
+  const previousResult = await getPreviousStall(dTag, relays, signer, channel)
+  const previous = previousResult?.previous
   if (!previous && !hasMetadata) return { pause }
 
   const publishStall = async (event) => {
     const signedEvent = await signer.signEvent(event)
-    // App stores are fetching stall events just from 44b relay for now
-    const relays = [...new Set([...writeRelays, 'wss://relay.44billion.net'])]
     return await throttledSendEvent(signedEvent, relays, { pause, log, trailingPause: true })
   }
 
@@ -557,7 +621,18 @@ async function maybeUploadStall ({
     }
   }
 
-  if (!changed) return { pause }
+  if (!changed) {
+    const { storedEvents } = previousResult
+
+    const matchingEvents = storedEvents.filter(e => e.id === previous.id)
+    const coveredRelays = new Set(matchingEvents.map(e => e.meta?.relay).filter(Boolean))
+    const missingRelays = relays.filter(r => !coveredRelays.has(r))
+
+    if (missingRelays.length === 0) return { pause }
+
+    log(`Re-uploading existing stall event to ${missingRelays.length} missing relays (out of ${relays.length})`)
+    return await throttledSendEvent(previous, missingRelays, { pause, log, trailingPause: true })
+  }
 
   return await publishStall({
     kind,
@@ -567,7 +642,7 @@ async function maybeUploadStall ({
   })
 }
 
-async function getPreviousStall (dTagValue, writeRelays, signer, channel) {
+async function getPreviousStall (dTagValue, relays, signer, channel) {
   const kind = {
     main: 37348,
     next: 37349,
@@ -579,8 +654,15 @@ async function getPreviousStall (dTagValue, writeRelays, signer, channel) {
     authors: [await signer.getPublicKey()],
     '#d': [dTagValue],
     limit: 1
-  }, writeRelays)).result
+  }, relays)).result
 
   if (storedEvents.length === 0) return null
-  return storedEvents.sort((a, b) => b.created_at - a.created_at)[0]
+
+  storedEvents.sort((a, b) => b.created_at - a.created_at)
+
+  return {
+    previous: storedEvents[0],
+    storedEvents,
+    targetRelayCount: relays.length
+  }
 }

package/src/services/nostr-relays.js

@@ -15,6 +15,9 @@ export const freeRelays = [
   'wss://relay.damus.io',
   'wss://relay.nostr.band'
 ]
+export const nappRelays = [
+  'wss://relay.44billion.net'
+]
 
 // Interacts with Nostr relays
 export class NostrRelays {
@@ -77,6 +80,7 @@ export class NostrRelays {
         const relay = await this.#getRelay(url)
         sub = relay.subscribe([filter], {
           onevent: (event) => {
+            event.meta = { relay: url }
             events.push(event)
           },
           onclose: err => {
@@ -112,6 +116,9 @@ export class NostrRelays {
 
   // 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) => {
       let timer
       const p = Promise.withResolvers()
@@ -121,7 +128,7 @@ export class NostrRelays {
         }, timeout))
 
         const relay = await this.#getRelay(url)
-        await relay.publish(event)
+        await relay.publish(eventToSend)
         p.resolve()
       } catch (err) {
         if (err.message?.startsWith('duplicate:')) return p.resolve()