@bsv/sdk 1.3.13 → 1.3.15

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

@@ -8,7 +8,7 @@ import {
   Signature,
   WalletProtocol,
   ProtoWallet
-} from '../../../mod'
+} from '../../../mod.js'
 
 /**
  * Represents an Identity Certificate as per the Wallet interface specifications.
@@ -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,24 +215,27 @@ 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) {
+    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}`
       )
@@ -264,10 +267,10 @@ export default class Certificate {
   static getCertificateFieldEncryptionDetails(
     fieldName: string,
     serialNumber?: string
-  ): { protocolID: WalletProtocol; keyID: string } {
+  ): { protocolID: WalletProtocol, keyID: string } {
     return {
       protocolID: [2, 'certificate field encryption'],
-      keyID: `${serialNumber} ${fieldName}`
+      keyID: `${serialNumber ?? 'unknown'} ${fieldName}`
     }
   }
 }

package/src/auth/certificates/MasterCertificate.ts

@@ -8,10 +8,9 @@ import {
   PubKeyHex,
   Random,
   WalletCounterparty,
-  ProtoWallet,
-  OriginatorDomainNameStringUnder250Bytes
-} from '../../../mod'
-import Certificate from './Certificate'
+  ProtoWallet
+} from '../../../mod.js'
+import Certificate from './Certificate.js'
 
 interface CreateCertificateFieldsResult {
   certificateFields: Record<CertificateFieldNameUnder50Bytes, Base64String>
@@ -59,9 +58,9 @@ export class MasterCertificate extends Certificate {
 
     // 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}".`
         )
       }
     }
@@ -86,8 +85,7 @@ 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,
@@ -112,8 +110,7 @@ export class MasterCertificate extends Certificate {
             plaintext: fieldSymmetricKey.toArray(),
             ...Certificate.getCertificateFieldEncryptionDetails(fieldName), // Only fieldName used on MasterCertificate
             counterparty: certifierOrSubject
-          },
-          originator
+          }
         )
       masterKeyring[fieldName] = Utils.toBase64(encryptedFieldRevelationKey)
     }
@@ -147,8 +144,7 @@ export class MasterCertificate extends Certificate {
     fields: Record<CertificateFieldNameUnder50Bytes, Base64String>,
     fieldsToReveal: string[],
     masterKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>,
-    serialNumber: Base64String,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    serialNumber: Base64String
   ): Promise<Record<CertificateFieldNameUnder50Bytes, string>> {
     if (!Array.isArray(fieldsToReveal)) {
       throw new Error('fieldsToReveal must be an array of strings')
@@ -156,7 +152,7 @@ export class MasterCertificate extends Certificate {
     const fieldRevelationKeyring = {}
     for (const fieldName of fieldsToReveal) {
       // Make sure that fields to reveal is a subset of the certificate fields
-      if (!fields[fieldName]) {
+      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.`
         )
@@ -183,8 +179,7 @@ export class MasterCertificate extends Certificate {
               serialNumber
             ),
             counterparty: verifier
-          },
-          originator
+          }
         )
 
       // Add encryptedFieldRevelationKey to fieldRevelationKeyring
@@ -221,28 +216,26 @@ export class MasterCertificate extends Certificate {
     subject: WalletCounterparty,
     fields: Record<CertificateFieldNameUnder50Bytes, string>,
     certificateType: string,
-    getRevocationOutpoint = async (serialNumber: string): Promise<string> => {
+    getRevocationOutpoint = async (_serial: string): Promise<string> => {
+      void _serial // Explicitly acknowledge unused parameter
       return 'Certificate revocation not tracked.'
     },
-    serialNumber?: string
+    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)
 
-    // 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,
@@ -278,7 +271,7 @@ 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 {
@@ -297,7 +290,7 @@ export class MasterCertificate extends Certificate {
         ).decryptedFieldValue
       }
       return decryptedFields
-    } catch (e) {
+    } catch {
       throw new Error('Failed to decrypt all master certificate fields.')
     }
   }
@@ -307,10 +300,9 @@ export class MasterCertificate extends Certificate {
     masterKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>,
     fieldName: Base64String,
     fieldValue: Base64String,
-    counterparty: WalletCounterparty,
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ fieldRevelationKey: number[]; decryptedFieldValue: string }> {
-    if (!masterKeyring || Object.keys(masterKeyring).length === 0) {
+    counterparty: WalletCounterparty
+  ): Promise<{ fieldRevelationKey: number[], decryptedFieldValue: string }> {
+    if (masterKeyring == null || Object.keys(masterKeyring).length === 0) {
       throw new Error('A MasterCertificate must have a valid masterKeyring!')
     }
     try {
@@ -320,8 +312,7 @@ export class MasterCertificate extends Certificate {
             ciphertext: Utils.toArray(masterKeyring[fieldName], 'base64'),
             ...Certificate.getCertificateFieldEncryptionDetails(fieldName), // Only fieldName used on MasterCertificate
             counterparty
-          },
-          originator
+          }
         )
 
       const decryptedFieldValue = new SymmetricKey(fieldRevelationKey).decrypt(
@@ -331,7 +322,7 @@ export class MasterCertificate extends Certificate {
         fieldRevelationKey,
         decryptedFieldValue: Utils.toUTF8(decryptedFieldValue as number[])
       }
-    } catch (e) {
+    } catch {
       throw new Error('Failed to decrypt certificate field!')
     }
   }

package/src/auth/certificates/VerifiableCertificate.ts

@@ -7,8 +7,8 @@ import {
   OutpointString,
   PubKeyHex,
   ProtoWallet
-} from '../../../mod'
-import Certificate from './Certificate'
+} from '../../../mod.js'
+import Certificate from './Certificate.js'
 
 /**
  * VerifiableCertificate extends the Certificate class, adding functionality to manage a verifier-specific keyring.
@@ -59,11 +59,12 @@ export class VerifiableCertificate extends Certificate {
   async decryptFields(
     verifierWallet: ProtoWallet
   ): Promise<Record<CertificateFieldNameUnder50Bytes, string>> {
-    if (!this.keyring || Object.keys(this.keyring).length === 0) {
+    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> =
         {}
@@ -85,7 +86,8 @@ export class VerifiableCertificate extends Certificate {
       return decryptedFields
     } catch (error) {
       throw new Error(
-        `Failed to decrypt selectively revealed certificate fields using keyring: ${error instanceof Error ? error.message : error}`
+        `Failed to decrypt selectively revealed certificate fields using keyring: ${String(error instanceof Error ? error.message : error)}`
+
       )
     }
   }