Update scenarios

src/app/router.ts

@@ -56,7 +56,7 @@ export const decodeEntity = entity => {
     // pass
   }
 
-  return {type, data, relays: hints.FetchFromHints(data?.relays || []).getUrls()}
+  return {type, data, relays: hints.scenario([data?.relays || []]).getUrls()}
 }
 
 // Serializers
@@ -143,7 +143,12 @@ router.extend("notes", (id, {relays = []} = {}) => {
 
 router.extend("people", (pubkey, {relays = []} = {}) => {
   if (relays.length < 3) {
-    relays = relays.concat(hints.FetchFromPubkey(pubkey).getUrls(3 - relays.length))
+    relays = relays.concat(
+      hints
+        .FromPubkeys([pubkey])
+        .limit(3 - relays.length)
+        .getUrls(),
+    )
   }
 
   return nip19.nprofileEncode({pubkey, relays})

src/app/shared/Compose.svelte

@@ -30,7 +30,7 @@
 
   const pubkeyEncoder = {
     encode: pubkey => {
-      const relays = hints.FetchFromPubkey(pubkey).getUrls(3)
+      const relays = hints.FromPubkeys([pubkey]).limit(3).getUrls()
       const nprofile = nip19.nprofileEncode({pubkey, relays})
 
       return "nostr:" + nprofile

src/app/shared/Feed.svelte

@@ -47,7 +47,7 @@
       selection = getRelaysFromFilters(compileFilters([filter]))
     }
 
-    return hints.FetchFromHints(selection).getUrls().concat(LOCAL_RELAY_URL)
+    return hints.scenario([selection]).getUrls().concat(LOCAL_RELAY_URL)
   }
 
   const loadMore = () => feed.load(5)

src/app/shared/Note.svelte

@@ -69,7 +69,7 @@
     if (interactive && !["I"].includes(target.tagName) && !target.closest("a")) {
       router
         .at("notes")
-        .of(getIdOrAddress(event), {relays: hints.FetchEvent(event).getUrls(3)})
+        .of(getIdOrAddress(event), {relays: hints.Event(event).limit(3).getUrls()})
         .cx({context: ctx.concat(event)})
         .open()
     }
@@ -80,21 +80,21 @@
   const goToDetail = () =>
     router
       .at("notes")
-      .of(getIdOrAddress(event), {relays: hints.FetchEvent(event).getUrls(3)})
+      .of(getIdOrAddress(event), {relays: hints.Event(event).limit(3).getUrls()})
       .cx({context: ctx.concat(event)})
       .push()
 
   const goToParent = () =>
     router
       .at("notes")
-      .of(reply.value(), {relays: hints.FetchEventParent(event).getUrls(3)})
+      .of(reply.value(), {relays: hints.EventParent(event).limit(3).getUrls()})
       .cx({context: ctx.concat(event)})
       .open()
 
   const goToThread = () =>
     router
       .at("notes")
-      .of(getIdOrAddress(event), {relays: hints.FetchEvent(event).getUrls(3)})
+      .of(getIdOrAddress(event), {relays: hints.Event(event).limit(3).getUrls()})
       .at("thread")
       .cx({context: ctx.concat(event)})
       .open()
@@ -180,7 +180,7 @@
 
     if (!event.pubkey) {
       event = await loadOne({
-        relays: hints.FetchFromHints(relays).getUrls(),
+        relays: hints.scenario([relays]).getUrls(),
         filters: getIdFilters([event.id]),
       })
     }
@@ -205,7 +205,7 @@
       }
 
       load({
-        relays: hints.FetchEventChildren(event).getUrls(),
+        relays: hints.EventChildren(event).getUrls(),
         filters: getReplyFilters([event], {kinds}),
         onEvent: batch(200, events => {
           ctx = uniqBy(prop("id"), ctx.concat(events))

src/app/shared/NoteActions.svelte

@@ -55,8 +55,8 @@
   export let zapper
 
   const tags = Tags.fromEvent(note)
-  const relays = hints.FetchEvent(note).getUrls(3)
   const address = tags.context().values().first()
+  const relays = hints.Event(note).limit(3).getUrls()
   const nevent = nip19.neventEncode({id: note.id, relays})
   const muted = isEventMuted.derived($isEventMuted => $isEventMuted(note, true))
   const kindHandlers = deriveHandlers(note.kind).derived(filter((h: any) => h.recs.length > 1))
@@ -66,7 +66,7 @@
   const repliesCount = tweened(0, {interpolate})
   const handler = handlers.key(tags.get("client")?.mark())
 
-  //const report = () => router.at("notes").of(note.id, {relays: hints.FetchEvent(note).getUrls(3)}).at('report').qp({pubkey: note.pubkey}).open()
+  //const report = () => router.at("notes").of(note.id, {relays: hints.Event(note).getUrls(3)}).at('report').qp({pubkey: note.pubkey}).open()
 
   const setView = v => {
     view = v
@@ -139,7 +139,7 @@
   const broadcast = () => {
     Publisher.publish({
       event: asNostrEvent(note),
-      relays: hints.Broadcast().getUrls(),
+      relays: hints.Outbox().getUrls(),
     })
 
     toast.show("info", "Note has been re-published!")

src/app/shared/NoteContentKind0.svelte

@@ -19,7 +19,7 @@
     router
       .at("people")
       .of(pubkey)
-      .cx({relays: hints.FetchEvent(note).getUrls(3)})
+      .cx({relays: hints.Event(note).limit(3).getUrls()})
       .open()
 </script>
 

src/app/shared/NoteContentQuote.svelte

@@ -1,6 +1,5 @@
 <script lang="ts">
   import {onMount} from "svelte"
-  import {uniq} from "ramda"
   import {isShareableRelayUrl, getAddress} from "paravel"
   import {filterVals} from "hurdak"
   import {asArray} from "src/util/misc"
@@ -20,11 +19,12 @@
 
   const {id, identifier, kind, pubkey} = value
 
-  // Prioritize hints in relay selection by merging directly
-  const relays = uniq([
-    ...(value.relays || []).filter(isShareableRelayUrl),
-    ...hints.FetchEventParent(note).getUrls(),
-  ])
+  const relays = hints
+    .merge([
+      hints.scenario([(value.relays || []).filter(isShareableRelayUrl)]),
+      hints.EventParent(note),
+    ])
+    .getUrls()
 
   const openQuote = e => {
     const noteId = value.id || quote?.id

src/app/shared/NoteContentRating.svelte

@@ -15,7 +15,7 @@
 
   if (tag) {
     const [type, value] = tag.valueOf()
-    const relays = hints.FetchEvent(note).getUrls(3)
+    const relays = hints.Event(note).limit(3).getUrls()
 
     href = switcherFn(type, {
       r: () => router.at("relays").of(value).toString(),

src/app/shared/NoteOptions.svelte

@@ -13,7 +13,7 @@
   import RelayCard from "src/app/shared/RelayCard.svelte"
   import GroupSummary from "src/app/shared/GroupSummary.svelte"
   import RelaySearch from "src/app/shared/RelaySearch.svelte"
-  import {env, hints, session, deriveGroupOptions, displayRelay} from "src/engine"
+  import {env, hints, deriveGroupOptions, displayRelay} from "src/engine"
 
   export let hideFields = []
   export let initialValues: {
@@ -58,7 +58,7 @@
     }
 
     if (!relaysDirty) {
-      values.relays = hints.PublishToContexts(values.groups).getUrls()
+      values.relays = hints.WithinMultipleContexts(values.groups).getUrls()
     }
   }
 

src/app/shared/PersonActions.svelte

@@ -92,7 +92,7 @@
   const share = () =>
     router
       .at("qrcode")
-      .of(nip19.nprofileEncode({pubkey, relays: hints.FetchFromPubkey(pubkey).getUrls()}))
+      .of(nip19.nprofileEncode({pubkey, relays: hints.FromPubkeys([pubkey]).limit(3).getUrls()}))
       .open()
 </script>
 

src/app/shared/PersonCollections.svelte

@@ -37,7 +37,7 @@
   }
 
   load({
-    relays: hints.FetchFromPubkey(pubkey).getUrls(),
+    relays: hints.FromPubkeys([pubkey]).getUrls(),
     filters: [{kinds: [1985], authors: [pubkey], "#L": ["#t"]}],
     onEvent: batch(300, chunk => {
       events = [...events, ...chunk]

src/app/shared/PersonFollowers.svelte

@@ -20,7 +20,7 @@
   onMount(() => {
     const scroller = createScroller(loadMore, {element: getModal()})
     const sub = subscribe({
-      relays: hints.FetchFromPubkey(pubkey).getUrls(),
+      relays: hints.FromPubkeys([pubkey]).getUrls(),
       filters: [{kinds: [3], "#p": [pubkey]}],
       onEvent: batch(500, (events: Event[]) => {
         const newPubkeys = pluck("pubkey", events)

src/app/shared/RelaySearch.svelte

@@ -42,7 +42,7 @@
   )
 
   load({
-    relays: hints.Aggregate().getUrls(),
+    relays: hints.Inbox().getUrls(),
     filters: [{limit: 1000, kinds: [1986], "#l": ["review/relay"]}],
     onEvent: event => {
       reviews = reviews.concat(event)

src/app/state.ts

@@ -1,6 +1,6 @@
 import Bugsnag from "@bugsnag/js"
 import {hash, union} from "hurdak"
-import {now} from "paravel"
+import {ConnectionStatus} from "paravel"
 import {warn} from "src/util/logger"
 import {userKinds} from "src/util/nostr"
 import {toast} from "src/partials/state"
@@ -88,11 +88,15 @@ setInterval(() => {
   // Prune connections we haven't used in a while, clear errors periodically,
   // and keep track of slow connections
   for (const [url, connection] of pool.data.entries()) {
-    if (connection.meta.last_activity < now() - 60) {
-      connection.socket.disconnect()
-    } else if (connection.lastError < Date.now() - 10_000) {
-      connection.clearError()
-    } else if (userRelays.has(url) && connection.meta.quality < 0.3) {
+    const {lastPublish, lastRequest, lastFault} = connection.meta
+    const lastActivity = Math.max(lastPublish, lastRequest)
+    const status = connection.meta.getStatus()
+
+    if (lastActivity < Date.now() - 60_000) {
+      connection.disconnect()
+    } else if (lastFault < Date.now() - 10_000) {
+      connection.disconnect()
+    } else if (userRelays.has(url) && status === ConnectionStatus.Slow) {
       $slowConnections.push(url)
     }
   }

src/app/views/GroupList.svelte

@@ -50,7 +50,7 @@
     })
 
     load({
-      relays: hints.Aggregate().getUrls(),
+      relays: hints.User().getUrls(),
       filters: [
         {kinds: [35834, 34550], authors: admins},
         {kinds: [35834, 34550], limit: 500},

src/app/views/InviteCreate.svelte

@@ -79,7 +79,7 @@
   const addGroup = e => {
     const newGroup = {
       address: groupSelection.address,
-      relay: hints.FetchFromContext(groupSelection.address).getUrl(),
+      relay: hints.WithinContext(groupSelection.address).getUrl(),
       claim: groupClaim,
     }
 

src/app/views/Login.svelte

@@ -88,7 +88,7 @@
 
   onMount(() => {
     load({
-      relays: hints.Aggregate().getUrls(),
+      relays: hints.Inbox().getUrls(),
       filters: [
         {
           kinds: [Handlerinformation],

src/app/views/NoteCreate.svelte

@@ -61,7 +61,7 @@
     summary: "",
     price: "",
     currency: currencyOptions.find(whereEq({code: "SAT"})),
-    relays: hints.PublishToContexts(defaultGroups).getUrls(),
+    relays: hints.WithinMultipleContexts(defaultGroups).getUrls(),
     groups: defaultGroups,
     anonymous: false,
     location: null,
@@ -197,7 +197,10 @@
     }
 
     if (quote) {
-      const nevent = nip19.neventEncode({id: quote.id, relays: hints.FetchEvent(quote).getUrls(3)})
+      const nevent = nip19.neventEncode({
+        id: quote.id,
+        relays: hints.Event(quote).limit(3).getUrls(),
+      })
 
       compose.nevent("nostr:" + nevent)
     }

src/app/views/UserData.svelte

@@ -70,7 +70,7 @@
           <Anchor
             href={router
               .at("notes")
-              .of(event.id, {relays: hints.FetchEvent(event).getUrls(3)})
+              .of(event.id, {relays: hints.Event(event).limit(3).getUrls()})
               .toString()}>
             <i class="fa fa-link text-accent" />
           </Anchor>

src/app/views/Zap.svelte

@@ -62,7 +62,7 @@
         if (percent > 0 && totalWeight > 0) {
           zaps.push({
             pubkey: $env.PLATFORM_PUBKEY,
-            relay: hints.FetchFromPubkey($env.PLATFORM_PUBKEY).getUrl(),
+            relay: hints.FromPubkeys([$env.PLATFORM_PUBKEY]).getUrl(),
             amount: Math.round(zaps.reduce((a, z) => a + z.amount, 0) * percent),
             status: "pending",
             isTip: true,
@@ -86,7 +86,9 @@
         return
       }
 
-      const relays = hints.PublishMessage([zap.pubkey]).getUrls(null, [zap.relay])
+      const relays = hints
+        .merge([hints.PublishMessage(zap.pubkey), hints.scenario([[zap.relay]])])
+        .getUrls()
 
       zaps[i].invoice = await requestZap(msg, zap.amount, {
         eid,

src/engine/channels/commands.ts

@@ -23,7 +23,7 @@ export const sendLegacyMessage = async (channelId: string, content: string) => {
 
   return Publisher.publish({
     event: await signer.get().signAsUser(template),
-    relays: hints.PublishMessage(recipients).getUrls(),
+    relays: hints.PublishMessage(pubkey).getUrls(),
   })
 }
 
@@ -46,7 +46,7 @@ export const sendMessage = async (channelId: string, content: string) => {
 
     Publisher.publish({
       event: rumor.wrap,
-      relays: hints.PublishMessage(recipients).getUrls(),
+      relays: hints.merge(recipients.map(hints.PublishMessage)).getUrls(),
     })
   }
 }

src/engine/channels/requests.ts

@@ -19,7 +19,7 @@ export const loadAllMessages = ({reload = false} = {}) => {
   })
 
   const cursor = new MultiCursor({
-    relays: hints.FetchAllMessages().getUrls(),
+    relays: hints.AllMessages().getUrls(),
     filters: [
       {kinds: [4], authors: [pubkey], since},
       {kinds: [4, 1059], "#p": [pubkey], since},
@@ -53,7 +53,7 @@ export const listenForMessages = (pubkeys: string[]) => {
 
   return subscribe({
     skipCache: true,
-    relays: hints.FetchMessages(pubkeys).getUrls(),
+    relays: hints.Messages(pubkeys).getUrls(),
     filters: [
       {kinds: [4], authors: allPubkeys, "#p": allPubkeys},
       {kinds: [1059], "#p": [pubkey]},

src/engine/events/commands.ts

@@ -21,7 +21,7 @@ export const markAsSeenPublicly = batch(5000, async idChunks => {
     const event = await signer.get().signAsUser(createReadReceipt(ids))
 
     if (event) {
-      Publisher.publish({event, relays: hints.NoteToSelf().getUrls()})
+      Publisher.publish({event, relays: hints.Outbox().getUrls()})
     }
   }
 })
@@ -41,7 +41,7 @@ export const markAsSeenPrivately = batch(5000, async idChunks => {
 
     Publisher.publish({
       event: rumor.wrap,
-      relays: hints.NoteToSelf().getUrls(),
+      relays: hints.Outbox().getUrls(),
     })
   }
 })

src/engine/events/requests.ts

@@ -8,7 +8,7 @@ export const loadDeletes = () => {
   const since = Math.max(0, deletes_last_synced - seconds(6, "hour"))
 
   return load({
-    relays: hints.Aggregate().getUrls(),
+    relays: hints.User().getUrls(),
     filters: [{kinds: [5], authors: [pubkey], since}],
   })
 }
@@ -18,7 +18,7 @@ export const loadSeen = () => {
   const since = Math.max(0, deletes_last_synced - seconds(6, "hour"))
 
   return load({
-    relays: hints.NoteToSelf().getUrls(),
+    relays: hints.Outbox().getUrls(),
     filters: [{kinds: [15], authors: [pubkey], since}],
   })
 }
@@ -39,7 +39,7 @@ export const loadGiftWrap = () => {
     const since = Math.max(0, nip59_messages_last_synced - seconds(6, "hour"))
 
     return load({
-      relays: hints.FetchAllMessages().getUrls(),
+      relays: hints.AllMessages().getUrls(),
       filters: [{kinds: [1059, 1060], authors: [pubkey], since}],
     })
   }

src/engine/groups/commands.ts

@@ -11,7 +11,12 @@ import {displayPubkey} from "src/engine/people/utils"
 import {hints} from "src/engine/relays/utils"
 import {GroupAccess} from "./model"
 import {groups, groupAdminKeys, groupSharedKeys} from "./state"
-import {deriveGroup, deriveAdminKeyForGroup, deriveSharedKeyForGroup, deriveIsGroupMember} from "./utils"
+import {
+  deriveGroup,
+  deriveAdminKeyForGroup,
+  deriveSharedKeyForGroup,
+  deriveIsGroupMember,
+} from "./utils"
 
 // Key state management
 
@@ -80,7 +85,7 @@ export const wrapWithFallback = async (template, {author = null, wrap}) => {
 
 export const publishToGroupAdmin = async (address, template) => {
   const addr = Address.fromRaw(address)
-  const relays = hints.PublishToContext(address).getUrls()
+  const relays = hints.WithinContext(address).getUrls()
   const pubkeys = [addr.pubkey, session.get().pubkey]
 
   const pubs = []
@@ -104,7 +109,7 @@ export const publishToGroupAdmin = async (address, template) => {
 }
 
 export const publishAsGroupAdminPublicly = async (address, template) => {
-  const relays = hints.PublishToContext(address).getUrls()
+  const relays = hints.WithinContext(address).getUrls()
   const adminKey = deriveAdminKeyForGroup(address).get()
   const event = await signer.get().signWithKey(template, adminKey.privkey)
 
@@ -112,7 +117,7 @@ export const publishAsGroupAdminPublicly = async (address, template) => {
 }
 
 export const publishAsGroupAdminPrivately = async (address, template) => {
-  const relays = hints.PublishToContext(address).getUrls()
+  const relays = hints.WithinContext(address).getUrls()
   const adminKey = deriveAdminKeyForGroup(address).get()
   const sharedKey = deriveSharedKeyForGroup(address).get()
 
@@ -160,7 +165,7 @@ export const publishToGroupsPrivately = async (addresses, template, {anonymous =
   const pubs = []
   const events = []
   for (const address of addresses) {
-    const relays = hints.PublishToContext(address).getUrls()
+    const relays = hints.WithinContext(address).getUrls()
     const thisTemplate = updateIn("tags", (tags: string[][]) => [...tags, ["a", address]], template)
     const sharedKey = deriveSharedKeyForGroup(address).get()
 
@@ -229,7 +234,7 @@ export const publishToZeroOrMoreGroups = async (addresses, template, {anonymous
 // Admin functions
 
 export const publishKeyShares = async (address, pubkeys, template) => {
-  const relays = hints.PublishToContext(address).getUrls()
+  const relays = hints.WithinContext(address).getUrls()
   const adminKey = deriveAdminKeyForGroup(address).get()
 
   const pubs = []

src/engine/groups/projections.ts

@@ -53,7 +53,7 @@ projections.addHandler(24, (e: Event) => {
 
     // Load the group's metadata and posts
     load({
-      relays: hints.FetchFromHints(relays).getUrls(),
+      relays: hints.scenario([relays]).getUrls(),
       filters: [
         ...getIdFilters([address]),
         {kinds: [1059, 1060], "#p": [pubkey]},
@@ -160,7 +160,7 @@ projections.addHandler(10004, (e: Event) => {
 
   const addresses = Tags.fromEvent(e).communities().values().valueOf()
 
-  for (const address of uniq(Object.keys($session.groups.values || {}).concat(addresses))) {
+  for (const address of uniq(Object.keys($session.groups?.values || {}).concat(addresses))) {
     $session = modifyGroupStatus($session, address, e.created_at, {
       joined: addresses.includes(address),
     })

src/engine/groups/requests.ts

@@ -44,7 +44,7 @@ export const loadGroups = async (rawAddrs: string[], relays: string[] = []) => {
 
   if (addrs.length > 0) {
     load({
-      relays: hints.FetchFromHints(relays).getUrls(),
+      relays: hints.scenario([relays]).getUrls(),
       filters: [{kinds: [34550, 35834], authors, "#d": identifiers}],
     })
   }

src/engine/groups/utils.ts

@@ -1,6 +1,6 @@
 import {prop, uniqBy, defaultTo, sortBy, last, whereEq} from "ramda"
 import {ellipsize, first, seconds} from "hurdak"
-import {Tags, Address, useMaximalFallbacks, RelayMode} from "paravel"
+import {Tags, Address} from "paravel"
 import {fuzzy} from "src/util/misc"
 import type {GroupStatus, Session} from "src/engine/session/model"
 import {pubkey} from "src/engine/session/state"
@@ -70,12 +70,7 @@ export const getGroupReqInfo = (address = null) => {
     recipients.push(key.pubkey)
   }
 
-  const relays = hints
-    .merge({
-      fallbackPolicy: useMaximalFallbacks(RelayMode.Inbox),
-      scenarios: addresses.map(a => hints.FetchFromContext(a)),
-    })
-    .getUrls()
+  const relays = hints.merge(addresses.map(hints.WithinContext)).getUrls()
 
   return {admins, recipients, relays, since}
 }
@@ -86,7 +81,7 @@ export const getCommunityReqInfo = (address = null) => {
 
   return {
     since: since - seconds(6, "hour"),
-    relays: hints.FetchFromContext(address).getUrls(),
+    relays: hints.WithinContext(address).getUrls(),
   }
 }
 

src/engine/handlers/commands.ts

@@ -13,7 +13,7 @@ export const deriveHandlers = cached({
     const $follows = follows.get()
 
     load({
-      relays: hints.Aggregate().getUrls(),
+      relays: hints.Inbox().getUrls(),
       filters: [
         {kinds: [31989], "#d": [String(kind)], authors: Array.from($follows)},
         {kinds: [31990], "#k": [String(kind)]},

src/engine/network/utils/dvms.ts

@@ -27,7 +27,7 @@ export const dvmRequest = async ({
   onProgress = null,
 }: DVMRequestOpts): Promise<Event> => {
   if (!relays) {
-    relays = hints.Broadcast().getUrls(null, env.get().DVM_RELAYS)
+    relays = hints.merge([hints.Outbox(), hints.scenario([env.get().DVM_RELAYS])]).getUrls()
   }
 
   if (typeof input !== "string") {

src/engine/network/utils/filters.ts

@@ -1,4 +1,4 @@
-import {Address, getAddress, isContextAddress, useMaximalFallbacks, RelayMode} from "paravel"
+import {Address, getAddress, isContextAddress} from "paravel"
 import {omit, without, find, prop, groupBy, uniq} from "ramda"
 import {shuffle, randomId, seconds, avg} from "hurdak"
 import {isAddressable} from "src/util/nostr"
@@ -166,18 +166,17 @@ export const compileFilters = (filters: DynamicFilter[], opts: CompileFiltersOpt
 
 export const getRelaysFromFilters = filters =>
   hints
-    .merge({
-      fallbackPolicy: useMaximalFallbacks(RelayMode.Inbox),
-      scenarios: filters.flatMap(filter => {
+    .merge(
+      filters.map(filter => {
         if (filter["#a"]?.some(isContextAddress)) {
-          return filter["#a"].filter(isContextAddress).map(hints.FetchFromContext)
+          return hints.WithinMultipleContexts(filter["#a"].filter(isContextAddress))
         }
 
         if (filter.authors) {
-          return filter.authors.map(hints.FetchFromPubkey)
+          return hints.FromPubkeys(filter.authors)
         }
 
-        return [hints.Aggregate()]
+        return hints.Inbox()
       }),
-    })
+    )
     .getUrls()

src/engine/network/utils/load.ts

@@ -90,11 +90,7 @@ export const execute = batch(500, (items: LoadItem[]) => {
 
   // If we're using multiplexer, let it do its thing
   if (getSetting("multiplextr_url")) {
-    loadChunk(
-      items,
-      hints.FetchFromHints(items.map(getPath(["request", "relays"]))).getUrls(),
-      tracker,
-    )
+    loadChunk(items, hints.scenario(items.map(getPath(["request", "relays"]))).getUrls(), tracker)
   } else {
     const itemsByRelay = {}
     for (const item of items) {

src/engine/network/utils/pubkeys.ts

@@ -68,6 +68,6 @@ export const loadPubkeys = async (
 
   return load({
     filters,
-    relays: hints.FetchFromPubkeys(pubkeys).getUrls(null, relays),
+    relays: hints.merge([hints.scenario([relays]), hints.FromPubkeys(pubkeys)]).getUrls(),
   })
 }

src/engine/network/utils/publish.ts

@@ -150,7 +150,7 @@ export type PublishOpts = EventOpts & {
 export const publish = async (template, {sk, relays}: PublishOpts = {}) => {
   return Publisher.publish({
     timeout: 5000,
-    relays: relays || hints.Broadcast().getUrls(),
+    relays: relays || hints.Outbox().getUrls(),
     event: sk
       ? await signer.get().signWithKey(template, sk)
       : await signer.get().signAsUser(template),

src/engine/network/utils/subscribe.ts

@@ -11,12 +11,12 @@ import {Tracker} from "./tracker"
 export type SubscribeOpts = Omit<SubscriptionOpts, "executor"> & {
   relays?: string[]
   tracker?: Tracker
+  executor?: Executor
   skipCache?: boolean
   shouldProject?: boolean
   onEvent?: (e: Event) => void
   onEose?: (url: string) => void
   onClose?: (events: Event[]) => void
-  executor?: Executor
 }
 
 const getExecutorFromOpts = (opts: SubscribeOpts) => {

src/engine/network/utils/thread.ts

@@ -41,7 +41,7 @@ export class ThreadLoader {
 
     if (filteredIds.length > 0) {
       load({
-        relays: hints.FetchFromHints(this.relays).getUrls(),
+        relays: hints.scenario([this.relays]).getUrls(),
         filters: getIdFilters(filteredIds),
         onEvent: batch(300, (events: Event[]) => {
           this.addToThread(events)

src/engine/notes/commands.ts

@@ -7,7 +7,7 @@ export const publishNote = (content, tags = [], relays = null) =>
 
 export const publishDeletion = ids =>
   createAndPublish(5, {
-    relays: hints.Broadcast().getUrls(),
+    relays: hints.Outbox().getUrls(),
     tags: ids.map(id => [id.includes(":") ? "a" : "e", id]),
   })
 

src/engine/notes/requests.ts

@@ -21,7 +21,7 @@ export const dereferenceNote = async ({
     }
 
     return loadOne({
-      relays: hints.FetchFromHints(relays).getUrls(),
+      relays: hints.scenario([relays]).getUrls(),
       filters: getIdFilters([eid]),
     })
   }
@@ -45,7 +45,7 @@ export const dereferenceNote = async ({
       subscribe({
         timeout: 3000,
         closeOnEose: true,
-        relays: hints.FetchFromHints(relays).getUrls(),
+        relays: hints.scenario([relays]).getUrls(),
         filters: [{kinds: [kind], authors: [pubkey], "#d": [identifier]}],
         onClose: () => resolve(note),
         onEvent: event => {
@@ -67,7 +67,7 @@ type LoadReactionsRequest = {
 
 const executeLoadReactions = batch(500, async (requests: LoadReactionsRequest[]) => {
   const ids = pluck("id", requests)
-  const relays = hints.FetchFromHints(...pluck("relays", requests)).getUrls()
+  const relays = hints.scenario(pluck("relays", requests)).getUrls()
 
   let data = {}
 

src/engine/notifications/requests.ts

@@ -1,4 +1,4 @@
-import {now, Tags, RelayMode, useMaximalFallbacks} from "paravel"
+import {now, Tags} from "paravel"
 import {seconds, updateIn, batch, doPipe} from "hurdak"
 import {pluck, max, slice, filter, without, sortBy} from "ramda"
 import {noteKinds, repostKinds, reactionKinds} from "src/util/nostr"
@@ -40,12 +40,7 @@ const onNotificationEvent = batch(300, (chunk: Event[]) => {
   loadPubkeys(pubkeys)
 
   load({
-    relays: hints
-      .merge({
-        fallbackPolicy: useMaximalFallbacks(RelayMode.Inbox),
-        scenarios: eventsWithParent.map(hints.FetchEventParent),
-      })
-      .getUrls(),
+    relays: hints.merge(eventsWithParent.map(hints.EventParent)).getUrls(),
     filters: getIdFilters(
       eventsWithParent.flatMap(e => Tags.fromEvent(e).replies().values().valueOf()),
     ),
@@ -90,7 +85,7 @@ export const loadNotifications = () => {
     timeout: 15000,
     skipCache: true,
     closeOnEose: true,
-    relays: hints.Aggregate().getUrls(),
+    relays: hints.Inbox().getUrls(),
     onEvent: onNotificationEvent,
   })
 }
@@ -121,7 +116,7 @@ export const listenForNotifications = async () => {
     filters,
     timeout: 30_000,
     skipCache: true,
-    relays: hints.Aggregate().getUrls(),
+    relays: hints.Inbox().getUrls(),
     onEvent: onNotificationEvent,
   })
 }

src/engine/people/utils.ts

@@ -166,7 +166,7 @@ export const getWotScore = (pk, tpk) => {
 }
 
 const annotatePerson = pubkey => {
-  const relays = hints.FetchFromPubkey(pubkey).getUrls()
+  const relays = hints.FromPubkeys([pubkey]).getUrls()
 
   return {
     pubkey,

src/engine/relays/utils.ts

@@ -1,8 +1,8 @@
 import {nip19} from "nostr-tools"
 import {Router} from "paravel"
-import {normalizeRelayUrl as normalize, fromNostrURI} from "paravel"
+import {normalizeRelayUrl as normalize, ConnectionStatus, fromNostrURI} from "paravel"
 import {sortBy, whereEq, pluck, uniq, prop, last} from "ramda"
-import {displayList} from "hurdak"
+import {displayList, switcher} from "hurdak"
 import {fuzzy} from "src/util/misc"
 import {LOCAL_RELAY_URL} from "src/util/nostr"
 import {env} from "src/engine/session/state"
@@ -37,9 +37,6 @@ export const decodeRelay = entity => {
   }
 }
 
-export const relayIsLowQuality = (url: string) =>
-  pool.get(url, {autoConnect: false})?.meta?.quality < 0.6
-
 export const displayRelay = ({url}: Relay) => last(url.split("://")).replace(/\/$/, "")
 
 export const displayRelays = (relays: Relay[], max = 3) =>
@@ -90,9 +87,20 @@ export const hints = new Router({
   getUserPubkey: () => stateKey.get(),
   getGroupRelays: getGroupRelayUrls,
   getCommunityRelays: getGroupRelayUrls,
-  getPubkeyInboxRelays: pubkey => getPubkeyRelayUrls(pubkey, "read"),
-  getPubkeyOutboxRelays: pubkey => getPubkeyRelayUrls(pubkey, "write"),
-  getFallbackInboxRelays: () => env.get().DEFAULT_RELAYS,
-  getFallbackOutboxRelays: () => env.get().DEFAULT_RELAYS,
-  getDefaultLimit: () => getSetting("relay_limit"),
+  getPubkeyRelays: getPubkeyRelayUrls,
+  getDefaultRelays: () => env.get().DEFAULT_RELAYS,
+  getDefaultLimit: () => parseInt(getSetting("relay_limit")),
+  getRelayQuality: (url: string) => {
+    const connection = pool.get(url, {autoConnect: false})
+
+    return switcher(connection?.meta.getStatus(), {
+      [ConnectionStatus.Unauthorized]: 0.5,
+      [ConnectionStatus.Forbidden]: 0,
+      [ConnectionStatus.Error]: 0,
+      [ConnectionStatus.Closed]: 0.6,
+      [ConnectionStatus.Slow]: 0.5,
+      [ConnectionStatus.Ok]: 1,
+      default: 0.5,
+    })
+  },
 })

src/engine/reports/commands.ts

@@ -7,6 +7,6 @@ import {Publisher} from "src/engine/network/utils"
 // Use an ephemeral private key for user privacy
 export const publishReport = async (content = "", tags = []) =>
   Publisher.publish({
-    relays: hints.Broadcast().getUrls(),
+    relays: hints.Outbox().getUrls(),
     event: await signer.get().signWithKey(createEvent(1984, {content, tags}), generatePrivateKey()),
   })