Convert reports

src/app/state.ts

@@ -5,7 +5,7 @@ import {nip19} from "nostr-tools"
 import {navigate} from "svelte-routing"
 import {writable} from "svelte/store"
 import {whereEq, omit, filter, pluck, sortBy, slice} from "ramda"
-import {hash, sleep, doPipe, shuffle} from "hurdak"
+import {hash, union, sleep, doPipe, shuffle} from "hurdak"
 import {warn} from "src/util/logger"
 import {now} from "src/util/misc"
 import {userKinds, noteKinds} from "src/util/nostr"
@@ -176,9 +176,9 @@ export const login = async (method: string, key: string | {pubkey: string; token
 
 export const toastProgress = progress => {
   const {event, succeeded, failed, timeouts, completed, pending} = progress
-  const total = completed.size + pending.size
+  const relays = Array.from(union(completed, pending))
 
-  let message = `Published to ${succeeded.size}/${total} relays`
+  let message = `Published to ${succeeded.size}/${relays.length} relays`
 
   const extra = []
   if (failed.size > 0) {
@@ -203,7 +203,7 @@ export const toastProgress = progress => {
         text: message,
         link: {
           text: "Details",
-          onClick: () => modal.push({type: "publish/info", event, progress}),
+          onClick: () => modal.push({type: "publish/info", event, progress, relays}),
         },
       }
 

src/app/views/PublishInfo.svelte

@@ -1,29 +1,30 @@
 <script lang="ts">
+  import {union} from "hurdak"
   import {nip19} from "nostr-tools"
   import {modal} from "src/partials/state"
   import Content from "src/partials/Content.svelte"
   import Heading from "src/partials/Heading.svelte"
   import Anchor from "src/partials/Anchor.svelte"
-  import {getSetting, getUserRelayUrls} from "src/engine2"
   import RelayCard from "src/app/shared/RelayCard.svelte"
-  import {Outbox, Nip65} from "src/app/engine"
+  import {Publisher} from "src/engine2"
   import {toastProgress} from "src/app/state"
 
   export let event
   export let progress
 
+  const {succeeded, timeouts, failed} = progress
+
   const noteLink =
     "/" +
     nip19.neventEncode({
       id: event.id,
-      relays: Array.from(progress.succeeded),
+      relays: Array.from(succeeded),
     })
 
   const retry = () => {
-    const limit = getSetting("relay_limit")
-    const relays = Nip65.getPublishHints(limit, event, getUserRelayUrls("write"))
+    const relays = Array.from(union(timeouts, failed)) as string[]
 
-    Outbox.publish({event, relays, onProgress: toastProgress})
+    Publisher.publish({relays, event}).on("progress", toastProgress)
 
     modal.pop()
   }

src/app/views/ReportCreate.svelte

@@ -1,5 +1,4 @@
 <script>
-  import {generatePrivateKey} from "nostr-tools"
   import {identity} from "ramda"
   import {seconds} from "hurdak"
   import {fuzzy, now} from "src/util/misc"
@@ -9,8 +8,7 @@
   import Anchor from "src/partials/Anchor.svelte"
   import Field from "src/partials/Field.svelte"
   import MultiSelect from "src/partials/MultiSelect.svelte"
-  import {getUserRelayUrls} from "src/engine2"
-  import {Builder, Outbox} from "src/app/engine"
+  import {publishReport} from "src/engine2"
 
   export let note
 
@@ -28,12 +26,7 @@
       }
     }
 
-    Outbox.publish({
-      event: Builder.createReport({tagClient: false, tags}),
-      relays: getUserRelayUrls("write"),
-      sk: generatePrivateKey(),
-    })
-
+    publishReport({tags})
     toast.show("info", "Your report has been sent!")
     modal.pop()
   }

src/engine2/commands/index.ts

@@ -1,8 +1,11 @@
+export * from "./publisher"
 export * from "./session"
+export * from "./util"
 export * from "./nip01"
 export * from "./nip04"
 export * from "./nip24"
 export * from "./nip28"
 export * from "./nip32"
+export * from "./nip56"
 export * from "./nip57"
 export * from "./nip95"

src/engine2/commands/nip56.ts

@@ -0,0 +1,12 @@
+import {generatePrivateKey} from "nostr-tools"
+import {signer, getUserRelayUrls} from "src/engine2/queries"
+import type {PublishOpts} from "./util"
+import {buildEvent} from "./util"
+import {Publisher} from "./publisher"
+
+// Use an ephemeral private key for user privacy
+export const publishReport = ({relays = null, content = "", tags = []}: PublishOpts) =>
+  Publisher.publish({
+    relays: relays || getUserRelayUrls("write"),
+    event: signer.get().signWithKey(buildEvent(1984, {content, tags}), generatePrivateKey()),
+  })

src/engine2/commands/publisher.ts

@@ -2,31 +2,31 @@ import EventEmitter from "events"
 import {omit} from "ramda"
 import {defer, union, difference} from "hurdak"
 import {info} from "src/util/logger"
-import type {Event} from "src/engine2/model"
+import type {Event, NostrEvent} from "src/engine2/model"
 import {getUrls, getExecutor} from "src/engine2/queries"
 
-export type PublishOpts = {
+export type PublisherOpts = {
   timeout?: number
   verb?: string
 }
 
-export type StaticPublishOpts = PublishOpts & {
-  event: Event
+export type StaticPublisherOpts = PublisherOpts & {
+  event: NostrEvent
   relays: string[]
 }
 
 export class Publisher extends EventEmitter {
   result = defer()
 
-  constructor(readonly event: Event) {
+  constructor(readonly event: NostrEvent) {
     super()
 
-    if (event.wrap) {
+    if ((event as Event).wrap) {
       throw new Error("Can't publish unwrapped events")
     }
   }
 
-  static publish({event, relays, ...opts}: StaticPublishOpts) {
+  static publish({event, relays, ...opts}: StaticPublisherOpts) {
     const publisher = new Publisher(event)
 
     publisher.publish(relays, opts)
@@ -34,7 +34,7 @@ export class Publisher extends EventEmitter {
     return publisher
   }
 
-  publish(relays, {timeout, verb}: PublishOpts = {}) {
+  publish(relays, {timeout, verb}: PublisherOpts = {}) {
     const urls = getUrls(relays)
     const executor = getExecutor(urls, {bypassBoot: verb === "AUTH"})
 

src/engine2/model/index.ts

@@ -2,6 +2,8 @@ import type {Event as NostrToolsEvent, UnsignedEvent} from "nostr-tools"
 
 // Message types
 
+export type NostrEvent = NostrToolsEvent
+
 export type Event = Omit<NostrToolsEvent, "kind"> & {
   kind: number
   seen_on: string[]