@bsv/sdk 1.3.12 → 1.3.13

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

@@ -1,27 +1,84 @@
-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"
+import { PrivateKey } from '../../../../mod'
+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'
 
 // 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
+{
   constructor(rootKeyOrKeyDeriver: PrivateKey | 'anyone' | KeyDeriverApi) {
     super(rootKeyOrKeyDeriver)
     if (typeof rootKeyOrKeyDeriver['identityKey'] !== 'string') {
-      rootKeyOrKeyDeriver = new KeyDeriver(rootKeyOrKeyDeriver as PrivateKey | 'anyone')
+      rootKeyOrKeyDeriver = new KeyDeriver(
+        rootKeyOrKeyDeriver as PrivateKey | 'anyone'
+      )
     }
     this.keyDeriver = rootKeyOrKeyDeriver as KeyDeriver
   }
-  isAuthenticated(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<AuthenticatedResult> {
-    throw new Error("not implemented")
+  isAuthenticated(
+    args: {},
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<AuthenticatedResult> {
+    throw new Error('not implemented')
   }
-  waitForAuthentication(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<AuthenticatedResult> {
-    throw new Error("not implemented")
+  waitForAuthentication(
+    args: {},
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<AuthenticatedResult> {
+    throw new Error('not implemented')
   }
-  getNetwork(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<GetNetworkResult> {
-    throw new Error("not implemented")
+  getNetwork(
+    args: {},
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<GetNetworkResult> {
+    throw new Error('not implemented')
   }
-  getVersion(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<GetVersionResult> {
-    throw new Error("not implemented")
+  getVersion(
+    args: {},
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<GetVersionResult> {
+    throw new Error('not implemented')
   }
   async getPublicKey(
     args: GetPublicKeyArgs,
@@ -34,7 +91,9 @@ export class CompletedProtoWallet extends ProtoWallet implements WalletInterface
       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.')
+        throw new Error(
+          'protocolID and keyID are required if identityKey is false or undefined.'
+        )
       }
       return {
         publicKey: this.keyDeriver
@@ -49,64 +108,94 @@ export class CompletedProtoWallet extends ProtoWallet implements WalletInterface
     }
   }
 
-  async createAction(args: CreateActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<CreateActionResult> {
-    throw new Error("not implemented")
+  async createAction(
+    args: CreateActionArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<CreateActionResult> {
+    throw new Error('not implemented')
   }
-  async signAction(args: SignActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<SignActionResult> {
-    throw new Error("not implemented")
+  async signAction(
+    args: SignActionArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<SignActionResult> {
+    throw new Error('not implemented')
   }
-  async abortAction(args: AbortActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<AbortActionResult> {
-    throw new Error("not implemented")
+  async abortAction(
+    args: AbortActionArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<AbortActionResult> {
+    throw new Error('not implemented')
   }
-  async listActions(args: ListActionsArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<ListActionsResult> {
-    throw new Error("not implemented")
+  async listActions(
+    args: ListActionsArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<ListActionsResult> {
+    throw new Error('not implemented')
   }
-  async internalizeAction(args: InternalizeActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<InternalizeActionResult> {
-    throw new Error("not implemented")
+  async internalizeAction(
+    args: InternalizeActionArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<InternalizeActionResult> {
+    throw new Error('not implemented')
   }
-  async listOutputs(args: ListOutputsArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<ListOutputsResult> {
-    throw new Error("not implemented")
+  async listOutputs(
+    args: ListOutputsArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<ListOutputsResult> {
+    throw new Error('not implemented')
   }
-  async relinquishOutput(args: RelinquishOutputArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<RelinquishOutputResult> {
-    throw new Error("not implemented")
+  async relinquishOutput(
+    args: RelinquishOutputArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<RelinquishOutputResult> {
+    throw new Error('not implemented')
   }
-  async acquireCertificate(args: AcquireCertificateArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<AcquireCertificateResult> {
-    throw new Error("not implemented")
+  async acquireCertificate(
+    args: AcquireCertificateArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<AcquireCertificateResult> {
+    throw new Error('not implemented')
   }
-  async listCertificates(args: ListCertificatesArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<ListCertificatesResult> {
-    throw new Error("not implemented")
+  async listCertificates(
+    args: ListCertificatesArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<ListCertificatesResult> {
+    throw new Error('not implemented')
   }
-  async proveCertificate(args: ProveCertificateArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<ProveCertificateResult> {
-    throw new Error("not implemented")
+  async proveCertificate(
+    args: ProveCertificateArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<ProveCertificateResult> {
+    throw new Error('not implemented')
   }
-  async relinquishCertificate(args: RelinquishCertificateArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<RelinquishCertificateResult> {
-    throw new Error("not implemented")
+  async relinquishCertificate(
+    args: RelinquishCertificateArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<RelinquishCertificateResult> {
+    throw new Error('not implemented')
   }
-  async discoverByIdentityKey(args: DiscoverByIdentityKeyArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<DiscoverCertificatesResult> {
-    throw new Error("not implemented")
+  async discoverByIdentityKey(
+    args: DiscoverByIdentityKeyArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<DiscoverCertificatesResult> {
+    throw new Error('not implemented')
   }
-  async discoverByAttributes(args: DiscoverByAttributesArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<DiscoverCertificatesResult> {
-    throw new Error("not implemented")
+  async discoverByAttributes(
+    args: DiscoverByAttributesArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<DiscoverCertificatesResult> {
+    throw new Error('not implemented')
   }
-  async getHeight(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<GetHeightResult> {
-    throw new Error("not implemented")
+  async getHeight(
+    args: {},
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<GetHeightResult> {
+    throw new Error('not implemented')
   }
-  async getHeaderForHeight(args: GetHeaderArgs, originator?: OriginatorDomainNameStringUnder250Bytes)
-    : Promise<GetHeaderResult> {
-    throw new Error("not implemented")
+  async getHeaderForHeight(
+    args: GetHeaderArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<GetHeaderResult> {
+    throw new Error('not implemented')
   }
-}
+}

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

@@ -1,14 +1,20 @@
-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 +29,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', () => {
@@ -97,15 +107,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 key for field: "name"'
+      )
     })
 
     it('should throw if decryption fails for any field', async () => {
@@ -118,7 +133,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 +161,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 +177,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 +217,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 +258,17 @@ 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,
+          'my-originator'
+        )
       expect(keyringForVerifier).toHaveProperty('name')
     })
 
@@ -321,8 +345,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 +368,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'

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

@@ -1,9 +1,13 @@
-import { VerifiableCertificate } from '../../../../dist/cjs/src/auth/certificates/VerifiableCertificate.js'
-import { PrivateKey, SymmetricKey, Utils } from '../../../../dist/cjs/src/primitives/index.js'
-import { CompletedProtoWallet } from '../../../../dist/cjs/src/auth/certificates/__tests/CompletedProtoWallet.js'
-import { Certificate } from '../../../../dist/cjs/src/auth/certificates/index.js'
-import { MasterCertificate } from '../../../../dist/cjs/src/auth/certificates/MasterCertificate.js'
-import { ProtoWallet } from '../../../../dist/cjs/src/wallet/index.js'
+import { VerifiableCertificate } from '../../../auth/certificates/VerifiableCertificate'
+import {
+  PrivateKey,
+  SymmetricKey,
+  Utils
+} from '../../../../mod'
+import { CompletedProtoWallet } from '../../../auth/certificates/__tests/CompletedProtoWallet'
+import { Certificate } from '../../../auth/certificates/index'
+import { MasterCertificate } from '../../../auth/certificates/MasterCertificate'
+import { ProtoWallet } from '../../../wallet/index'
 
 describe('VerifiableCertificate', () => {
   const subjectPrivateKey = PrivateKey.fromRandom()
@@ -18,7 +22,8 @@ describe('VerifiableCertificate', () => {
 
   const sampleType = Utils.toBase64(new Array(32).fill(1))
   const sampleSerialNumber = Utils.toBase64(new Array(32).fill(2))
-  const sampleRevocationOutpoint = 'deadbeefdeadbeefdeadbeefdeadbeef00000000000000000000000000000000.1'
+  const sampleRevocationOutpoint =
+    'deadbeefdeadbeefdeadbeefdeadbeef00000000000000000000000000000000.1'
 
   const plaintextFields = {
     name: 'Alice',
@@ -30,11 +35,12 @@ describe('VerifiableCertificate', () => {
 
   beforeEach(async () => {
     // For each test, we'll build a fresh VerifiableCertificate with valid encryption
-    const { certificateFields, masterKeyring } = await MasterCertificate.createCertificateFields(
-      subjectWallet,
-      certifierIdentityKey,
-      plaintextFields
-    )
+    const { certificateFields, masterKeyring } =
+      await MasterCertificate.createCertificateFields(
+        subjectWallet,
+        certifierIdentityKey,
+        plaintextFields
+      )
     const keyringForVerifier = await MasterCertificate.createKeyringForVerifier(
       subjectWallet,
       certifierIdentityKey,
@@ -62,7 +68,9 @@ describe('VerifiableCertificate', () => {
       expect(verifiableCert.serialNumber).toEqual(sampleSerialNumber)
       expect(verifiableCert.subject).toEqual(subjectIdentityKey)
       expect(verifiableCert.certifier).toEqual(certifierIdentityKey)
-      expect(verifiableCert.revocationOutpoint).toEqual(sampleRevocationOutpoint)
+      expect(verifiableCert.revocationOutpoint).toEqual(
+        sampleRevocationOutpoint
+      )
       expect(verifiableCert.fields).toBeDefined()
       expect(verifiableCert.keyring).toBeDefined()
     })
@@ -97,7 +105,9 @@ describe('VerifiableCertificate', () => {
         verifiableCert.signature
       )
 
-      await expect(emptyKeyringCert.decryptFields(verifierWallet)).rejects.toThrow(
+      await expect(
+        emptyKeyringCert.decryptFields(verifierWallet)
+      ).rejects.toThrow(
         'A keyring is required to decrypt certificate fields for the verifier.'
       )
     })
@@ -105,26 +115,30 @@ describe('VerifiableCertificate', () => {
     it('should fail if the encrypted field or its key is tampered', async () => {
       // Tamper the keyring so it doesn't match the field encryption
       verifiableCert.keyring.name = Utils.toBase64([9, 9, 9, 9])
-      await expect(verifiableCert.decryptFields(verifierWallet)).rejects.toThrow(
+      await expect(
+        verifiableCert.decryptFields(verifierWallet)
+      ).rejects.toThrow(
         /Failed to decrypt selectively revealed certificate fields using keyring/
       )
     })
 
     it('should be able to decrypt fields using the anyone wallet', async () => {
-      const { certificateFields, masterKeyring } = await MasterCertificate.createCertificateFields(
-        subjectWallet,
-        certifierIdentityKey,
-        plaintextFields
-      )
-      const keyringForVerifier = await MasterCertificate.createKeyringForVerifier(
-        subjectWallet,
-        certifierIdentityKey,
-        'anyone',
-        certificateFields,
-        Object.keys(certificateFields),
-        masterKeyring,
-        sampleSerialNumber
-      )
+      const { certificateFields, masterKeyring } =
+        await MasterCertificate.createCertificateFields(
+          subjectWallet,
+          certifierIdentityKey,
+          plaintextFields
+        )
+      const keyringForVerifier =
+        await MasterCertificate.createKeyringForVerifier(
+          subjectWallet,
+          certifierIdentityKey,
+          'anyone',
+          certificateFields,
+          Object.keys(certificateFields),
+          masterKeyring,
+          sampleSerialNumber
+        )
       verifiableCert = new VerifiableCertificate(
         sampleType,
         sampleSerialNumber,
@@ -134,8 +148,10 @@ describe('VerifiableCertificate', () => {
         certificateFields,
         keyringForVerifier
       )
-      const decrypted = await verifiableCert.decryptFields(new ProtoWallet('anyone'))
+      const decrypted = await verifiableCert.decryptFields(
+        new ProtoWallet('anyone')
+      )
       expect(decrypted).toEqual(plaintextFields)
     })
   })
-})
+})

package/src/auth/certificates/index.ts

@@ -1,4 +1,4 @@
-export { default as Certificate } from './Certificate.js'
-export * from './MasterCertificate.js'
-export * from './VerifiableCertificate.js'
-export * from './__tests/CompletedProtoWallet.js'
+export { default as Certificate } from "./Certificate";
+export * from "./MasterCertificate";
+export * from "./VerifiableCertificate";
+export * from "./__tests/CompletedProtoWallet";