@bsv/sdk 1.3.12 → 1.3.14

package/src/auth/certificates/__tests/VerifiableCertificate.test.ts

@@ -1,9 +1,8 @@
-import { VerifiableCertificate } from '../../../../dist/cjs/src/auth/certificates/VerifiableCertificate.js'
-import { PrivateKey, SymmetricKey, Utils } from '../../../../dist/cjs/src/primitives/index.js'
-import { CompletedProtoWallet } from '../../../../dist/cjs/src/auth/certificates/__tests/CompletedProtoWallet.js'
-import { Certificate } from '../../../../dist/cjs/src/auth/certificates/index.js'
-import { MasterCertificate } from '../../../../dist/cjs/src/auth/certificates/MasterCertificate.js'
-import { ProtoWallet } from '../../../../dist/cjs/src/wallet/index.js'
+import { VerifiableCertificate } from '../../../auth/certificates/VerifiableCertificate'
+import { PrivateKey, Utils } from '../../../../mod'
+import { CompletedProtoWallet } from '../../../auth/certificates/__tests/CompletedProtoWallet'
+import { MasterCertificate } from '../../../auth/certificates/MasterCertificate'
+import { ProtoWallet } from '../../../wallet/index'
 
 describe('VerifiableCertificate', () => {
   const subjectPrivateKey = PrivateKey.fromRandom()
@@ -18,7 +17,8 @@ describe('VerifiableCertificate', () => {
 
   const sampleType = Utils.toBase64(new Array(32).fill(1))
   const sampleSerialNumber = Utils.toBase64(new Array(32).fill(2))
-  const sampleRevocationOutpoint = 'deadbeefdeadbeefdeadbeefdeadbeef00000000000000000000000000000000.1'
+  const sampleRevocationOutpoint =
+    'deadbeefdeadbeefdeadbeefdeadbeef00000000000000000000000000000000.1'
 
   const plaintextFields = {
     name: 'Alice',
@@ -30,11 +30,12 @@ describe('VerifiableCertificate', () => {
 
   beforeEach(async () => {
     // For each test, we'll build a fresh VerifiableCertificate with valid encryption
-    const { certificateFields, masterKeyring } = await MasterCertificate.createCertificateFields(
-      subjectWallet,
-      certifierIdentityKey,
-      plaintextFields
-    )
+    const { certificateFields, masterKeyring } =
+      await MasterCertificate.createCertificateFields(
+        subjectWallet,
+        certifierIdentityKey,
+        plaintextFields
+      )
     const keyringForVerifier = await MasterCertificate.createKeyringForVerifier(
       subjectWallet,
       certifierIdentityKey,
@@ -62,7 +63,9 @@ describe('VerifiableCertificate', () => {
       expect(verifiableCert.serialNumber).toEqual(sampleSerialNumber)
       expect(verifiableCert.subject).toEqual(subjectIdentityKey)
       expect(verifiableCert.certifier).toEqual(certifierIdentityKey)
-      expect(verifiableCert.revocationOutpoint).toEqual(sampleRevocationOutpoint)
+      expect(verifiableCert.revocationOutpoint).toEqual(
+        sampleRevocationOutpoint
+      )
       expect(verifiableCert.fields).toBeDefined()
       expect(verifiableCert.keyring).toBeDefined()
     })
@@ -97,7 +100,9 @@ describe('VerifiableCertificate', () => {
         verifiableCert.signature
       )
 
-      await expect(emptyKeyringCert.decryptFields(verifierWallet)).rejects.toThrow(
+      await expect(
+        emptyKeyringCert.decryptFields(verifierWallet)
+      ).rejects.toThrow(
         'A keyring is required to decrypt certificate fields for the verifier.'
       )
     })
@@ -105,26 +110,30 @@ describe('VerifiableCertificate', () => {
     it('should fail if the encrypted field or its key is tampered', async () => {
       // Tamper the keyring so it doesn't match the field encryption
       verifiableCert.keyring.name = Utils.toBase64([9, 9, 9, 9])
-      await expect(verifiableCert.decryptFields(verifierWallet)).rejects.toThrow(
+      await expect(
+        verifiableCert.decryptFields(verifierWallet)
+      ).rejects.toThrow(
         /Failed to decrypt selectively revealed certificate fields using keyring/
       )
     })
 
     it('should be able to decrypt fields using the anyone wallet', async () => {
-      const { certificateFields, masterKeyring } = await MasterCertificate.createCertificateFields(
-        subjectWallet,
-        certifierIdentityKey,
-        plaintextFields
-      )
-      const keyringForVerifier = await MasterCertificate.createKeyringForVerifier(
-        subjectWallet,
-        certifierIdentityKey,
-        'anyone',
-        certificateFields,
-        Object.keys(certificateFields),
-        masterKeyring,
-        sampleSerialNumber
-      )
+      const { certificateFields, masterKeyring } =
+        await MasterCertificate.createCertificateFields(
+          subjectWallet,
+          certifierIdentityKey,
+          plaintextFields
+        )
+      const keyringForVerifier =
+        await MasterCertificate.createKeyringForVerifier(
+          subjectWallet,
+          certifierIdentityKey,
+          'anyone',
+          certificateFields,
+          Object.keys(certificateFields),
+          masterKeyring,
+          sampleSerialNumber
+        )
       verifiableCert = new VerifiableCertificate(
         sampleType,
         sampleSerialNumber,
@@ -134,8 +143,10 @@ describe('VerifiableCertificate', () => {
         certificateFields,
         keyringForVerifier
       )
-      const decrypted = await verifiableCert.decryptFields(new ProtoWallet('anyone'))
+      const decrypted = await verifiableCert.decryptFields(
+        new ProtoWallet('anyone')
+      )
       expect(decrypted).toEqual(plaintextFields)
     })
   })
-})
+})

package/src/auth/certificates/index.ts

@@ -1,4 +1,4 @@
 export { default as Certificate } from './Certificate.js'
 export * from './MasterCertificate.js'
 export * from './VerifiableCertificate.js'
-export * from './__tests/CompletedProtoWallet.js'
+export * from './__tests/CompletedProtoWallet.js'

package/src/auth/clients/AuthFetch.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { Utils, Random, P2PKH, PublicKey, WalletInterface } from '../../../mod.js'
 import { Peer } from '../Peer.js'
 import { SimplifiedFetchTransport } from '../transports/SimplifiedFetchTransport.js'

package/src/auth/clients/index.ts

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

package/src/auth/transports/SimplifiedFetchTransport.ts

@@ -1,10 +1,18 @@
-import { AuthMessage, RequestedCertificateSet, Transport } from "../types.js"
+// @ts-nocheck
+import { AuthMessage, RequestedCertificateSet, Transport } from '../types.js'
 import { Utils } from '../../../mod.js'
 
+// Define the expected shape of error responses
+interface ErrorInfo {
+  status: string
+  description: string
+  code?: string
+}
+
 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.
@@ -30,27 +38,32 @@ 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.')
+    if (this.onDataCallback == null) {
+      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)
-      })
+      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) {
+      if (response.ok && typeof this.onDataCallback === 'function') { // ✅ Explicitly check if it's a function
         const responseMessage = await response.json()
         if (responseMessage?.status !== 'certificate received') {
           this.onDataCallback(responseMessage as AuthMessage)
@@ -61,49 +74,77 @@ export class SimplifiedFetchTransport implements Transport {
       }
     } 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
+      const httpRequestWithAuthHeaders: {
+        method: string // ✅ Add method property
+        headers: Record<string, string>
+        body?: string | Record<string, unknown> | Uint8Array
+      } = {
+        method: httpRequest.method, // ✅ Copy method from httpRequest
+        headers: httpRequest.headers,
+        body: Array.isArray(httpRequest.body)
+          ? JSON.stringify(httpRequest.body)
+          : httpRequest.body
+      }
+
       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 (httpRequestWithAuthHeaders.body !== null && httpRequestWithAuthHeaders.body !== undefined) {
+        const headers = httpRequestWithAuthHeaders.headers
+        if (headers['content-type'] === undefined || headers['content-type'] === null || headers['content-type'].trim() === '') {
+          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')) {
-          // Convert byte array to JSON string
-          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')) {
-          // Convert byte array to plain UTF-8 string
-          httpRequestWithAuthHeaders.body = Utils.toUTF8(httpRequestWithAuthHeaders.body);
-        } else {
-          // For all other content types, treat as binary data
-          httpRequestWithAuthHeaders.body = new Uint8Array(httpRequestWithAuthHeaders.body);
+        if (typeof httpRequestWithAuthHeaders.body !== 'undefined') {
+          if (contentType.includes('application/json') ||
+            contentType.includes('application/x-www-form-urlencoded') ||
+            contentType.includes('text/plain')) {
+            // Convert byte array or object to UTF-8 string
+            if (httpRequestWithAuthHeaders.body instanceof Uint8Array) {
+              httpRequestWithAuthHeaders.body = Utils.toUTF8(
+                Array.from(httpRequestWithAuthHeaders.body) // Convert Uint8Array to number[]
+              )
+            } else if (typeof httpRequestWithAuthHeaders.body === 'object') {
+              httpRequestWithAuthHeaders.body = JSON.stringify(httpRequestWithAuthHeaders.body)
+            }
+          } else {
+            // For all other content types, ensure it's Uint8Array
+            if (!(httpRequestWithAuthHeaders.body instanceof Uint8Array)) {
+              httpRequestWithAuthHeaders.body = new Uint8Array(
+                typeof httpRequestWithAuthHeaders.body === 'string'
+                  ? Utils.toArray(httpRequestWithAuthHeaders.body, 'utf8') // Convert string to byte array
+                  : []
+              )
+            }
+          }
         }
       }
 
-
       // Send the actual fetch request to the server
       const response = await this.fetchClient(url, {
         method: httpRequestWithAuthHeaders.method,
@@ -113,38 +154,50 @@ export class SimplifiedFetchTransport implements Transport {
 
       // Check for an acceptable status
       if (!SUCCESS_STATUS_CODES.includes(response.status)) {
-        // Try parsing JSON error
-        let errorInfo;
+        let errorInfo: ErrorInfo | null = null // Explicitly initialize
+
         try {
-          errorInfo = await response.json();
+          errorInfo = await response.json() as ErrorInfo // Cast response to expected type
         } 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.trim() !== '' ? text : 'Unknown error'}`
+          )
         }
 
         // If we find a known { status: 'error', code, description } structure
-        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);
+        if (
+          errorInfo !== null && // ✅ Explicitly check for null
+          errorInfo.status === 'error' &&
+          typeof errorInfo.description === 'string'
+        ) {
+          const msg = `HTTP ${response.status} - ${errorInfo.description}`
+          throw new Error(
+            typeof errorInfo.code === 'string' ? `${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.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: Array<[string, string]> = []
       // Collect headers into a raw array for sorting
-      const headersArray: [string, string][] = []
+      const headersArray: Array<[string, string]> = []
       response.headers.forEach((value, key) => {
         const lowerKey = key.toLowerCase()
         if (lowerKey.startsWith('x-bsv-') || lowerKey === 'authorization') {
@@ -174,7 +227,7 @@ export class SimplifiedFetchTransport implements Transport {
       }
 
       // Handle body
-      if (parsedBody) {
+      if (parsedBody !== null && parsedBody !== undefined) { // ✅ Explicitly check for null/undefined
         const bodyAsArray = Array.from(new Uint8Array(parsedBody))
         payloadWriter.writeVarIntNum(bodyAsArray.length)
         payloadWriter.write(bodyAsArray)
@@ -184,18 +237,27 @@ export class SimplifiedFetchTransport implements Transport {
 
       // 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') ?? '', // Ensure string
+        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') ?? undefined,
+        yourNonce: response.headers.get('x-bsv-auth-your-nonce') ?? undefined,
+        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) {
+      if (responseMessage.version === undefined || responseMessage.version === null || responseMessage.version.trim() === '') {
         throw new Error('HTTP server failed to authenticate')
       }
 
@@ -205,30 +267,41 @@ export class SimplifiedFetchTransport implements Transport {
   }
 
   /**
-   * 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> {
-    this.onDataCallback = (m) => {
-      callback(m)
+  async onData(
+    callback: (message: AuthMessage) => Promise<void>
+  ): Promise<void> {
+    this.onDataCallback = (m) => { // ✅ Removed `async` here
+      void (async () => { // ✅ Wraps the async function inside a void IIFE
+        try {
+          await callback(m) // ✅ Ensures proper `await`
+        } catch (error) {
+          console.error(
+            'Error handling AuthMessage:',
+            error instanceof Error ? error.message : String(error)
+          )
+        }
+      })()
     }
   }
 
   /**
    * 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[],
+    method: string
+    urlPostfix: string
+    headers: Record<string, string>
+    body: number[]
     requestId: string
   } {
     // Create a reader
@@ -288,4 +361,4 @@ export class SimplifiedFetchTransport implements Transport {
       requestId
     }
   }
-}
+}

package/src/auth/transports/index.ts

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

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
   })
 
@@ -49,9 +52,19 @@ describe('verifyNonce', () => {
     (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(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 () => {
@@ -75,7 +88,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 +97,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))