@bsv/sdk 1.3.12 → 1.3.13

package/src/transaction/http/NodejsHttpClient.ts

@@ -1,53 +1,67 @@
-import { HttpClient, HttpClientRequestOptions, HttpClientResponse } from './HttpClient.js'
+import {
+  HttpClient,
+  HttpClientRequestOptions,
+  HttpClientResponse,
+} from "./HttpClient";
 
-/** Node.js Https module interface limited to options needed by ts-sdk */
+/** Node Https module interface limited to options needed by ts-sdk */
 export interface HttpsNodejs {
-  request: (url: string, options: HttpClientRequestOptions, callback: (res: any) => void) => NodejsHttpClientRequest
+  request: (
+    url: string,
+    options: HttpClientRequestOptions,
+    callback: (res: any) => void
+  ) => NodejsHttpClientRequest;
 }
 
-/** Nodejs result of the Node.js https.request call limited to options needed by ts-sdk */
+/** Nodejs result of the Node https.request call limited to options needed by ts-sdk */
 export interface NodejsHttpClientRequest {
-  write: (chunk: string) => void
+  write: (chunk: string) => void;
 
-  on: (event: string, callback: (data: any) => void) => void
+  on: (event: string, callback: (data: any) => void) => void;
 
-  end: (() => void) & (() => void)
+  end: (() => void) & (() => void);
 }
 
 /**
- * Adapter for Node.js Https module to be used as HttpClient
+ * Adapter for Node Https module to be used as HttpClient
  */
 export class NodejsHttpClient implements HttpClient {
-  constructor (private readonly https: HttpsNodejs) {}
+  constructor(private readonly https: HttpsNodejs) {}
 
-  async request (url: string, requestOptions: HttpClientRequestOptions): Promise<HttpClientResponse> {
+  async request(
+    url: string,
+    requestOptions: HttpClientRequestOptions
+  ): Promise<HttpClientResponse> {
     return await new Promise((resolve, reject) => {
       const req = this.https.request(url, requestOptions, (res) => {
-        let body = ''
-        res.on('data', (chunk: string) => {
-          body += chunk
-        })
-        res.on('end', () => {
-          const ok = res.statusCode >= 200 && res.statusCode <= 299
-          const mediaType = res.headers['content-type']
-          const data = body && mediaType.startsWith('application/json') ? JSON.parse(body) : body
+        let body = "";
+        res.on("data", (chunk: string) => {
+          body += chunk;
+        });
+        res.on("end", () => {
+          const ok = res.statusCode >= 200 && res.statusCode <= 299;
+          const mediaType = res.headers["content-type"];
+          const data =
+            body && mediaType.startsWith("application/json")
+              ? JSON.parse(body)
+              : body;
           resolve({
             status: res.statusCode,
             statusText: res.statusMessage,
             ok,
-            data
-          })
-        })
-      })
+            data,
+          });
+        });
+      });
 
-      req.on('error', (error) => {
-        reject(error)
-      })
+      req.on("error", (error) => {
+        reject(error);
+      });
 
       if (requestOptions.data) {
-        req.write(JSON.stringify(requestOptions.data))
+        req.write(JSON.stringify(requestOptions.data));
       }
-      req.end()
-    })
+      req.end();
+    });
   }
 }

package/src/transaction/http/index.ts

@@ -1,6 +1,10 @@
-export type { HttpClient, HttpClientResponse, HttpClientRequestOptions } from './HttpClient.js'
-export { defaultHttpClient } from './DefaultHttpClient.js'
-export { NodejsHttpClient } from './NodejsHttpClient.js'
-export { FetchHttpClient } from './FetchHttpClient.js'
-export type { Fetch, FetchOptions } from './FetchHttpClient.js'
-export type { HttpsNodejs, NodejsHttpClientRequest } from './NodejsHttpClient.js'
+export type {
+  HttpClient,
+  HttpClientResponse,
+  HttpClientRequestOptions,
+} from "./HttpClient";
+export { defaultHttpClient } from "./DefaultHttpClient";
+export { NodejsHttpClient } from "./NodejsHttpClient";
+export { FetchHttpClient } from "./FetchHttpClient";
+export type { Fetch, FetchOptions } from "./FetchHttpClient";
+export type { HttpsNodejs, NodejsHttpClientRequest } from "./NodejsHttpClient";

package/src/transaction/index.ts

@@ -1,10 +1,14 @@
-export { default as Transaction } from './Transaction.js'
-export { default as MerklePath } from './MerklePath.js'
-export type { default as TransactionInput } from './TransactionInput.js'
-export type { default as TransactionOutput } from './TransactionOutput.js'
-export type { Broadcaster, BroadcastFailure, BroadcastResponse } from './Broadcaster.js'
-export { isBroadcastResponse, isBroadcastFailure } from './Broadcaster.js'
-export type { default as ChainTracker } from './ChainTracker.js'
-export { default as BeefTx } from './BeefTx.js'
-export * from './Beef.js'
-export { default as BeefParty } from './BeefParty.js'
+export { default as Transaction } from './Transaction'
+export { default as MerklePath } from './MerklePath'
+export type { default as TransactionInput } from './TransactionInput'
+export type { default as TransactionOutput } from './TransactionOutput'
+export type {
+  Broadcaster,
+  BroadcastFailure,
+  BroadcastResponse
+} from './Broadcaster'
+export { isBroadcastResponse, isBroadcastFailure } from './Broadcaster'
+export type { default as ChainTracker } from './ChainTracker'
+export { default as BeefTx } from './BeefTx'
+export * from './Beef'
+export { default as BeefParty } from './BeefParty'

package/src/wallet/CachedKeyDeriver.ts

@@ -1,6 +1,6 @@
-import { PrivateKey, PublicKey, SymmetricKey } from '../primitives/index.js'
-import { Counterparty, KeyDeriver } from './KeyDeriver.js'
-import { WalletProtocol } from './Wallet.interfaces.js'
+import { PrivateKey, PublicKey, SymmetricKey } from '../primitives/index'
+import { Counterparty, KeyDeriver } from './KeyDeriver'
+import { WalletProtocol } from './Wallet.interfaces'
 
 /**
  * A cached version of KeyDeriver that caches the results of key derivation methods.
@@ -13,98 +13,133 @@ export default class CachedKeyDeriver {
   private readonly maxCacheSize: number
 
   /**
-     * Initializes the CachedKeyDeriver instance with a root private key and optional cache settings.
-     * @param {PrivateKey | 'anyone'} rootKey - The root private key or the string 'anyone'.
-     * @param {Object} [options] - Optional settings for the cache.
-     * @param {number} [options.maxCacheSize=1000] - The maximum number of entries to store in the cache.
-     */
-  constructor (rootKey: PrivateKey | 'anyone', options?: { maxCacheSize?: number }) {
+   * Initializes the CachedKeyDeriver instance with a root private key and optional cache settings.
+   * @param {PrivateKey | 'anyone'} rootKey - The root private key or the string 'anyone'.
+   * @param {Object} [options] - Optional settings for the cache.
+   * @param {number} [options.maxCacheSize=1000] - The maximum number of entries to store in the cache.
+   */
+  constructor (
+    rootKey: PrivateKey | 'anyone',
+    options?: { maxCacheSize?: number }
+  ) {
     this.keyDeriver = new KeyDeriver(rootKey)
     this.cache = new Map<string, any>()
     this.maxCacheSize = options?.maxCacheSize || 1000
   }
 
   /**
-     * Derives a public key based on protocol ID, key ID, and counterparty.
-     * Caches the result for future calls with the same parameters.
-     * @param {WalletProtocol} protocolID - The protocol ID including a security level and protocol name.
-     * @param {string} keyID - The key identifier.
-     * @param {Counterparty} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
-     * @param {boolean} [forSelf=false] - Whether deriving for self.
-     * @returns {PublicKey} - The derived public key.
-     */
+   * Derives a public key based on protocol ID, key ID, and counterparty.
+   * Caches the result for future calls with the same parameters.
+   * @param {WalletProtocol} protocolID - The protocol ID including a security level and protocol name.
+   * @param {string} keyID - The key identifier.
+   * @param {Counterparty} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
+   * @param {boolean} [forSelf=false] - Whether deriving for self.
+   * @returns {PublicKey} - The derived public key.
+   */
   derivePublicKey (
     protocolID: WalletProtocol,
     keyID: string,
     counterparty: Counterparty,
     forSelf: boolean = false
   ): PublicKey {
-    const cacheKey = this.generateCacheKey('derivePublicKey', protocolID, keyID, counterparty, forSelf)
+    const cacheKey = this.generateCacheKey(
+      'derivePublicKey',
+      protocolID,
+      keyID,
+      counterparty,
+      forSelf
+    )
     if (this.cache.has(cacheKey)) {
       return this.cacheGet(cacheKey)
     } else {
-      const result = this.keyDeriver.derivePublicKey(protocolID, keyID, counterparty, forSelf)
+      const result = this.keyDeriver.derivePublicKey(
+        protocolID,
+        keyID,
+        counterparty,
+        forSelf
+      )
       this.cacheSet(cacheKey, result)
       return result
     }
   }
 
   /**
-     * Derives a private key based on protocol ID, key ID, and counterparty.
-     * Caches the result for future calls with the same parameters.
-     * @param {WalletProtocol} protocolID - The protocol ID including a security level and protocol name.
-     * @param {string} keyID - The key identifier.
-     * @param {Counterparty} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
-     * @returns {PrivateKey} - The derived private key.
-     */
+   * Derives a private key based on protocol ID, key ID, and counterparty.
+   * Caches the result for future calls with the same parameters.
+   * @param {WalletProtocol} protocolID - The protocol ID including a security level and protocol name.
+   * @param {string} keyID - The key identifier.
+   * @param {Counterparty} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
+   * @returns {PrivateKey} - The derived private key.
+   */
   derivePrivateKey (
     protocolID: WalletProtocol,
     keyID: string,
     counterparty: Counterparty
   ): PrivateKey {
-    const cacheKey = this.generateCacheKey('derivePrivateKey', protocolID, keyID, counterparty)
+    const cacheKey = this.generateCacheKey(
+      'derivePrivateKey',
+      protocolID,
+      keyID,
+      counterparty
+    )
     if (this.cache.has(cacheKey)) {
       return this.cacheGet(cacheKey)
     } else {
-      const result = this.keyDeriver.derivePrivateKey(protocolID, keyID, counterparty)
+      const result = this.keyDeriver.derivePrivateKey(
+        protocolID,
+        keyID,
+        counterparty
+      )
       this.cacheSet(cacheKey, result)
       return result
     }
   }
 
   /**
-     * Derives a symmetric key based on protocol ID, key ID, and counterparty.
-     * Caches the result for future calls with the same parameters.
-     * @param {WalletProtocol} protocolID - The protocol ID including a security level and protocol name.
-     * @param {string} keyID - The key identifier.
-     * @param {Counterparty} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
-     * @returns {SymmetricKey} - The derived symmetric key.
-     * @throws {Error} - Throws an error if attempting to derive a symmetric key for 'anyone'.
-     */
+   * Derives a symmetric key based on protocol ID, key ID, and counterparty.
+   * Caches the result for future calls with the same parameters.
+   * @param {WalletProtocol} protocolID - The protocol ID including a security level and protocol name.
+   * @param {string} keyID - The key identifier.
+   * @param {Counterparty} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
+   * @returns {SymmetricKey} - The derived symmetric key.
+   * @throws {Error} - Throws an error if attempting to derive a symmetric key for 'anyone'.
+   */
   deriveSymmetricKey (
     protocolID: WalletProtocol,
     keyID: string,
     counterparty: Counterparty
   ): SymmetricKey {
-    const cacheKey = this.generateCacheKey('deriveSymmetricKey', protocolID, keyID, counterparty)
+    const cacheKey = this.generateCacheKey(
+      'deriveSymmetricKey',
+      protocolID,
+      keyID,
+      counterparty
+    )
     if (this.cache.has(cacheKey)) {
       return this.cacheGet(cacheKey)
     } else {
-      const result = this.keyDeriver.deriveSymmetricKey(protocolID, keyID, counterparty)
+      const result = this.keyDeriver.deriveSymmetricKey(
+        protocolID,
+        keyID,
+        counterparty
+      )
       this.cacheSet(cacheKey, result)
       return result
     }
   }
 
   /**
-     * Reveals the shared secret between the root key and the counterparty.
-     * Caches the result for future calls with the same parameters.
-     * @param {Counterparty} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
-     * @returns {number[]} - The shared secret as a number array.
-     * @throws {Error} - Throws an error if attempting to reveal a shared secret for 'self'.
-     */
+   * Reveals the shared secret between the root key and the counterparty.
+   * Caches the result for future calls with the same parameters.
+   * @param {Counterparty} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
+   * @returns {number[]} - The shared secret as a number array.
+   * @throws {Error} - Throws an error if attempting to reveal a shared secret for 'self'.
+   */
   revealCounterpartySecret (counterparty: Counterparty): number[] {
-    const cacheKey = this.generateCacheKey('revealCounterpartySecret', counterparty)
+    const cacheKey = this.generateCacheKey(
+      'revealCounterpartySecret',
+      counterparty
+    )
     if (this.cache.has(cacheKey)) {
       return this.cacheGet(cacheKey)
     } else {
@@ -115,44 +150,55 @@ export default class CachedKeyDeriver {
   }
 
   /**
-     * Reveals the specific key association for a given protocol ID, key ID, and counterparty.
-     * Caches the result for future calls with the same parameters.
-     * @param {Counterparty} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
-     * @param {WalletProtocol} protocolID - The protocol ID including a security level and protocol name.
-     * @param {string} keyID - The key identifier.
-     * @returns {number[]} - The specific key association as a number array.
-     */
+   * Reveals the specific key association for a given protocol ID, key ID, and counterparty.
+   * Caches the result for future calls with the same parameters.
+   * @param {Counterparty} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
+   * @param {WalletProtocol} protocolID - The protocol ID including a security level and protocol name.
+   * @param {string} keyID - The key identifier.
+   * @returns {number[]} - The specific key association as a number array.
+   */
   revealSpecificSecret (
     counterparty: Counterparty,
     protocolID: WalletProtocol,
     keyID: string
   ): number[] {
-    const cacheKey = this.generateCacheKey('revealSpecificSecret', counterparty, protocolID, keyID)
+    const cacheKey = this.generateCacheKey(
+      'revealSpecificSecret',
+      counterparty,
+      protocolID,
+      keyID
+    )
     if (this.cache.has(cacheKey)) {
       return this.cacheGet(cacheKey)
     } else {
-      const result = this.keyDeriver.revealSpecificSecret(counterparty, protocolID, keyID)
+      const result = this.keyDeriver.revealSpecificSecret(
+        counterparty,
+        protocolID,
+        keyID
+      )
       this.cacheSet(cacheKey, result)
       return result
     }
   }
 
   /**
-     * Generates a unique cache key based on the method name and input parameters.
-     * @param {string} methodName - The name of the method.
-     * @param {...any} args - The arguments passed to the method.
-     * @returns {string} - The generated cache key.
-     */
+   * Generates a unique cache key based on the method name and input parameters.
+   * @param {string} methodName - The name of the method.
+   * @param {...any} args - The arguments passed to the method.
+   * @returns {string} - The generated cache key.
+   */
   private generateCacheKey (methodName: string, ...args: any[]): string {
-    const serializedArgs = args.map((arg) => this.serializeArgument(arg)).join('|')
+    const serializedArgs = args
+      .map((arg) => this.serializeArgument(arg))
+      .join('|')
     return `${methodName}|${serializedArgs}`
   }
 
   /**
-     * Serializes an argument to a string for use in a cache key.
-     * @param {any} arg - The argument to serialize.
-     * @returns {string} - The serialized argument.
-     */
+   * Serializes an argument to a string for use in a cache key.
+   * @param {any} arg - The argument to serialize.
+   * @returns {string} - The serialized argument.
+   */
   private serializeArgument (arg: any): string {
     if (arg instanceof PublicKey || arg instanceof PrivateKey) {
       return arg.toString()
@@ -166,10 +212,10 @@ export default class CachedKeyDeriver {
   }
 
   /**
-     * Retrieves an item from the cache and updates its position to reflect recent use.
-     * @param {string} cacheKey - The key of the cached item.
-     * @returns {any} - The cached value.
-     */
+   * Retrieves an item from the cache and updates its position to reflect recent use.
+   * @param {string} cacheKey - The key of the cached item.
+   * @returns {any} - The cached value.
+   */
   private cacheGet (cacheKey: string): any {
     const value = this.cache.get(cacheKey)
     // Update the entry to reflect recent use
@@ -179,10 +225,10 @@ export default class CachedKeyDeriver {
   }
 
   /**
-     * Adds an item to the cache and evicts the least recently used item if necessary.
-     * @param {string} cacheKey - The key of the item to cache.
-     * @param {any} value - The value to cache.
-     */
+   * Adds an item to the cache and evicts the least recently used item if necessary.
+   * @param {string} cacheKey - The key of the item to cache.
+   * @param {any} value - The value to cache.
+   */
   private cacheSet (cacheKey: string, value: any): void {
     if (this.cache.size >= this.maxCacheSize) {
       // Evict the least recently used item (first item in Map)