@bsv/sdk 1.3.11 → 1.3.13

package/src/auth/clients/index.ts

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

package/src/auth/index.ts

@@ -1,7 +1,7 @@
-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'
+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'

package/src/auth/transports/SimplifiedFetchTransport.ts

@@ -1,19 +1,19 @@
-import { AuthMessage, RequestedCertificateSet, Transport } from "../types.js"
-import { Utils } from '../../../mod.js'
+import { AuthMessage, RequestedCertificateSet, Transport } from "../types";
+import { Utils } from "../../../mod";
 
-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 +21,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,86 +30,106 @@ 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)) {
@@ -119,164 +139,186 @@ 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
@@ -285,7 +327,7 @@ export class SimplifiedFetchTransport implements Transport {
       method,
       headers: requestHeaders,
       body: requestBody,
-      requestId
-    }
+      requestId,
+    };
   }
-}
+}

package/src/auth/transports/index.ts

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

package/src/auth/types.ts

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

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

@@ -1,16 +1,15 @@
-import { PrivateKey, Random, Utils } from '../../../../dist/cjs/src/primitives/index.js'
-import { ProtoWallet } from '../../../../dist/cjs/src/wallet/ProtoWallet.js'
-import { WalletInterface } from '../../../../dist/cjs/src/wallet/Wallet.interfaces.js'
-import { createNonce } from '../../../../dist/cjs/src/auth/utils/createNonce.js'
-import { verifyNonce } from '../../../../dist/cjs/src/auth/utils/verifyNonce.js'
-import { hash256 } from '../../../../dist/cjs/src/primitives/Hash.js'
+import { PrivateKey, Utils } from '../../../primitives/index'
+import { WalletInterface } from '../../../wallet/Wallet.interfaces'
+import { createNonce } from '../../../auth/utils/createNonce'
+import { verifyNonce } from '../../../auth/utils/verifyNonce'
+import { CompletedProtoWallet } from '../../../auth/certificates/__tests/CompletedProtoWallet'
 
 describe('createNonce', () => {
   let mockWallet: WalletInterface
 
   beforeEach(() => {
     mockWallet = {
-      createHmac: jest.fn().mockResolvedValue({ hmac: new Uint8Array(16) }),
+      createHmac: jest.fn().mockResolvedValue({ hmac: new Uint8Array(16) })
     } as unknown as WalletInterface
   })
 
@@ -20,9 +19,13 @@ describe('createNonce', () => {
 
   it('throws an error if wallet fails to create HMAC', async () => {
     // Mock failure of HMAC creation
-    (mockWallet.createHmac as jest.Mock).mockRejectedValue(new Error('Failed to create HMAC'))
+    ;(mockWallet.createHmac as jest.Mock).mockRejectedValue(
+      new Error('Failed to create HMAC')
+    )
 
-    await expect(createNonce(mockWallet)).rejects.toThrow('Failed to create HMAC')
+    await expect(createNonce(mockWallet)).rejects.toThrow(
+      'Failed to create HMAC'
+    )
   })
 
   it('creates a 256-bit nonce', async () => {
@@ -37,7 +40,7 @@ describe('verifyNonce', () => {
   beforeEach(() => {
     mockWallet = {
       createHmac: jest.fn().mockResolvedValue({ hmac: new Uint8Array(16) }),
-      verifyHmac: jest.fn().mockResolvedValue({ valid: true }),
+      verifyHmac: jest.fn().mockResolvedValue({ valid: true })
     } as unknown as WalletInterface
   })
 
@@ -46,23 +49,31 @@ 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 + '=', mockWallet)).resolves.toEqual(false)
-    await expect(verifyNonce(Buffer.from(nonce + Buffer.from('extra').toString('base64'), 'base64').toString('base64'), mockWallet)).resolves.toEqual(false)
+    await expect(
+      verifyNonce(
+        Buffer.from(
+          nonce + Buffer.from('extra').toString('base64'),
+          'base64'
+        ).toString('base64'),
+        mockWallet
+      )
+    ).resolves.toEqual(false)
   })
 
   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)
@@ -75,7 +86,7 @@ describe('verifyNonce', () => {
   })
 
   it('verifies nonce using real createHmac and verifyHmac', async () => {
-    const realWallet = new ProtoWallet(PrivateKey.fromRandom())
+    const realWallet = new CompletedProtoWallet(PrivateKey.fromRandom())
 
     const nonce = await createNonce(realWallet)
     const isValid = await verifyNonce(nonce, realWallet)
@@ -84,33 +95,49 @@ describe('verifyNonce', () => {
   })
 
   it('SerialNumber use-case', async () => {
-    const clientWallet = new ProtoWallet(PrivateKey.fromRandom())
-    const serverWallet = new ProtoWallet(PrivateKey.fromRandom())
+    const clientWallet = new CompletedProtoWallet(PrivateKey.fromRandom())
+    const serverWallet = new CompletedProtoWallet(PrivateKey.fromRandom())
 
     // Client creates a random nonce that the server can verify
-    const clientNonce = await createNonce(clientWallet, (await serverWallet.getPublicKey({ identityKey: true })).publicKey)
+    const clientNonce = await createNonce(
+      clientWallet,
+      (await serverWallet.getPublicKey({ identityKey: true })).publicKey
+    )
     // The server verifies the client created the nonce provided
-    await verifyNonce(clientNonce, serverWallet, (await clientWallet.getPublicKey({ identityKey: true })).publicKey)
+    await verifyNonce(
+      clientNonce,
+      serverWallet,
+      (await clientWallet.getPublicKey({ identityKey: true })).publicKey
+    )
     // Server creates a random nonce that the client can verify
-    const serverNonce = await createNonce(serverWallet, (await clientWallet.getPublicKey({ identityKey: true })).publicKey)
+    const serverNonce = await createNonce(
+      serverWallet,
+      (await clientWallet.getPublicKey({ identityKey: true })).publicKey
+    )
     // The server compute a serial number from the client and server nonce
     const { hmac: serialNumber } = await serverWallet.createHmac({
-      data: clientNonce + serverNonce,
+      data: Utils.toArray(clientNonce + serverNonce, 'utf8'),
       protocolID: [2, 'certificate creation'],
       keyID: serverNonce + clientNonce,
-      counterparty: (await clientWallet.getPublicKey({ identityKey: true })).publicKey
+      counterparty: (await clientWallet.getPublicKey({ identityKey: true }))
+        .publicKey
     })
 
     // Client verifies server's nonce
-    await verifyNonce(serverNonce, clientWallet, (await serverWallet.getPublicKey({ identityKey: true })).publicKey)
+    await verifyNonce(
+      serverNonce,
+      clientWallet,
+      (await serverWallet.getPublicKey({ identityKey: true })).publicKey
+    )
 
     // Client verifies the server included their nonce
     const { valid } = await clientWallet.verifyHmac({
       hmac: serialNumber,
-      data: clientNonce + serverNonce,
+      data: Utils.toArray(clientNonce + serverNonce, 'utf8'),
       protocolID: [2, 'certificate creation'],
       keyID: serverNonce + clientNonce,
-      counterparty: (await serverWallet.getPublicKey({ identityKey: true })).publicKey,
+      counterparty: (await serverWallet.getPublicKey({ identityKey: true }))
+        .publicKey
     })
 
     console.log(Utils.toBase64(serialNumber))