@bsv/sdk 1.3.12 → 1.3.14

package/src/auth/__tests/SessionManager.test.ts

@@ -10,7 +10,7 @@ describe('SessionManager', () => {
     validSession = {
       isAuthenticated: false,
       sessionNonce: 'testSessionNonce',
-      peerIdentityKey: 'testPeerIdentityKey',
+      peerIdentityKey: 'testPeerIdentityKey'
     }
   })
 
@@ -18,20 +18,37 @@ describe('SessionManager', () => {
     it('should add a session when sessionNonce and peerIdentityKey are present', () => {
       sessionManager.addSession(validSession)
 
-      expect(sessionManager.getSession(validSession.sessionNonce!)).toBe(validSession)
-      expect(sessionManager.getSession(validSession.peerIdentityKey!)).toBe(validSession)
+      if (typeof validSession.sessionNonce === 'string') {
+        expect(sessionManager.getSession(validSession.sessionNonce)).toBe(
+          validSession
+        )
+      }
+
+      if (typeof validSession.peerIdentityKey === 'string') {
+        expect(sessionManager.getSession(validSession.peerIdentityKey)).toBe(
+          validSession
+        )
+      }
     })
 
     it('should throw an error if sessionNonce and peerIdentityKey are missing', () => {
-      const invalidSession = { ...validSession, sessionNonce: undefined, peerIdentityKey: undefined }
-
-      expect(() => sessionManager.addSession(invalidSession)).toThrow('Invalid session: at least one of sessionNonce or peerIdentityKey is required.')
+      const invalidSession = {
+        ...validSession,
+        sessionNonce: undefined,
+        peerIdentityKey: undefined
+      }
+
+      expect(() => sessionManager.addSession(invalidSession)).toThrow(
+        'Invalid session: at least one of sessionNonce or peerIdentityKey is required.'
+      )
     })
 
     it('should not throw an error if just peerIdentityKey is missing', () => {
       const invalidSession = { ...validSession, peerIdentityKey: undefined }
 
-      expect(() => sessionManager.addSession(invalidSession)).not.toThrow('Invalid session: peerIdentityKey is required.')
+      expect(() => sessionManager.addSession(invalidSession)).not.toThrow(
+        'Invalid session: peerIdentityKey is required.'
+      )
     })
   })
 
@@ -39,19 +56,29 @@ describe('SessionManager', () => {
     it('should retrieve a session by sessionNonce', () => {
       sessionManager.addSession(validSession)
 
-      const retrievedSession = sessionManager.getSession(validSession.sessionNonce!)
-      expect(retrievedSession).toBe(validSession)
+      if (typeof validSession.sessionNonce === 'string') {
+        const retrievedSession = sessionManager.getSession(
+          validSession.sessionNonce
+        )
+        expect(retrievedSession).toBe(validSession)
+      }
     })
 
     it('should retrieve a session by peerIdentityKey', () => {
       sessionManager.addSession(validSession)
 
-      const retrievedSession = sessionManager.getSession(validSession.peerIdentityKey!)
-      expect(retrievedSession).toBe(validSession)
+      if (typeof validSession.peerIdentityKey === 'string') {
+        const retrievedSession = sessionManager.getSession(
+          validSession.peerIdentityKey
+        )
+        expect(retrievedSession).toBe(validSession)
+      }
     })
 
     it('should return undefined for a non-existent identifier', () => {
-      const retrievedSession = sessionManager.getSession('nonExistentIdentifier')
+      const retrievedSession = sessionManager.getSession(
+        'nonExistentIdentifier'
+      )
       expect(retrievedSession).toBeUndefined()
     })
   })
@@ -61,14 +88,29 @@ describe('SessionManager', () => {
       sessionManager.addSession(validSession)
 
       sessionManager.removeSession(validSession)
-      expect(sessionManager.getSession(validSession.sessionNonce!)).toBeUndefined()
-      expect(sessionManager.getSession(validSession.peerIdentityKey!)).toBeUndefined()
+
+      if (typeof validSession.sessionNonce === 'string') {
+        expect(
+          sessionManager.getSession(validSession.sessionNonce)
+        ).toBeUndefined()
+      }
+      if (typeof validSession.peerIdentityKey === 'string') {
+        expect(
+          sessionManager.getSession(validSession.peerIdentityKey)
+        ).toBeUndefined()
+      }
     })
 
     it('should not throw an error when removing a session with undefined identifiers', () => {
-      const sessionWithUndefinedIdentifiers = { ...validSession, sessionNonce: undefined, peerIdentityKey: undefined }
-
-      expect(() => sessionManager.removeSession(sessionWithUndefinedIdentifiers)).not.toThrow()
+      const sessionWithUndefinedIdentifiers = {
+        ...validSession,
+        sessionNonce: undefined,
+        peerIdentityKey: undefined
+      }
+
+      expect(() =>
+        sessionManager.removeSession(sessionWithUndefinedIdentifiers)
+      ).not.toThrow()
     })
   })
 
@@ -76,8 +118,14 @@ describe('SessionManager', () => {
     it('should return true if a session exists for the identifier', () => {
       sessionManager.addSession(validSession)
 
-      expect(sessionManager.hasSession(validSession.sessionNonce!)).toBe(true)
-      expect(sessionManager.hasSession(validSession.peerIdentityKey!)).toBe(true)
+      if (typeof validSession.sessionNonce === 'string') {
+        expect(sessionManager.hasSession(validSession.sessionNonce)).toBe(true)
+      }
+      if (typeof validSession.peerIdentityKey === 'string') {
+        expect(sessionManager.hasSession(validSession.peerIdentityKey)).toBe(
+          true
+        )
+      }
     })
 
     it('should return false if no session exists for the identifier', () => {

package/src/auth/__tests/build.test.ts

@@ -0,0 +1,11 @@
+import { PrivateKey, PublicKey } from '../../../mod'
+
+describe('Peer class mutual authentication and certificate exchange', () => {
+  for (let i = 0; i < 20; i++) {
+    it(`tests point ${i + 1}`, () => {
+      const pubKeyString = PrivateKey.fromRandom().toPublicKey().toString()
+      const test = PublicKey.fromString(pubKeyString)
+      expect(test).toBeTruthy()
+    })
+  }
+})

package/src/auth/certificates/Certificate.ts

@@ -48,7 +48,7 @@ export default class Certificate {
 
   /**
    * Certificate signature by the certifier's private key, DER encoded hex string.
-  */
+   */
   signature?: HexString
 
   /**
@@ -130,8 +130,8 @@ export default class Certificate {
     }
 
     // Write signature if included
-    if (includeSignature && this.signature && this.signature.length > 0) {
-      const signatureBytes = Utils.toArray(this.signature, 'hex')
+    if (includeSignature && (this.signature ?? '').length > 0) { // ✅ Explicitly handle nullish signature
+      const signatureBytes = Utils.toArray(this.signature as string, 'hex') // ✅ Type assertion ensures it's a string
       writer.write(signatureBytes)
     }
 
@@ -215,29 +215,36 @@ export default class Certificate {
     const verifier = new ProtoWallet('anyone')
     const verificationData = this.toBinary(false) // Exclude the signature from the verification data
 
+    const signatureHex = this.signature ?? '' // Provide a fallback value (empty string)
+
     const { valid } = await verifier.verifySignature({
-      signature: Utils.toArray(this.signature, 'hex'),
+      signature: Utils.toArray(signatureHex, 'hex'), // Now it is always a string
       data: verificationData,
       protocolID: [2, 'certificate signature'],
       keyID: `${this.type} ${this.serialNumber}`,
       counterparty: this.certifier // The certifier is the one who signed the certificate
     })
+
     return valid
   }
 
   /**
-   * Signs the certificate using the provided certifier wallet.
-   *
-   * @param {Wallet} certifierWallet - The wallet representing the certifier.
-   * @returns {Promise<void>}
-   */
+ * Signs the certificate using the provided certifier wallet.
+ *
+ * @param {Wallet} certifierWallet - The wallet representing the certifier.
+ * @returns {Promise<void>}
+ */
   async sign(certifierWallet: ProtoWallet): Promise<void> {
-    if (this.signature) {
-      throw new Error(`Certificate has already been signed! Signature present: ${this.signature}`)
+    if (this.signature != null && this.signature.length > 0) { // ✅ Explicitly checking for null/undefined
+      throw new Error(
+        `Certificate has already been signed! Signature present: ${this.signature}`
+      )
     }
 
     // Ensure the certifier declared is the one actually signing
-    this.certifier = (await certifierWallet.getPublicKey({ identityKey: true })).publicKey
+    this.certifier = (
+      await certifierWallet.getPublicKey({ identityKey: true })
+    ).publicKey
 
     const preimage = this.toBinary(false) // Exclude the signature when signing
     const { signature } = await certifierWallet.createSignature({
@@ -257,7 +264,13 @@ export default class Certificate {
    *   - `protocolID` (WalletProtocol): The protocol ID for certificate field encryption.
    *   - `keyID` (string): A unique key identifier derived from the serial number and field name.
    */
-  static getCertificateFieldEncryptionDetails(fieldName: string, serialNumber?: string): { protocolID: WalletProtocol, keyID: string } {
-    return { protocolID: [2, 'certificate field encryption'], keyID: `${serialNumber} ${fieldName}` }
+  static getCertificateFieldEncryptionDetails(
+    fieldName: string,
+    serialNumber?: string
+  ): { protocolID: WalletProtocol, keyID: string } {
+    return {
+      protocolID: [2, 'certificate field encryption'],
+      keyID: `${serialNumber ?? 'unknown'} ${fieldName}`
+    }
   }
 }

package/src/auth/certificates/MasterCertificate.ts

@@ -8,8 +8,7 @@ import {
   PubKeyHex,
   Random,
   WalletCounterparty,
-  ProtoWallet,
-  OriginatorDomainNameStringUnder250Bytes
+  ProtoWallet
 } from '../../../mod.js'
 import Certificate from './Certificate.js'
 
@@ -47,13 +46,21 @@ export class MasterCertificate extends Certificate {
     masterKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>,
     signature?: HexString
   ) {
-    super(type, serialNumber, subject, certifier, revocationOutpoint, fields, signature)
+    super(
+      type,
+      serialNumber,
+      subject,
+      certifier,
+      revocationOutpoint,
+      fields,
+      signature
+    )
 
     // Ensure every field in `fields` is a string and has a corresponding key in `masterKeyring`
     for (const fieldName of Object.keys(fields)) {
-      if (!masterKeyring[fieldName]) {
+      if (masterKeyring[fieldName] === undefined || masterKeyring[fieldName] === '') {
         throw new Error(
-          `Master keyring must contain a value for every field. Missing key for field: "${fieldName}".`
+          `Master keyring must contain a value for every field. Missing or empty key for field: "${fieldName}".`
         )
       }
     }
@@ -78,21 +85,33 @@ export class MasterCertificate extends Certificate {
   static async createCertificateFields(
     creatorWallet: ProtoWallet,
     certifierOrSubject: WalletCounterparty,
-    fields: Record<CertificateFieldNameUnder50Bytes, string>,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    fields: Record<CertificateFieldNameUnder50Bytes, string>
   ): Promise<CreateCertificateFieldsResult> {
-    const certificateFields: Record<CertificateFieldNameUnder50Bytes, Base64String> = {}
-    const masterKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String> = {}
+    const certificateFields: Record<
+      CertificateFieldNameUnder50Bytes,
+      Base64String
+    > = {}
+    const masterKeyring: Record<
+      CertificateFieldNameUnder50Bytes,
+      Base64String
+    > = {}
     for (const [fieldName, fieldValue] of Object.entries(fields)) {
       const fieldSymmetricKey = SymmetricKey.fromRandom()
-      const encryptedFieldValue = fieldSymmetricKey.encrypt(Utils.toArray(fieldValue, 'utf8'))
-      certificateFields[fieldName] = Utils.toBase64(encryptedFieldValue as number[])
+      const encryptedFieldValue = fieldSymmetricKey.encrypt(
+        Utils.toArray(fieldValue, 'utf8')
+      )
+      certificateFields[fieldName] = Utils.toBase64(
+        encryptedFieldValue as number[]
+      )
 
-      const { ciphertext: encryptedFieldRevelationKey } = await creatorWallet.encrypt({
-        plaintext: fieldSymmetricKey.toArray(),
-        ...Certificate.getCertificateFieldEncryptionDetails(fieldName), // Only fieldName used on MasterCertificate
-        counterparty: certifierOrSubject
-      }, originator)
+      const { ciphertext: encryptedFieldRevelationKey } =
+        await creatorWallet.encrypt(
+          {
+            plaintext: fieldSymmetricKey.toArray(),
+            ...Certificate.getCertificateFieldEncryptionDetails(fieldName), // Only fieldName used on MasterCertificate
+            counterparty: certifierOrSubject
+          }
+        )
       masterKeyring[fieldName] = Utils.toBase64(encryptedFieldRevelationKey)
     }
 
@@ -125,30 +144,48 @@ export class MasterCertificate extends Certificate {
     fields: Record<CertificateFieldNameUnder50Bytes, Base64String>,
     fieldsToReveal: string[],
     masterKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>,
-    serialNumber: Base64String,
-    originator?: OriginatorDomainNameStringUnder250Bytes): Promise<Record<CertificateFieldNameUnder50Bytes, string>> {
+    serialNumber: Base64String
+  ): Promise<Record<CertificateFieldNameUnder50Bytes, string>> {
     if (!Array.isArray(fieldsToReveal)) {
       throw new Error('fieldsToReveal must be an array of strings')
     }
     const fieldRevelationKeyring = {}
     for (const fieldName of fieldsToReveal) {
       // Make sure that fields to reveal is a subset of the certificate fields
-      if (!fields[fieldName]) {
-        throw new Error(`Fields to reveal must be a subset of the certificate fields. Missing the "${fieldName}" field.`)
+      if (fields[fieldName] === undefined || fields[fieldName] === null || fields[fieldName] === '') {
+        throw new Error(
+          `Fields to reveal must be a subset of the certificate fields. Missing the "${fieldName}" field.`
+        )
       }
 
       // Decrypt the master field key and verify that derived key actually decrypts requested field
-      const masterFieldKey = (await this.decryptField(subjectWallet, masterKeyring, fieldName, fields[fieldName], certifier)).fieldRevelationKey
+      const masterFieldKey = (
+        await this.decryptField(
+          subjectWallet,
+          masterKeyring,
+          fieldName,
+          fields[fieldName],
+          certifier
+        )
+      ).fieldRevelationKey
 
       // Encrypt derived fieldRevelationKey for verifier
-      const { ciphertext: encryptedFieldRevelationKey } = await subjectWallet.encrypt({
-        plaintext: masterFieldKey,
-        ...Certificate.getCertificateFieldEncryptionDetails(fieldName, serialNumber),
-        counterparty: verifier
-      }, originator)
+      const { ciphertext: encryptedFieldRevelationKey } =
+        await subjectWallet.encrypt(
+          {
+            plaintext: masterFieldKey,
+            ...Certificate.getCertificateFieldEncryptionDetails(
+              fieldName,
+              serialNumber
+            ),
+            counterparty: verifier
+          }
+        )
 
       // Add encryptedFieldRevelationKey to fieldRevelationKeyring
-      fieldRevelationKeyring[fieldName] = Utils.toBase64(encryptedFieldRevelationKey)
+      fieldRevelationKeyring[fieldName] = Utils.toBase64(
+        encryptedFieldRevelationKey
+      )
     }
 
     // Return the field revelation keyring which can be used to create a verifiable certificate for a verifier.
@@ -157,21 +194,21 @@ export class MasterCertificate extends Certificate {
 
   /**
    * Issues a new MasterCertificate for a specified subject.
-   * 
+   *
    * This method generates a certificate containing encrypted fields and a keyring
    * for the subject to decrypt all fields. Each field is encrypted with a randomly
    * generated symmetric key, which is then encrypted for the subject. The certificate
    * can also includes a revocation outpoint to manage potential revocation.
-   * 
+   *
    * @param {ProtoWallet} certifierWallet - The wallet of the certifier, used to sign the certificate and encrypt field keys.
    * @param {WalletCounterparty} subject - The subject for whom the certificate is issued.
    * @param {Record<CertificateFieldNameUnder50Bytes, string>} fields - Unencrypted certificate fields to include, with their names and values.
    * @param {string} certificateType - The type of certificate being issued.
-   * @param {function(string, Record<CertificateFieldNameUnder50Bytes, string>?): Promise<string>} getRevocationOutpoint - 
+   * @param {function(string, Record<CertificateFieldNameUnder50Bytes, string>?): Promise<string>} getRevocationOutpoint -
    *   Optional function to obtain a revocation outpoint for the certificate. Defaults to a placeholder.
    * @param {function(string): Promise<void>} updateProgress - Optional callback for reporting progress updates during the operation. Defaults to a no-op.
    * @returns {Promise<MasterCertificate>} - A signed MasterCertificate instance containing the encrypted fields and subject specific keyring.
-   * 
+   *
    * @throws {Error} Throws an error if any operation (e.g., encryption, signing) fails during certificate issuance.
    */
   static async issueCertificateForSubject(
@@ -179,31 +216,26 @@ export class MasterCertificate extends Certificate {
     subject: WalletCounterparty,
     fields: Record<CertificateFieldNameUnder50Bytes, string>,
     certificateType: string,
-    getRevocationOutpoint = async (
-      serialNumber: string
-    ): Promise<string> => { return 'Certificate revocation not tracked.' },
-    serialNumber?: string
+    getRevocationOutpoint = async (_serial: string): Promise<string> => {
+      void _serial // Explicitly acknowledge unused parameter
+      return 'Certificate revocation not tracked.'
+    },
+    serialNumber?: string // ✅ Optional parameter
   ): Promise<MasterCertificate> {
     // 1. Generate a random serialNumber if not provided
-    if (!serialNumber) {
-      serialNumber = Utils.toBase64(Random(32))
-    }
+    const finalSerialNumber = serialNumber ?? Utils.toBase64(Random(32)) // ✅ Explicit nullish check
 
     // 2. Create encrypted certificate fields and associated master keyring
-    const { certificateFields, masterKeyring } = await this.createCertificateFields(
-      certifierWallet,
-      subject,
-      fields,
-    )
+    const { certificateFields, masterKeyring } =
+      await this.createCertificateFields(certifierWallet, subject, fields)
 
-    // 3. Obtain a revocation outpoint (ex. certifier can call wallet.createAction())
-    const revocationOutpoint = await getRevocationOutpoint(serialNumber)
-    // TODO: Validate revocation outpoint format
+    // 3. Obtain a revocation outpoint
+    const revocationOutpoint = await getRevocationOutpoint(finalSerialNumber) // ✅ Use `finalSerialNumber`
 
     // 4. Create new MasterCertificate instance
     const certificate = new MasterCertificate(
       certificateType,
-      serialNumber,
+      finalSerialNumber, // ✅ Use `finalSerialNumber`
       subject,
       (await certifierWallet.getPublicKey({ identityKey: true })).publicKey,
       revocationOutpoint,
@@ -216,7 +248,6 @@ export class MasterCertificate extends Certificate {
     return certificate
   }
 
-
   /**
    * Decrypts all fields in the MasterCertificate using the subject's or certifier's wallet.
    *
@@ -240,17 +271,26 @@ export class MasterCertificate extends Certificate {
     fields: Record<CertificateFieldNameUnder50Bytes, Base64String>,
     counterparty: WalletCounterparty
   ): Promise<Record<CertificateFieldNameUnder50Bytes, string>> {
-    if (!masterKeyring || Object.keys(masterKeyring).length === 0) {
+    if (masterKeyring == null || Object.keys(masterKeyring).length === 0) {
       throw new Error('A MasterCertificate must have a valid masterKeyring!')
     }
     try {
-      const decryptedFields: Record<CertificateFieldNameUnder50Bytes, string> = {}
+      const decryptedFields: Record<CertificateFieldNameUnder50Bytes, string> =
+        {}
       // Note: we want to iterate through all fields, not just masterKeyring keys/value pairs.
       for (const fieldName of Object.keys(fields)) {
-        decryptedFields[fieldName] = (await this.decryptField(subjectOrCertifierWallet, masterKeyring, fieldName, fields[fieldName], counterparty)).decryptedFieldValue
+        decryptedFields[fieldName] = (
+          await this.decryptField(
+            subjectOrCertifierWallet,
+            masterKeyring,
+            fieldName,
+            fields[fieldName],
+            counterparty
+          )
+        ).decryptedFieldValue
       }
       return decryptedFields
-    } catch (e) {
+    } catch {
       throw new Error('Failed to decrypt all master certificate fields.')
     }
   }
@@ -260,25 +300,29 @@ export class MasterCertificate extends Certificate {
     masterKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>,
     fieldName: Base64String,
     fieldValue: Base64String,
-    counterparty: WalletCounterparty,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    counterparty: WalletCounterparty
   ): Promise<{ fieldRevelationKey: number[], decryptedFieldValue: string }> {
-    if (!masterKeyring || Object.keys(masterKeyring).length === 0) {
+    if (masterKeyring == null || Object.keys(masterKeyring).length === 0) {
       throw new Error('A MasterCertificate must have a valid masterKeyring!')
     }
     try {
-      const { plaintext: fieldRevelationKey } = await subjectOrCertifierWallet.decrypt({
-        ciphertext: Utils.toArray(masterKeyring[fieldName], 'base64'),
-        ...Certificate.getCertificateFieldEncryptionDetails(fieldName), // Only fieldName used on MasterCertificate
-        counterparty
-      }, originator)
+      const { plaintext: fieldRevelationKey } =
+        await subjectOrCertifierWallet.decrypt(
+          {
+            ciphertext: Utils.toArray(masterKeyring[fieldName], 'base64'),
+            ...Certificate.getCertificateFieldEncryptionDetails(fieldName), // Only fieldName used on MasterCertificate
+            counterparty
+          }
+        )
 
-      const decryptedFieldValue = new SymmetricKey(fieldRevelationKey).decrypt(Utils.toArray(fieldValue, 'base64'))
+      const decryptedFieldValue = new SymmetricKey(fieldRevelationKey).decrypt(
+        Utils.toArray(fieldValue, 'base64')
+      )
       return {
         fieldRevelationKey,
         decryptedFieldValue: Utils.toUTF8(decryptedFieldValue as number[])
       }
-    } catch (e) {
+    } catch {
       throw new Error('Failed to decrypt certificate field!')
     }
   }

package/src/auth/certificates/VerifiableCertificate.ts

@@ -37,7 +37,15 @@ export class VerifiableCertificate extends Certificate {
     signature?: HexString,
     decryptedFields?: Record<CertificateFieldNameUnder50Bytes, Base64String>
   ) {
-    super(type, serialNumber, subject, certifier, revocationOutpoint, fields, signature)
+    super(
+      type,
+      serialNumber,
+      subject,
+      certifier,
+      revocationOutpoint,
+      fields,
+      signature
+    )
     this.keyring = keyring
     this.decryptedFields = decryptedFields
   }
@@ -48,25 +56,39 @@ export class VerifiableCertificate extends Certificate {
    * @returns {Promise<Record<CertificateFieldNameUnder50Bytes, string>>} - A promise that resolves to an object where each key is a field name and each value is the decrypted field value as a string.
    * @throws {Error} Throws an error if any of the decryption operations fail, with a message indicating the failure context.
    */
-  async decryptFields(verifierWallet: ProtoWallet): Promise<Record<CertificateFieldNameUnder50Bytes, string>> {
-    if (!this.keyring || Object.keys(this.keyring).length === 0) {
-      throw new Error('A keyring is required to decrypt certificate fields for the verifier.')
+  async decryptFields(
+    verifierWallet: ProtoWallet
+  ): Promise<Record<CertificateFieldNameUnder50Bytes, string>> {
+    if (this.keyring == null || Object.keys(this.keyring).length === 0) { // ✅ Explicitly check null and empty object
+      throw new Error(
+        'A keyring is required to decrypt certificate fields for the verifier.'
+      )
     }
+
     try {
-      const decryptedFields: Record<CertificateFieldNameUnder50Bytes, string> = {}
+      const decryptedFields: Record<CertificateFieldNameUnder50Bytes, string> =
+        {}
       for (const fieldName in this.keyring) {
         const { plaintext: fieldRevelationKey } = await verifierWallet.decrypt({
           ciphertext: Utils.toArray(this.keyring[fieldName], 'base64'),
-          ...Certificate.getCertificateFieldEncryptionDetails(fieldName, this.serialNumber),
+          ...Certificate.getCertificateFieldEncryptionDetails(
+            fieldName,
+            this.serialNumber
+          ),
           counterparty: this.subject
         })
 
-        const fieldValue = new SymmetricKey(fieldRevelationKey).decrypt(Utils.toArray(this.fields[fieldName], 'base64'))
+        const fieldValue = new SymmetricKey(fieldRevelationKey).decrypt(
+          Utils.toArray(this.fields[fieldName], 'base64')
+        )
         decryptedFields[fieldName] = Utils.toUTF8(fieldValue as number[])
       }
       return decryptedFields
     } catch (error) {
-      throw new Error(`Failed to decrypt selectively revealed certificate fields using keyring: ${error instanceof Error ? error.message : error}`)
+      throw new Error(
+        `Failed to decrypt selectively revealed certificate fields using keyring: ${String(error instanceof Error ? error.message : error)}`
+
+      )
     }
   }
 }