Move hints back to strings, make sure the strings are what the user asked for

packages/lib/Tools.ts

@@ -60,20 +60,6 @@ export const groupBy = <T>(f: (x: T) => string, xs: T[]) => {
   return r
 }
 
-export const pushToKey = <T>(m: Record<string, T[]> | Map<string, T[]>, k: string, v: T) => {
-  if (m instanceof Map) {
-    const a = m.get(k) || []
-
-    a.push(v)
-    m.set(k, a)
-  } else {
-    m[k] = m[k] || []
-    m[k].push(v)
-  }
-
-  return m
-}
-
 export const sample = <T>(n: number, xs: T[]) => {
   const result: T[] = []
 

packages/network/Subscribe.ts

@@ -237,7 +237,7 @@ export const executeSubscription = (sub: Subscription) => {
 export const executeSubscriptions = (subs: Subscription[]) =>
   mergeSubscriptions(subs).forEach(executeSubscription)
 
-export const executeSubscriptionBatched = batch(500, executeSubscriptions)
+export const executeSubscriptionBatched = batch(300, executeSubscriptions)
 
 export const subscribe = (request: SubscribeRequest) => {
   const subscription: Subscription = makeSubscription(request)

packages/util/Filters.ts

@@ -78,7 +78,7 @@ export const combineFilters = (filters: Filter[]) => {
   return result
 }
 
-export const getIdFilters = (idsOrAddresses: string[]) => {
+export const getIdFilters = (idsOrAddresses: Iterable<string>) => {
   const ids = []
   const aFilters = []
 

packages/util/Router.ts

@@ -1,8 +1,8 @@
-import type {EventTemplate, UnsignedEvent} from 'nostr-tools'
+import type {EventTemplate} from 'nostr-tools'
 import {first, identity, sortBy, uniq, shuffle} from '@coracle.social/lib'
+import {Tags, Tag} from '@coracle.social/util'
 import type {Rumor} from './Events'
 import {getAddress, isReplaceable} from './Events'
-import {Tag, Tags} from './Tags'
 import {isShareableRelayUrl} from './Relays'
 import {GROUP_DEFINITION, COMMUNITY_DEFINITION} from './Kinds'
 import {addressFromEvent, decodeAddress, isCommunityAddress, isGroupAddress} from './Address'
@@ -23,16 +23,16 @@ export type RouterOptions = {
   getRedundancy: () => number
 }
 
-export type TagsByRelay = Map<string, Tags>
+export type ValuesByRelay = Map<string, Set<string>>
 
-export type RelayTags = {
+export type RelayValues = {
   relay: string
-  tags: Tags
+  values: Set<string>
 }
 
-export type TagRelays = {
+export type ValueRelays = {
-  tag: Tag
+  value: string
-  relays: string[]
+  relays: Set<string>
 }
 
 export type FallbackPolicy = (count: number, limit: number) => number
@@ -45,11 +45,11 @@ export class Router {
   getTagSelections = (tags: Tags) =>
     tags
       .filter(t => isShareableRelayUrl(t.nth(2)))
-      .mapTo(t => this.selection(t.take(2), [t.nth(2)]))
+      .mapTo(t => this.selection(t.nth(1), [t.nth(2)]))
       .valueOf()
 
   getPubkeySelection = (pubkey: string, mode?: RelayMode) =>
-    this.pubkeySelection(pubkey, this.options.getPubkeyRelays(pubkey, mode))
+    this.selection(pubkey, this.options.getPubkeyRelays(pubkey, mode))
 
   getPubkeySelections = (pubkeys: string[], mode?: RelayMode) =>
     pubkeys.map(pubkey => this.getPubkeySelection(pubkey, mode))
@@ -59,32 +59,35 @@ export class Router {
 
   getContextSelections = (tags: Tags) => {
     return [
-      ...tags.communities().mapTo(t => this.selection(t, this.options.getCommunityRelays(t.value()))).valueOf(),
+      ...tags.communities().mapTo(t => this.selection(t.value(), this.options.getCommunityRelays(t.value()))).valueOf(),
-      ...tags.groups().mapTo(t => this.selection(t, this.options.getGroupRelays(t.value()))).valueOf(),
+      ...tags.groups().mapTo(t => this.selection(t.value(), this.options.getGroupRelays(t.value()))).valueOf(),
     ]
   }
 
-  // Utilities for creating ItemSelections
+  // Utilities for creating ValueRelays
 
-  selection = (tag: Tag, relays: string[]) => ({tag, relays})
+  selection = (value: string, relays: Iterable<string>) => ({value, relays: new Set(relays)})
 
-  pubkeySelection = (pubkey: string, relays: string[]) =>
+  selections = (values: string[], relays: string[]) =>
-    this.selection(Tag.fromPubkey(pubkey), relays)
+    values.map(value => this.selection(value, relays))
+
+  forceValue = (value: string, selections: ValueRelays[]) =>
+    selections.map(({relays}) => this.selection(value, relays))
 
   // Utilities for processing hints
 
-  relaySelectionsFromMap = (tagsByRelay: TagsByRelay) =>
+  relaySelectionsFromMap = (valuesByRelay: ValuesByRelay) =>
-    Array.from(tagsByRelay).map(([relay, tags]: [string, Tags]) => ({relay, tags}))
+    Array.from(valuesByRelay).map(([relay, values]: [string, Set<string>]) => ({relay, values}))
 
-  scoreRelaySelection = ({tags, relay}: RelayTags) =>
+  scoreRelaySelection = ({values, relay}: RelayValues) =>
-    tags.count() * this.options.getRelayQuality(relay)
+    values.size * this.options.getRelayQuality(relay)
 
-  sortRelaySelections = (relaySelections: RelayTags[]) => {
+  sortRelaySelections = (relaySelections: RelayValues[]) => {
     const scores = new Map<string, number>()
-    const getScore = (relayTags: RelayTags) => scores.get(relayTags.relay) || 0
+    const getScore = (relayValues: RelayValues) => scores.get(relayValues.relay) || 0
 
-    for (const relayTags of relaySelections) {
+    for (const relayValues of relaySelections) {
-      scores.set(relayTags.relay, this.scoreRelaySelection(relayTags))
+      scores.set(relayValues.relay, this.scoreRelaySelection(relayValues))
     }
 
     return sortBy(getScore, relaySelections.filter(getScore))
@@ -92,22 +95,15 @@ export class Router {
 
   // Utilities for creating scenarios
 
-  scenario = (selections: TagRelays[]) => new RouterScenario(this, selections)
+  scenario = (selections: ValueRelays[]) => new RouterScenario(this, selections)
 
   merge = (scenarios: RouterScenario[]) =>
     this.scenario(scenarios.flatMap((scenario: RouterScenario) => scenario.selections))
 
-  tagScenario = (tags: Tags, relays: string[]) =>
+  product = (values: string[], relays: string[]) =>
-    this.scenario(tags.mapTo(tag => this.selection(tag, relays)).valueOf())
+    this.scenario(this.selections(values, relays))
 
-  idScenario = (ids: string[], relays: string[]) =>
+  fromRelays = (relays: string[]) => this.scenario([this.selection("", relays)])
-    this.tagScenario(Tags.wrap(ids.map(id => ["e", id])), relays)
-
-  pubkeyScenario = (pubkeys: string[], relays: string[]) =>
-    this.tagScenario(Tags.wrap(pubkeys.map(pubkey => ["p", pubkey])), relays)
-
-  addressScenario = (addresses: string[], relays: string[]) =>
-    this.tagScenario(Tags.wrap(addresses.map(address => ["a", address])), relays)
 
   // Routing scenarios
 
@@ -129,35 +125,42 @@ export class Router {
       this.getPubkeySelection(pubkey, RelayMode.Read),
     ]).policy(this.addMinimalFallbacks)
 
-  Event = (event: UnsignedEvent) =>
+  Event = (event: Rumor) =>
-    this.scenario([
+    this.scenario(this.forceValue(event.id, [
       this.getPubkeySelection(event.pubkey, RelayMode.Write),
       ...this.getContextSelections(Tags.fromEvent(event).context()),
-    ])
+    ]))
 
-  EventChildren = (event: UnsignedEvent) =>
+  EventChildren = (event: Rumor) =>
-    this.scenario([
+    this.scenario(this.forceValue(event.id, [
       this.getPubkeySelection(event.pubkey, RelayMode.Read),
       ...this.getContextSelections(Tags.fromEvent(event).context()),
-    ])
+    ]))
 
-  EventAncestors = (event: UnsignedEvent) => {
+  EventAncestors = (event: Rumor, type: "mentions" | "replies" | "roots") => {
     const tags = Tags.fromEvent(event)
-    const ptags = tags.whereKey("p")
+    const ancestors = tags.ancestors()[type]
-    const atags = tags.context()
+    const pubkeys = tags.whereKey("p").values().valueOf()
-    const {replies, roots} = tags.ancestors()
+    const communities = tags.communities().values().valueOf()
-
+    const groups = tags.groups().values().valueOf()
-    return this.scenario([
+    const relays = uniq([
-      ...this.getTagSelections(replies),
+      ...this.options.getPubkeyRelays(event.pubkey, RelayMode.Read),
-      ...this.getTagSelections(roots),
+      ...pubkeys.flatMap((k: string) => this.options.getPubkeyRelays(k, RelayMode.Write)),
-      ...this.getTagSelections(ptags),
+      ...communities.flatMap((a: string) => this.options.getCommunityRelays(a)),
-      ...this.getContextSelections(atags),
+      ...groups.flatMap((a: string) => this.options.getGroupRelays(a)),
-      ...this.getPubkeySelections(ptags.values().valueOf(), RelayMode.Write),
+      ...ancestors.relays().valueOf(),
-      this.getPubkeySelection(event.pubkey, RelayMode.Read),
     ])
+
+    return this.product(ancestors.values().valueOf(), relays)
   }
 
-  PublishEvent = (event: UnsignedEvent) => {
+  EventMentions = (event: Rumor) => this.EventAncestors(event, "mentions")
+
+  EventParents = (event: Rumor) => this.EventAncestors(event, "replies")
+
+  EventRoots = (event: Rumor) => this.EventAncestors(event, "roots")
+
+  PublishEvent = (event: Rumor) => {
     const tags = Tags.fromEvent(event)
     const mentions = tags.values("p").valueOf()
 
@@ -168,11 +171,11 @@ export class Router {
         .policy(this.addNoFallbacks)
     }
 
-    return this.scenario([
+    return this.scenario(this.forceValue(event.id, [
       this.getPubkeySelection(event.pubkey, RelayMode.Write),
       ...this.getContextSelections(tags.context()),
       ...this.getPubkeySelections(mentions, RelayMode.Read),
-    ])
+    ]))
   }
 
   FromPubkeys = (pubkeys: string[]) =>
@@ -220,7 +223,7 @@ export class Router {
   tagEventId = (event: Rumor, ...extra: string[]) =>
     Tag.from(["e", event.id, this.Event(event).getUrl(), ...extra])
 
-  tagEventAddress = (event: UnsignedEvent, ...extra: string[]) =>
+  tagEventAddress = (event: Rumor, ...extra: string[]) =>
     Tag.from(["a", getAddress(event), this.Event(event).getUrl(), ...extra])
 
   tagEvent = (event: Rumor, ...extra: string[]) => {
@@ -233,7 +236,7 @@ export class Router {
     return new Tags(tags)
   }
 
-  address = (event: UnsignedEvent) =>
+  address = (event: Rumor) =>
     addressFromEvent(event, this.Event(event).redundancy(3).getUrls())
 }
 
@@ -246,13 +249,13 @@ export type RouterScenarioOptions = {
 }
 
 export class RouterScenario {
-  constructor(readonly router: Router, readonly selections: TagRelays[], readonly options: RouterScenarioOptions = {}) {}
+  constructor(readonly router: Router, readonly selections: ValueRelays[], readonly options: RouterScenarioOptions = {}) {}
 
   clone = (options: RouterScenarioOptions) =>
     new RouterScenario(this.router, this.selections, {...this.options, ...options})
 
-  select = (f: (selection: Tag) => boolean) =>
+  select = (f: (selection: string) => boolean) =>
-    new RouterScenario(this.router, this.selections.filter(({tag}) => f(tag)), this.options)
+    new RouterScenario(this.router, this.selections.filter(({value}) => f(value)), this.options)
 
   redundancy = (redundancy: number) => this.clone({redundancy})
 
@@ -267,42 +270,42 @@ export class RouterScenario {
   getLimit = () => this.options.limit
 
   getSelections = () => {
-    const tagsByRelay: TagsByRelay = new Map()
+    const valuesByRelay: ValuesByRelay = new Map()
-    for (const {tag, relays} of this.selections) {
+    for (const {value, relays} of this.selections) {
       for (const relay of relays) {
-        addTagToMap(tagsByRelay, relay, tag)
+        addToKey(valuesByRelay, relay, value)
       }
     }
 
     const redundancy = this.getRedundancy()
     const seen = new Map<string, number>()
-    const result: TagsByRelay = new Map()
+    const result: ValuesByRelay = new Map()
-    const relaySelections = this.router.relaySelectionsFromMap(tagsByRelay)
+    const relaySelections = this.router.relaySelectionsFromMap(valuesByRelay)
     for (const {relay} of this.router.sortRelaySelections(relaySelections)) {
-      const tags = []
+      const values = new Set<string>()
-      for (const tag of tagsByRelay.get(relay)?.valueOf() || []) {
+      for (const value of valuesByRelay.get(relay) || []) {
-        const timesSeen = seen.get(tag.value()) || 0
+        const timesSeen = seen.get(value) || 0
 
         if (timesSeen < redundancy) {
-          seen.set(tag.value(), timesSeen + 1)
+          seen.set(value, timesSeen + 1)
-          tags.push(tag)
+          values.add(value)
         }
       }
 
-      if (tags.length > 0) {
+      if (values.size > 0) {
-        result.set(relay, Tags.from(tags))
+        result.set(relay, values)
       }
     }
 
     const fallbacks = shuffle(this.router.options.getStaticRelays())
     const fallbackPolicy = this.getPolicy()
-    for (const {tag} of this.selections) {
+    for (const {value} of this.selections) {
-      const timesSeen = seen.get(tag.value()) || 0
+      const timesSeen = seen.get(value) || 0
       const fallbacksNeeded = fallbackPolicy(timesSeen, redundancy)
 
       if (fallbacksNeeded > 0) {
         for (const relay of fallbacks.slice(0, fallbacksNeeded)) {
-          addTagToMap(result, relay, tag)
+          addToKey(result, relay, value)
         }
       }
     }
@@ -314,10 +317,14 @@ export class RouterScenario {
       : this.router.relaySelectionsFromMap(result)
   }
 
-  getUrls = () => this.getSelections().map((selection: RelayTags) => selection.relay)
+  getUrls = () => this.getSelections().map((selection: RelayValues) => selection.relay)
 
   getUrl = () => first(this.getUrls())
 }
 
-const addTagToMap = (m: Map<string, Tags>, k: string, v: Tag) =>
+const addToKey = <T>(m: Map<string, Set<T>>, k: string, v: T) => {
-  m.set(k, (m.get(k) || Tags.from([])).append(v))
+  const a = m.get(k) || new Set<T>()
+
+  a.add(v)
+  m.set(k, a)
+}

packages/util/Tags.ts

@@ -79,7 +79,7 @@ export class Tags extends (Fluent<Tag> as OmitStatics<typeof Fluent<Tag>, 'from'
 
   topics = () => this.whereKey("t").values().map((t: string) => t.replace(/^#/, ""))
 
-  ancestors = () => {
+  ancestors = (x?: boolean) => {
     const tags = this.filter(t => ["a", "e", "q"].includes(t.key()) && !t.isContext())
     const parentTags = tags.filter(t => ["a", "e"].includes(t.key()))
     const mentionTags = tags.whereKey("q")
@@ -95,10 +95,10 @@ export class Tags extends (Fluent<Tag> as OmitStatics<typeof Fluent<Tag>, 'from'
           replies.push(t.valueOf())
         } else if (t.mark() === 'mention') {
           mentions.push(t.valueOf())
-        } else if (i === 0) {
-          roots.push(t.valueOf())
         } else if (i === parentTags.count() - 1) {
           replies.push(t.valueOf())
+        } else if (i === 0) {
+          roots.push(t.valueOf())
         } else {
           mentions.push(t.valueOf())
         }