@bsv/sdk 1.3.12 → 1.3.14

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

@@ -1,25 +1,25 @@
-import { Wallet } from '../../../../dist/cjs/src/wallet/Wallet.interfaces.js'
-import { getVerifiableCertificates } from '../../../../dist/cjs/src/auth/utils/getVerifiableCertificates'
-import { RequestedCertificateSet } from '../../../../dist/cjs/src/auth/types.js'
-import { VerifiableCertificate } from '../../../../dist/cjs/src/auth/certificates/VerifiableCertificate.js'
+import { WalletInterface } from '../../../wallet/Wallet.interfaces'
+import { getVerifiableCertificates } from '../../../auth/utils/getVerifiableCertificates'
+import { RequestedCertificateSet } from '../../../auth/types'
+import { VerifiableCertificate } from '../../../auth/certificates/VerifiableCertificate'
 
 describe('getVerifiableCertificates', () => {
-  let mockWallet: Wallet
+  let mockWallet: WalletInterface
   let requestedCertificates: RequestedCertificateSet
   let verifierIdentityKey: string
 
   beforeEach(() => {
     mockWallet = {
       listCertificates: jest.fn(),
-      proveCertificate: jest.fn(),
-    } as unknown as Wallet
+      proveCertificate: jest.fn()
+    } as unknown as WalletInterface
 
     requestedCertificates = {
       certifiers: ['certifier1', 'certifier2'],
       types: {
         certType1: ['field1', 'field2'],
-        certType2: ['field3'],
-      },
+        certType2: ['field3']
+      }
     }
 
     verifierIdentityKey = 'verifier_public_key'
@@ -33,7 +33,7 @@ describe('getVerifiableCertificates', () => {
       certifier: 'certifier1',
       revocationOutpoint: 'outpoint1',
       fields: { field1: 'encryptedData1', field2: 'encryptedData2' },
-      signature: 'signature1',
+      signature: 'signature1'
     };
 
     (mockWallet.listCertificates as jest.Mock).mockResolvedValue({
@@ -43,17 +43,21 @@ describe('getVerifiableCertificates', () => {
       keyringForVerifier: { field1: 'key1', field2: 'key2' }
     })
 
-    const result = await getVerifiableCertificates(mockWallet, requestedCertificates, verifierIdentityKey)
+    const result = await getVerifiableCertificates(
+      mockWallet,
+      requestedCertificates,
+      verifierIdentityKey
+    )
 
     expect(mockWallet.listCertificates).toHaveBeenCalledWith({
       certifiers: requestedCertificates.certifiers,
-      types: Object.keys(requestedCertificates.types),
+      types: Object.keys(requestedCertificates.types)
     })
 
     expect(mockWallet.proveCertificate).toHaveBeenCalledWith({
       certificate: mockCertificate,
       fieldsToReveal: requestedCertificates.types[mockCertificate.type],
-      verifier: verifierIdentityKey,
+      verifier: verifierIdentityKey
     })
 
     expect(result).toHaveLength(1)
@@ -70,11 +74,16 @@ describe('getVerifiableCertificates', () => {
     })
   })
 
-
   it('returns an empty array when no matching certificates are found', async () => {
-    (mockWallet.listCertificates as jest.Mock).mockResolvedValue({ certificates: [] })
+    (mockWallet.listCertificates as jest.Mock).mockResolvedValue({
+      certificates: []
+    })
 
-    const result = await getVerifiableCertificates(mockWallet, requestedCertificates, verifierIdentityKey)
+    const result = await getVerifiableCertificates(
+      mockWallet,
+      requestedCertificates,
+      verifierIdentityKey
+    )
 
     expect(result).toEqual([])
     expect(mockWallet.listCertificates).toHaveBeenCalled()
@@ -82,11 +91,17 @@ describe('getVerifiableCertificates', () => {
   })
 
   it('propagates errors from listCertificates', async () => {
-    (mockWallet.listCertificates as jest.Mock).mockRejectedValue(new Error('listCertificates failed'))
-
-    await expect(getVerifiableCertificates(mockWallet, requestedCertificates, verifierIdentityKey)).rejects.toThrow(
-      'listCertificates failed'
+    (mockWallet.listCertificates as jest.Mock).mockRejectedValue(
+      new Error('listCertificates failed')
     )
+
+    await expect(
+      getVerifiableCertificates(
+        mockWallet,
+        requestedCertificates,
+        verifierIdentityKey
+      )
+    ).rejects.toThrow('listCertificates failed')
   })
 
   it('propagates errors from proveCertificate', async () => {
@@ -97,30 +112,41 @@ describe('getVerifiableCertificates', () => {
       certifier: 'certifier1',
       revocationOutpoint: 'outpoint1',
       fields: { field1: 'encryptedData1', field2: 'encryptedData2' },
-      signature: 'signature1',
+      signature: 'signature1'
     };
 
     (mockWallet.listCertificates as jest.Mock).mockResolvedValue({
-      certificates: [mockCertificate],
+      certificates: [mockCertificate]
     });
-    (mockWallet.proveCertificate as jest.Mock).mockRejectedValue(new Error('proveCertificate failed'))
-
-    await expect(getVerifiableCertificates(mockWallet, requestedCertificates, verifierIdentityKey)).rejects.toThrow(
-      'proveCertificate failed'
+    (mockWallet.proveCertificate as jest.Mock).mockRejectedValue(
+      new Error('proveCertificate failed')
     )
+
+    await expect(
+      getVerifiableCertificates(
+        mockWallet,
+        requestedCertificates,
+        verifierIdentityKey
+      )
+    ).rejects.toThrow('proveCertificate failed')
   })
 
   it('handles empty requested certificates gracefully', async () => {
     requestedCertificates = { certifiers: [], types: {} };
+    (mockWallet.listCertificates as jest.Mock).mockResolvedValue({
+      certificates: []
+    })
 
-    (mockWallet.listCertificates as jest.Mock).mockResolvedValue({ certificates: [] })
-
-    const result = await getVerifiableCertificates(mockWallet, requestedCertificates, verifierIdentityKey)
+    const result = await getVerifiableCertificates(
+      mockWallet,
+      requestedCertificates,
+      verifierIdentityKey
+    )
 
     expect(result).toEqual([])
     expect(mockWallet.listCertificates).toHaveBeenCalledWith({
       certifiers: [],
-      types: [],
+      types: []
     })
   })
 })

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

@@ -1,13 +1,25 @@
-import { validateCertificates } from '../../../../dist/cjs/src/auth/utils/validateCertificates.js'
-import { VerifiableCertificate } from '../../../../dist/cjs/src/auth/certificates/VerifiableCertificate.js'
-import { ProtoWallet } from '../../../../dist/cjs/src/wallet/index.js'
-import { PrivateKey } from '../../../../dist/cjs/src/primitives/index.js'
-
-let mockVerify = jest.fn(() => Promise.resolve(true))
-let mockDecryptFields = jest.fn(() => Promise.resolve({ field1: 'decryptedValue1' }))
-const mockInstances = []
-
-jest.mock('../../../../dist/cjs/src/auth/certificates/VerifiableCertificate.js', () => {
+import { validateCertificates } from '../../../auth/utils/validateCertificates'
+import { VerifiableCertificate } from '../../../auth/certificates/VerifiableCertificate'
+import { ProtoWallet } from '../../../wallet/index'
+import { PrivateKey } from '../../../primitives/index'
+
+let mockVerify = jest.fn(async () => await Promise.resolve(true))
+let mockDecryptFields = jest.fn(
+  async () => await Promise.resolve({ field1: 'decryptedValue1' })
+)
+const mockInstances: Array<{
+  type: string
+  serialNumber: string
+  subject: string
+  certifier: string
+  revocationOutpoint: string
+  fields: Record<string, string>
+  decryptedFields: Record<string, unknown>
+  verify: jest.Mock<Promise<boolean>>
+  decryptFields: jest.Mock<Promise<Record<string, string>>> // ✅ Explicit return type
+}> = []
+
+jest.mock('../../../auth/certificates/VerifiableCertificate', () => {
   return {
     VerifiableCertificate: jest.fn().mockImplementation(() => {
       const instance = {
@@ -19,11 +31,11 @@ jest.mock('../../../../dist/cjs/src/auth/certificates/VerifiableCertificate.js',
         fields: { field1: 'encryptedData1' },
         decryptedFields: {},
         verify: mockVerify,
-        decryptFields: mockDecryptFields,
+        decryptFields: mockDecryptFields
       }
       mockInstances.push(instance)
       return instance
-    }),
+    })
   }
 })
 
@@ -36,8 +48,10 @@ describe('validateCertificates', () => {
     mockInstances.length = 0 // Clear tracked instances
 
     // Reset state
-    mockVerify = jest.fn(() => Promise.resolve(true))
-    mockDecryptFields = jest.fn(() => Promise.resolve({ field1: 'decryptedValue1' }))
+    mockVerify = jest.fn(async () => await Promise.resolve(true))
+    mockDecryptFields = jest.fn(
+      async () => await Promise.resolve({ field1: 'decryptedValue1' })
+    )
 
     verifierWallet = new ProtoWallet(new PrivateKey(1))
     message = {
@@ -50,16 +64,20 @@ describe('validateCertificates', () => {
           certifier: 'valid_certifier',
           revocationOutpoint: 'outpoint',
           fields: { field1: 'encryptedData1' },
-          decryptedFields: {},
-        },
-      ],
+          decryptedFields: {}
+        }
+      ]
     }
   })
 
   it('completes without errors for valid input', async () => {
-    await expect(validateCertificates(verifierWallet, message)).resolves.not.toThrow()
+    await expect(
+      validateCertificates(verifierWallet, message)
+    ).resolves.not.toThrow()
 
-    expect(VerifiableCertificate).toHaveBeenCalledTimes(message.certificates.length)
+    expect(VerifiableCertificate).toHaveBeenCalledTimes(
+      message.certificates.length
+    )
     expect(mockVerify).toHaveBeenCalledTimes(message.certificates.length)
     expect(mockDecryptFields).toHaveBeenCalledWith(verifierWallet)
   })
@@ -68,7 +86,7 @@ describe('validateCertificates', () => {
     message.identityKey = 'different_subject'
 
     await expect(validateCertificates(verifierWallet, message)).rejects.toThrow(
-      `The subject of one of your certificates ("valid_subject") is not the same as the request sender ("different_subject").`
+      'The subject of one of your certificates ("valid_subject") is not the same as the request sender ("different_subject").'
     )
   })
 
@@ -76,38 +94,38 @@ describe('validateCertificates', () => {
     mockVerify.mockResolvedValueOnce(false)
 
     await expect(validateCertificates(verifierWallet, message)).rejects.toThrow(
-      `The signature for the certificate with serial number valid_serial is invalid!`
+      'The signature for the certificate with serial number valid_serial is invalid!'
     )
   })
 
   it('throws an error for unrequested certifier', async () => {
     const certificatesRequested = {
       certifiers: ['another_certifier'],
-      types: { requested_type: ['field1'] },
+      types: { requested_type: ['field1'] }
     }
 
     await expect(
       validateCertificates(verifierWallet, message, certificatesRequested)
     ).rejects.toThrow(
-      `Certificate with serial number valid_serial has an unrequested certifier: valid_certifier`
+      'Certificate with serial number valid_serial has an unrequested certifier: valid_certifier'
     )
   })
 
   it('throws an error for unrequested certificate type', async () => {
     const certificatesRequested = {
       certifiers: ['valid_certifier'],
-      types: { another_type: ['field1'] },
+      types: { another_type: ['field1'] }
     }
 
     await expect(
       validateCertificates(verifierWallet, message, certificatesRequested)
-    ).rejects.toThrow(
-      `Certificate with type requested_type was not requested`
-    )
+    ).rejects.toThrow('Certificate with type requested_type was not requested')
   })
 
   it('decrypts fields without throwing errors', async () => {
-    await expect(validateCertificates(verifierWallet, message)).resolves.not.toThrow()
+    await expect(
+      validateCertificates(verifierWallet, message)
+    ).resolves.not.toThrow()
     for (const instance of mockInstances) {
       expect(instance.decryptFields).toHaveBeenCalledWith(verifierWallet)
     }
@@ -115,7 +133,9 @@ describe('validateCertificates', () => {
 
   it('throws an error if a field decryption fails', async () => {
     mockDecryptFields.mockRejectedValue(new Error('Decryption failed'))
-    await expect(validateCertificates(verifierWallet, message)).rejects.toThrow('Decryption failed')
+    await expect(validateCertificates(verifierWallet, message)).rejects.toThrow(
+      'Decryption failed'
+    )
   })
 
   it('handles multiple certificates properly', async () => {
@@ -126,12 +146,14 @@ describe('validateCertificates', () => {
       certifier: 'valid_certifier',
       revocationOutpoint: 'outpoint',
       fields: { field1: 'encryptedData1' },
-      decryptedFields: {},
+      decryptedFields: {}
     }
 
     message.certificates.push(anotherCertificate)
 
-    await expect(validateCertificates(verifierWallet, message)).resolves.not.toThrow()
+    await expect(
+      validateCertificates(verifierWallet, message)
+    ).resolves.not.toThrow()
 
     expect(VerifiableCertificate).toHaveBeenCalledTimes(2)
     expect(mockVerify).toHaveBeenCalledTimes(2)

package/src/auth/utils/createNonce.ts

@@ -1,4 +1,9 @@
-import { Utils, Random, WalletInterface, WalletCounterparty } from '../../../mod.js'
+import {
+  Utils,
+  Random,
+  WalletInterface,
+  WalletCounterparty
+} from '../../../mod.js'
 
 /**
  * Creates a nonce derived from a wallet
@@ -6,7 +11,10 @@ import { Utils, Random, WalletInterface, WalletCounterparty } from '../../../mod
  * @param counterparty - The counterparty to the nonce creation. Defaults to 'self'.
  * @returns A random nonce derived with a wallet
  */
-export async function createNonce(wallet: WalletInterface, counterparty: WalletCounterparty = 'self'): Promise<string> {
+export async function createNonce(
+  wallet: WalletInterface,
+  counterparty: WalletCounterparty = 'self'
+): Promise<string> {
   // Generate 16 random bytes for the first half of the data
   const firstHalf = Random(16)
   // Create an sha256 HMAC
@@ -19,4 +27,4 @@ export async function createNonce(wallet: WalletInterface, counterparty: WalletC
   // Concatenate firstHalf and secondHalf as the nonce bytes
   const nonceBytes = [...firstHalf, ...hmac]
   return Utils.toBase64(nonceBytes)
-}
+}

package/src/auth/utils/getVerifiableCertificates.ts

@@ -1,6 +1,6 @@
-import { VerifiableCertificate } from "../certificates/VerifiableCertificate.js"
-import { WalletInterface } from "../../../mod.js"
-import { RequestedCertificateSet } from "../types.js"
+import { VerifiableCertificate } from '../certificates/VerifiableCertificate.js'
+import { WalletInterface } from '../../../mod.js'
+import { RequestedCertificateSet } from '../types.js'
 
 /**
  * Retrieves an array of verifiable certificates based on the request.
@@ -10,7 +10,11 @@ import { RequestedCertificateSet } from "../types.js"
  * @param {string} verifierIdentityKey - The public key of the verifier requesting the certificates.
  * @returns {Promise<VerifiableCertificate[]>} An array of verifiable certificates.
  */
-export const getVerifiableCertificates = async (wallet: WalletInterface, requestedCertificates: RequestedCertificateSet, verifierIdentityKey: string): Promise<VerifiableCertificate[]> => {
+export const getVerifiableCertificates = async (
+  wallet: WalletInterface,
+  requestedCertificates: RequestedCertificateSet,
+  verifierIdentityKey: string
+): Promise<VerifiableCertificate[]> => {
   // Find matching certificates we have
   // Note: This may return multiple certificates that match the correct type.
   const matchingCertificates = await wallet.listCertificates({
@@ -20,7 +24,7 @@ export const getVerifiableCertificates = async (wallet: WalletInterface, request
 
   // For each certificate requested, create a verifiable cert with selectively revealed fields
   return await Promise.all(
-    matchingCertificates.certificates.map(async certificate => {
+    matchingCertificates.certificates.map(async (certificate) => {
       const { keyringForVerifier } = await wallet.proveCertificate({
         certificate,
         fieldsToReveal: requestedCertificates.types[certificate.type],
@@ -36,5 +40,6 @@ export const getVerifiableCertificates = async (wallet: WalletInterface, request
         keyringForVerifier,
         certificate.signature
       )
-    }))
-}
+    })
+  )
+}

package/src/auth/utils/validateCertificates.ts

@@ -1,6 +1,6 @@
-import { WalletInterface } from "../../wallet/index.js"
-import { AuthMessage, RequestedCertificateSet } from "../types.js"
-import { VerifiableCertificate } from "../certificates/VerifiableCertificate.js"
+import { WalletInterface } from '../../wallet/index.js'
+import { AuthMessage, RequestedCertificateSet } from '../types.js'
+import { VerifiableCertificate } from '../certificates/VerifiableCertificate.js'
 
 /**
  * Validates and processes the certificates received from a peer.
@@ -10,45 +10,63 @@ import { VerifiableCertificate } from "../certificates/VerifiableCertificate.js"
  * @returns {Promise<void>}
  * @throws Will throw an error if certificate validation or field decryption fails.
  */
-export const validateCertificates = async (verifierWallet: WalletInterface, message: AuthMessage, certificatesRequested?: RequestedCertificateSet): Promise<void> => {
-  await Promise.all(message.certificates.map(async (incomingCert: VerifiableCertificate) => {
-    if (incomingCert.subject !== message.identityKey) {
-      throw new Error(`The subject of one of your certificates ("${incomingCert.subject}") is not the same as the request sender ("${message.identityKey}").`)
-    }
+export const validateCertificates = async (
+  verifierWallet: WalletInterface,
+  message: AuthMessage,
+  certificatesRequested?: RequestedCertificateSet
+): Promise<void> => {
+  if ((message.certificates == null) || message.certificates.length === 0) {
+    throw new Error('No certificates were provided in the AuthMessage.')
+  }
 
-    // Verify Certificate structure and signature
-    const certToVerify = new VerifiableCertificate(
-      incomingCert.type,
-      incomingCert.serialNumber,
-      incomingCert.subject,
-      incomingCert.certifier,
-      incomingCert.revocationOutpoint,
-      incomingCert.fields,
-      incomingCert.keyring,
-      incomingCert.signature
-    )
-    const isValidCert = await certToVerify.verify()
-    if (!isValidCert) {
-      throw new Error(`The signature for the certificate with serial number ${certToVerify.serialNumber} is invalid!`)
-    }
-
-    // Check if the certificate matches requested certifiers, types, and fields
-    if (certificatesRequested) {
-      const { certifiers, types } = certificatesRequested
+  await Promise.all(
+    message.certificates.map(async (incomingCert: VerifiableCertificate) => {
+      if (incomingCert.subject !== message.identityKey) {
+        throw new Error(
+          `The subject of one of your certificates ("${incomingCert.subject}") is not the same as the request sender ("${message.identityKey}").`
+        )
+      }
 
-      // Check certifier matches
-      if (!certifiers.includes(certToVerify.certifier)) {
-        throw new Error(`Certificate with serial number ${certToVerify.serialNumber} has an unrequested certifier: ${certToVerify.certifier}`)
+      // Verify Certificate structure and signature
+      const certToVerify = new VerifiableCertificate(
+        incomingCert.type,
+        incomingCert.serialNumber,
+        incomingCert.subject,
+        incomingCert.certifier,
+        incomingCert.revocationOutpoint,
+        incomingCert.fields,
+        incomingCert.keyring,
+        incomingCert.signature
+      )
+      const isValidCert = await certToVerify.verify()
+      if (!isValidCert) {
+        throw new Error(
+          `The signature for the certificate with serial number ${certToVerify.serialNumber} is invalid!`
+        )
       }
 
-      // Check type and fields match requested
-      const requestedFields = types[certToVerify.type]
-      if (!requestedFields) {
-        throw new Error(`Certificate with type ${certToVerify.type} was not requested`)
+      // Check if the certificate matches requested certifiers, types, and fields
+      if (certificatesRequested != null) {
+        const { certifiers, types } = certificatesRequested
+
+        // Check certifier matches
+        if (!certifiers.includes(certToVerify.certifier)) {
+          throw new Error(
+            `Certificate with serial number ${certToVerify.serialNumber} has an unrequested certifier: ${certToVerify.certifier}`
+          )
+        }
+
+        // Check type and fields match requested
+        const requestedFields = types[certToVerify.type]
+        if (requestedFields == null) { // ✅ Explicitly check for null or undefined
+          throw new Error(
+            `Certificate with type ${certToVerify.type} was not requested`
+          )
+        }
       }
-    }
 
-    // Attempt to decrypt fields
-    await certToVerify.decryptFields(verifierWallet)
-  }))
-}
+      // Attempt to decrypt fields
+      await certToVerify.decryptFields(verifierWallet)
+    })
+  )
+}

package/src/auth/utils/verifyNonce.ts

@@ -1,4 +1,4 @@
-import { Utils, WalletCounterparty, WalletInterface } from '../../../mod.js'
+import { Utils, WalletInterface, WalletCounterparty } from '../../../mod.js'
 
 /**
  * Verifies a nonce derived from a wallet
@@ -7,7 +7,11 @@ import { Utils, WalletCounterparty, WalletInterface } from '../../../mod.js'
  * @param counterparty - The counterparty to the nonce creation. Defaults to 'self'.
  * @returns The status of the validation
  */
-export async function verifyNonce(nonce: string, wallet: WalletInterface, counterparty: WalletCounterparty = 'self'): Promise<boolean> {
+export async function verifyNonce(
+  nonce: string,
+  wallet: WalletInterface,
+  counterparty: WalletCounterparty = 'self'
+): Promise<boolean> {
   // Convert nonce from base64 string to Uint8Array
   const buffer = Utils.toArray(nonce, 'base64')
 

package/src/compat/BSM.ts

@@ -33,7 +33,11 @@ export const magicHash = (messageBuf: number[]): number[] => {
  * @param mode The mode of operation. When "base64", the BSM format signature is returned. When "raw", a Signature object is returned. Default: "base64".
  * @returns The signature object when in raw mode, or the BSM base64 string when in base64 mode.
  */
-export const sign = (message: number[], privateKey: PrivateKey, mode: 'raw' | 'base64' = 'base64'): Signature | string => {
+export const sign = (
+  message: number[],
+  privateKey: PrivateKey,
+  mode: 'raw' | 'base64' = 'base64'
+): Signature | string => {
   const hashBuf = magicHash(message)
   const sig = ECDSA.sign(new BigNumber(hashBuf), privateKey, true)
   if (mode === 'raw') {
@@ -52,7 +56,11 @@ export const sign = (message: number[], privateKey: PrivateKey, mode: 'raw' | 'b
  * @param pubKey The public key for verification.
  * @returns True if the signature is valid, false otherwise.
  */
-export const verify = (message: number[], sig: Signature, pubKey: PublicKey): boolean => {
+export const verify = (
+  message: number[],
+  sig: Signature,
+  pubKey: PublicKey
+): boolean => {
   const hashBuf = magicHash(message)
   return ECDSA.verify(new BigNumber(hashBuf), sig, pubKey)
 }