@did-btcr2/keypair 0.7.1 → 0.8.0

package/src/pair.ts

@@ -1,11 +1,12 @@
 import {
   Hex,
+  HexString,
   KeyBytes,
   KeyPairError,
   SchnorrKeyPairObject
 } from '@did-btcr2/common';
-import { CompressedSecp256k1PublicKey } from './public.js';
-import { Secp256k1SecretKey } from './secret.js';
+import { CompressedSecp256k1PublicKey, PublicKey } from './public.js';
+import { Secp256k1SecretKey, SecretKey } from './secret.js';
 import { HexSchnorrKeyPair, MultibaseKeys, RawSchnorrKeyPair, SchnorrKeyPairParams } from './types.js';
 
 /**
@@ -15,21 +16,15 @@ import { HexSchnorrKeyPair, MultibaseKeys, RawSchnorrKeyPair, SchnorrKeyPairPara
  */
 export interface KeyPair {
   /**
-   * @type {CompressedSecp256k1PublicKey} The public key associated with the SchnorrKeyPair (required).
+   * @type {PublicKey} The public key associated with the SchnorrKeyPair (required).
    */
-  readonly publicKey: CompressedSecp256k1PublicKey;
+  readonly publicKey: PublicKey;
 
   /**
-   * @type {Secp256k1SecretKey} The secret key associated with the SchnorrKeyPair (optional).
+   * @type {SecretKey} The secret key associated with the SchnorrKeyPair (optional).
    * @throws {KeyPairError} If the secret key is not available.
    */
-  readonly secretKey?: Secp256k1SecretKey;
-
-  /**
-   * JSON representation of the SchnorrKeyPair object.
-   * @returns {SchnorrKeyPairObject} The SchnorrKeyPair as a JSON object.
-   */
-  json(): SchnorrKeyPairObject;
+  readonly secretKey?: SecretKey;
 }
 
 /**
@@ -39,16 +34,16 @@ export interface KeyPair {
  */
 export class SchnorrKeyPair implements KeyPair {
   /** @type {Secp256k1SecretKey} The secret key object */
-  private _secretKey?: Secp256k1SecretKey;
+  #secretKey?: Secp256k1SecretKey;
 
   /** @type {CompressedSecp256k1PublicKey} The public key object */;
-  private _publicKey: CompressedSecp256k1PublicKey;
+  #publicKey: CompressedSecp256k1PublicKey;
 
   /** @type {string} The public key in multibase format */
-  private _publicKeyMultibase: string;
+  #publicKeyMultibase: string;
 
   /** @type {string} The secret key in multibase format */
-  private _secretKeyMultibase: string;
+  #secretKeyMultibase: string;
 
   /**
    * Creates an instance of Keys. Must provide a at least a secret key.
@@ -67,22 +62,22 @@ export class SchnorrKeyPair implements KeyPair {
 
     // Set the secretKey
     if(params.secretKey instanceof Uint8Array) {
-      this._secretKey = new Secp256k1SecretKey(params.secretKey);
+      this.#secretKey = new Secp256k1SecretKey(params.secretKey);
     } else if (params.secretKey instanceof Secp256k1SecretKey) {
-      this._secretKey = params.secretKey;
+      this.#secretKey = params.secretKey;
     }
 
     // Set the publicKey
     if(params.publicKey instanceof CompressedSecp256k1PublicKey) {
-      this._publicKey = params.publicKey;
+      this.#publicKey = params.publicKey;
     } else if (params.publicKey instanceof Uint8Array) {
-      this._publicKey = new CompressedSecp256k1PublicKey(params.publicKey);
+      this.#publicKey = new CompressedSecp256k1PublicKey(params.publicKey);
     } else {
-      this._publicKey = this._secretKey!.computePublicKey();
+      this.#publicKey = this.#secretKey!.computePublicKey();
     }
 
-    this._publicKeyMultibase = this._publicKey.multibase.encoded;
-    this._secretKeyMultibase = this._secretKey ? this._secretKey.multibase : '';
+    this.#publicKeyMultibase = this.#publicKey.multibase.encoded;
+    this.#secretKeyMultibase = this.#secretKey ? this.#secretKey.multibase : '';
   }
 
   /**
@@ -92,15 +87,15 @@ export class SchnorrKeyPair implements KeyPair {
    */
   get secretKey(): Secp256k1SecretKey {
     // If the secret key is not available, throw an error
-    if(!this._secretKey) {
+    if(!this.#secretKey) {
       throw new KeyPairError('Secret key not available', 'SECRET_KEY_ERROR');
     }
     // If the secret key is not valid, throw an error
-    if(!this._secretKey.isValid()) {
+    if(!this.#secretKey.isValid()) {
       throw new KeyPairError('Secret key is not valid', 'SECRET_KEY_ERROR');
     }
     // Return a copy of the secret key
-    const secret = this._secretKey;
+    const secret = this.#secretKey;
     return secret;
   }
 
@@ -119,9 +114,9 @@ export class SchnorrKeyPair implements KeyPair {
       if(!publicKey.equals(cPk))
         throw new KeyPairError('Public key is not a valid pair with the secret key', 'PUBLIC_KEY_ERROR');
     }
-    this._publicKey = publicKey;
-    this._publicKeyMultibase = publicKey.multibase.encoded;
-    this._secretKeyMultibase = this._secretKey ? this._secretKey.multibase : '';
+    this.#publicKey = publicKey;
+    this.#publicKeyMultibase = publicKey.multibase.encoded;
+    this.#secretKeyMultibase = this.#secretKey ? this.#secretKey.multibase : '';
   }
 
   /**
@@ -129,7 +124,7 @@ export class SchnorrKeyPair implements KeyPair {
    * @returns {CompressedSecp256k1PublicKey} The CompressedSecp256k1PublicKey object
    */
   get publicKey(): CompressedSecp256k1PublicKey {
-    const publicKey = this._publicKey;
+    const publicKey = this.#publicKey;
     return publicKey;
   }
 
@@ -151,7 +146,7 @@ export class SchnorrKeyPair implements KeyPair {
   get hex(): HexSchnorrKeyPair {
     return {
       public : this.publicKey.hex,
-      secret : this._secretKey ? this.secretKey.hex : undefined
+      secret : this.#secretKey ? this.secretKey.hex : undefined
     };
   }
 
@@ -161,8 +156,8 @@ export class SchnorrKeyPair implements KeyPair {
    */
   get multibase(): MultibaseKeys {
     return {
-      publicKeyMultibase  : this._publicKeyMultibase,
-      secretKeyMultibase : this._secretKeyMultibase,
+      publicKeyMultibase : this.#publicKeyMultibase,
+      secretKeyMultibase : this.#secretKeyMultibase,
     };
   }
 
@@ -194,24 +189,26 @@ export class SchnorrKeyPair implements KeyPair {
    * @param {Secp256k1SecretKey | KeyBytes} data The secret key bytes
    * @returns {SchnorrKeyPair} A new SchnorrKeyPair object
    */
-  public static fromPrivateKey(data: Secp256k1SecretKey | KeyBytes): SchnorrKeyPair {
-
-    // If the secret key is a Secp256k1SecretKey object, get the raw bytes else use the bytes
-    const bytes = data instanceof Secp256k1SecretKey ? data.bytes : data;
-
-    // Throw error if the secret key is not 32 bytes
-    if(bytes.length !== 32) {
-      throw new KeyPairError('Invalid arg: must be 32 byte secret key', 'FROM_PRIVATE_KEY_ERROR');
+  public static fromSecret(data: KeyBytes | HexString): SchnorrKeyPair {
+
+    // If the data is Secp256k1SecretKey object, get the raw bytes
+    // Else if data is string, convert to byte array
+    // Else must be bytes, use them
+    const secret = typeof data === 'string'
+      ? Buffer.from(data, 'hex')
+      : data;
+
+    // Check the lenth
+    if(secret.length !== 32) {
+      throw new KeyPairError('Invalid arg: must be 32 byte secret key', 'FROM_SECRET_KEY_ERROR');
     }
 
     // If pk Uint8Array, construct Secp256k1SecretKey object else use the object
-    const secret = data instanceof Uint8Array ? new Secp256k1SecretKey(data) : data;
+    const secretKey = new Secp256k1SecretKey(secret);
+    const publicKey = secretKey.computePublicKey();
 
     // Return a new Keys object
-    return new SchnorrKeyPair({
-      secretKey : data instanceof Uint8Array ? new Secp256k1SecretKey(data) : data,
-      publicKey : secret.computePublicKey()
-    });
+    return new SchnorrKeyPair({ secretKey, publicKey });
   }
 
   /**

package/src/public.ts

@@ -1,6 +1,7 @@
 import {
   BIP340_PUBLIC_KEY_MULTIBASE_PREFIX,
   BIP340_PUBLIC_KEY_MULTIBASE_PREFIX_HASH,
+  Bytes,
   CURVE,
   Hex,
   KeyBytes,
@@ -12,7 +13,13 @@ import { sha256 } from '@noble/hashes/sha2';
 import { base58btc } from 'multiformats/bases/base58';
 import * as tinysecp from 'tiny-secp256k1';
 import { Secp256k1SecretKey } from './secret.js';
+import { CryptoOptions } from './types.js';
 
+/**
+ * Point Interface representing an (x, y) coordinate on the secp256k1 curve.
+ * @interface Point
+ * @type {Point}
+ */
 export interface Point {
   x: KeyBytes;
   y: KeyBytes;
@@ -119,10 +126,10 @@ export interface PublicKey {
  */
 export class CompressedSecp256k1PublicKey implements PublicKey {
   /** @type {KeyBytes} The public key bytes */
-  private readonly _bytes: KeyBytes;
+  readonly #bytes: KeyBytes;
 
   /** @type {MultibaseObject} The public key as a MultibaseObject */
-  private _multibase: MultibaseObject = {
+  readonly #multibase: MultibaseObject = {
     prefix  : BIP340_PUBLIC_KEY_MULTIBASE_PREFIX,
     key     : [],
     encoded : ''
@@ -130,31 +137,36 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
 
   /**
    * Creates a CompressedSecp256k1PublicKey instance.
-   * @param {KeyBytes} bytes The public key byte array.
+   * @param {Hex} initialBytes The public key byte array.
    * @throws {PublicKeyError} if the byte length is not 32 (x-only) or 33 (compressed)
    */
-  constructor(bytes: KeyBytes) {
+  constructor(initialBytes: Hex) {
+    // Convert hex string to Uint8Array if necessary
+    const keyBytes = initialBytes instanceof Uint8Array
+      ? initialBytes
+      : Uint8Array.from(Buffer.from(initialBytes, 'hex'));
+
     // If the byte length is not 33, throw an error
-    if(bytes.length !== 33) {
+    if(!keyBytes || keyBytes.length !== 33) {
       throw new PublicKeyError(
         'Invalid argument: byte length must be 33 (compressed)',
-        'CONSTRUCTOR_ERROR', { bytes }
+        'CONSTRUCTOR_ERROR', { keyBytes }
       );
     }
 
     // Validate the point is on curve and in compressed form
-    if (!tinysecp.isPoint(bytes)) {
+    if (!tinysecp.isPoint(keyBytes)) {
       throw new PublicKeyError(
-        'Invalid argument: bytes are not a valid secp256k1 compressed point',
-        'CONSTRUCTOR_ERROR', { bytes }
+        'Invalid argument: not a valid secp256k1 compressed point',
+        'CONSTRUCTOR_ERROR', { keyBytes }
       );
     }
     // Set the bytes
-    this._bytes = bytes;
+    this.#bytes = keyBytes;
 
     // Set multibase
-    this._multibase.encoded = this.encode();
-    this._multibase.key = [...this._multibase.prefix, ...this.compressed];
+    this.#multibase.encoded = this.encode();
+    this.#multibase.key = [...this.#multibase.prefix, ...this.compressed];
   }
 
   /**
@@ -162,7 +174,7 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
    * @returns {KeyBytes} The 33-byte compressed public key (0x02 or 0x03, x).
    */
   get compressed(): KeyBytes {
-    const bytes = new Uint8Array(this._bytes);
+    const bytes = new Uint8Array(this.#bytes);
     return bytes;
   };
 
@@ -179,7 +191,8 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
    * X-only (32-byte) view of the public key per BIP-340.
    */
   get xOnly(): KeyBytes {
-    return this._bytes.slice(1);
+    const xOnly = this.compressed.slice(1);
+    return xOnly;
   }
 
   /**
@@ -188,7 +201,7 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
    * @throws {PublicKeyError} If the parity byte is not 0x02 or 0x03.
    */
   get parity(): 0x02 | 0x03 {
-    const parity = this._bytes[0];
+    const parity = this.compressed[0];
     if(![0x02, 0x03].includes(parity)) {
       throw new PublicKeyError(
         'Invalid state: parity byte must be 2 or 3',
@@ -203,7 +216,7 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
    * @returns {boolean} True if the public key has even Y.
    */
   get isEven(): boolean {
-    return this._bytes[0] === 0x02;
+    return this.parity === 0x02;
   }
 
   /**
@@ -229,15 +242,15 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
    * @returns {MultibaseObject} An object containing the multibase bytes, address and prefix.
    */
   get multibase(): MultibaseObject {
-    const multibase = this._multibase;
+    const multibase = this.#multibase;
     return multibase;
   }
 
   /**
    * Returns the raw public key as a hex string.
-   * @returns {Hex} The public key as a hex string.
+   * @returns {string} The public key as a hex string.
    */
-  get hex(): Hex {
+  get hex(): string {
     const hex = Buffer.from(this.compressed).toString('hex');
     return hex;
   }
@@ -257,41 +270,15 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
    * Returns the BIP-340 (x-only) representation of this key.
    * @returns {KeyBytes} The BIP-340 (x-only) representation of the public key.
    */
-  public bip340(): KeyBytes {
+  bip340(): KeyBytes {
     return this.xOnly;
   }
 
-  /**
-   * Returns the point of the public key.
-   * @param {Hex} pk The public key in hex (Uint8Array or string) format.
-   * @returns {Point} The point of the public key.
-   * @throws {PublicKeyError} If the public key is not a valid hex string or byte array.
-   */
-  static point(pk: Hex): Point {
-    // If the public key is a hex string, convert it to a CompressedSecp256k1PublicKey object and return the point
-    if(typeof pk === 'string' && /^[0-9a-fA-F]+$/.test(pk)) {
-      const publicKey = new CompressedSecp256k1PublicKey(Buffer.fromHex(pk));
-      return publicKey.point;
-    }
-
-    // If the public key is a byte array or ArrayBuffer, convert it to a CompressedSecp256k1PublicKey object and return the point
-    if(pk instanceof Uint8Array || ArrayBuffer.isView(pk)) {
-      const publicKey = new CompressedSecp256k1PublicKey(pk as KeyBytes);
-      return publicKey.point;
-    }
-
-    // If the public key is neither a hex string nor a byte array, throw an error
-    throw new PublicKeyError(
-      'Invalid publicKey: must be a hex string or byte array',
-      'POINT_ERROR', { publicKey: pk }
-    );
-  }
-
   /**
    * Decodes the multibase string to the 35-byte corresponding public key (2 byte prefix + 32 byte public key).
    * @returns {KeyBytes} The decoded public key: prefix and public key bytes
    */
-  public decode(): KeyBytes {
+  decode(): KeyBytes {
     // Decode the public key multibase string
     const decoded = base58btc.decode(this.multibase.encoded);
 
@@ -325,9 +312,9 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
    * Encodes compressed secp256k1 public key from bytes to BIP340 multibase format.
    * @returns {string} The public key encoded in base-58-btc multibase format.
    */
-  public encode(): string {
+  encode(): string {
     // Convert public key bytes to an array
-    const pk = this.compressed.toArray();
+    const pk = Array.from(this.compressed);
 
     // Ensure the public key is 33-byte secp256k1 compressed public key
     if (pk.length !== 33) {
@@ -338,13 +325,33 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
     }
 
     // Convert prefix to an array
-    const publicKeyMultibase = BIP340_PUBLIC_KEY_MULTIBASE_PREFIX.toArray();
+    const publicKeyMultibase = Array.from(BIP340_PUBLIC_KEY_MULTIBASE_PREFIX);
 
     // Push the public key bytes at the end of the prefix
     publicKeyMultibase.push(...pk);
 
     // Encode the bytes in base58btc format and return
-    return base58btc.encode(publicKeyMultibase.toUint8Array());
+    return base58btc.encode(Uint8Array.from(publicKeyMultibase));
+  }
+
+  /**
+   * Verify a signature using schnorr or ecdsa.
+   * @param {SignatureBytes} signature Signature for verification.
+   * @param {string} data Data for verification.
+   * @param {CryptoOptions} opts Options for signing.
+   * @param {('ecdsa' | 'schnorr')} opts.scheme The signature scheme to use. Default is 'schnorr'.
+   * @returns {boolean} If the signature is valid against the public key.
+   */
+  verify(signature: Bytes, data: Bytes, opts?: CryptoOptions): boolean {
+    opts ??= { scheme: 'schnorr' };
+    // Verify the signature depending on the scheme and return the result
+    if(opts.scheme === 'ecdsa') {
+      return tinysecp.verify(data, this.compressed, signature); }
+    else if(opts.scheme === 'schnorr') {
+      return tinysecp.verifySchnorr(data, this.x, signature);
+    }
+
+    throw new PublicKeyError(`Invalid scheme: ${opts.scheme}.`, 'VERIFY_SIGNATURE_ERROR', opts);
   }
 
   /**
@@ -352,7 +359,7 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
    * @param {CompressedSecp256k1PublicKey} other The other public key to compare
    * @returns {boolean} True if the public keys are equal, false otherwise.
    */
-  public equals(other: CompressedSecp256k1PublicKey): boolean {
+  equals(other: CompressedSecp256k1PublicKey): boolean {
     return this.hex === other.hex;
   }
 
@@ -360,51 +367,18 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
    * JSON representation of a CompressedSecp256k1PublicKey object.
    * @returns {PublicKeyObject} The CompressedSecp256k1PublicKey as a JSON object.
    */
-  public json(): PublicKeyObject {
+  json(): PublicKeyObject {
     return {
       hex       : this.hex,
       multibase : this.multibase,
       point     : {
-        x      : this.x.toArray(),
-        y      : this.y.toArray(),
+        x      : Array.from(this.x),
+        y      : Array.from(this.y),
         parity : this.parity,
       },
     };
   }
 
-  /**
-   * Creates a CompressedSecp256k1PublicKey object from a JSON representation.
-   * @param {PublicKeyObject} json The JSON object to initialize the CompressedSecp256k1PublicKey.
-   * @returns {CompressedSecp256k1PublicKey} The initialized CompressedSecp256k1PublicKey object.
-   */
-  public static fromJSON(json: PublicKeyObject): CompressedSecp256k1PublicKey {
-    json.point.x.unshift(json.point.parity);
-    return new CompressedSecp256k1PublicKey(json.point.x.toUint8Array());
-  }
-
-  /**
-   * Computes the deterministic public key for a given secret key.
-   * @param {Secp256k1SecretKey | KeyBytes} sk The Secp256k1SecretKey object or the secret key bytes
-   * @returns {CompressedSecp256k1PublicKey} A new CompressedSecp256k1PublicKey object
-   */
-  public static fromSecretKey(sk: Secp256k1SecretKey | KeyBytes): CompressedSecp256k1PublicKey {
-    // If the secret key is a Secp256k1SecretKey object, get the raw bytes else use the bytes
-    const bytes = sk instanceof Secp256k1SecretKey ? sk.bytes : sk;
-
-    // Throw error if the secret key is not 32 bytes
-    if(bytes.length !== 32) {
-      throw new PublicKeyError('Invalid arg: must be 32 byte secret key', 'FROM_SECRET_KEY_ERROR');
-    }
-
-    // Compute the public key from the secret key
-    const secret = sk instanceof Secp256k1SecretKey
-      ? sk
-      : new Secp256k1SecretKey(sk);
-
-    // Return a new CompressedSecp256k1PublicKey object
-    return secret.computePublicKey();
-  }
-
   /**
    * Computes modular exponentiation: (base^exp) % mod.
    * Used for computing modular square roots.
@@ -413,7 +387,7 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
    * @param {bigint} mod The modulus value
    * @returns {bigint} The result of the modular exponentiation
    */
-  public modPow(base: bigint, exp: bigint, mod: bigint): bigint {
+  modPow(base: bigint, exp: bigint, mod: bigint): bigint {
     let result = 1n;
     while (exp > 0n) {
       if (exp & 1n) result = (result * base) % mod;
@@ -430,7 +404,7 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
    * @param {bigint} p The prime modulus
    * @returns {bigint} The square root of `a` mod `p`
    */
-  public sqrtMod(a: bigint, p: bigint): bigint {
+  sqrtMod(a: bigint, p: bigint): bigint {
     return this.modPow(a, (p + 1n) >> 2n, p);
   };
 
@@ -439,7 +413,7 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
    * @param xBytes 32-byte x-coordinate
    * @returns {Uint8Array} 65-byte uncompressed public key (starts with `0x04`)
    */
-  public liftX(): Uint8Array {
+  liftX(): Uint8Array {
     // Ensure x-coordinate is 32 bytes
     if (this.x.length !== 32) {
       throw new PublicKeyError('Invalid argument: x-coordinate length must be 32 bytes', 'LIFT_X_ERROR');
@@ -458,9 +432,82 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
     const y = this.sqrtMod(ySquared, CURVE.p);
 
     // Convert x and y to Uint8Array
-    const yBytes = Buffer.fromHex(y.toString(16).padStart(64, '0'));
+    const yBytes = Buffer.from(y.toString(16).padStart(64, '0'), 'hex');
 
     // Return 65-byte uncompressed public key: `0x04 || x || y`
     return new Uint8Array(Buffer.concat([Buffer.from([0x04]), Buffer.from(this.x), yBytes]));
   };
+
+  /**
+   * Static method to validate a public key.
+   * @param {Hex} pk The public key in hex (Uint8Array or string) format.
+   * @returns {boolean} True if the public key is valid, false otherwise.
+   */
+  static isValid(pk: Hex): boolean {
+    try {
+      new CompressedSecp256k1PublicKey(pk);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Returns the point of the public key.
+   * @param {Hex} pk The public key in hex (Uint8Array or string) format.
+   * @returns {Point} The point of the public key.
+   * @throws {PublicKeyError} If the public key is not a valid hex string or byte array.
+   */
+  static point(pk: Hex): Point {
+    // If the public key is a hex string, convert it to a CompressedSecp256k1PublicKey object and return the point
+    if(typeof pk === 'string' && /^[0-9a-fA-F]+$/.test(pk)) {
+      const publicKey = new CompressedSecp256k1PublicKey(Buffer.from(pk, 'hex'));
+      return publicKey.point;
+    }
+
+    // If the public key is a byte array or ArrayBuffer, convert it to a CompressedSecp256k1PublicKey object and return the point
+    if(pk instanceof Uint8Array || ArrayBuffer.isView(pk)) {
+      const publicKey = new CompressedSecp256k1PublicKey(pk as KeyBytes);
+      return publicKey.point;
+    }
+
+    // If the public key is neither a hex string nor a byte array, throw an error
+    throw new PublicKeyError(
+      'Invalid publicKey: must be a hex string or byte array',
+      'POINT_ERROR', { publicKey: pk }
+    );
+  }
+
+  /**
+   * Creates a CompressedSecp256k1PublicKey object from a JSON representation.
+   * @param {PublicKeyObject} json The JSON object to initialize the CompressedSecp256k1PublicKey.
+   * @returns {CompressedSecp256k1PublicKey} The initialized CompressedSecp256k1PublicKey object.
+   */
+  static fromJSON(json: PublicKeyObject): CompressedSecp256k1PublicKey {
+    json.point.x.unshift(json.point.parity);
+    return new CompressedSecp256k1PublicKey(Uint8Array.from(json.point.x));
+  }
+
+  /**
+   * Computes the deterministic public key for a given secret key.
+   * @param {Secp256k1SecretKey | KeyBytes} sk The Secp256k1SecretKey object or the secret key bytes
+   * @returns {CompressedSecp256k1PublicKey} A new CompressedSecp256k1PublicKey object
+   */
+  static fromSecretKey(sk: Secp256k1SecretKey | KeyBytes): CompressedSecp256k1PublicKey {
+    // If the secret key is a Secp256k1SecretKey object, get the raw bytes else use the bytes
+    const bytes = sk instanceof Secp256k1SecretKey ? sk.bytes : sk;
+
+    // Throw error if the secret key is not 32 bytes
+    if(bytes.length !== 32) {
+      throw new PublicKeyError('Invalid arg: must be 32 byte secret key', 'FROM_SECRET_KEY_ERROR');
+    }
+
+    // Compute the public key from the secret key
+    const secret = sk instanceof Secp256k1SecretKey
+      ? sk
+      : new Secp256k1SecretKey(sk);
+
+    // Return a new CompressedSecp256k1PublicKey object
+    return secret.computePublicKey();
+  }
 }