@bsv/sdk 1.3.12 → 1.3.13

package/src/messages/__tests/SignedMessage.test.ts

@@ -1,53 +1,59 @@
-import { sign, verify } from '../../../dist/cjs/src/messages/SignedMessage'
-import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey'
+import { sign, verify } from "../../messages/SignedMessage";
+import PrivateKey from "../../primitives/PrivateKey";
 
-describe('SignedMessage', () => {
-  it('Signs a message for a recipient', () => {
-    const sender = new PrivateKey(15)
-    const recipient = new PrivateKey(21)
-    const recipientPub = recipient.toPublicKey()
-    const message = [1, 2, 4, 8, 16, 32]
-    const signature = sign(message, sender, recipientPub)
-    const verified = verify(message, signature, recipient)
-    expect(verified).toEqual(true)
-  })
-  it('Signs a message for anyone', () => {
-    const sender = new PrivateKey(15)
-    const message = [1, 2, 4, 8, 16, 32]
-    const signature = sign(message, sender)
-    const verified = verify(message, signature)
-    expect(verified).toEqual(true)
-  })
-  it('Fails to verify a message with a wrong version', () => {
-    const sender = new PrivateKey(15)
-    const recipient = new PrivateKey(21)
-    const recipientPub = recipient.toPublicKey()
-    const message = [1, 2, 4, 8, 16, 32]
-    const signature = sign(message, sender, recipientPub)
-    signature[0] = 1
-    expect(() => verify(message, signature, recipient)).toThrow(new Error(
-      'Message version mismatch: Expected 42423301, received 01423301'
-    ))
-  })
-  it('Fails to verify a message with no verifier when required', () => {
-    const sender = new PrivateKey(15)
-    const recipient = new PrivateKey(21)
-    const recipientPub = recipient.toPublicKey()
-    const message = [1, 2, 4, 8, 16, 32]
-    const signature = sign(message, sender, recipientPub)
-    expect(() => verify(message, signature)).toThrow(new Error(
-      'This signature can only be verified with knowledge of a specific private key. The associated public key is: 02352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5'
-    ))
-  })
-  it('Fails to verify a message with a wrong verifier', () => {
-    const sender = new PrivateKey(15)
-    const recipient = new PrivateKey(21)
-    const wrongRecipient = new PrivateKey(22)
-    const recipientPub = recipient.toPublicKey()
-    const message = [1, 2, 4, 8, 16, 32]
-    const signature = sign(message, sender, recipientPub)
-    expect(() => verify(message, signature, wrongRecipient)).toThrow(new Error(
-      'The recipient public key is 03421f5fc9a21065445c96fdb91c0c1e2f2431741c72713b4b99ddcb316f31e9fc but the signature requres the recipient to have public key 02352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5'
-    ))
-  })
-})
+describe("SignedMessage", () => {
+  it("Signs a message for a recipient", () => {
+    const sender = new PrivateKey(15);
+    const recipient = new PrivateKey(21);
+    const recipientPub = recipient.toPublicKey();
+    const message = [1, 2, 4, 8, 16, 32];
+    const signature = sign(message, sender, recipientPub);
+    const verified = verify(message, signature, recipient);
+    expect(verified).toEqual(true);
+  });
+  it("Signs a message for anyone", () => {
+    const sender = new PrivateKey(15);
+    const message = [1, 2, 4, 8, 16, 32];
+    const signature = sign(message, sender);
+    const verified = verify(message, signature);
+    expect(verified).toEqual(true);
+  });
+  it("Fails to verify a message with a wrong version", () => {
+    const sender = new PrivateKey(15);
+    const recipient = new PrivateKey(21);
+    const recipientPub = recipient.toPublicKey();
+    const message = [1, 2, 4, 8, 16, 32];
+    const signature = sign(message, sender, recipientPub);
+    signature[0] = 1;
+    expect(() => verify(message, signature, recipient)).toThrow(
+      new Error(
+        "Message version mismatch: Expected 42423301, received 01423301"
+      )
+    );
+  });
+  it("Fails to verify a message with no verifier when required", () => {
+    const sender = new PrivateKey(15);
+    const recipient = new PrivateKey(21);
+    const recipientPub = recipient.toPublicKey();
+    const message = [1, 2, 4, 8, 16, 32];
+    const signature = sign(message, sender, recipientPub);
+    expect(() => verify(message, signature)).toThrow(
+      new Error(
+        "This signature can only be verified with knowledge of a specific private key. The associated public key is: 02352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5"
+      )
+    );
+  });
+  it("Fails to verify a message with a wrong verifier", () => {
+    const sender = new PrivateKey(15);
+    const recipient = new PrivateKey(21);
+    const wrongRecipient = new PrivateKey(22);
+    const recipientPub = recipient.toPublicKey();
+    const message = [1, 2, 4, 8, 16, 32];
+    const signature = sign(message, sender, recipientPub);
+    expect(() => verify(message, signature, wrongRecipient)).toThrow(
+      new Error(
+        "The recipient public key is 03421f5fc9a21065445c96fdb91c0c1e2f2431741c72713b4b99ddcb316f31e9fc but the signature requres the recipient to have public key 02352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5"
+      )
+    );
+  });
+});

package/src/messages/index.ts

@@ -1,2 +1,2 @@
-export * as SignedMessage from './SignedMessage.js'
-export * as EncryptedMessage from './EncryptedMessage.js'
+export * as SignedMessage from './SignedMessage'
+export * as EncryptedMessage from './EncryptedMessage'

package/src/overlay-tools/LookupResolver.ts

@@ -1,19 +1,19 @@
-import { Transaction } from '../transaction/index.js'
-import OverlayAdminTokenTemplate from './OverlayAdminTokenTemplate.js'
+import { Transaction } from '../transaction/index'
+import OverlayAdminTokenTemplate from './OverlayAdminTokenTemplate'
 
 /**
  * The question asked to the Overlay Services Engine when a consumer of state wishes to look up information.
  */
 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,9 +88,15 @@ 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) =>
       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,7 +136,8 @@ export default class LookupResolver {
   private readonly additionalHosts: Record<string, string[]>
 
   constructor (config?: LookupResolverConfig) {
-    const { facilitator, slapTrackers, hostOverrides, additionalHosts } = config ?? {} as LookupResolverConfig
+    const { facilitator, slapTrackers, hostOverrides, additionalHosts } =
+      config ?? ({} as LookupResolverConfig)
     this.facilitator = facilitator ?? new HTTPSOverlayLookupFacilitator()
     this.slapTrackers = slapTrackers ?? DEFAULT_SLAP_TRACKERS
     this.hostOverrides = hostOverrides ?? {}
@@ -128,7 +147,10 @@ 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
@@ -144,17 +166,21 @@ export default class LookupResolver {
       ]
     }
     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)
+      .map(result => result.value)
 
     if (successfulResponses.length === 0) {
       throw new Error('No successful responses from any hosts')
@@ -192,10 +218,10 @@ export default class LookupResolver {
   }
 
   /**
-     * 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 +232,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,7 +252,10 @@ 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
             }

package/src/overlay-tools/OverlayAdminTokenTemplate.ts

@@ -1,8 +1,8 @@
-import PushDrop from '../script/templates/PushDrop.js'
-import { WalletInterface } from '../wallet/Wallet.interfaces.js'
-import { LockingScript, ScriptTemplate, UnlockingScript } from '../script/index.js'
-import { Transaction } from '../transaction/index.js'
-import { Utils } from '../primitives/index.js'
+import PushDrop from '../script/templates/PushDrop'
+import { WalletInterface } from '../wallet/Wallet.interfaces'
+import { LockingScript, ScriptTemplate, UnlockingScript } from '../script/index'
+import { Transaction } from '../transaction/index'
+import { Utils } from '../primitives/index'
 
 /**
  * Script template enabling the creation, unlocking, and decoding of SHIP and SLAP advertisements.
@@ -11,11 +11,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 +41,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 +70,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'
+    )
   }
 }