@bsv/sdk 1.3.13 → 1.3.15

package/src/auth/clients/index.ts

@@ -1 +1 @@
-export * from "./AuthFetch";
+export * from './AuthFetch.js'

package/src/auth/index.ts

@@ -1,7 +1,7 @@
-export * from './certificates/index'
-export * from './Peer'
-export * from './SessionManager'
-export * from './types'
-export * from './utils/index'
-export * from './clients/index'
-export * from './transports/index'
+export * from './certificates/index.js'
+export * from './Peer.js'
+export * from './SessionManager.js'
+export * from './types.js'
+export * from './utils/index.js'
+export * from './clients/index.js'
+export * from './transports/index.js'

package/src/auth/transports/SimplifiedFetchTransport.ts

@@ -1,19 +1,21 @@
-import { AuthMessage, RequestedCertificateSet, Transport } from "../types";
-import { Utils } from "../../../mod";
+// @ts-nocheck
+// @ts-ignore
+import { AuthMessage, RequestedCertificateSet, Transport } from "../types.js"
+import { Utils } from '../../../mod.js'
 
-const SUCCESS_STATUS_CODES = [200, 402];
+const SUCCESS_STATUS_CODES = [200, 402]
 
 // Only bind window.fetch in the browser
-const defaultFetch = typeof window !== "undefined" ? fetch.bind(window) : fetch;
+const defaultFetch = typeof window !== 'undefined' ? fetch.bind(window) : fetch;
 
 /**
  * Implements an HTTP-specific transport for handling Peer mutual authentication messages.
  * This class integrates with fetch to send and receive authenticated messages between peers.
  */
 export class SimplifiedFetchTransport implements Transport {
-  private onDataCallback?: (message: AuthMessage) => void;
-  fetchClient: typeof fetch;
-  baseUrl: string;
+  private onDataCallback?: (message: AuthMessage) => void
+  fetchClient: typeof fetch
+  baseUrl: string
 
   /**
    * Constructs a new instance of SimplifiedFetchTransport.
@@ -21,8 +23,8 @@ export class SimplifiedFetchTransport implements Transport {
    * @param fetchClient - A fetch implementation to use for HTTP requests (default: global fetch).
    */
   constructor(baseUrl: string, fetchClient = defaultFetch) {
-    this.fetchClient = fetchClient;
-    this.baseUrl = baseUrl;
+    this.fetchClient = fetchClient
+    this.baseUrl = baseUrl
   }
 
   /**
@@ -30,106 +32,86 @@ export class SimplifiedFetchTransport implements Transport {
    * Handles both general and authenticated message types. For general messages,
    * the payload is deserialized and sent as an HTTP request. For other message types,
    * the message is sent as a POST request to the `/auth` endpoint.
-   *
+   * 
    * @param message - The AuthMessage to send.
    * @returns A promise that resolves when the message is successfully sent.
-   *
+   * 
    * @throws Will throw an error if no listener has been registered via `onData`.
    */
   async send(message: AuthMessage): Promise<void> {
     if (!this.onDataCallback) {
-      throw new Error(
-        "Listen before you start speaking. God gave you two ears and one mouth for a reason."
-      );
+      throw new Error('Listen before you start speaking. God gave you two ears and one mouth for a reason.')
     }
 
-    if (message.messageType !== "general") {
-      const response = await this.fetchClient(
-        `${this.baseUrl}/.well-known/auth`,
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify(message),
-        }
-      );
+    if (message.messageType !== 'general') {
+      const response = await this.fetchClient(`${this.baseUrl}/.well-known/auth`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(message)
+      })
       // Handle the response if data is received and callback is set
       if (response.ok && this.onDataCallback) {
-        const responseMessage = await response.json();
-        if (responseMessage?.status !== "certificate received") {
-          this.onDataCallback(responseMessage as AuthMessage);
+        const responseMessage = await response.json()
+        if (responseMessage?.status !== 'certificate received') {
+          this.onDataCallback(responseMessage as AuthMessage)
         }
       } else {
         // Server may be a non authenticated server
-        throw new Error("HTTP server failed to authenticate");
+        throw new Error('HTTP server failed to authenticate')
       }
     } else {
       // Parse message payload
-      const httpRequest = this.deserializeRequestPayload(message.payload);
+      const httpRequest = this.deserializeRequestPayload(message.payload)
 
       // Send the byte array as the HTTP payload
-      const url = `${this.baseUrl}${httpRequest.urlPostfix}`;
-      let httpRequestWithAuthHeaders: any = httpRequest;
-      if (typeof httpRequest.headers !== "object") {
-        httpRequestWithAuthHeaders.headers = {};
+      const url = `${this.baseUrl}${httpRequest.urlPostfix}`
+      let httpRequestWithAuthHeaders: any = httpRequest
+      if (typeof httpRequest.headers !== 'object') {
+        httpRequestWithAuthHeaders.headers = {}
       }
 
       // Append auth headers in request to server
-      httpRequestWithAuthHeaders.headers["x-bsv-auth-version"] =
-        message.version;
-      httpRequestWithAuthHeaders.headers["x-bsv-auth-identity-key"] =
-        message.identityKey;
-      httpRequestWithAuthHeaders.headers["x-bsv-auth-nonce"] = message.nonce;
-      httpRequestWithAuthHeaders.headers["x-bsv-auth-your-nonce"] =
-        message.yourNonce;
-      httpRequestWithAuthHeaders.headers["x-bsv-auth-signature"] = Utils.toHex(
-        message.signature
-      );
-      httpRequestWithAuthHeaders.headers["x-bsv-auth-request-id"] =
-        httpRequest.requestId;
+      httpRequestWithAuthHeaders.headers['x-bsv-auth-version'] = message.version
+      httpRequestWithAuthHeaders.headers['x-bsv-auth-identity-key'] = message.identityKey
+      httpRequestWithAuthHeaders.headers['x-bsv-auth-nonce'] = message.nonce
+      httpRequestWithAuthHeaders.headers['x-bsv-auth-your-nonce'] = message.yourNonce
+      httpRequestWithAuthHeaders.headers['x-bsv-auth-signature'] = Utils.toHex(message.signature)
+      httpRequestWithAuthHeaders.headers['x-bsv-auth-request-id'] = httpRequest.requestId
 
       // Ensure Content-Type is set for requests with a body
       if (httpRequestWithAuthHeaders.body) {
         const headers = httpRequestWithAuthHeaders.headers;
-        if (!headers["content-type"]) {
-          throw new Error(
-            "Content-Type header is required for requests with a body."
-          );
+        if (!headers['content-type']) {
+          throw new Error('Content-Type header is required for requests with a body.');
         }
 
-        const contentType = headers["content-type"];
+        const contentType = headers['content-type'];
 
         // Transform body based on Content-Type
-        if (contentType.includes("application/json")) {
+        if (contentType.includes('application/json')) {
           // Convert byte array to JSON string
-          httpRequestWithAuthHeaders.body = Utils.toUTF8(
-            httpRequestWithAuthHeaders.body
-          );
-        } else if (contentType.includes("application/x-www-form-urlencoded")) {
+          httpRequestWithAuthHeaders.body = Utils.toUTF8(httpRequestWithAuthHeaders.body);
+        } else if (contentType.includes('application/x-www-form-urlencoded')) {
           // Convert byte array to URL-encoded string
-          httpRequestWithAuthHeaders.body = Utils.toUTF8(
-            httpRequestWithAuthHeaders.body
-          );
-        } else if (contentType.includes("text/plain")) {
+          httpRequestWithAuthHeaders.body = Utils.toUTF8(httpRequestWithAuthHeaders.body);
+        } else if (contentType.includes('text/plain')) {
           // Convert byte array to plain UTF-8 string
-          httpRequestWithAuthHeaders.body = Utils.toUTF8(
-            httpRequestWithAuthHeaders.body
-          );
+          httpRequestWithAuthHeaders.body = Utils.toUTF8(httpRequestWithAuthHeaders.body);
         } else {
           // For all other content types, treat as binary data
-          httpRequestWithAuthHeaders.body = new Uint8Array(
-            httpRequestWithAuthHeaders.body
-          );
+          httpRequestWithAuthHeaders.body = new Uint8Array(httpRequestWithAuthHeaders.body);
         }
       }
 
+
       // Send the actual fetch request to the server
       const response = await this.fetchClient(url, {
         method: httpRequestWithAuthHeaders.method,
         headers: httpRequestWithAuthHeaders.headers,
-        body: httpRequestWithAuthHeaders.body,
-      });
+        body: httpRequestWithAuthHeaders.body
+      })
 
       // Check for an acceptable status
       if (!SUCCESS_STATUS_CODES.includes(response.status)) {
@@ -139,186 +121,164 @@ export class SimplifiedFetchTransport implements Transport {
           errorInfo = await response.json();
         } catch {
           // Fallback to text if JSON parse fails
-          const text = await response.text().catch(() => "");
-          throw new Error(
-            `HTTP ${response.status} - ${text || "Unknown error"}`
-          );
+          const text = await response.text().catch(() => '');
+          throw new Error(`HTTP ${response.status} - ${text || 'Unknown error'}`);
         }
 
         // If we find a known { status: 'error', code, description } structure
-        if (
-          errorInfo?.status === "error" &&
-          typeof errorInfo.description === "string"
-        ) {
+        if (errorInfo?.status === 'error' && typeof errorInfo.description === 'string') {
           const msg = `HTTP ${response.status} - ${errorInfo.description}`;
-          throw new Error(
-            errorInfo.code ? `${msg} (code: ${errorInfo.code})` : msg
-          );
+          throw new Error(errorInfo.code ? `${msg} (code: ${errorInfo.code})` : msg);
         }
 
         // Otherwise just throw whatever we got
-        throw new Error(
-          `HTTP ${response.status} - ${JSON.stringify(errorInfo)}`
-        );
+        throw new Error(`HTTP ${response.status} - ${JSON.stringify(errorInfo)}`);
       }
 
-      const parsedBody = await response.arrayBuffer();
-      const payloadWriter = new Utils.Writer();
-      payloadWriter.write(
-        Utils.toArray(response.headers.get("x-bsv-auth-request-id"), "base64")
-      );
-      payloadWriter.writeVarIntNum(response.status);
+      const parsedBody = await response.arrayBuffer()
+      const payloadWriter = new Utils.Writer()
+      payloadWriter.write(Utils.toArray(response.headers.get('x-bsv-auth-request-id'), 'base64'))
+      payloadWriter.writeVarIntNum(response.status)
 
       // Filter out headers the server signed:
       // - Custom headers prefixed with x-bsv are included, except auth
       // - x-bsv-auth headers are not allowed
       // - authorization header is signed by the server
-      const includedHeaders: [string, string][] = [];
+      const includedHeaders: [string, string][] = []
       // Collect headers into a raw array for sorting
-      const headersArray: [string, string][] = [];
+      const headersArray: [string, string][] = []
       response.headers.forEach((value, key) => {
-        const lowerKey = key.toLowerCase();
-        if (lowerKey.startsWith("x-bsv-") || lowerKey === "authorization") {
-          if (!lowerKey.startsWith("x-bsv-auth")) {
-            headersArray.push([lowerKey, value]);
+        const lowerKey = key.toLowerCase()
+        if (lowerKey.startsWith('x-bsv-') || lowerKey === 'authorization') {
+          if (!lowerKey.startsWith('x-bsv-auth')) {
+            headersArray.push([lowerKey, value])
           }
         }
-      });
+      })
 
       // Sort headers explicitly to match server-side order
-      headersArray.sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
-      includedHeaders.push(...headersArray);
+      headersArray.sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
+      includedHeaders.push(...headersArray)
 
       // nHeaders
-      payloadWriter.writeVarIntNum(includedHeaders.length);
+      payloadWriter.writeVarIntNum(includedHeaders.length)
       for (let i = 0; i < includedHeaders.length; i++) {
         // headerKeyLength
-        const headerKeyAsArray = Utils.toArray(includedHeaders[i][0], "utf8");
-        payloadWriter.writeVarIntNum(headerKeyAsArray.length);
+        const headerKeyAsArray = Utils.toArray(includedHeaders[i][0], 'utf8')
+        payloadWriter.writeVarIntNum(headerKeyAsArray.length)
         // headerKey
-        payloadWriter.write(headerKeyAsArray);
+        payloadWriter.write(headerKeyAsArray)
         // headerValueLength
-        const headerValueAsArray = Utils.toArray(includedHeaders[i][1], "utf8");
-        payloadWriter.writeVarIntNum(headerValueAsArray.length);
+        const headerValueAsArray = Utils.toArray(includedHeaders[i][1], 'utf8')
+        payloadWriter.writeVarIntNum(headerValueAsArray.length)
         // headerValue
-        payloadWriter.write(headerValueAsArray);
+        payloadWriter.write(headerValueAsArray)
       }
 
       // Handle body
       if (parsedBody) {
-        const bodyAsArray = Array.from(new Uint8Array(parsedBody));
-        payloadWriter.writeVarIntNum(bodyAsArray.length);
-        payloadWriter.write(bodyAsArray);
+        const bodyAsArray = Array.from(new Uint8Array(parsedBody))
+        payloadWriter.writeVarIntNum(bodyAsArray.length)
+        payloadWriter.write(bodyAsArray)
       } else {
-        payloadWriter.writeVarIntNum(-1);
+        payloadWriter.writeVarIntNum(-1)
       }
 
       // Build the correct AuthMessage for the response
       const responseMessage: AuthMessage = {
-        version: response.headers.get("x-bsv-auth-version"),
-        messageType:
-          response.headers.get("x-bsv-auth-message-type") ===
-          "certificateRequest"
-            ? "certificateRequest"
-            : "general",
-        identityKey: response.headers.get("x-bsv-auth-identity-key"),
-        nonce: response.headers.get("x-bsv-auth-nonce"),
-        yourNonce: response.headers.get("x-bsv-auth-your-nonce"),
-        requestedCertificates: JSON.parse(
-          response.headers.get("x-bsv-auth-requested-certificates")
-        ) as RequestedCertificateSet,
+        version: response.headers.get('x-bsv-auth-version'),
+        messageType: response.headers.get('x-bsv-auth-message-type') === 'certificateRequest' ? 'certificateRequest' : 'general',
+        identityKey: response.headers.get('x-bsv-auth-identity-key'),
+        nonce: response.headers.get('x-bsv-auth-nonce'),
+        yourNonce: response.headers.get('x-bsv-auth-your-nonce'),
+        requestedCertificates: JSON.parse(response.headers.get('x-bsv-auth-requested-certificates')) as RequestedCertificateSet,
         payload: payloadWriter.toArray(),
-        signature: Utils.toArray(
-          response.headers.get("x-bsv-auth-signature"),
-          "hex"
-        ),
-      };
+        signature: Utils.toArray(response.headers.get('x-bsv-auth-signature'), 'hex'),
+      }
 
       // If the server didn't provide the correct authentication headers, throw an error
       if (!responseMessage.version) {
-        throw new Error("HTTP server failed to authenticate");
+        throw new Error('HTTP server failed to authenticate')
       }
 
       // Handle the response if data is received and callback is set
-      this.onDataCallback(responseMessage);
+      this.onDataCallback(responseMessage)
     }
   }
 
   /**
-   * Registers a callback to handle incoming messages.
+   * Registers a callback to handle incoming messages. 
    * This must be called before sending any messages to ensure responses can be processed.
-   *
+   * 
    * @param callback - A function to invoke when an incoming AuthMessage is received.
    * @returns A promise that resolves once the callback is set.
    */
-  async onData(
-    callback: (message: AuthMessage) => Promise<void>
-  ): Promise<void> {
+  async onData(callback: (message: AuthMessage) => Promise<void>): Promise<void> {
     this.onDataCallback = (m) => {
-      callback(m);
-    };
+      callback(m)
+    }
   }
 
   /**
    * Deserializes a request payload from a byte array into an HTTP request-like structure.
-   *
+   * 
    * @param payload - The serialized payload to deserialize.
    * @returns An object representing the deserialized request, including the method,
    *          URL postfix (path and query string), headers, body, and request ID.
    */
   deserializeRequestPayload(payload: number[]): {
-    method: string;
-    urlPostfix: string;
-    headers: Record<string, string>;
-    body: number[];
-    requestId: string;
+    method: string,
+    urlPostfix: string,
+    headers: Record<string, string>,
+    body: number[],
+    requestId: string
   } {
     // Create a reader
-    const requestReader = new Utils.Reader(payload);
+    const requestReader = new Utils.Reader(payload)
     // The first 32 bytes is the requestId
-    const requestId = Utils.toBase64(requestReader.read(32));
+    const requestId = Utils.toBase64(requestReader.read(32))
 
     // Method
-    const methodLength = requestReader.readVarIntNum();
-    let method = "GET";
+    const methodLength = requestReader.readVarIntNum()
+    let method = 'GET'
     if (methodLength > 0) {
-      method = Utils.toUTF8(requestReader.read(methodLength));
+      method = Utils.toUTF8(requestReader.read(methodLength))
     }
 
     // Path
-    const pathLength = requestReader.readVarIntNum();
-    let path = "";
+    const pathLength = requestReader.readVarIntNum()
+    let path = ''
     if (pathLength > 0) {
-      path = Utils.toUTF8(requestReader.read(pathLength));
+      path = Utils.toUTF8(requestReader.read(pathLength))
     }
 
     // Search
-    const searchLength = requestReader.readVarIntNum();
-    let search = "";
+    const searchLength = requestReader.readVarIntNum()
+    let search = ''
     if (searchLength > 0) {
-      search = Utils.toUTF8(requestReader.read(searchLength));
+      search = Utils.toUTF8(requestReader.read(searchLength))
     }
 
     // Read headers
-    const requestHeaders = {};
-    const nHeaders = requestReader.readVarIntNum();
+    const requestHeaders = {}
+    const nHeaders = requestReader.readVarIntNum()
     if (nHeaders > 0) {
       for (let i = 0; i < nHeaders; i++) {
-        const nHeaderKeyBytes = requestReader.readVarIntNum();
-        const headerKeyBytes = requestReader.read(nHeaderKeyBytes);
-        const headerKey = Utils.toUTF8(headerKeyBytes);
-        const nHeaderValueBytes = requestReader.readVarIntNum();
-        const headerValueBytes = requestReader.read(nHeaderValueBytes);
-        const headerValue = Utils.toUTF8(headerValueBytes);
-        requestHeaders[headerKey] = headerValue;
+        const nHeaderKeyBytes = requestReader.readVarIntNum()
+        const headerKeyBytes = requestReader.read(nHeaderKeyBytes)
+        const headerKey = Utils.toUTF8(headerKeyBytes)
+        const nHeaderValueBytes = requestReader.readVarIntNum()
+        const headerValueBytes = requestReader.read(nHeaderValueBytes)
+        const headerValue = Utils.toUTF8(headerValueBytes)
+        requestHeaders[headerKey] = headerValue
       }
     }
 
     // Read body
-    let requestBody;
-    const requestBodyBytes = requestReader.readVarIntNum();
+    let requestBody
+    const requestBodyBytes = requestReader.readVarIntNum()
     if (requestBodyBytes > 0) {
-      requestBody = requestReader.read(requestBodyBytes);
+      requestBody = requestReader.read(requestBodyBytes)
     }
 
     // Return the deserialized RequestInit
@@ -327,7 +287,7 @@ export class SimplifiedFetchTransport implements Transport {
       method,
       headers: requestHeaders,
       body: requestBody,
-      requestId,
-    };
+      requestId
+    }
   }
-}
+}

package/src/auth/transports/index.ts

@@ -1 +1 @@
-export * from "./SimplifiedFetchTransport";
+export * from './SimplifiedFetchTransport.js'

package/src/auth/types.ts

@@ -1,4 +1,4 @@
-import { VerifiableCertificate } from './certificates/VerifiableCertificate'
+import { VerifiableCertificate } from './certificates/VerifiableCertificate.js'
 
 export interface RequestedCertificateTypeIDAndFieldList {
   [certificateTypeID: string]: string[]

package/src/auth/utils/__tests/cryptononce.test.ts

@@ -19,7 +19,7 @@ describe('createNonce', () => {
 
   it('throws an error if wallet fails to create HMAC', async () => {
     // Mock failure of HMAC creation
-    ;(mockWallet.createHmac as jest.Mock).mockRejectedValue(
+    (mockWallet.createHmac as jest.Mock).mockRejectedValue(
       new Error('Failed to create HMAC')
     )
 
@@ -49,10 +49,12 @@ describe('verifyNonce', () => {
   })
 
   it('does not verify an invalid nonce', async () => {
-    ;(mockWallet.verifyHmac as jest.Mock).mockResolvedValue({ valid: false })
+    (mockWallet.verifyHmac as jest.Mock).mockResolvedValue({ valid: false })
 
     const nonce = await createNonce(mockWallet)
-    await expect(verifyNonce(nonce + 'ABC', mockWallet)).resolves.toEqual(false)
+    await expect(verifyNonce(nonce + 'ABC', mockWallet)).resolves.toEqual(
+      false
+    )
     await expect(verifyNonce(nonce + '=', mockWallet)).resolves.toEqual(false)
     await expect(
       verifyNonce(
@@ -66,14 +68,14 @@ describe('verifyNonce', () => {
   })
 
   it('returns false for an invalid HMAC verification', async () => {
-    ;(mockWallet.verifyHmac as jest.Mock).mockResolvedValue({ valid: false })
+    (mockWallet.verifyHmac as jest.Mock).mockResolvedValue({ valid: false })
 
     const nonce = await createNonce(mockWallet)
     await expect(verifyNonce(nonce, mockWallet)).resolves.toEqual(false)
   })
 
   it('verifies a 256-bit nonce', async () => {
-    ;(mockWallet.verifyHmac as jest.Mock).mockResolvedValue({ valid: true })
+    (mockWallet.verifyHmac as jest.Mock).mockResolvedValue({ valid: true })
 
     const nonce1 = await createNonce(mockWallet)
     const nonce2 = await createNonce(mockWallet)

package/src/auth/utils/__tests/getVerifiableCertificates.test.ts

@@ -34,12 +34,12 @@ describe('getVerifiableCertificates', () => {
       revocationOutpoint: 'outpoint1',
       fields: { field1: 'encryptedData1', field2: 'encryptedData2' },
       signature: 'signature1'
-    }
+    };
 
-    ;(mockWallet.listCertificates as jest.Mock).mockResolvedValue({
+    (mockWallet.listCertificates as jest.Mock).mockResolvedValue({
       certificates: [mockCertificate]
-    })
-    ;(mockWallet.proveCertificate as jest.Mock).mockResolvedValue({
+    });
+    (mockWallet.proveCertificate as jest.Mock).mockResolvedValue({
       keyringForVerifier: { field1: 'key1', field2: 'key2' }
     })
 
@@ -75,7 +75,7 @@ describe('getVerifiableCertificates', () => {
   })
 
   it('returns an empty array when no matching certificates are found', async () => {
-    ;(mockWallet.listCertificates as jest.Mock).mockResolvedValue({
+    (mockWallet.listCertificates as jest.Mock).mockResolvedValue({
       certificates: []
     })
 
@@ -91,7 +91,7 @@ describe('getVerifiableCertificates', () => {
   })
 
   it('propagates errors from listCertificates', async () => {
-    ;(mockWallet.listCertificates as jest.Mock).mockRejectedValue(
+    (mockWallet.listCertificates as jest.Mock).mockRejectedValue(
       new Error('listCertificates failed')
     )
 
@@ -113,12 +113,12 @@ describe('getVerifiableCertificates', () => {
       revocationOutpoint: 'outpoint1',
       fields: { field1: 'encryptedData1', field2: 'encryptedData2' },
       signature: 'signature1'
-    }
+    };
 
-    ;(mockWallet.listCertificates as jest.Mock).mockResolvedValue({
+    (mockWallet.listCertificates as jest.Mock).mockResolvedValue({
       certificates: [mockCertificate]
-    })
-    ;(mockWallet.proveCertificate as jest.Mock).mockRejectedValue(
+    });
+    (mockWallet.proveCertificate as jest.Mock).mockRejectedValue(
       new Error('proveCertificate failed')
     )
 
@@ -132,8 +132,8 @@ describe('getVerifiableCertificates', () => {
   })
 
   it('handles empty requested certificates gracefully', async () => {
-    requestedCertificates = { certifiers: [], types: {} }
-    ;(mockWallet.listCertificates as jest.Mock).mockResolvedValue({
+    requestedCertificates = { certifiers: [], types: {} };
+    (mockWallet.listCertificates as jest.Mock).mockResolvedValue({
       certificates: []
     })