@bsv/sdk 1.3.12 → 1.3.14

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

@@ -1,6 +1,6 @@
-import { Certificate } from '../../../../dist/cjs/src/auth/index.js'
-import { CompletedProtoWallet } from '../../../../dist/cjs/src/auth/certificates/__tests/CompletedProtoWallet.js'
-import { Utils, PrivateKey } from '../../../../dist/cjs/src/primitives/index.js'
+import { Certificate } from '../../../auth/index'
+import { CompletedProtoWallet } from '../../../auth/certificates/__tests/CompletedProtoWallet'
+import { Utils, PrivateKey } from '../../../primitives/index'
 
 describe('Certificate', () => {
   // Sample data for testing
@@ -9,8 +9,11 @@ describe('Certificate', () => {
   const sampleSubjectPrivateKey = PrivateKey.fromRandom()
   const sampleSubjectPubKey = sampleSubjectPrivateKey.toPublicKey().toString()
   const sampleCertifierPrivateKey = PrivateKey.fromRandom()
-  const sampleCertifierPubKey = sampleCertifierPrivateKey.toPublicKey().toString()
-  const sampleRevocationOutpoint = 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef.1'
+  const sampleCertifierPubKey = sampleCertifierPrivateKey
+    .toPublicKey()
+    .toString()
+  const sampleRevocationOutpoint =
+    'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef.1'
   const sampleFields = {
     name: 'Alice',
     email: 'alice@example.com',
@@ -56,7 +59,9 @@ describe('Certificate', () => {
     expect(deserializedCertificate.serialNumber).toEqual(sampleSerialNumber)
     expect(deserializedCertificate.subject).toEqual(sampleSubjectPubKey)
     expect(deserializedCertificate.certifier).toEqual(sampleCertifierPubKey)
-    expect(deserializedCertificate.revocationOutpoint).toEqual(sampleRevocationOutpoint)
+    expect(deserializedCertificate.revocationOutpoint).toEqual(
+      sampleRevocationOutpoint
+    )
     expect(deserializedCertificate.signature).toBeUndefined()
     expect(deserializedCertificate.fields).toEqual(sampleFields)
   })
@@ -83,7 +88,9 @@ describe('Certificate', () => {
     expect(deserializedCertificate.serialNumber).toEqual(sampleSerialNumber)
     expect(deserializedCertificate.subject).toEqual(sampleSubjectPubKey)
     expect(deserializedCertificate.certifier).toEqual(sampleCertifierPubKey)
-    expect(deserializedCertificate.revocationOutpoint).toEqual(sampleRevocationOutpoint)
+    expect(deserializedCertificate.revocationOutpoint).toEqual(
+      sampleRevocationOutpoint
+    )
     expect(deserializedCertificate.signature).toEqual(certificate.signature)
     expect(deserializedCertificate.fields).toEqual(sampleFields)
   })
@@ -157,7 +164,9 @@ describe('Certificate', () => {
     )
 
     // Verify the signature
-    await expect(certificate.verify()).rejects.toThrowErrorMatchingInlineSnapshot(`"Signature is not valid"`)
+    await expect(
+      certificate.verify()
+    ).rejects.toThrowErrorMatchingInlineSnapshot('"Signature is not valid"')
   })
 
   it('should handle certificates with empty fields', async () => {
@@ -194,7 +203,7 @@ describe('Certificate', () => {
       sampleCertifierPubKey,
       sampleRevocationOutpoint,
       sampleFields,
-      'deadbeef1234', // Placeholder signature
+      'deadbeef1234' // Placeholder signature
     )
 
     // Serialize without signature
@@ -206,9 +215,10 @@ describe('Certificate', () => {
   })
 
   it('should correctly handle certificates with long field names and values', async () => {
-    const longFieldName = 'longFieldName_'.repeat(10) as any // Exceeding typical lengths
+    const longFieldName = 'longFieldName_'.repeat(10) // ✅ Removed `as any`
     const longFieldValue = 'longFieldValue_'.repeat(20)
-    const fields = {
+
+    const fields: Record<string, string> = { // ✅ Explicitly type `fields`
       [longFieldName]: longFieldValue
     }
 
@@ -251,7 +261,9 @@ describe('Certificate', () => {
     const serialized = certificate.toBinary(false)
     const deserializedCertificate = Certificate.fromBinary(serialized)
 
-    expect(deserializedCertificate.revocationOutpoint).toEqual(sampleRevocationOutpoint)
+    expect(deserializedCertificate.revocationOutpoint).toEqual(
+      sampleRevocationOutpoint
+    )
   })
 
   it('should correctly handle certificates with no fields', async () => {
@@ -280,7 +292,7 @@ describe('Certificate', () => {
     expect(isValid).toBe(true)
   })
 
-  it('should throw if already signed, and should update the certifier field if it differs from the wallet\'s public key', async () => {
+  it("should throw if already signed, and should update the certifier field if it differs from the wallet's public key", async () => {
     // Scenario 1: Certificate already has a signature
     const preSignedCertificate = new Certificate(
       sampleType,
@@ -299,7 +311,9 @@ describe('Certificate', () => {
     )
 
     // Scenario 2: The certifier property is set to something different from the wallet's public key
-    const mismatchedCertifierPubKey = PrivateKey.fromRandom().toPublicKey().toString()
+    const mismatchedCertifierPubKey = PrivateKey.fromRandom()
+      .toPublicKey()
+      .toString()
     const certificateWithMismatch = new Certificate(
       sampleType,
       sampleSerialNumber,
@@ -311,10 +325,11 @@ describe('Certificate', () => {
 
     // Sign the certificate; it should automatically update
     // the certifier field to match the wallet's actual public key
-    const certifierPubKey = ((await certifierWallet.getPublicKey({ identityKey: true })).publicKey)
+    const certifierPubKey = (
+      await certifierWallet.getPublicKey({ identityKey: true })
+    ).publicKey
     await certificateWithMismatch.sign(certifierWallet)
     expect(certificateWithMismatch.certifier).toBe(certifierPubKey)
     expect(await certificateWithMismatch.verify()).toBe(true)
   })
-
-})
+})

package/src/auth/certificates/__tests/CompletedProtoWallet.ts

@@ -1,112 +1,215 @@
-import { PrivateKey } from "mod.js"
-import { ProtoWallet, WalletInterface, CreateActionArgs, OriginatorDomainNameStringUnder250Bytes, CreateActionResult, SignActionArgs, SignActionResult, AbortActionArgs, AbortActionResult, ListActionsArgs, ListActionsResult, InternalizeActionArgs, InternalizeActionResult, ListOutputsArgs, ListOutputsResult, RelinquishOutputArgs, RelinquishOutputResult, AcquireCertificateArgs, AcquireCertificateResult, ListCertificatesArgs, ListCertificatesResult, ProveCertificateArgs, ProveCertificateResult, RelinquishCertificateArgs, RelinquishCertificateResult, DiscoverByIdentityKeyArgs, DiscoverCertificatesResult, DiscoverByAttributesArgs, GetHeightResult, GetHeaderArgs, GetHeaderResult, KeyDeriverApi, KeyDeriver, GetPublicKeyArgs, GetPublicKeyResult, PubKeyHex, AuthenticatedResult, GetNetworkResult, GetVersionResult } from "../../../wallet/index.js"
+//@ts-nocheck
+import { PrivateKey } from '../../../../mod.js'
+import {
+  ProtoWallet,
+  WalletInterface,
+
+  CreateActionResult,
+
+  SignActionResult,
+
+  AbortActionResult,
+
+  ListActionsResult,
+
+  InternalizeActionResult,
+
+  ListOutputsResult,
+
+  RelinquishOutputResult,
+
+  AcquireCertificateResult,
+
+  ListCertificatesResult,
+
+  ProveCertificateResult,
+
+  RelinquishCertificateResult,
+
+  DiscoverCertificatesResult,
+
+  GetHeightResult,
+
+  GetHeaderResult,
+  KeyDeriverApi,
+  KeyDeriver,
+  GetPublicKeyArgs,
+  PubKeyHex,
+  AuthenticatedResult,
+  GetNetworkResult,
+  GetVersionResult
+} from '../../../wallet/index.js'
 
 // Test Mock wallet which extends ProtoWallet but still implements Wallet interface
 // Unsupported methods throw
-export class CompletedProtoWallet extends ProtoWallet implements WalletInterface {
+export class CompletedProtoWallet
+  extends ProtoWallet
+  implements WalletInterface {
+  keyDeriver: KeyDeriver
   constructor(rootKeyOrKeyDeriver: PrivateKey | 'anyone' | KeyDeriverApi) {
     super(rootKeyOrKeyDeriver)
-    if (typeof rootKeyOrKeyDeriver['identityKey'] !== 'string') {
-      rootKeyOrKeyDeriver = new KeyDeriver(rootKeyOrKeyDeriver as PrivateKey | 'anyone')
+
+    if (rootKeyOrKeyDeriver instanceof KeyDeriver) {
+      this.keyDeriver = rootKeyOrKeyDeriver
+    } else if (
+      typeof rootKeyOrKeyDeriver === 'string' ||
+      rootKeyOrKeyDeriver instanceof PrivateKey
+    ) {
+      this.keyDeriver = new KeyDeriver(rootKeyOrKeyDeriver)
+    } else {
+      throw new Error('Invalid key deriver provided')
     }
-    this.keyDeriver = rootKeyOrKeyDeriver as KeyDeriver
   }
-  isAuthenticated(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<AuthenticatedResult> {
-    throw new Error("not implemented")
+
+  async isAuthenticated(
+  ): Promise<AuthenticatedResult> {
+    throw new Error('not implemented')
   }
-  waitForAuthentication(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<AuthenticatedResult> {
-    throw new Error("not implemented")
+
+  async waitForAuthentication(
+
+  ): Promise<AuthenticatedResult> {
+    throw new Error('not implemented')
   }
-  getNetwork(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<GetNetworkResult> {
-    throw new Error("not implemented")
+
+  async getNetwork(
+
+  ): Promise<GetNetworkResult> {
+    throw new Error('not implemented')
   }
-  getVersion(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<GetVersionResult> {
-    throw new Error("not implemented")
+
+  async getVersion(
+
+  ): Promise<GetVersionResult> {
+    throw new Error('not implemented')
   }
+
   async getPublicKey(
-    args: GetPublicKeyArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: GetPublicKeyArgs
   ): Promise<{ publicKey: PubKeyHex }> {
-    if (args.privileged) {
+    if (args.privileged === true) {
       throw new Error('no privilege support')
     }
-    if (args.identityKey) {
+
+    if (args.identityKey === true) {
+      if (this.keyDeriver === null || this.keyDeriver === undefined) {
+        throw new Error('keyDeriver is not initialized')
+      }
+
       return { publicKey: this.keyDeriver.rootKey.toPublicKey().toString() }
     } else {
-      if (!args.protocolID || !args.keyID) {
-        throw new Error('protocolID and keyID are required if identityKey is false or undefined.')
+      if (args.protocolID == null || typeof args.keyID !== 'string' || args.keyID.trim() === '') {
+        throw new Error(
+          'protocolID and keyID are required if identityKey is false or undefined.'
+        )
       }
+
+      if (this.keyDeriver === null || this.keyDeriver === undefined) {
+        throw new Error('keyDeriver is not initialized')
+      }
+
       return {
         publicKey: this.keyDeriver
           .derivePublicKey(
             args.protocolID,
             args.keyID,
-            args.counterparty || 'self',
-            args.forSelf
+            typeof args.counterparty === 'string' && args.counterparty.trim() !== ''
+              ? args.counterparty
+              : 'self',
+            Boolean(args.forSelf)
           )
           .toString()
       }
     }
   }
 
-  async createAction(args: CreateActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<CreateActionResult> {
-    throw new Error("not implemented")
+  async createAction(
+
+  ): Promise<CreateActionResult> {
+    throw new Error('not implemented')
   }
-  async signAction(args: SignActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<SignActionResult> {
-    throw new Error("not implemented")
+
+  async signAction(
+
+  ): Promise<SignActionResult> {
+    throw new Error('not implemented')
   }
-  async abortAction(args: AbortActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<AbortActionResult> {
-    throw new Error("not implemented")
+
+  async abortAction(
+
+  ): Promise<AbortActionResult> {
+    throw new Error('not implemented')
   }
-  async listActions(args: ListActionsArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<ListActionsResult> {
-    throw new Error("not implemented")
+
+  async listActions(
+
+  ): Promise<ListActionsResult> {
+    throw new Error('not implemented')
   }
-  async internalizeAction(args: InternalizeActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<InternalizeActionResult> {
-    throw new Error("not implemented")
+
+  async internalizeAction(
+
+  ): Promise<InternalizeActionResult> {
+    throw new Error('not implemented')
   }
-  async listOutputs(args: ListOutputsArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<ListOutputsResult> {
-    throw new Error("not implemented")
+
+  async listOutputs(
+
+  ): Promise<ListOutputsResult> {
+    throw new Error('not implemented')
   }
-  async relinquishOutput(args: RelinquishOutputArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<RelinquishOutputResult> {
-    throw new Error("not implemented")
+
+  async relinquishOutput(
+
+  ): Promise<RelinquishOutputResult> {
+    throw new Error('not implemented')
   }
-  async acquireCertificate(args: AcquireCertificateArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<AcquireCertificateResult> {
-    throw new Error("not implemented")
+
+  async acquireCertificate(
+
+  ): Promise<AcquireCertificateResult> {
+    throw new Error('not implemented')
   }
-  async listCertificates(args: ListCertificatesArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<ListCertificatesResult> {
-    throw new Error("not implemented")
+
+  async listCertificates(
+
+  ): Promise<ListCertificatesResult> {
+    throw new Error('not implemented')
   }
-  async proveCertificate(args: ProveCertificateArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<ProveCertificateResult> {
-    throw new Error("not implemented")
+
+  async proveCertificate(
+
+  ): Promise<ProveCertificateResult> {
+    throw new Error('not implemented')
   }
-  async relinquishCertificate(args: RelinquishCertificateArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<RelinquishCertificateResult> {
-    throw new Error("not implemented")
+
+  async relinquishCertificate(
+
+  ): Promise<RelinquishCertificateResult> {
+    throw new Error('not implemented')
   }
-  async discoverByIdentityKey(args: DiscoverByIdentityKeyArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<DiscoverCertificatesResult> {
-    throw new Error("not implemented")
+
+  async discoverByIdentityKey(
+
+  ): Promise<DiscoverCertificatesResult> {
+    throw new Error('not implemented')
   }
-  async discoverByAttributes(args: DiscoverByAttributesArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<DiscoverCertificatesResult> {
-    throw new Error("not implemented")
+
+  async discoverByAttributes(
+
+  ): Promise<DiscoverCertificatesResult> {
+    throw new Error('not implemented')
   }
-  async getHeight(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<GetHeightResult> {
-    throw new Error("not implemented")
+
+  async getHeight(
+
+  ): Promise<GetHeightResult> {
+    throw new Error('not implemented')
   }
-  async getHeaderForHeight(args: GetHeaderArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<GetHeaderResult> {
-    throw new Error("not implemented")
+
+  async getHeaderForHeight(
+
+  ): Promise<GetHeaderResult> {
+    throw new Error('not implemented')
   }
-}
+}

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

@@ -1,14 +1,15 @@
-import { MasterCertificate } from '../../../../dist/cjs/src/auth/certificates/MasterCertificate.js'
-import { VerifiableCertificate } from '../../../../dist/cjs/src/auth/certificates/VerifiableCertificate.js'
-import { PrivateKey, SymmetricKey, Utils, Random } from '../../../../dist/cjs/src/primitives/index.js'
-import { CompletedProtoWallet } from '../../../../dist/cjs/src/auth/certificates/__tests/CompletedProtoWallet.js'
+import { MasterCertificate } from '../../../auth/certificates/MasterCertificate'
+import { VerifiableCertificate } from '../../../auth/certificates/VerifiableCertificate'
+import { PrivateKey, SymmetricKey, Utils, Random } from '../../../../mod'
+import { CompletedProtoWallet } from '../../../auth/certificates/__tests/CompletedProtoWallet'
 
 describe('MasterCertificate', () => {
   const subjectPrivateKey = PrivateKey.fromRandom()
   const certifierPrivateKey = PrivateKey.fromRandom()
 
   // A mock revocation outpoint for testing
-  const mockRevocationOutpoint = 'deadbeefdeadbeefdeadbeefdeadbeef00000000000000000000000000000000.1'
+  const mockRevocationOutpoint =
+    'deadbeefdeadbeefdeadbeefdeadbeef00000000000000000000000000000000.1'
 
   // Arbitrary certificate data (in plaintext)
   const plaintextFields = {
@@ -23,8 +24,12 @@ describe('MasterCertificate', () => {
   let certifierIdentityKey: string
 
   beforeAll(async () => {
-    subjectIdentityKey = (await subjectWallet.getPublicKey({ identityKey: true })).publicKey
-    certifierIdentityKey = (await certifierWallet.getPublicKey({ identityKey: true })).publicKey
+    subjectIdentityKey = (
+      await subjectWallet.getPublicKey({ identityKey: true })
+    ).publicKey
+    certifierIdentityKey = (
+      await certifierWallet.getPublicKey({ identityKey: true })
+    ).publicKey
   })
 
   describe('constructor', () => {
@@ -61,7 +66,7 @@ describe('MasterCertificate', () => {
       const fields = { name: 'encrypted_value' }
       const masterKeyring = {} // intentionally empty
 
-      expect(() => {
+      expect(() => (
         new MasterCertificate(
           Utils.toBase64(Random(16)), // type
           Utils.toBase64(Random(16)), // serialNumber
@@ -71,7 +76,7 @@ describe('MasterCertificate', () => {
           fields,
           masterKeyring
         )
-      }).toThrowError(/Master keyring must contain a value for every field/)
+      )).toThrowError(/Master keyring must contain a value for every field/)
     })
   })
 
@@ -97,15 +102,20 @@ describe('MasterCertificate', () => {
 
     it('should throw if masterKeyring is empty or invalid', async () => {
       // Manually create a MasterCertificate with an empty masterKeyring
-      expect(() => new MasterCertificate(
-        Utils.toBase64(Random(16)),
-        Utils.toBase64(Random(16)),
-        subjectIdentityKey,
-        certifierIdentityKey,
-        mockRevocationOutpoint,
-        { name: Utils.toBase64([1, 2, 3]) },
-        {}
-      )).toThrow("Master keyring must contain a value for every field. Missing key for field: \"name\"");
+      expect(
+        () =>
+          new MasterCertificate(
+            Utils.toBase64(Random(16)),
+            Utils.toBase64(Random(16)),
+            subjectIdentityKey,
+            certifierIdentityKey,
+            mockRevocationOutpoint,
+            { name: Utils.toBase64([1, 2, 3]) },
+            {}
+          )
+      ).toThrow(
+        'Master keyring must contain a value for every field. Missing or empty key for field: "name"'
+      )
     })
 
     it('should throw if decryption fails for any field', async () => {
@@ -118,7 +128,11 @@ describe('MasterCertificate', () => {
         certifierIdentityKey,
         mockRevocationOutpoint,
         {
-          name: Utils.toBase64(SymmetricKey.fromRandom().encrypt(Utils.toArray('Alice', 'utf8')) as number[])
+          name: Utils.toBase64(
+            SymmetricKey.fromRandom().encrypt(
+              Utils.toArray('Alice', 'utf8')
+            ) as number[]
+          )
         },
         { name: badKeyMasterKeyring }
       )
@@ -142,7 +156,9 @@ describe('MasterCertificate', () => {
     let issuedCert: MasterCertificate
 
     beforeAll(async () => {
-      verifierIdentityKey = (await verifierWallet.getPublicKey({ identityKey: true })).publicKey
+      verifierIdentityKey = (
+        await verifierWallet.getPublicKey({ identityKey: true })
+      ).publicKey
       // Issue a certificate to reuse in tests
       issuedCert = await MasterCertificate.issueCertificateForSubject(
         certifierWallet,
@@ -156,15 +172,16 @@ describe('MasterCertificate', () => {
       // We only want to share "name" with the verifier
       const fieldsToReveal = ['name']
 
-      const keyringForVerifier = await MasterCertificate.createKeyringForVerifier(
-        subjectWallet,
-        issuedCert.certifier, // the original certifier
-        verifierIdentityKey,       // the new verifier
-        issuedCert.fields,    // encrypted fields
-        fieldsToReveal,
-        issuedCert.masterKeyring,
-        issuedCert.serialNumber
-      )
+      const keyringForVerifier =
+        await MasterCertificate.createKeyringForVerifier(
+          subjectWallet,
+          issuedCert.certifier, // the original certifier
+          verifierIdentityKey, // the new verifier
+          issuedCert.fields, // encrypted fields
+          fieldsToReveal,
+          issuedCert.masterKeyring,
+          issuedCert.serialNumber
+        )
 
       // The new keyring should only contain "name"
       expect(Object.keys(keyringForVerifier)).toHaveLength(1)
@@ -195,7 +212,8 @@ describe('MasterCertificate', () => {
           verifierIdentityKey,
           issuedCert.fields,
           ['nonexistent_field'],
-          issuedCert.masterKeyring
+          issuedCert.masterKeyring,
+          issuedCert.serialNumber
         )
       ).rejects.toThrow(
         /Fields to reveal must be a subset of the certificate fields\. Missing the "nonexistent_field" field\./
@@ -235,16 +253,16 @@ describe('MasterCertificate', () => {
 
     it('should support optional originator parameter', async () => {
       const fieldsToReveal = ['name']
-      const keyringForVerifier = await MasterCertificate.createKeyringForVerifier(
-        subjectWallet,
-        issuedCert.certifier,
-        verifierIdentityKey,
-        issuedCert.fields,
-        fieldsToReveal,
-        issuedCert.masterKeyring,
-        issuedCert.serialNumber,
-        'my-originator'
-      )
+      const keyringForVerifier =
+        await MasterCertificate.createKeyringForVerifier(
+          subjectWallet,
+          issuedCert.certifier,
+          verifierIdentityKey,
+          issuedCert.fields,
+          fieldsToReveal,
+          issuedCert.masterKeyring,
+          issuedCert.serialNumber
+        )
       expect(keyringForVerifier).toHaveProperty('name')
     })
 
@@ -259,8 +277,7 @@ describe('MasterCertificate', () => {
         issuedCert.fields,
         fieldsToReveal,
         issuedCert.masterKeyring,
-        issuedCert.serialNumber,
-        'my-originator'
+        issuedCert.serialNumber
       )
       expect(anyoneKeyring).toHaveProperty('name')
 
@@ -272,8 +289,7 @@ describe('MasterCertificate', () => {
         issuedCert.fields,
         fieldsToReveal,
         issuedCert.masterKeyring,
-        issuedCert.serialNumber,
-        'my-originator'
+        issuedCert.serialNumber
       )
       expect(selfKeyring).toHaveProperty('name')
     })
@@ -321,8 +337,8 @@ describe('MasterCertificate', () => {
         subjectIdentityKey,
         newPlaintextFields,
         'TEST_CERT',
-        undefined,     // No custom revocation function
-        customSerialNumber   // Pass our custom serial number
+        undefined, // No custom revocation function
+        customSerialNumber // Pass our custom serial number
       )
 
       expect(newCert).toBeInstanceOf(MasterCertificate)
@@ -344,7 +360,7 @@ describe('MasterCertificate', () => {
 
       // Issue the certificate for "self"
       const selfSignedCert = await MasterCertificate.issueCertificateForSubject(
-        subjectWallet,   // act as certifier
+        subjectWallet, // act as certifier
         'self',
         selfSignedFields,
         'SELF_SIGNED_TEST'