@bsv/sdk 1.3.12 → 1.3.14

package/src/overlay-tools/LookupResolver.ts

@@ -6,14 +6,14 @@ import OverlayAdminTokenTemplate from './OverlayAdminTokenTemplate.js'
  */
 export interface LookupQuestion {
   /**
-     * The identifier for a Lookup Service which the person asking the question wishes to use.
-     */
+   * The identifier for a Lookup Service which the person asking the question wishes to use.
+   */
   service: string
 
   /**
-     * The query which will be forwarded to the Lookup Service.
-     * Its type depends on that prescribed by the Lookup Service employed.
-     */
+   * The query which will be forwarded to the Lookup Service.
+   * Its type depends on that prescribed by the Lookup Service employed.
+   */
   query: unknown
 }
 
@@ -21,16 +21,18 @@ export interface LookupQuestion {
  * How the Overlay Services Engine responds to a Lookup Question.
  * It may comprise either an output list or a freeform response from the Lookup Service.
  */
-export type LookupAnswer = {
-  type: 'output-list'
-  outputs: Array<{
-    beef: number[]
-    outputIndex: number
-  }>
-} | {
-  type: 'freeform'
-  result: unknown
-}
+export type LookupAnswer =
+  | {
+    type: 'output-list'
+    outputs: Array<{
+      beef: number[]
+      outputIndex: number
+    }>
+  }
+  | {
+    type: 'freeform'
+    result: unknown
+  }
 
 /** Default SLAP trackers */
 export const DEFAULT_SLAP_TRACKERS: string[] = [
@@ -72,7 +74,11 @@ export interface OverlayLookupFacilitator {
    * @param timeout - Specifics how long to wait for a lookup answer in milliseconds.
    * @returns
    */
-  lookup: (url: string, question: LookupQuestion, timeout?: number) => Promise<LookupAnswer>
+  lookup: (
+    url: string,
+    question: LookupQuestion,
+    timeout?: number
+  ) => Promise<LookupAnswer>
 }
 
 export class HTTPSOverlayLookupFacilitator implements OverlayLookupFacilitator {
@@ -82,11 +88,17 @@ export class HTTPSOverlayLookupFacilitator implements OverlayLookupFacilitator {
     this.fetchClient = httpClient
   }
 
-  async lookup (url: string, question: LookupQuestion, timeout: number = 5000): Promise<LookupAnswer> {
+  async lookup (
+    url: string,
+    question: LookupQuestion,
+    timeout: number = 5000
+  ): Promise<LookupAnswer> {
     if (!url.startsWith('https:')) {
-      throw new Error('HTTPS facilitator can only use URLs that start with "https:"')
+      throw new Error(
+        'HTTPS facilitator can only use URLs that start with "https:"'
+      )
     }
-    const timeoutPromise = new Promise((_, reject) =>
+    const timeoutPromise = new Promise((resolve, reject) =>
       setTimeout(() => reject(new Error('Request timed out')), timeout)
     )
 
@@ -95,10 +107,16 @@ export class HTTPSOverlayLookupFacilitator implements OverlayLookupFacilitator {
       headers: {
         'Content-Type': 'application/json'
       },
-      body: JSON.stringify({ service: question.service, query: question.query })
+      body: JSON.stringify({
+        service: question.service,
+        query: question.query
+      })
     })
 
-    const response: Response = await Promise.race([fetchPromise, timeoutPromise]) as Response
+    const response: Response = (await Promise.race([
+      fetchPromise,
+      timeoutPromise
+    ])) as Response
 
     if (response.ok) {
       return await response.json()
@@ -118,9 +136,22 @@ export default class LookupResolver {
   private readonly additionalHosts: Record<string, string[]>
 
   constructor (config?: LookupResolverConfig) {
-    const { facilitator, slapTrackers, hostOverrides, additionalHosts } = config ?? {} as LookupResolverConfig
+    const defaultConfig: LookupResolverConfig = {
+      facilitator: new HTTPSOverlayLookupFacilitator(),
+      slapTrackers: DEFAULT_SLAP_TRACKERS,
+      hostOverrides: {},
+      additionalHosts: {}
+    }
+
+    const {
+      facilitator = defaultConfig.facilitator,
+      slapTrackers = defaultConfig.slapTrackers,
+      hostOverrides = defaultConfig.hostOverrides,
+      additionalHosts = defaultConfig.additionalHosts
+    } = config ?? defaultConfig // ✅ Use a default object directly
+
     this.facilitator = facilitator ?? new HTTPSOverlayLookupFacilitator()
-    this.slapTrackers = slapTrackers ?? DEFAULT_SLAP_TRACKERS
+    this.slapTrackers = slapTrackers ?? []
     this.hostOverrides = hostOverrides ?? {}
     this.additionalHosts = additionalHosts ?? {}
   }
@@ -128,33 +159,40 @@ export default class LookupResolver {
   /**
    * Given a LookupQuestion, returns a LookupAnswer. Aggregates across multiple services and supports resiliency.
    */
-  async query (question: LookupQuestion, timeout?: number): Promise<LookupAnswer> {
+  async query (
+    question: LookupQuestion,
+    timeout?: number
+  ): Promise<LookupAnswer> {
     let competentHosts: string[] = []
     if (question.service === 'ls_slap') {
       competentHosts = this.slapTrackers
-    } else if (this.hostOverrides[question.service]) {
+    } else if (this.hostOverrides[question.service] != null) {
       competentHosts = this.hostOverrides[question.service]
     } else {
       competentHosts = await this.findCompetentHosts(question.service)
     }
-    if (this.additionalHosts[question.service]) {
+    if (this.additionalHosts[question.service]?.length > 0) {
       competentHosts = [
         ...competentHosts,
         ...this.additionalHosts[question.service]
       ]
     }
     if (competentHosts.length < 1) {
-      throw new Error(`No competent hosts found by the SLAP trackers for lookup service: ${question.service}`)
+      throw new Error(
+        `No competent hosts found by the SLAP trackers for lookup service: ${question.service}`
+      )
     }
 
     // Use Promise.allSettled to handle individual host failures
     const hostResponses = await Promise.allSettled(
-      competentHosts.map(async host => await this.facilitator.lookup(host, question, timeout))
+      competentHosts.map(
+        async (host) => await this.facilitator.lookup(host, question, timeout)
+      )
     )
 
     const successfulResponses = hostResponses
-      .filter(result => result.status === 'fulfilled')
-      .map(result => (result).value)
+      .filter((result): result is PromiseFulfilledResult<LookupAnswer> => result.status === 'fulfilled')
+      .map((result) => result.value)
 
     if (successfulResponses.length === 0) {
       throw new Error('No successful responses from any hosts')
@@ -164,38 +202,46 @@ export default class LookupResolver {
     if (successfulResponses[0].type === 'freeform') {
       // Return the first freeform response
       return successfulResponses[0]
-    } else {
-      // Aggregate outputs from all successful responses
-      const outputs = new Map<string, { beef: number[], outputIndex: number }>()
-      for (const response of successfulResponses) {
-        if (response.type !== 'output-list') {
-          continue
-        }
-        try {
-          for (const output of response.outputs) {
-            try {
-              const key = `${Transaction.fromBEEF(output.beef).id('hex')}.${output.outputIndex}`
+    }
+
+    // Aggregate outputs from all successful responses
+    const outputs = new Map<string, { beef: number[], outputIndex: number }>()
+
+    for (const response of successfulResponses) {
+      if (response.type !== 'output-list') {
+        continue
+      }
+      try {
+        for (const output of response.outputs) {
+          try {
+            const txId: string = String(Transaction.fromBEEF(output.beef).id('hex'))
+
+            if (txId !== '') { // ✅ Ensures `txId` is always a non-empty string
+              const key = `${String(txId)}.${String(output.outputIndex)}`
               outputs.set(key, output)
-            } catch (e) {
-              continue
+            } else {
+              console.warn('Invalid transaction ID:', txId)
             }
+          } catch {
+            continue
           }
-        } catch (e) {
-          continue
         }
+      } catch (error) {
+        console.error('Error processing response outputs:', error)
       }
-      return {
-        type: 'output-list',
-        outputs: Array.from(outputs.values())
-      }
+    }
+    // ✅ Ensure function always returns a value
+    return {
+      type: 'output-list',
+      outputs: Array.from(outputs.values())
     }
   }
 
   /**
-     * Returns a list of competent hosts for a given lookup service.
-     * @param service Service for which competent hosts are to be returned
-     * @returns Array of hosts competent for resolving queries
-     */
+   * Returns a list of competent hosts for a given lookup service.
+   * @param service Service for which competent hosts are to be returned
+   * @returns Array of hosts competent for resolving queries
+   */
   private async findCompetentHosts (service: string): Promise<string[]> {
     const query: LookupQuestion = {
       service: 'ls_slap',
@@ -206,7 +252,10 @@ export default class LookupResolver {
 
     // Use Promise.allSettled to handle individual SLAP tracker failures
     const trackerResponses = await Promise.allSettled(
-      this.slapTrackers.map(async tracker => await this.facilitator.lookup(tracker, query, MAX_TRACKER_WAIT_TIME))
+      this.slapTrackers.map(
+        async (tracker) =>
+          await this.facilitator.lookup(tracker, query, MAX_TRACKER_WAIT_TIME)
+      )
     )
 
     const hosts = new Set<string>()
@@ -223,12 +272,15 @@ export default class LookupResolver {
             const tx = Transaction.fromBEEF(output.beef)
             const script = tx.outputs[output.outputIndex].lockingScript
             const parsed = OverlayAdminTokenTemplate.decode(script)
-            if (parsed.topicOrService !== service || parsed.protocol !== 'SLAP') {
+            if (
+              parsed.topicOrService !== service ||
+              parsed.protocol !== 'SLAP'
+            ) {
               // Invalid advertisement, skip
               continue
             }
             hosts.add(parsed.domain)
-          } catch (e) {
+          } catch {
             // Invalid output, skip
             continue
           }

package/src/overlay-tools/OverlayAdminTokenTemplate.ts

@@ -1,6 +1,10 @@
 import PushDrop from '../script/templates/PushDrop.js'
 import { WalletInterface } from '../wallet/Wallet.interfaces.js'
-import { LockingScript, ScriptTemplate, UnlockingScript } from '../script/index.js'
+import {
+  LockingScript,
+  ScriptTemplate,
+  UnlockingScript
+} from '../script/index.js'
 import { Transaction } from '../transaction/index.js'
 import { Utils } from '../primitives/index.js'
 
@@ -11,11 +15,16 @@ export default class OverlayAdminTokenTemplate implements ScriptTemplate {
   pushDrop: PushDrop
 
   /**
-     * Decodes a SHIP or SLAP advertisement from a given locking script.
-     * @param script Locking script comprising a SHIP or SLAP token to decode
-     * @returns Decoded SHIP or SLAP advertisement
-     */
-  static decode (script: LockingScript): { protocol: 'SHIP' | 'SLAP', identityKey: string, domain: string, topicOrService: string } {
+   * Decodes a SHIP or SLAP advertisement from a given locking script.
+   * @param script Locking script comprising a SHIP or SLAP token to decode
+   * @returns Decoded SHIP or SLAP advertisement
+   */
+  static decode (script: LockingScript): {
+    protocol: 'SHIP' | 'SLAP'
+    identityKey: string
+    domain: string
+    topicOrService: string
+  } {
     const result = PushDrop.decode(script)
     if (result.fields.length < 4) {
       throw new Error('Invalid SHIP/SLAP advertisement!')
@@ -36,22 +45,28 @@ export default class OverlayAdminTokenTemplate implements ScriptTemplate {
   }
 
   /**
-     * Constructs a new Overlay Admin template instance
-     * @param wallet Wallet to use for locking and unlocking
-     */
+   * Constructs a new Overlay Admin template instance
+   * @param wallet Wallet to use for locking and unlocking
+   */
   constructor (wallet: WalletInterface) {
     this.pushDrop = new PushDrop(wallet)
   }
 
   /**
-     * Creates a new advertisement locking script
-     * @param protocol SHIP or SLAP
-     * @param domain Domain where the topic or service is available
-     * @param topicOrService Topic or service to advertise
-     * @returns Locking script comprising the advertisement token
-     */
-  async lock (protocol: 'SHIP' | 'SLAP', domain: string, topicOrService: string): Promise<LockingScript> {
-    const { publicKey: identityKey } = await this.pushDrop.wallet.getPublicKey({ identityKey: true })
+   * Creates a new advertisement locking script
+   * @param protocol SHIP or SLAP
+   * @param domain Domain where the topic or service is available
+   * @param topicOrService Topic or service to advertise
+   * @returns Locking script comprising the advertisement token
+   */
+  async lock (
+    protocol: 'SHIP' | 'SLAP',
+    domain: string,
+    topicOrService: string
+  ): Promise<LockingScript> {
+    const { publicKey: identityKey } = await this.pushDrop.wallet.getPublicKey({
+      identityKey: true
+    })
     return await this.pushDrop.lock(
       [
         Utils.toArray(protocol, 'utf8'),
@@ -59,21 +74,35 @@ export default class OverlayAdminTokenTemplate implements ScriptTemplate {
         Utils.toArray(domain, 'utf8'),
         Utils.toArray(topicOrService, 'utf8')
       ],
-      [2, protocol === 'SHIP' ? 'Service Host Interconnect' : 'Service Lookup Availability'],
+      [
+        2,
+        protocol === 'SHIP'
+          ? 'Service Host Interconnect'
+          : 'Service Lookup Availability'
+      ],
       '1',
       'self'
     )
   }
 
   /**
-     * Unlocks an advertisement token as part of a transaction.
-     * @param protocol SHIP or SLAP, depending on the token to unlock
-     * @returns Script unlocker capable of unlocking the advertisement token
-     */
+   * Unlocks an advertisement token as part of a transaction.
+   * @param protocol SHIP or SLAP, depending on the token to unlock
+   * @returns Script unlocker capable of unlocking the advertisement token
+   */
   unlock (protocol: 'SHIP' | 'SLAP'): {
     sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
     estimateLength: (tx: Transaction, inputIndex: number) => Promise<number>
   } {
-    return this.pushDrop.unlock([2, protocol === 'SHIP' ? 'Service Host Interconnect' : 'Service Lookup Availability'], '1', 'self')
+    return this.pushDrop.unlock(
+      [
+        2,
+        protocol === 'SHIP'
+          ? 'Service Host Interconnect'
+          : 'Service Lookup Availability'
+      ],
+      '1',
+      'self'
+    )
   }
 }