@bsv/sdk 1.1.32 → 1.2.0

package/mod.ts

@@ -8,4 +8,8 @@ export * from "./src/transaction/chaintrackers/index.js"
 export * from "./src/transaction/http/index.js"
 export * from "./src/messages/index.js"
 export * from "./src/compat/index.js"
-export * from "./src/totp/index.js"
+export * from "./src/totp/index.js"
+export * from "./src/wallet/index.js"
+export * from "./src/wallet/substrates/index.js"
+export * from "./src/auth/index.js"
+export * from "./src/overlay-tools/index.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.1.32",
+  "version": "1.2.0",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",
@@ -134,6 +134,46 @@
       "require": "./dist/cjs/src/totp/*.js",
       "types": "./dist/types/src/totp/*.d.ts"
     },
+    "./wallet": {
+      "import": "./dist/esm/src/wallet/index.js",
+      "require": "./dist/cjs/src/wallet/index.js",
+      "types": "./dist/types/src/wallet/index.d.ts"
+    },
+    "./wallet/*": {
+      "import": "./dist/esm/src/wallet/*.js",
+      "require": "./dist/cjs/src/wallet/*.js",
+      "types": "./dist/types/src/wallet/*.d.ts"
+    },
+    "./wallet/substrates": {
+      "import": "./dist/esm/src/wallet/substrates/index.js",
+      "require": "./dist/cjs/src/wallet/substrates/index.js",
+      "types": "./dist/types/src/wallet/substrates/index.d.ts"
+    },
+    "./wallet/substrates/*": {
+      "import": "./dist/esm/src/wallet/substrates/*.js",
+      "require": "./dist/cjs/src/wallet/substrates/*.js",
+      "types": "./dist/types/src/wallet/substrates/*.d.ts"
+    },
+    "./auth": {
+      "import": "./dist/esm/src/auth/index.js",
+      "require": "./dist/cjs/src/auth/index.js",
+      "types": "./dist/types/src/auth/index.d.ts"
+    },
+    "./auth/*": {
+      "import": "./dist/esm/src/auth/*.js",
+      "require": "./dist/cjs/src/auth/*.js",
+      "types": "./dist/types/src/auth/*.d.ts"
+    },
+    "./overlay-tools": {
+      "import": "./dist/esm/src/overlay-tools/index.js",
+      "require": "./dist/cjs/src/overlay-tools/index.js",
+      "types": "./dist/types/src/overlay-tools/index.d.ts"
+    },
+    "./overlay-tools/*": {
+      "import": "./dist/esm/src/overlay-tools/*.js",
+      "require": "./dist/cjs/src/overlay-tools/*.js",
+      "types": "./dist/types/src/overlay-tools/*.d.ts"
+    },
     "./umd": {
       "import": "./dist/umd/bundle.js"
     }
@@ -148,7 +188,7 @@
     "build:umd": "webpack --config webpack.config.js",
     "dev": "tsc -b -w",
     "prepublish": "npm run build",
-    "doc": "ts2md --inputFilename=src/script/index.ts --outputFilename=docs/script.md --filenameSubString=script --firstHeadingLevel=1 && ts2md --inputFilename=src/primitives/index.ts --outputFilename=docs/primitives.md --filenameSubString=primitives --firstHeadingLevel=1 && ts2md --inputFilename=src/transaction/index.ts --outputFilename=docs/transaction.md --filenameSubString=transaction --firstHeadingLevel=1 && ts2md --inputFilename=src/messages/index.ts --outputFilename=docs/messages.md --filenameSubString=messages --firstHeadingLevel=1 && ts2md --inputFilename=src/compat/index.ts --outputFilename=docs/compat.md --filenameSubString=compat --firstHeadingLevel=1"
+    "doc": "ts2md --inputFilename=src/script/index.ts --outputFilename=docs/script.md --filenameSubString=script --firstHeadingLevel=1 && ts2md --inputFilename=src/primitives/index.ts --outputFilename=docs/primitives.md --filenameSubString=primitives --firstHeadingLevel=1 && ts2md --inputFilename=src/transaction/index.ts --outputFilename=docs/transaction.md --filenameSubString=transaction --firstHeadingLevel=1 && ts2md --inputFilename=src/messages/index.ts --outputFilename=docs/messages.md --filenameSubString=messages --firstHeadingLevel=1 && ts2md --inputFilename=src/compat/index.ts --outputFilename=docs/compat.md --filenameSubString=compat --firstHeadingLevel=1 && ts2md --inputFilename=src/wallet/index.ts --outputFilename=docs/wallet.md --filenameSubString=wallet --firstHeadingLevel=1 && ts2md --inputFilename=src/totp/index.ts --outputFilename=docs/totp.md --filenameSubString=totp --firstHeadingLevel=1 && ts2md --inputFilename=src/overlay-tools/index.ts --outputFilename=docs/overlay-tools.md --filenameSubString=overlay-tools --firstHeadingLevel=1"
   },
   "repository": {
     "type": "git",
@@ -168,8 +208,9 @@
   },
   "homepage": "https://github.com/bitcoin-sv/ts-sdk#readme",
   "devDependencies": {
-    "@types/jest": "^29.5.5",
+    "@types/jest": "^29.5.14",
     "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
     "ts-jest": "^29.1.1",
     "ts-loader": "^9.5.1",
     "ts-standard": "^12.0.2",

package/src/auth/Certificate.ts

@@ -0,0 +1,233 @@
+import { Utils } from '../primitives/index.js'
+import { Wallet, Base64String, PubKeyHex, HexString, OutpointString, CertificateFieldNameUnder50Bytes } from '../wallet/Wallet.interfaces.js'
+import ProtoWallet from '../wallet/ProtoWallet.js'
+
+/**
+ * Represents an Identity Certificate as per the Wallet interface specifications.
+ *
+ * This class provides methods to serialize and deserialize certificates, as well as signing and verifying the certificate's signature.
+ */
+export default class Certificate {
+  /**
+   * Type identifier for the certificate, base64 encoded string, 32 bytes.
+   */
+  type: Base64String
+
+  /**
+   * Unique serial number of the certificate, base64 encoded string, 32 bytes.
+   */
+  serialNumber: Base64String
+
+  /**
+   * The public key belonging to the certificate's subject, compressed public key hex string.
+   */
+  subject: PubKeyHex
+
+  /**
+   * Public key of the certifier who issued the certificate, compressed public key hex string.
+   */
+  certifier: PubKeyHex
+
+  /**
+   * The outpoint used to confirm that the certificate has not been revoked (TXID.OutputIndex), as a string.
+   */
+  revocationOutpoint: OutpointString
+
+  /**
+   * All the fields present in the certificate, with field names as keys and field values as strings.
+   */
+  fields: Record<CertificateFieldNameUnder50Bytes, string>
+
+  /**
+   * Certificate signature by the certifier's private key, DER encoded hex string.
+  */
+  signature?: HexString
+
+  /**
+   * Constructs a new Certificate.
+   *
+   * @param {Base64String} type - Type identifier for the certificate, base64 encoded string, 32 bytes.
+   * @param {Base64String} serialNumber - Unique serial number of the certificate, base64 encoded string, 32 bytes.
+   * @param {PubKeyHex} subject - The public key belonging to the certificate's subject, compressed public key hex string.
+   * @param {PubKeyHex} certifier - Public key of the certifier who issued the certificate, compressed public key hex string.
+   * @param {OutpointString} revocationOutpoint - The outpoint used to confirm that the certificate has not been revoked (TXID.OutputIndex), as a string.
+   * @param {Record<CertificateFieldNameUnder50Bytes, string>} fields - All the fields present in the certificate.
+   * @param {HexString} signature - Certificate signature by the certifier's private key, DER encoded hex string.
+   */
+  constructor(
+    type: Base64String,
+    serialNumber: Base64String,
+    subject: PubKeyHex,
+    certifier: PubKeyHex,
+    revocationOutpoint: OutpointString,
+    fields: Record<CertificateFieldNameUnder50Bytes, string>,
+    signature?: HexString,
+  ) {
+    this.type = type
+    this.serialNumber = serialNumber
+    this.subject = subject
+    this.certifier = certifier
+    this.revocationOutpoint = revocationOutpoint
+    this.fields = fields
+    this.signature = signature
+  }
+
+  /**
+   * Serializes the certificate into binary format, with or without a signature.
+   *
+   * @param {boolean} [includeSignature=true] - Whether to include the signature in the serialization.
+   * @returns {number[]} - The serialized certificate in binary format.
+   */
+  toBin(includeSignature: boolean = true): number[] {
+    const writer = new Utils.Writer()
+
+    // Write type (Base64String, 32 bytes)
+    const typeBytes = Utils.toArray(this.type, 'base64')
+    writer.write(typeBytes)
+
+    // Write serialNumber (Base64String, 32 bytes)
+    const serialNumberBytes = Utils.toArray(this.serialNumber, 'base64')
+    writer.write(serialNumberBytes)
+
+    // Write subject (33 bytes compressed PubKeyHex)
+    const subjectBytes = Utils.toArray(this.subject, 'hex')
+    writer.write(subjectBytes)
+
+    // Write certifier (33 bytes compressed PubKeyHex)
+    const certifierBytes = Utils.toArray(this.certifier, 'hex')
+    writer.write(certifierBytes)
+
+    // Write revocationOutpoint (TXID + OutputIndex)
+    const [txid, outputIndex] = this.revocationOutpoint.split('.')
+    const txidBytes = Utils.toArray(txid, 'hex')
+    writer.write(txidBytes)
+    writer.writeVarIntNum(Number(outputIndex))
+
+    // Write fields
+    const fieldEntries = Object.entries(this.fields)
+    writer.writeVarIntNum(fieldEntries.length)
+    for (const [fieldName, fieldValue] of fieldEntries) {
+      // Field name
+      const fieldNameBytes = Utils.toArray(fieldName, 'utf8')
+      writer.writeVarIntNum(fieldNameBytes.length)
+      writer.write(fieldNameBytes)
+
+      // Field value
+      const fieldValueBytes = Utils.toArray(fieldValue, 'utf8')
+      writer.writeVarIntNum(fieldValueBytes.length)
+      writer.write(fieldValueBytes)
+    }
+
+    // Write signature if included
+    if (includeSignature && this.signature && this.signature.length > 0) {
+      const signatureBytes = Utils.toArray(this.signature, 'hex')
+      writer.writeVarIntNum(signatureBytes.length)
+      writer.write(signatureBytes)
+    }
+
+    return writer.toArray()
+  }
+
+  /**
+   * Deserializes a certificate from binary format.
+   *
+   * @param {number[]} bin - The binary data representing the certificate.
+   * @returns {Certificate} - The deserialized Certificate object.
+   */
+  static fromBin(bin: number[]): Certificate {
+    const reader = new Utils.Reader(bin)
+
+    // Read type
+    const typeBytes = reader.read(32)
+    const type = Utils.toBase64(typeBytes)
+
+    // Read serialNumber
+    const serialNumberBytes = reader.read(32)
+    const serialNumber = Utils.toBase64(serialNumberBytes)
+
+    // Read subject (33 bytes)
+    const subjectBytes = reader.read(33)
+    const subject = Utils.toHex(subjectBytes)
+
+    // Read certifier (33 bytes)
+    const certifierBytes = reader.read(33)
+    const certifier = Utils.toHex(certifierBytes)
+
+    // Read revocationOutpoint
+    const txidBytes = reader.read(32)
+    const txid = Utils.toHex(txidBytes)
+    const outputIndex = reader.readVarIntNum()
+    const revocationOutpoint = `${txid}.${outputIndex}`
+
+    // Read fields
+    const numFields = reader.readVarIntNum()
+    const fields: Record<CertificateFieldNameUnder50Bytes, string> = {}
+    for (let i = 0; i < numFields; i++) {
+      // Field name
+      const fieldNameLength = reader.readVarIntNum()
+      const fieldNameBytes = reader.read(fieldNameLength)
+      const fieldName = Utils.toUTF8(fieldNameBytes) as CertificateFieldNameUnder50Bytes
+
+      // Field value
+      const fieldValueLength = reader.readVarIntNum()
+      const fieldValueBytes = reader.read(fieldValueLength)
+      const fieldValue = Utils.toUTF8(fieldValueBytes)
+
+      fields[fieldName] = fieldValue
+    }
+
+    // Read signature if present
+    let signature: string | undefined = undefined
+    if (!reader.eof()) {
+      const signatureLength = reader.readVarIntNum()
+      const signatureBytes = reader.read(signatureLength)
+      signature = Utils.toHex(signatureBytes)
+    }
+
+    return new Certificate(
+      type,
+      serialNumber,
+      subject,
+      certifier,
+      revocationOutpoint,
+      fields,
+      signature
+    )
+  }
+
+  /**
+   * Verifies the certificate's signature.
+   *
+   * @returns {Promise<boolean>} - A promise that resolves to true if the signature is valid.
+   */
+  async verify(): Promise<boolean> {
+    // A verifier can be any wallet capable of verifying signatures
+    const verifier = new ProtoWallet('anyone')
+    const verificationData = this.toBin(false) // Exclude the signature from the verification data
+
+    const { valid } = await verifier.verifySignature({
+      signature: Utils.toArray(this.signature, 'hex'),
+      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} certifier - The wallet representing the certifier.
+   * @returns {Promise<void>}
+   */
+  async sign(certifier: Wallet): Promise<void> {
+    const preimage = this.toBin(false) // Exclude the signature when signing
+    const { signature } = await certifier.createSignature({
+      data: preimage,
+      protocolID: [2, 'certificate signature'],
+      keyID: `${this.type} ${this.serialNumber}`
+    })
+    this.signature = Utils.toHex(signature)
+  }
+}

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

@@ -0,0 +1,282 @@
+import Certificate from '../../../dist/cjs/src/auth/Certificate.js'
+import ProtoWallet from '../../../dist/cjs/src/wallet/ProtoWallet.js'
+import { Utils, PrivateKey } from '../../../dist/cjs/src/primitives/index.js'
+
+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 sampleFields = {
+        name: 'Alice',
+        email: 'alice@example.com',
+        organization: 'Example Corp'
+    }
+    const sampleFieldsEmpty = {}
+
+    it('should construct a Certificate with valid data', () => {
+        const certificate = new Certificate(
+            sampleType,
+            sampleSerialNumber,
+            sampleSubjectPubKey,
+            sampleCertifierPubKey,
+            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', () => {
+        const certificate = new Certificate(
+            sampleType,
+            sampleSerialNumber,
+            sampleSubjectPubKey,
+            sampleCertifierPubKey,
+            sampleRevocationOutpoint,
+            sampleFields,
+            undefined // No signature
+        )
+
+        const serialized = certificate.toBin(false) // Exclude signature
+        const deserializedCertificate = Certificate.fromBin(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,
+            sampleSubjectPubKey,
+            sampleCertifierPubKey,
+            sampleRevocationOutpoint,
+            sampleFields,
+            undefined // No signature
+        )
+
+        // Sign the certificate
+        const certifierWallet: ProtoWallet = new ProtoWallet(sampleCertifierPrivateKey)
+        await certificate.sign(certifierWallet)
+
+        const serialized = certificate.toBin(true) // Include signature
+        const deserializedCertificate = Certificate.fromBin(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,
+            sampleSubjectPubKey,
+            sampleCertifierPubKey,
+            sampleRevocationOutpoint,
+            sampleFields,
+            undefined // No signature
+        )
+
+        // Sign the certificate
+        const certifierWallet: ProtoWallet = new ProtoWallet(sampleCertifierPrivateKey)
+        await certificate.sign(certifierWallet)
+
+        // Verify the signature
+        const isValid = await certificate.verify()
+        expect(isValid).toBe(true)
+    })
+
+    it('should fail verification if the Certificate is tampered with', async () => {
+        const certificate = new Certificate(
+            sampleType,
+            sampleSerialNumber,
+            sampleSubjectPubKey,
+            sampleCertifierPubKey,
+            sampleRevocationOutpoint,
+            sampleFields,
+            undefined // No signature
+        )
+
+        // Sign the certificate
+        const certifierWallet: ProtoWallet = new ProtoWallet(sampleCertifierPrivateKey)
+        await certificate.sign(certifierWallet)
+
+        // Tamper with the certificate (modify a field)
+        certificate.fields.email = 'attacker@example.com'
+
+        // Verify the signature
+        await expect(certificate.verify()).rejects.toThrow()
+    })
+
+    it('should fail verification if the signature is missing', async () => {
+        const certificate = new Certificate(
+            sampleType,
+            sampleSerialNumber,
+            sampleSubjectPubKey,
+            sampleCertifierPubKey,
+            sampleRevocationOutpoint,
+            sampleFields,
+            undefined // No signature
+        )
+
+        // Verify the signature
+        await expect(certificate.verify()).rejects.toThrow()
+    })
+
+    it('should fail verification if the signature is incorrect', async () => {
+        const certificate = new Certificate(
+            sampleType,
+            sampleSerialNumber,
+            sampleSubjectPubKey,
+            sampleCertifierPubKey,
+            sampleRevocationOutpoint,
+            sampleFields,
+            '3045022100cde229279465bb91992ccbc30bf6ed4eb8cdd9d517f31b30ff778d500d5400010220134f0e4065984f8668a642a5ad7a80886265f6aaa56d215d6400c216a4802177' // Incorrect signature
+        )
+
+        // Verify the signature
+        await expect(certificate.verify()).rejects.toThrowErrorMatchingInlineSnapshot(`"Signature is not valid"`)
+    })
+
+    it('should handle certificates with empty fields', async () => {
+        const certificate = new Certificate(
+            sampleType,
+            sampleSerialNumber,
+            sampleSubjectPubKey,
+            sampleCertifierPubKey,
+            sampleRevocationOutpoint,
+            sampleFieldsEmpty,
+            undefined // No signature
+        )
+
+        // Sign the certificate
+        const certifierWallet: ProtoWallet = new ProtoWallet(sampleCertifierPrivateKey)
+        await certificate.sign(certifierWallet)
+
+        // Serialize and deserialize
+        const serialized = certificate.toBin(true)
+        const deserializedCertificate = Certificate.fromBin(serialized)
+
+        expect(deserializedCertificate.fields).toEqual(sampleFieldsEmpty)
+
+        // Verify the signature
+        const isValid = await deserializedCertificate.verify()
+        expect(isValid).toBe(true)
+    })
+
+    it('should correctly handle serialization/deserialization when signature is excluded', () => {
+        const certificate = new Certificate(
+            sampleType,
+            sampleSerialNumber,
+            sampleSubjectPubKey,
+            sampleCertifierPubKey,
+            sampleRevocationOutpoint,
+            sampleFields,
+            'deadbeef1234', // Placeholder signature
+        )
+
+        // Serialize without signature
+        const serialized = certificate.toBin(false)
+        const deserializedCertificate = Certificate.fromBin(serialized)
+
+        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)
+        const fields = {
+            [longFieldName]: longFieldValue
+        }
+
+        const certificate = new Certificate(
+            sampleType,
+            sampleSerialNumber,
+            sampleSubjectPubKey,
+            sampleCertifierPubKey,
+            sampleRevocationOutpoint,
+            fields,
+            undefined // No signature
+        )
+
+        // Sign the certificate
+        const certifierWallet: ProtoWallet = new ProtoWallet(sampleCertifierPrivateKey)
+        await certificate.sign(certifierWallet)
+
+        // Serialize and deserialize
+        const serialized = certificate.toBin(true)
+        const deserializedCertificate = Certificate.fromBin(serialized)
+
+        expect(deserializedCertificate.fields).toEqual(fields)
+
+        // Verify the signature
+        const isValid = await deserializedCertificate.verify()
+        expect(isValid).toBe(true)
+    })
+
+    it('should correctly serialize and deserialize the revocationOutpoint', () => {
+        const certificate = new Certificate(
+            sampleType,
+            sampleSerialNumber,
+            sampleSubjectPubKey,
+            sampleCertifierPubKey,
+            sampleRevocationOutpoint,
+            sampleFields,
+            undefined // No signature
+        )
+
+        const serialized = certificate.toBin(false)
+        const deserializedCertificate = Certificate.fromBin(serialized)
+
+        expect(deserializedCertificate.revocationOutpoint).toEqual(sampleRevocationOutpoint)
+    })
+
+    it('should correctly handle certificates with no fields', async () => {
+        const certificate = new Certificate(
+            sampleType,
+            sampleSerialNumber,
+            sampleSubjectPubKey,
+            sampleCertifierPubKey,
+            sampleRevocationOutpoint,
+            {}, // No fields
+            undefined // No signature
+        )
+
+        // Sign the certificate
+        const certifierWallet: ProtoWallet = new ProtoWallet(sampleCertifierPrivateKey)
+        await certificate.sign(certifierWallet)
+
+        // Serialize and deserialize
+        const serialized = certificate.toBin(true)
+        const deserializedCertificate = Certificate.fromBin(serialized)
+
+        expect(deserializedCertificate.fields).toEqual({})
+
+        // Verify the signature
+        const isValid = await deserializedCertificate.verify()
+        expect(isValid).toBe(true)
+    })
+})

package/src/auth/index.ts

@@ -0,0 +1 @@
+export { default as Certificate } from './Certificate.js'