@bsv/sdk 2.0.16 → 2.1.1

package/src/overlay-tools/LookupResolver.ts

@@ -38,6 +38,44 @@ export type LookupAnswer =
     }>
   }
 
+/**
+ * Per-call options for {@link LookupResolver.query} and {@link LookupResolver.query$}.
+ * All optional; defaults preserve prior behavior.
+ */
+export interface LookupQueryOptions {
+  /**
+   * Override the grace window (ms) between the first valid response and the resolution of the query.
+   * Late responders arriving within this window are merged into the result. Default 80 ms.
+   * Raise for identity-style paths (e.g. ~300 ms) where divergence between hosts matters.
+   */
+  graceMs?: number
+  /**
+   * Soft timeout (ms). When set:
+   *  - `query()` resolves with whatever has arrived as soon as any host answers, or after this timeout.
+   *  - `query$()` emits a (possibly empty) snapshot after this timeout if no host has answered yet,
+   *    then continues yielding late-host enrichments until the iterator is broken or final emission.
+   */
+  softTimeoutMs?: number
+}
+
+/**
+ * One emission from {@link LookupResolver.query$}. Carries the cumulative output set discovered so far
+ * plus a small envelope describing progress across hosts. Callers can render fast on the first emission
+ * and refine in place as more hosts answer.
+ */
+export interface LookupAnswerProgress {
+  type: 'output-list'
+  outputs: Array<{ beef: number[], outputIndex: number, context?: number[] }>
+  /** Parallel array of resolved tx ids for each output (same index as `outputs`). */
+  txIds: string[]
+  /** True only for the final emission, after every in-flight host has settled. */
+  isFinal: boolean
+  /** Number of ranked hosts that were queried. */
+  hostCount: number
+  /** Number of hosts that have settled (success / fail / timeout). */
+  completedHosts: number
+}
+
 /** Default SLAP trackers */
 export const DEFAULT_SLAP_TRACKERS: string[] = [
   // BSVA clusters
@@ -119,7 +157,7 @@ export class HTTPSOverlayLookupFacilitator implements OverlayLookupFacilitator {
 
   constructor (httpClient = defaultFetch, allowHTTP: boolean = false) {
     if (typeof httpClient !== 'function') {
-      throw new Error(
+      throw new TypeError(
         'HTTPSOverlayLookupFacilitator requires a fetch implementation. ' +
         'In environments without fetch, provide a polyfill or custom implementation.'
       )
@@ -131,7 +169,7 @@ export class HTTPSOverlayLookupFacilitator implements OverlayLookupFacilitator {
   async lookup (
     url: string,
     question: LookupQuestion,
-    timeout: number = 5000
+    timeout: number = 2000
   ): Promise<LookupAnswer> {
     if (!url.startsWith('https:') && !this.allowHTTP) {
       throw new Error(
@@ -139,7 +177,7 @@ export class HTTPSOverlayLookupFacilitator implements OverlayLookupFacilitator {
       )
     }
 
-    const controller = typeof AbortController !== 'undefined' ? new AbortController() : undefined
+    const controller = typeof AbortController === 'undefined' ? undefined : new AbortController()
     const timer = setTimeout(() => {
       try { controller?.abort() } catch { /* noop */ }
     }, timeout)
@@ -190,7 +228,7 @@ export class HTTPSOverlayLookupFacilitator implements OverlayLookupFacilitator {
       }
     } catch (e) {
       // Normalize timeouts to a consistent error message
-      if ((e as any)?.name === 'AbortError') throw new Error('Request timed out')
+      if ((e as { name?: string })?.name === 'AbortError') throw new Error('Request timed out')
       throw e
     } finally {
       clearTimeout(timer)
@@ -248,11 +286,48 @@ export default class LookupResolver {
 
   /**
    * Given a LookupQuestion, returns a LookupAnswer. Aggregates across multiple services and supports resiliency.
+   *
+   * Optional `options.graceMs` overrides the per-call grace window (default 80 ms).
+   * Optional `options.softTimeoutMs` resolves the query early with whatever has arrived once any host has
+   * answered (or with an empty result if no host has answered by `softTimeoutMs`).
    */
   async query (
     question: LookupQuestion,
-    timeout?: number
+    timeout?: number,
+    options?: LookupQueryOptions
   ): Promise<LookupAnswer> {
+    let last: LookupAnswerProgress | null = null
+    // Existing fast-but-narrow contract: return at the first cumulative emission
+    // (the post-grace aggregate, or the final emission when every host settles
+    // before the grace window). Callers wanting progressive enrichment use query$().
+    for await (const partial of this.query$(question, timeout, options)) {
+      last = partial
+      break
+    }
+    return {
+      type: 'output-list',
+      outputs: last?.outputs ?? []
+    }
+  }
+
+  /**
+   * Iterable form of {@link query}. Emits partial results as hosts answer.
+   *
+   * Emission order:
+   *  - First emission: after the grace window expires (or as soon as the soft timeout elapses), containing
+   *    every output gathered from hosts that answered by then.
+   *  - Subsequent emissions: re-emitted whenever a late host returns extra outputs that weren't in earlier
+   *    emissions. Each emission contains the cumulative `outputs` set.
+   *  - Final emission: `isFinal: true` once all in-flight hosts have settled (success / fail / timeout). The
+   *    caller can `break` early; outstanding work is bounded by the per-host timeout.
+   *
+   * No host work runs past its per-host `timeout` — there is no leak risk on early break.
+   */
+  async * query$ (
+    question: LookupQuestion,
+    timeout?: number,
+    options?: LookupQueryOptions
+  ): AsyncIterable<LookupAnswerProgress> {
     let competentHosts: string[] = []
     if (question.service === 'ls_slap') {
       competentHosts = this.networkPreset === 'local' ? ['http://localhost:8080'] : this.slapTrackers
@@ -282,48 +357,58 @@ export default class LookupResolver {
       throw new Error(`All competent hosts for ${question.service} are temporarily unavailable due to backoff.`)
     }
 
-    // Fire all hosts; resolve as soon as we have results from any host,
-    // then allow a short grace window for additional hosts to contribute.
-    const GRACE_MS = 80
-    const answers: LookupAnswer[] = await new Promise<LookupAnswer[]>((resolve) => {
-      const collected: LookupAnswer[] = []
-      let pending = rankedHosts.length
-      let graceTimer: ReturnType<typeof setTimeout> | null = null
-
-      const tryResolve = (): void => {
-        if (graceTimer !== null) clearTimeout(graceTimer)
-        resolve(collected)
-      }
+    const graceMs = options?.graceMs ?? 80
+    const softTimeoutMs = options?.softTimeoutMs
 
-      for (const host of rankedHosts) {
-        this.lookupHostWithTracking(host, question, timeout)
-          .then((answer) => {
-            if (answer?.type === 'output-list' && Array.isArray(answer.outputs) && answer.outputs.length > 0) {
-              collected.push(answer)
-              // First valid response: start a grace window for others
-              if (collected.length === 1 && pending > 1) {
-                graceTimer = setTimeout(tryResolve, GRACE_MS)
-              }
-            }
-          })
-          .catch(() => { /* host failed; tracked by lookupHostWithTracking */ })
-          .finally(() => {
-            pending--
-            if (pending === 0) tryResolve()
-          })
+    const hostCount = rankedHosts.length
+    const outputsMap = new Map<string, { beef: number[], context?: number[], outputIndex: number }>()
+    const txIds: string[] = []
+    let completedHosts = 0
+    let firstResponseAt: number | null = null
+
+    type Event = { kind: 'answer', answer: LookupAnswer } | { kind: 'done' } | { kind: 'soft' }
+    const queue: Event[] = []
+    let waiter: ((v: void) => void) | null = null
+    const push = (e: Event): void => {
+      queue.push(e)
+      if (waiter !== null) {
+        const w = waiter
+        waiter = null
+        w()
       }
-    })
+    }
 
-    const outputsMap = new Map<string, { beef: number[], context?: number[], outputIndex: number }>()
+    for (const host of rankedHosts) {
+      this.lookupHostWithTracking(host, question, timeout)
+        .then((answer) => {
+          if (answer?.type === 'output-list' && Array.isArray(answer.outputs) && answer.outputs.length > 0) {
+            push({ kind: 'answer', answer })
+          }
+        })
+        .catch(() => { /* tracked already */ })
+        .finally(() => {
+          completedHosts++
+          push({ kind: 'done' })
+        })
+    }
+
+    let softTimer: ReturnType<typeof setTimeout> | null = null
+    if (typeof softTimeoutMs === 'number' && softTimeoutMs >= 0) {
+      softTimer = setTimeout(() => push({ kind: 'soft' }), softTimeoutMs)
+    }
+
+    let graceTimer: ReturnType<typeof setTimeout> | null = null
+    let graceFired = false
+    let emittedOnce = false
 
-    // Memo key helper for tx parsing
-    const beefKey = (beef: number[]): string => {
-      if (typeof beef !== 'object') return '' // The invalid BEEF has an empty key.
+    const beefKey = (beef: number[] | undefined): string => {
+      if (typeof beef !== 'object' || beef == null) return ''
       return beef.join(',')
     }
 
-    for (const response of answers) {
-      for (const output of response.outputs) {
+    const mergeAnswer = (answer: LookupAnswer): boolean => {
+      let added = false
+      for (const output of answer.outputs) {
         const keyForBeef = beefKey(output.beef)
         let memo = this.txMemo.get(keyForBeef)
         const now = Date.now()
@@ -337,14 +422,66 @@ export default class LookupResolver {
             continue
           }
         }
-
         const uniqKey = `${memo.txId}.${output.outputIndex}`
-        outputsMap.set(uniqKey, output)
+        if (!outputsMap.has(uniqKey)) {
+          outputsMap.set(uniqKey, output)
+          txIds.push(memo.txId)
+          added = true
+        }
       }
+      return added
     }
-    return {
+
+    const snapshot = (isFinal: boolean): LookupAnswerProgress => ({
       type: 'output-list',
-      outputs: Array.from(outputsMap.values())
+      outputs: Array.from(outputsMap.values()),
+      txIds: txIds.slice(),
+      isFinal,
+      hostCount,
+      completedHosts
+    })
+
+    try {
+      while (completedHosts < hostCount) {
+        if (queue.length === 0) {
+          await new Promise<void>((resolve) => { waiter = resolve })
+        }
+        const e = queue.shift() as Event
+        if (e.kind === 'answer') {
+          const added = mergeAnswer(e.answer)
+          if (firstResponseAt === null) {
+            firstResponseAt = Date.now()
+            if (!graceFired && graceMs > 0) {
+              graceTimer = setTimeout(() => {
+                graceFired = true
+                push({ kind: 'soft' })
+              }, graceMs)
+            } else {
+              graceFired = true
+            }
+          }
+          if (graceFired && added) {
+            emittedOnce = true
+            yield snapshot(false)
+          }
+        } else if (e.kind === 'soft') {
+          if (!emittedOnce) {
+            graceFired = true
+            emittedOnce = true
+            yield snapshot(false)
+          }
+          if (typeof softTimeoutMs === 'number' && firstResponseAt !== null) {
+            // Soft timeout: caller asked to bail out once any answer is in. Yield final.
+            break
+          }
+        } else if (e.kind === 'done') {
+          // continue loop; final emission happens after the loop
+        }
+      }
+      yield snapshot(true)
+    } finally {
+      if (graceTimer !== null) clearTimeout(graceTimer)
+      if (softTimer !== null) clearTimeout(softTimer)
     }
   }
 
@@ -375,7 +512,7 @@ export default class LookupResolver {
       try {
         const hosts = await this.hostsInFlight.get(service)
         if (typeof hosts !== 'object') {
-          throw new Error('Hosts is not defined.')
+          throw new TypeError('Hosts is not defined.')
         }
         return hosts.slice()
       } catch {

package/src/overlay-tools/SHIPBroadcaster.ts

@@ -50,6 +50,12 @@ export interface AdmittanceInstructions {
  */
 export type STEAK = Record<string, AdmittanceInstructions>
 
+/** The require mode for topic acknowledgment: all topics must be present, or any one suffices. */
+export type RequireMode = 'all' | 'any'
+
+/** Specifies which topics must be acknowledged: all, any, or a specific list. */
+export type TopicAcknowledgmentRequirement = RequireMode | string[]
+
 /** Configuration options for the SHIP broadcaster. */
 export interface SHIPBroadcasterConfig {
   /**
@@ -64,11 +70,11 @@ export interface SHIPBroadcasterConfig {
   /** The resolver used to locate suitable hosts with SHIP */
   resolver?: LookupResolver
   /** Determines which topics (all, any, or a specific list) must be present within all STEAKs received from every host for the broadcast to be considered a success. By default, all hosts must acknowledge all topics. */
-  requireAcknowledgmentFromAllHostsForTopics?: 'all' | 'any' | string[]
+  requireAcknowledgmentFromAllHostsForTopics?: TopicAcknowledgmentRequirement
   /** Determines which topics (all, any, or a specific list) must be present within STEAK received from at least one host for the broadcast to be considered a success. */
-  requireAcknowledgmentFromAnyHostForTopics?: 'all' | 'any' | string[]
+  requireAcknowledgmentFromAnyHostForTopics?: TopicAcknowledgmentRequirement
   /** Determines a mapping whose keys are specific hosts and whose values are the topics (all, any, or a specific list) that must be present within the STEAK received by the given hosts, in order for the broadcast to be considered a success. */
-  requireAcknowledgmentFromSpecificHostsForTopics?: Record<string, 'all' | 'any' | string[]>
+  requireAcknowledgmentFromSpecificHostsForTopics?: Record<string, TopicAcknowledgmentRequirement>
 }
 
 /** Facilitates transaction broadcasts that return STEAK. */
@@ -128,9 +134,9 @@ export default class TopicBroadcaster implements Broadcaster {
   private readonly topics: string[]
   private readonly facilitator: OverlayBroadcastFacilitator
   private readonly resolver: LookupResolver
-  private readonly requireAcknowledgmentFromAllHostsForTopics: | 'all' | 'any' | string[]
-  private readonly requireAcknowledgmentFromAnyHostForTopics: | 'all' | 'any' | string[]
-  private readonly requireAcknowledgmentFromSpecificHostsForTopics: Record<string, 'all' | 'any' | string[]>
+  private readonly requireAcknowledgmentFromAllHostsForTopics: TopicAcknowledgmentRequirement
+  private readonly requireAcknowledgmentFromAnyHostForTopics: TopicAcknowledgmentRequirement
+  private readonly requireAcknowledgmentFromSpecificHostsForTopics: Record<string, TopicAcknowledgmentRequirement>
   private readonly networkPreset: 'mainnet' | 'testnet' | 'local'
 
   // Cache for findInterestedHosts to avoid repeated SHIP tracker lookups
@@ -233,7 +239,7 @@ export default class TopicBroadcaster implements Broadcaster {
       for (const [topic, instructions] of Object.entries(steak)) {
         const outputsToAdmit = instructions.outputsToAdmit
         const coinsToRetain = instructions.coinsToRetain
-        const coinsRemoved = instructions.coinsRemoved as number[]
+        const coinsRemoved = instructions.coinsRemoved
 
         if (
           outputsToAdmit?.length > 0 ||
@@ -248,162 +254,99 @@ export default class TopicBroadcaster implements Broadcaster {
     }
 
     // Now, perform the checks
+    const allHostsError = this.checkAllHostsRequirement(hostAcknowledgments)
+    if (allHostsError != null) return allHostsError
 
-    // Check requireAcknowledgmentFromAllHostsForTopics
-    let requiredTopicsAllHosts: string[]
-    let requireAllHosts: 'all' | 'any'
-
-    if (this.requireAcknowledgmentFromAllHostsForTopics === 'all') {
-      requiredTopicsAllHosts = this.topics
-      requireAllHosts = 'all'
-    } else if (this.requireAcknowledgmentFromAllHostsForTopics === 'any') {
-      requiredTopicsAllHosts = this.topics
-      requireAllHosts = 'any'
-    } else if (Array.isArray(this.requireAcknowledgmentFromAllHostsForTopics)) {
-      requiredTopicsAllHosts = this.requireAcknowledgmentFromAllHostsForTopics
-      requireAllHosts = 'all'
-    } else {
-      // Default to 'all' and 'all'
-      requiredTopicsAllHosts = this.topics
-      requireAllHosts = 'all'
-    }
+    const anyHostError = this.checkAnyHostRequirement(hostAcknowledgments)
+    if (anyHostError != null) return anyHostError
 
-    if (requiredTopicsAllHosts.length > 0) {
-      const allHostsAcknowledged = this.checkAcknowledgmentFromAllHosts(
-        hostAcknowledgments,
-        requiredTopicsAllHosts,
-        requireAllHosts
-      )
-      if (!allHostsAcknowledged) {
-        return {
-          status: 'error',
-          code: 'ERR_REQUIRE_ACK_FROM_ALL_HOSTS_FAILED',
-          description: 'Not all hosts acknowledged the required topics.'
-        }
-      }
+    const specificHostsError = this.checkSpecificHostsRequirement(hostAcknowledgments)
+    if (specificHostsError != null) return specificHostsError
+
+    // If all checks pass, return success
+    return {
+      status: 'success',
+      txid: tx.id('hex'),
+      message: `Sent to ${successfulHosts.length} Overlay Services ${successfulHosts.length === 1 ? 'host' : 'hosts'}.`
     }
+  }
 
-    // Check requireAcknowledgmentFromAnyHostForTopics
-    let requiredTopicsAnyHost: string[]
-    let requireAnyHost: 'all' | 'any'
-
-    if (this.requireAcknowledgmentFromAnyHostForTopics === 'all') {
-      requiredTopicsAnyHost = this.topics
-      requireAnyHost = 'all'
-    } else if (this.requireAcknowledgmentFromAnyHostForTopics === 'any') {
-      requiredTopicsAnyHost = this.topics
-      requireAnyHost = 'any'
-    } else if (Array.isArray(this.requireAcknowledgmentFromAnyHostForTopics)) {
-      requiredTopicsAnyHost = this.requireAcknowledgmentFromAnyHostForTopics
-      requireAnyHost = 'all'
-    } else {
-      // No requirement
-      requiredTopicsAnyHost = []
-      requireAnyHost = 'all'
+  /** Resolves the (requiredTopics, require) pair for requireAcknowledgmentFromAllHostsForTopics. */
+  private resolveAllHostsRequirement (): { requiredTopics: string[], require: RequireMode } {
+    const r = this.requireAcknowledgmentFromAllHostsForTopics
+    if (r === 'any') return { requiredTopics: this.topics, require: 'any' }
+    if (Array.isArray(r)) return { requiredTopics: r, require: 'all' }
+    // Default 'all' or unknown: all topics, all requirement
+    return { requiredTopics: this.topics, require: 'all' }
+  }
+
+  private checkAllHostsRequirement (hostAcknowledgments: Record<string, Set<string>>): BroadcastFailure | null {
+    const { requiredTopics, require } = this.resolveAllHostsRequirement()
+    if (requiredTopics.length === 0) return null
+    if (!this.checkAcknowledgmentFromAllHosts(hostAcknowledgments, requiredTopics, require)) {
+      return { status: 'error', code: 'ERR_REQUIRE_ACK_FROM_ALL_HOSTS_FAILED', description: 'Not all hosts acknowledged the required topics.' }
     }
+    return null
+  }
 
-    if (requiredTopicsAnyHost.length > 0) {
-      const anyHostAcknowledged = this.checkAcknowledgmentFromAnyHost(
-        hostAcknowledgments,
-        requiredTopicsAnyHost,
-        requireAnyHost
-      )
-      if (!anyHostAcknowledged) {
-        return {
-          status: 'error',
-          code: 'ERR_REQUIRE_ACK_FROM_ANY_HOST_FAILED',
-          description: 'No host acknowledged the required topics.'
-        }
-      }
+  /** Resolves the (requiredTopics, require) pair for requireAcknowledgmentFromAnyHostForTopics. */
+  private resolveAnyHostRequirement (): { requiredTopics: string[], require: RequireMode } {
+    const r = this.requireAcknowledgmentFromAnyHostForTopics
+    if (r === 'all') return { requiredTopics: this.topics, require: 'all' }
+    if (r === 'any') return { requiredTopics: this.topics, require: 'any' }
+    if (Array.isArray(r)) return { requiredTopics: r, require: 'all' }
+    return { requiredTopics: [], require: 'all' }
+  }
+
+  private checkAnyHostRequirement (hostAcknowledgments: Record<string, Set<string>>): BroadcastFailure | null {
+    const { requiredTopics, require } = this.resolveAnyHostRequirement()
+    if (requiredTopics.length === 0) return null
+    if (!this.checkAcknowledgmentFromAnyHost(hostAcknowledgments, requiredTopics, require)) {
+      return { status: 'error', code: 'ERR_REQUIRE_ACK_FROM_ANY_HOST_FAILED', description: 'No host acknowledged the required topics.' }
     }
+    return null
+  }
 
-    // Check requireAcknowledgmentFromSpecificHostsForTopics
-    if (
-      Object.keys(this.requireAcknowledgmentFromSpecificHostsForTopics).length >
-      0
-    ) {
-      const specificHostsAcknowledged =
-        this.checkAcknowledgmentFromSpecificHosts(
-          hostAcknowledgments,
-          this.requireAcknowledgmentFromSpecificHostsForTopics
-        )
-      if (!specificHostsAcknowledged) {
-        return {
-          status: 'error',
-          code: 'ERR_REQUIRE_ACK_FROM_SPECIFIC_HOSTS_FAILED',
-          description:
-            'Specific hosts did not acknowledge the required topics.'
-        }
-      }
+  private checkSpecificHostsRequirement (hostAcknowledgments: Record<string, Set<string>>): BroadcastFailure | null {
+    if (Object.keys(this.requireAcknowledgmentFromSpecificHostsForTopics).length === 0) return null
+    if (!this.checkAcknowledgmentFromSpecificHosts(hostAcknowledgments, this.requireAcknowledgmentFromSpecificHostsForTopics)) {
+      return { status: 'error', code: 'ERR_REQUIRE_ACK_FROM_SPECIFIC_HOSTS_FAILED', description: 'Specific hosts did not acknowledge the required topics.' }
     }
+    return null
+  }
 
-    // If all checks pass, return success
-    return {
-      status: 'success',
-      txid: tx.id('hex'),
-      message: `Sent to ${successfulHosts.length} Overlay Services ${successfulHosts.length === 1 ? 'host' : 'hosts'}.`
+  /**
+   * Returns true if `acknowledgedTopics` satisfies the given requirement against `requiredTopics`.
+   */
+  private topicsMatchRequirement (
+    acknowledgedTopics: Set<string>,
+    requiredTopics: string[],
+    require: RequireMode
+  ): boolean {
+    if (require === 'all') {
+      return requiredTopics.every(t => acknowledgedTopics.has(t))
     }
+    return requiredTopics.some(t => acknowledgedTopics.has(t))
   }
 
   private checkAcknowledgmentFromAllHosts (
     hostAcknowledgments: Record<string, Set<string>>,
     requiredTopics: string[],
-    require: 'all' | 'any'
+    require: RequireMode
   ): boolean {
-    for (const acknowledgedTopics of Object.values(hostAcknowledgments)) {
-      if (require === 'all') {
-        for (const topic of requiredTopics) {
-          if (!acknowledgedTopics.has(topic)) {
-            return false
-          }
-        }
-      } else if (require === 'any') {
-        let anyAcknowledged = false
-        for (const topic of requiredTopics) {
-          if (acknowledgedTopics.has(topic)) {
-            anyAcknowledged = true
-            break
-          }
-        }
-        if (!anyAcknowledged) {
-          return false
-        }
-      }
-    }
-    return true
+    return Object.values(hostAcknowledgments).every(
+      acknowledged => this.topicsMatchRequirement(acknowledged, requiredTopics, require)
+    )
   }
 
   private checkAcknowledgmentFromAnyHost (
     hostAcknowledgments: Record<string, Set<string>>,
     requiredTopics: string[],
-    require: 'all' | 'any'
+    require: RequireMode
   ): boolean {
-    if (require === 'all') {
-      // All required topics must be acknowledged by at least one host
-      for (const acknowledgedTopics of Object.values(hostAcknowledgments)) {
-        let acknowledgesAllRequiredTopics = true
-        for (const topic of requiredTopics) {
-          if (!acknowledgedTopics.has(topic)) {
-            acknowledgesAllRequiredTopics = false
-            break
-          }
-        }
-        if (acknowledgesAllRequiredTopics) {
-          return true
-        }
-      }
-      return false
-    } else {
-      // At least one required topic must be acknowledged by at least one host
-      for (const acknowledgedTopics of Object.values(hostAcknowledgments)) {
-        for (const topic of requiredTopics) {
-          if (acknowledgedTopics.has(topic)) {
-            return true
-          }
-        }
-      }
-      return false
-    }
+    return Object.values(hostAcknowledgments).some(
+      acknowledged => this.topicsMatchRequirement(acknowledged, requiredTopics, require)
+    )
   }
 
   private checkAcknowledgmentFromSpecificHosts (
@@ -417,11 +360,8 @@ export default class TopicBroadcaster implements Broadcaster {
         return false
       }
       let requiredTopics: string[]
-      let require: 'all' | 'any'
-      if (
-        requiredTopicsOrAllAny === 'all' ||
-        requiredTopicsOrAllAny === 'any'
-      ) {
+      let require: RequireMode
+      if (requiredTopicsOrAllAny === 'all' || requiredTopicsOrAllAny === 'any') {
         require = requiredTopicsOrAllAny
         requiredTopics = this.topics
       } else if (Array.isArray(requiredTopicsOrAllAny)) {
@@ -431,23 +371,8 @@ export default class TopicBroadcaster implements Broadcaster {
         // Invalid configuration
         continue
       }
-      if (require === 'all') {
-        for (const topic of requiredTopics) {
-          if (!acknowledgedTopics.has(topic)) {
-            return false
-          }
-        }
-      } else if (require === 'any') {
-        let anyAcknowledged = false
-        for (const topic of requiredTopics) {
-          if (acknowledgedTopics.has(topic)) {
-            anyAcknowledged = true
-            break
-          }
-        }
-        if (!anyAcknowledged) {
-          return false
-        }
+      if (!this.topicsMatchRequirement(acknowledgedTopics, requiredTopics, require)) {
+        return false
       }
     }
     return true
@@ -462,8 +387,8 @@ export default class TopicBroadcaster implements Broadcaster {
     // Handle the local network preset
     if (this.networkPreset === 'local') {
       const resultSet = new Set<string>()
-      for (let i = 0; i < this.topics.length; i++) {
-        resultSet.add(this.topics[i])
+      for (const topic of this.topics) {
+        resultSet.add(topic)
       }
       return { 'http://localhost:8080': resultSet }
     }
@@ -519,11 +444,10 @@ export default class TopicBroadcaster implements Broadcaster {
         ) {
           continue
         }
-        if (results[parsed.domain] === undefined) {
-          results[parsed.domain] = new Set()
-        }
+        results[parsed.domain] ??= new Set()
         results[parsed.domain].add(parsed.topicOrService)
-      } catch (e) {
+      } catch (_notShipOutput) {
+        // Output could not be decoded as an overlay admin token — not a SHIP advertisement; skip
         continue
       }
     }

package/src/primitives/AESGCM.ts

@@ -54,7 +54,7 @@ const Rcon = [
 const mul2 = new Uint8Array(256)
 const mul3 = new Uint8Array(256)
 for (let i = 0; i < 256; i++) {
-  const m2 = ((i << 1) ^ ((i & 0x80) !== 0 ? 0x1b : 0)) & 0xff
+  const m2 = ((i << 1) ^ ((i & 0x80) === 0 ? 0 : 0x1b)) & 0xff
   mul2[i] = m2
   mul3[i] = m2 ^ i
 }
@@ -217,7 +217,7 @@ export const checkBit = function (
   byteIndex: number,
   bitIndex: number
 ): 1 | 0 {
-  return (byteArray[byteIndex] & (0x01 << bitIndex)) !== 0 ? 1 : 0
+  return (byteArray[byteIndex] & (0x01 << bitIndex)) === 0 ? 0 : 1
 }
 
 export const getBytes = function (numericValue: number): number[] {