@bsv/sdk 1.3.12 → 1.3.13

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

@@ -1,24 +1,27 @@
-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', () => {
+describe("Certificate", () => {
   // Sample data for testing
-  const sampleType = Utils.toBase64(new Array(32).fill(1))
-  const sampleSerialNumber = Utils.toBase64(new Array(32).fill(2))
-  const sampleSubjectPrivateKey = PrivateKey.fromRandom()
-  const sampleSubjectPubKey = sampleSubjectPrivateKey.toPublicKey().toString()
-  const sampleCertifierPrivateKey = PrivateKey.fromRandom()
-  const sampleCertifierPubKey = sampleCertifierPrivateKey.toPublicKey().toString()
-  const sampleRevocationOutpoint = 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef.1'
+  const sampleType = Utils.toBase64(new Array(32).fill(1));
+  const sampleSerialNumber = Utils.toBase64(new Array(32).fill(2));
+  const sampleSubjectPrivateKey = PrivateKey.fromRandom();
+  const sampleSubjectPubKey = sampleSubjectPrivateKey.toPublicKey().toString();
+  const sampleCertifierPrivateKey = PrivateKey.fromRandom();
+  const sampleCertifierPubKey = sampleCertifierPrivateKey
+    .toPublicKey()
+    .toString();
+  const sampleRevocationOutpoint =
+    "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef.1";
   const sampleFields = {
-    name: 'Alice',
-    email: 'alice@example.com',
-    organization: 'Example Corp'
-  }
-  const sampleFieldsEmpty = {}
+    name: "Alice",
+    email: "alice@example.com",
+    organization: "Example Corp",
+  };
+  const sampleFieldsEmpty = {};
 
-  it('should construct a Certificate with valid data', () => {
+  it("should construct a Certificate with valid data", () => {
     const certificate = new Certificate(
       sampleType,
       sampleSerialNumber,
@@ -27,18 +30,18 @@ describe('Certificate', () => {
       sampleRevocationOutpoint,
       sampleFields,
       undefined // No signature
-    )
-
-    expect(certificate.type).toEqual(sampleType)
-    expect(certificate.serialNumber).toEqual(sampleSerialNumber)
-    expect(certificate.subject).toEqual(sampleSubjectPubKey)
-    expect(certificate.certifier).toEqual(sampleCertifierPubKey)
-    expect(certificate.revocationOutpoint).toEqual(sampleRevocationOutpoint)
-    expect(certificate.signature).toBeUndefined()
-    expect(certificate.fields).toEqual(sampleFields)
-  })
-
-  it('should serialize and deserialize the Certificate without signature', () => {
+    );
+
+    expect(certificate.type).toEqual(sampleType);
+    expect(certificate.serialNumber).toEqual(sampleSerialNumber);
+    expect(certificate.subject).toEqual(sampleSubjectPubKey);
+    expect(certificate.certifier).toEqual(sampleCertifierPubKey);
+    expect(certificate.revocationOutpoint).toEqual(sampleRevocationOutpoint);
+    expect(certificate.signature).toBeUndefined();
+    expect(certificate.fields).toEqual(sampleFields);
+  });
+
+  it("should serialize and deserialize the Certificate without signature", () => {
     const certificate = new Certificate(
       sampleType,
       sampleSerialNumber,
@@ -47,21 +50,23 @@ describe('Certificate', () => {
       sampleRevocationOutpoint,
       sampleFields,
       undefined // No signature
-    )
-
-    const serialized = certificate.toBinary(false) // Exclude signature
-    const deserializedCertificate = Certificate.fromBinary(serialized)
-
-    expect(deserializedCertificate.type).toEqual(sampleType)
-    expect(deserializedCertificate.serialNumber).toEqual(sampleSerialNumber)
-    expect(deserializedCertificate.subject).toEqual(sampleSubjectPubKey)
-    expect(deserializedCertificate.certifier).toEqual(sampleCertifierPubKey)
-    expect(deserializedCertificate.revocationOutpoint).toEqual(sampleRevocationOutpoint)
-    expect(deserializedCertificate.signature).toBeUndefined()
-    expect(deserializedCertificate.fields).toEqual(sampleFields)
-  })
-
-  it('should serialize and deserialize the Certificate with signature', async () => {
+    );
+
+    const serialized = certificate.toBinary(false); // Exclude signature
+    const deserializedCertificate = Certificate.fromBinary(serialized);
+
+    expect(deserializedCertificate.type).toEqual(sampleType);
+    expect(deserializedCertificate.serialNumber).toEqual(sampleSerialNumber);
+    expect(deserializedCertificate.subject).toEqual(sampleSubjectPubKey);
+    expect(deserializedCertificate.certifier).toEqual(sampleCertifierPubKey);
+    expect(deserializedCertificate.revocationOutpoint).toEqual(
+      sampleRevocationOutpoint
+    );
+    expect(deserializedCertificate.signature).toBeUndefined();
+    expect(deserializedCertificate.fields).toEqual(sampleFields);
+  });
+
+  it("should serialize and deserialize the Certificate with signature", async () => {
     const certificate = new Certificate(
       sampleType,
       sampleSerialNumber,
@@ -70,25 +75,27 @@ describe('Certificate', () => {
       sampleRevocationOutpoint,
       sampleFields,
       undefined // No signature
-    )
+    );
 
     // Sign the certificate
-    const certifierWallet = new CompletedProtoWallet(sampleCertifierPrivateKey)
-    await certificate.sign(certifierWallet)
-
-    const serialized = certificate.toBinary(true) // Include signature
-    const deserializedCertificate = Certificate.fromBinary(serialized)
-
-    expect(deserializedCertificate.type).toEqual(sampleType)
-    expect(deserializedCertificate.serialNumber).toEqual(sampleSerialNumber)
-    expect(deserializedCertificate.subject).toEqual(sampleSubjectPubKey)
-    expect(deserializedCertificate.certifier).toEqual(sampleCertifierPubKey)
-    expect(deserializedCertificate.revocationOutpoint).toEqual(sampleRevocationOutpoint)
-    expect(deserializedCertificate.signature).toEqual(certificate.signature)
-    expect(deserializedCertificate.fields).toEqual(sampleFields)
-  })
-
-  it('should sign the Certificate and verify the signature successfully', async () => {
+    const certifierWallet = new CompletedProtoWallet(sampleCertifierPrivateKey);
+    await certificate.sign(certifierWallet);
+
+    const serialized = certificate.toBinary(true); // Include signature
+    const deserializedCertificate = Certificate.fromBinary(serialized);
+
+    expect(deserializedCertificate.type).toEqual(sampleType);
+    expect(deserializedCertificate.serialNumber).toEqual(sampleSerialNumber);
+    expect(deserializedCertificate.subject).toEqual(sampleSubjectPubKey);
+    expect(deserializedCertificate.certifier).toEqual(sampleCertifierPubKey);
+    expect(deserializedCertificate.revocationOutpoint).toEqual(
+      sampleRevocationOutpoint
+    );
+    expect(deserializedCertificate.signature).toEqual(certificate.signature);
+    expect(deserializedCertificate.fields).toEqual(sampleFields);
+  });
+
+  it("should sign the Certificate and verify the signature successfully", async () => {
     const certificate = new Certificate(
       sampleType,
       sampleSerialNumber,
@@ -97,18 +104,18 @@ describe('Certificate', () => {
       sampleRevocationOutpoint,
       sampleFields,
       undefined // No signature
-    )
+    );
 
     // Sign the certificate
-    const certifierWallet = new CompletedProtoWallet(sampleCertifierPrivateKey)
-    await certificate.sign(certifierWallet)
+    const certifierWallet = new CompletedProtoWallet(sampleCertifierPrivateKey);
+    await certificate.sign(certifierWallet);
 
     // Verify the signature
-    const isValid = await certificate.verify()
-    expect(isValid).toBe(true)
-  })
+    const isValid = await certificate.verify();
+    expect(isValid).toBe(true);
+  });
 
-  it('should fail verification if the Certificate is tampered with', async () => {
+  it("should fail verification if the Certificate is tampered with", async () => {
     const certificate = new Certificate(
       sampleType,
       sampleSerialNumber,
@@ -117,20 +124,20 @@ describe('Certificate', () => {
       sampleRevocationOutpoint,
       sampleFields,
       undefined // No signature
-    )
+    );
 
     // Sign the certificate
-    const certifierWallet = new CompletedProtoWallet(sampleCertifierPrivateKey)
-    await certificate.sign(certifierWallet)
+    const certifierWallet = new CompletedProtoWallet(sampleCertifierPrivateKey);
+    await certificate.sign(certifierWallet);
 
     // Tamper with the certificate (modify a field)
-    certificate.fields.email = 'attacker@example.com'
+    certificate.fields.email = "attacker@example.com";
 
     // Verify the signature
-    await expect(certificate.verify()).rejects.toThrow()
-  })
+    await expect(certificate.verify()).rejects.toThrow();
+  });
 
-  it('should fail verification if the signature is missing', async () => {
+  it("should fail verification if the signature is missing", async () => {
     const certificate = new Certificate(
       sampleType,
       sampleSerialNumber,
@@ -139,13 +146,13 @@ describe('Certificate', () => {
       sampleRevocationOutpoint,
       sampleFields,
       undefined // No signature
-    )
+    );
 
     // Verify the signature
-    await expect(certificate.verify()).rejects.toThrow()
-  })
+    await expect(certificate.verify()).rejects.toThrow();
+  });
 
-  it('should fail verification if the signature is incorrect', async () => {
+  it("should fail verification if the signature is incorrect", async () => {
     const certificate = new Certificate(
       sampleType,
       sampleSerialNumber,
@@ -153,14 +160,16 @@ describe('Certificate', () => {
       sampleCertifierPubKey,
       sampleRevocationOutpoint,
       sampleFields,
-      '3045022100cde229279465bb91992ccbc30bf6ed4eb8cdd9d517f31b30ff778d500d5400010220134f0e4065984f8668a642a5ad7a80886265f6aaa56d215d6400c216a4802177' // Incorrect signature
-    )
+      "3045022100cde229279465bb91992ccbc30bf6ed4eb8cdd9d517f31b30ff778d500d5400010220134f0e4065984f8668a642a5ad7a80886265f6aaa56d215d6400c216a4802177" // Incorrect signature
+    );
 
     // 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 () => {
+  it("should handle certificates with empty fields", async () => {
     const certificate = new Certificate(
       sampleType,
       sampleSerialNumber,
@@ -169,24 +178,24 @@ describe('Certificate', () => {
       sampleRevocationOutpoint,
       sampleFieldsEmpty,
       undefined // No signature
-    )
+    );
 
     // Sign the certificate
-    const certifierWallet = new CompletedProtoWallet(sampleCertifierPrivateKey)
-    await certificate.sign(certifierWallet)
+    const certifierWallet = new CompletedProtoWallet(sampleCertifierPrivateKey);
+    await certificate.sign(certifierWallet);
 
     // Serialize and deserialize
-    const serialized = certificate.toBinary(true)
-    const deserializedCertificate = Certificate.fromBinary(serialized)
+    const serialized = certificate.toBinary(true);
+    const deserializedCertificate = Certificate.fromBinary(serialized);
 
-    expect(deserializedCertificate.fields).toEqual(sampleFieldsEmpty)
+    expect(deserializedCertificate.fields).toEqual(sampleFieldsEmpty);
 
     // Verify the signature
-    const isValid = await deserializedCertificate.verify()
-    expect(isValid).toBe(true)
-  })
+    const isValid = await deserializedCertificate.verify();
+    expect(isValid).toBe(true);
+  });
 
-  it('should correctly handle serialization/deserialization when signature is excluded', () => {
+  it("should correctly handle serialization/deserialization when signature is excluded", () => {
     const certificate = new Certificate(
       sampleType,
       sampleSerialNumber,
@@ -194,23 +203,23 @@ describe('Certificate', () => {
       sampleCertifierPubKey,
       sampleRevocationOutpoint,
       sampleFields,
-      'deadbeef1234', // Placeholder signature
-    )
+      "deadbeef1234" // Placeholder signature
+    );
 
     // Serialize without signature
-    const serialized = certificate.toBinary(false)
-    const deserializedCertificate = Certificate.fromBinary(serialized)
+    const serialized = certificate.toBinary(false);
+    const deserializedCertificate = Certificate.fromBinary(serialized);
 
-    expect(deserializedCertificate.signature).toBeUndefined() // Signature should be empty
-    expect(deserializedCertificate.fields).toEqual(sampleFields)
-  })
+    expect(deserializedCertificate.signature).toBeUndefined(); // Signature should be empty
+    expect(deserializedCertificate.fields).toEqual(sampleFields);
+  });
 
-  it('should correctly handle certificates with long field names and values', async () => {
-    const longFieldName = 'longFieldName_'.repeat(10) as any // Exceeding typical lengths
-    const longFieldValue = 'longFieldValue_'.repeat(20)
+  it("should correctly handle certificates with long field names and values", async () => {
+    const longFieldName = "longFieldName_".repeat(10) as any; // Exceeding typical lengths
+    const longFieldValue = "longFieldValue_".repeat(20);
     const fields = {
-      [longFieldName]: longFieldValue
-    }
+      [longFieldName]: longFieldValue,
+    };
 
     const certificate = new Certificate(
       sampleType,
@@ -220,24 +229,24 @@ describe('Certificate', () => {
       sampleRevocationOutpoint,
       fields,
       undefined // No signature
-    )
+    );
 
     // Sign the certificate
-    const certifierWallet = new CompletedProtoWallet(sampleCertifierPrivateKey)
-    await certificate.sign(certifierWallet)
+    const certifierWallet = new CompletedProtoWallet(sampleCertifierPrivateKey);
+    await certificate.sign(certifierWallet);
 
     // Serialize and deserialize
-    const serialized = certificate.toBinary(true)
-    const deserializedCertificate = Certificate.fromBinary(serialized)
+    const serialized = certificate.toBinary(true);
+    const deserializedCertificate = Certificate.fromBinary(serialized);
 
-    expect(deserializedCertificate.fields).toEqual(fields)
+    expect(deserializedCertificate.fields).toEqual(fields);
 
     // Verify the signature
-    const isValid = await deserializedCertificate.verify()
-    expect(isValid).toBe(true)
-  })
+    const isValid = await deserializedCertificate.verify();
+    expect(isValid).toBe(true);
+  });
 
-  it('should correctly serialize and deserialize the revocationOutpoint', () => {
+  it("should correctly serialize and deserialize the revocationOutpoint", () => {
     const certificate = new Certificate(
       sampleType,
       sampleSerialNumber,
@@ -246,15 +255,17 @@ describe('Certificate', () => {
       sampleRevocationOutpoint,
       sampleFields,
       undefined // No signature
-    )
+    );
 
-    const serialized = certificate.toBinary(false)
-    const deserializedCertificate = Certificate.fromBinary(serialized)
+    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 () => {
+  it("should correctly handle certificates with no fields", async () => {
     const certificate = new Certificate(
       sampleType,
       sampleSerialNumber,
@@ -263,24 +274,24 @@ describe('Certificate', () => {
       sampleRevocationOutpoint,
       {}, // No fields
       undefined // No signature
-    )
+    );
 
     // Sign the certificate
-    const certifierWallet = new CompletedProtoWallet(sampleCertifierPrivateKey)
-    await certificate.sign(certifierWallet)
+    const certifierWallet = new CompletedProtoWallet(sampleCertifierPrivateKey);
+    await certificate.sign(certifierWallet);
 
     // Serialize and deserialize
-    const serialized = certificate.toBinary(true)
-    const deserializedCertificate = Certificate.fromBinary(serialized)
+    const serialized = certificate.toBinary(true);
+    const deserializedCertificate = Certificate.fromBinary(serialized);
 
-    expect(deserializedCertificate.fields).toEqual({})
+    expect(deserializedCertificate.fields).toEqual({});
 
     // Verify the signature
-    const isValid = await deserializedCertificate.verify()
-    expect(isValid).toBe(true)
-  })
+    const isValid = await deserializedCertificate.verify();
+    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,
@@ -289,17 +300,19 @@ describe('Certificate', () => {
       sampleCertifierPubKey, // We'll pretend this was signed by them
       sampleRevocationOutpoint,
       sampleFields,
-      'deadbeef' // Already has a placeholder signature
-    )
-    const certifierWallet = new CompletedProtoWallet(sampleCertifierPrivateKey)
+      "deadbeef" // Already has a placeholder signature
+    );
+    const certifierWallet = new CompletedProtoWallet(sampleCertifierPrivateKey);
 
     // Trying to sign again should throw
     await expect(preSignedCertificate.sign(certifierWallet)).rejects.toThrow(
-      'Certificate has already been signed!'
-    )
+      "Certificate has already been signed!"
+    );
 
     // 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,
@@ -307,14 +320,15 @@ describe('Certificate', () => {
       mismatchedCertifierPubKey, // Different from actual wallet key
       sampleRevocationOutpoint,
       sampleFields
-    )
+    );
 
     // 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)
-    await certificateWithMismatch.sign(certifierWallet)
-    expect(certificateWithMismatch.certifier).toBe(certifierPubKey)
-    expect(await certificateWithMismatch.verify()).toBe(true)
-  })
-
-})
+    const certifierPubKey = (
+      await certifierWallet.getPublicKey({ identityKey: true })
+    ).publicKey;
+    await certificateWithMismatch.sign(certifierWallet);
+    expect(certificateWithMismatch.certifier).toBe(certifierPubKey);
+    expect(await certificateWithMismatch.verify()).toBe(true);
+  });
+});