@did-btcr2/keypair 0.5.1 → 0.7.0

package/src/pair.ts

@@ -4,25 +4,26 @@ import {
   KeyPairError,
   SchnorrKeyPairObject
 } from '@did-btcr2/common';
-import { PublicKey } from './public.js';
-import { SecretKey } from './secret.js';
+import { CompressedSecp256k1PublicKey } from './public.js';
+import { Secp256k1SecretKey } from './secret.js';
+import { MultibaseKeys, RawSchnorrKeyPair, SchnorrKeyPairParams } from './types.js';
 
 /**
- * Interface for KeyPair class.
+ * General KeyPair interface used by SchnorrKeyPair class.
  * @interface KeyPair
  * @type {KeyPair}
  */
 export interface KeyPair {
   /**
-   * @type {PublicKey} The PublicKey associated with the SchnorrKeyPair (required).
+   * @type {CompressedSecp256k1PublicKey} The public key associated with the SchnorrKeyPair (required).
    */
-  readonly publicKey: PublicKey;
+  readonly publicKey: CompressedSecp256k1PublicKey;
 
   /**
-   * @type {SecretKey} The SecretKey associated with the SchnorrKeyPair (optional).
+   * @type {Secp256k1SecretKey} The secret key associated with the SchnorrKeyPair (optional).
    * @throws {KeyPairError} If the secret key is not available.
    */
-  readonly secretKey?: SecretKey;
+  readonly secretKey?: Secp256k1SecretKey;
 
   /**
    * JSON representation of the SchnorrKeyPair object.
@@ -31,32 +32,17 @@ export interface KeyPair {
   json(): SchnorrKeyPairObject;
 }
 
-type RawKeyPair = {
-  public: KeyBytes;
-  secret?: KeyBytes
-}
-
-/** Params for the {@link SchnorrKeyPair} constructor */
-interface KeyParams {
-  secretKey?: SecretKey | KeyBytes;
-  publicKey?: PublicKey | KeyBytes;
-}
-
-interface MultibaseKeys {
-  publicKeyMultibase: string;
-  secretKeyMultibase: string
-}
 /**
- * Encapsulates a PublicKey and a SecretKey object as a single Keys object.
+ * Encapsulates a CompressedSecp256k1PublicKey and a Secp256k1SecretKey object as a single SchnorrKeyPair object.
  * @class SchnorrKeyPair
  * @type {SchnorrKeyPair}
  */
 export class SchnorrKeyPair implements KeyPair {
-  /** @type {SecretKey} The secret key object */
-  private _secretKey?: SecretKey;
+  /** @type {Secp256k1SecretKey} The secret key object */
+  private _secretKey?: Secp256k1SecretKey;
 
-  /** @type {PublicKey} The public key object */;
-  private _publicKey: PublicKey;
+  /** @type {CompressedSecp256k1PublicKey} The public key object */;
+  private _publicKey: CompressedSecp256k1PublicKey;
 
   /** @type {string} The public key in multibase format */
   private _publicKeyMultibase: string;
@@ -66,41 +52,45 @@ export class SchnorrKeyPair implements KeyPair {
 
   /**
    * Creates an instance of Keys. Must provide a at least a secret key.
-   * Can optionally provide both a private and public key, but must be a valid pair.
-   * @param {SecretKey} secretKey The secret key object
+   * Can optionally provide both a secret and public key, but must be a valid pair.
+   * @param {SchnorrKeyPairParams} params The parameters to initialize the Keys object.
+   * @param {CompressedSecp256k1PublicKey | KeyBytes} params.publicKey The public key object or bytes
+   * @param {Secp256k1SecretKey | KeyBytes} [params.secret] The secret key object or bytes
+   * @throws {KeyPairError} If neither a public key or secret key is provided.
+   * @throws {KeyPairError} If the public key is not a valid pair with the secret key.
    */
-  constructor({ secretKey, publicKey }: KeyParams = {}) {
+  constructor(params: SchnorrKeyPairParams = {}) {
     // If no secret key or public key, throw an error
-    if (!publicKey && !secretKey) {
+    if (!params.publicKey && !params.secretKey) {
       throw new KeyPairError('Argument missing: must at least provide a publicKey', 'CONSTRUCTOR_ERROR');
     }
 
-    // Set the secret key
-    if(secretKey instanceof Uint8Array) {
-      this._secretKey = new SecretKey(secretKey);
-    } else if (secretKey instanceof SecretKey) {
-      this._secretKey = secretKey;
+    // Set the secretKey
+    if(params.secretKey instanceof Uint8Array) {
+      this._secretKey = new Secp256k1SecretKey(params.secretKey);
+    } else if (params.secretKey instanceof Secp256k1SecretKey) {
+      this._secretKey = params.secretKey;
     }
 
-    // Set the public key
-    if(publicKey instanceof PublicKey) {
-      this._publicKey = publicKey;
-    } else if (publicKey instanceof Uint8Array) {
-      this._publicKey = new PublicKey(publicKey);
+    // Set the publicKey
+    if(params.publicKey instanceof CompressedSecp256k1PublicKey) {
+      this._publicKey = params.publicKey;
+    } else if (params.publicKey instanceof Uint8Array) {
+      this._publicKey = new CompressedSecp256k1PublicKey(params.publicKey);
     } else {
-      this._publicKey = new PublicKey(this._secretKey!.computePublicKey());
+      this._publicKey = this._secretKey!.computePublicKey();
     }
 
-    this._publicKeyMultibase = this._publicKey.multibase.address;
+    this._publicKeyMultibase = this._publicKey.multibase.encoded;
     this._secretKeyMultibase = this._secretKey ? this._secretKey.multibase : '';
   }
 
   /**
-   * Get the SecretKey.
-   * @returns {SecretKey} The SecretKey object
+   * Get the Secp256k1SecretKey.
+   * @returns {Secp256k1SecretKey} The Secp256k1SecretKey object
    * @throws {KeyPairError} If the secret key is not available
    */
-  get secretKey(): SecretKey {
+  get secretKey(): Secp256k1SecretKey {
     // If the secret key is not available, throw an error
     if(!this._secretKey) {
       throw new KeyPairError('Secret key not available', 'SECRET_KEY_ERROR');
@@ -110,39 +100,44 @@ export class SchnorrKeyPair implements KeyPair {
       throw new KeyPairError('Secret key is not valid', 'SECRET_KEY_ERROR');
     }
     // Return a copy of the secret key
-    const secretKey = this._secretKey;
-    return secretKey;
+    const secret = this._secretKey;
+    return secret;
   }
 
   /**
-   * Set the PublicKey.
-   * @param {PublicKey} publicKey The PublicKey object
+   * Set the CompressedSecp256k1PublicKey.
+   * @param {CompressedSecp256k1PublicKey} publicKey The CompressedSecp256k1PublicKey object
    * @throws {KeyPairError} If the public key is not a valid pair with the secret key.
    */
-  set publicKey(publicKey: PublicKey) {
+  set publicKey(publicKey: CompressedSecp256k1PublicKey) {
     // If the public key is not a valid pair with the secret key, throw an error
-    if(this.secretKey && !this.secretKey.isValidPair(publicKey)) {
-      throw new KeyPairError('Public key is not a valid pair with the secret key', 'PUBLIC_KEY_ERROR');
+    if(this.secretKey) {
+      if(!this.secretKey.hasValidPublicKey()) {
+        throw new KeyPairError('Secret key is not valid', 'SECRET_KEY_ERROR');
+      }
+      const cPk = this.secretKey.computePublicKey();
+      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.address;
+    this._publicKeyMultibase = publicKey.multibase.encoded;
     this._secretKeyMultibase = this._secretKey ? this._secretKey.multibase : '';
   }
 
   /**
-   * Get the PublicKey.
-   * @returns {PublicKey} The PublicKey object
+   * Get the CompressedSecp256k1PublicKey.
+   * @returns {CompressedSecp256k1PublicKey} The CompressedSecp256k1PublicKey object
    */
-  get publicKey(): PublicKey {
+  get publicKey(): CompressedSecp256k1PublicKey {
     const publicKey = this._publicKey;
     return publicKey;
   }
 
   /**
-   * Get the Keys as a raw key pair.
-   * @returns {RawKeyPair} The Keys as a raw key pair
+   * Get the raw bytes of each key in the SchnorrKeyPair.
+   * @returns {RawSchnorrKeyPair} JSON object with the SchnorrKeyPair raw bytes.
    */
-  get raw(): RawKeyPair {
+  get raw(): RawSchnorrKeyPair {
     return {
       public : this.publicKey.x,
       secret : this.secretKey ? this.secretKey.bytes : undefined
@@ -151,7 +146,7 @@ export class SchnorrKeyPair implements KeyPair {
 
   /**
    * Get the Keys in multibase format.
-   * @returns {MultibaseKeys} The SecretKey in multibase format
+   * @returns {MultibaseKeys} The Secp256k1SecretKey in multibase format
    */
   get multibase(): MultibaseKeys {
     return {
@@ -177,50 +172,51 @@ export class SchnorrKeyPair implements KeyPair {
    * @returns {SchnorrKeyPair} The initialized Keys object.
    */
   public static fromJSON(keys: SchnorrKeyPairObject): SchnorrKeyPair {
-    const secretKey = SecretKey.fromJSON(keys.secretKey);
-    const publicKey = PublicKey.fromJSON(keys.publicKey);
-    return new SchnorrKeyPair({ secretKey, publicKey });
+    return new SchnorrKeyPair({
+      secretKey : Secp256k1SecretKey.fromJSON(keys.secretKey),
+      publicKey : CompressedSecp256k1PublicKey.fromJSON(keys.publicKey)
+    });
   }
 
   /**
-   * Static method creates a new SchnorrKeyPair from a SecretKey object or secret key bytes.
-   * @param {SecretKey | KeyBytes} data The secret key bytes
+   * Static method creates a new SchnorrKeyPair from a Secp256k1SecretKey object or secret key bytes.
+   * @param {Secp256k1SecretKey | KeyBytes} data The secret key bytes
    * @returns {SchnorrKeyPair} A new SchnorrKeyPair object
    */
-  public static fromPrivateKey(data: SecretKey | KeyBytes): SchnorrKeyPair {
+  public static fromPrivateKey(data: Secp256k1SecretKey | KeyBytes): SchnorrKeyPair {
 
-    // If the secret key is a SecretKey object, get the raw bytes else use the bytes
-    const bytes = data instanceof SecretKey ? data.bytes : data;
+    // 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');
     }
 
-    // If pk Uint8Array, construct SecretKey object else use the object
-    const secretKey = data instanceof Uint8Array ? new SecretKey(data) : data;
-
-    // Compute the public key from the secret key
-    const publicKey = secretKey.computePublicKey();
+    // If pk Uint8Array, construct Secp256k1SecretKey object else use the object
+    const secret = data instanceof Uint8Array ? new Secp256k1SecretKey(data) : data;
 
     // Return a new Keys object
-    return new SchnorrKeyPair({ secretKey, publicKey });
+    return new SchnorrKeyPair({
+      secretKey : data instanceof Uint8Array ? new Secp256k1SecretKey(data) : data,
+      publicKey : secret.computePublicKey()
+    });
   }
 
   /**
-   * Static method creates a new Keys (SecretKey/PublicKey) bigint secret.
-   * @param {bigint} secret The secret key secret
-   * @returns {Keys} A new Keys object
+   * Static method creates a new Keys (Secp256k1SecretKey/CompressedSecp256k1PublicKey) from bigint entropy.
+   * @param {bigint} entropy The entropy in bigint form
+   * @returns {SchnorrKeyPair} A new SchnorrKeyPair object
    */
-  public static fromSecret(secret: bigint): SchnorrKeyPair {
-    const secretKey = SecretKey.fromSecret(secret);
+  public static fromEntropy(entropy: bigint): SchnorrKeyPair {
+    const secretKey = Secp256k1SecretKey.fromEntropy(entropy);
     const publicKey = secretKey.computePublicKey();
     return new SchnorrKeyPair({ secretKey, publicKey });
   }
 
   /**
    * Converts key bytes to a hex string.
-   * @param {KeyBytes} keyBytes The key bytes (private or public).
+   * @param {KeyBytes} keyBytes The key bytes (secret or public).
    * @returns {Hex} The key bytes as a hex string.
    */
   public static toHex(keyBytes: KeyBytes): Hex {
@@ -229,23 +225,23 @@ export class SchnorrKeyPair implements KeyPair {
 
   /**
    * Compares two Keys objects for equality.
-   * @param {SchnorrKeyPair} keys The main keys.
-   * @param {SchnorrKeyPair} otherKeys The other keys to compare.
+   * @param {SchnorrKeyPair} kp The main keys.
+   * @param {SchnorrKeyPair} otherKp The other keys to compare.
    * @returns {boolean} True if the public key and secret key are equal, false otherwise.
    */
-  public static equals(keys: SchnorrKeyPair, otherKeys: SchnorrKeyPair): boolean {
+  public static equals(kp: SchnorrKeyPair, otherKp: SchnorrKeyPair): boolean {
     // Deconstruct the public keys from the key pairs
-    const pk = keys.publicKey;
-    const otherPk = otherKeys.publicKey;
+    const pk = kp.publicKey;
+    const otherPk = otherKp.publicKey;
 
     // If publicKeys present, use to compare as hex strings.
     if(pk && otherPk) {
       return pk.hex === otherPk.hex;
     }
 
-    // Deconstruct the private keys from the key pairs
-    const sk = keys.secretKey;
-    const otherSk = otherKeys.secretKey;
+    // Deconstruct the secret keys from the key pairs
+    const sk = kp.secretKey;
+    const otherSk = otherKp.secretKey;
     if(sk && otherSk) {
       // Get the public key hex strings for both key pair publicKeys
       return sk.hex === otherSk.hex;
@@ -256,14 +252,14 @@ export class SchnorrKeyPair implements KeyPair {
 
   /**
    * Static method to generate a new random SchnorrKeyPair instance.
-   * @returns {SchnorrKeyPair} A new SecretKey object.
+   * @returns {SchnorrKeyPair} A new Secp256k1SecretKey object.
    */
   public static generate(): SchnorrKeyPair {
     // Generate random secret key bytes
-    const skBytes = SecretKey.random();
+    const sk = Secp256k1SecretKey.random();
 
-    // Construct a new SecretKey object
-    const secretKey = new SecretKey(skBytes);
+    // Construct a new Secp256k1SecretKey object
+    const secretKey = new Secp256k1SecretKey(sk);
 
     // Compute the public key from the secret key
     const publicKey = secretKey.computePublicKey();

package/src/public.ts

@@ -11,7 +11,8 @@ import {
 } from '@did-btcr2/common';
 import { sha256 } from '@noble/hashes/sha2';
 import { base58btc } from 'multiformats/bases/base58';
-import { SecretKey } from './secret.js';
+import * as tinysecp from 'tiny-secp256k1';
+import { Secp256k1SecretKey } from './secret.js';
 
 export interface Point {
   x: KeyBytes;
@@ -19,11 +20,17 @@ export interface Point {
 }
 
 /**
- * Interface for the PublicKey class.
- * @interface IPublicKey
- * @type {IPublicKey}
+ * General PublicKey Interface used by CompressedSecp256k1PublicKey.
+ * @interface PublicKey
+ * @type {PublicKey}
  */
-export interface IPublicKey {
+export interface PublicKey {
+  /**
+   * Compressed public key getter.
+   * @readonly @type {KeyBytes} The 33 byte compressed public key [parity, x-coord].
+   */
+  compressed: KeyBytes;
+
   /**
    * Uncompressed public key getter.
    * @readonly @type {KeyBytes} The 65 byte uncompressed public key [0x04, x-coord, y-coord].
@@ -31,41 +38,53 @@ export interface IPublicKey {
   uncompressed: KeyBytes;
 
   /**
-   * Compressed public key getter.
-   * @readonly @type {KeyBytes} The 33 byte compressed public key [parity, x-coord].
+   * X-only public key getter.
+   * @readonly @type {KeyBytes} The 32 byte x-only public key [x-coord].
    */
-  compressed: KeyBytes;
+  xOnly: KeyBytes;
 
   /**
-   * PublicKey parity getter.
+   * CompressedSecp256k1PublicKey parity getter.
    * @readonly @type {number} The 1 byte parity (0x02 if even, 0x03 if odd).
    */
   parity: number;
 
   /**
-   * PublicKey x-coordinate getter.
+   * CompressedSecp256k1PublicKey isEven getter.
+   * @readonly @type {boolean} True if the public key is even, false if odd.
+   */
+  isEven: boolean;
+
+  /**
+   * CompressedSecp256k1PublicKey x-coordinate getter.
    * @readonly @type {KeyBytes} The 32 byte x-coordinate of the public key.
    */
   x: KeyBytes;
 
   /**
-   * PublicKey y-coordinate getter.
+   * CompressedSecp256k1PublicKey y-coordinate getter.
    * @readonly @type {KeyBytes} The 32 byte y-coordinate of the public key.
    */
   y: KeyBytes;
 
   /**
-   * PublicKey multibase getter.
+   * CompressedSecp256k1PublicKey multibase getter.
    * @readonly @returns {MultibaseObject} The public key as MultibaseObject as a address string, key and prefix bytes.
    */
   multibase: MultibaseObject;
 
   /**
-   * PublicKey hex string getter.
+   * CompressedSecp256k1PublicKey hex string getter.
    * @readonly @type {Hex} The public key as a hex string.
    */
   hex: Hex;
 
+  /**
+   * CompressedSecp256k1PublicKey point getter.
+   * @readonly @type {Point} The public key as a point (x, y).
+   */
+  point: Point;
+
   /**
    * Decode the base58btc multibase string to the compressed public key prefixed with 0x02.
    * @returns {KeyBytes} The public key as a 33-byte compressed public key with header.
@@ -73,21 +92,21 @@ export interface IPublicKey {
   decode(): KeyBytes;
 
   /**
-   * Encode the PublicKey as an x-only base58btc multibase public key.
+   * Encode the CompressedSecp256k1PublicKey as an x-only base58btc multibase public key.
    * @returns {string} The public key formatted a base58btc multibase string.
    */
   encode(): string;
 
   /**
-   * PublicKey key equality check. Checks if `this` public key is equal to `other` public key.
-   * @param {PublicKey} other The public key to compare.
+   * CompressedSecp256k1PublicKey key equality check. Checks if `this` public key is equal to `other` public key.
+   * @param {CompressedSecp256k1PublicKey} other The public key to compare.
    * @returns {boolean} True if the public keys are equal.
    */
-  equals(other: PublicKey): boolean;
+  equals(other: CompressedSecp256k1PublicKey): boolean;
 
   /**
-   * JSON representation of a PublicKey object.
-   * @returns {PublicKeyObject} The PublicKey as a JSON object.
+   * JSON representation of a CompressedSecp256k1PublicKey object.
+   * @returns {PublicKeyObject} The CompressedSecp256k1PublicKey as a JSON object.
    */
   json(): PublicKeyObject;
 }
@@ -96,10 +115,10 @@ export interface IPublicKey {
  * Encapsulates a secp256k1 public key compliant to BIP-340 BIP schnorr signature scheme.
  * Provides get methods for different formats (compressed, x-only, multibase).
  * Provides helpers methods for comparison and serialization.
- * @class PublicKey
- * @type {PublicKey}
+ * @class CompressedSecp256k1PublicKey
+ * @type {CompressedSecp256k1PublicKey}
  */
-export class PublicKey implements PublicKey {
+export class CompressedSecp256k1PublicKey implements PublicKey {
   /** @type {KeyBytes} The public key bytes */
   private readonly _bytes: KeyBytes;
 
@@ -107,11 +126,11 @@ export class PublicKey implements PublicKey {
   private _multibase: MultibaseObject = {
     prefix  : BIP340_PUBLIC_KEY_MULTIBASE_PREFIX,
     key     : [],
-    address : ''
+    encoded : ''
   };
 
   /**
-   * Creates a PublicKey instance.
+   * Creates a CompressedSecp256k1PublicKey instance.
    * @param {KeyBytes} bytes The public key byte array.
    * @throws {PublicKeyError} if the byte length is not 32 (x-only) or 33 (compressed)
    */
@@ -123,11 +142,19 @@ export class PublicKey implements PublicKey {
         'CONSTRUCTOR_ERROR', { bytes }
       );
     }
+
+    // Validate the point is on curve and in compressed form
+    if (!tinysecp.isPoint(bytes)) {
+      throw new PublicKeyError(
+        'Invalid argument: bytes are not a valid secp256k1 compressed point',
+        'CONSTRUCTOR_ERROR', { bytes }
+      );
+    }
     // Set the bytes
     this._bytes = bytes;
 
     // Set multibase
-    this._multibase.address = this.encode();
+    this._multibase.encoded = this.encode();
     this._multibase.key = [...this._multibase.prefix, ...this.compressed];
   }
 
@@ -150,12 +177,34 @@ export class PublicKey implements PublicKey {
   }
 
   /**
-   * Get the parity byte of the public key.
-   * @returns {number} The parity byte of the public key.
+   * X-only (32-byte) view of the public key per BIP-340.
+   */
+  get xOnly(): KeyBytes {
+    return this._bytes.slice(1);
+  }
+
+  /**
+   * Parity of the SEC compressed public key.
+   * @returns {0x02 | 0x03} The parity byte (0x02 if even, 0x03 if odd).
+   * @throws {PublicKeyError} If the parity byte is not 0x02 or 0x03.
+   */
+  get parity(): 0x02 | 0x03 {
+    const parity = this._bytes[0];
+    if(![0x02, 0x03].includes(parity)) {
+      throw new PublicKeyError(
+        'Invalid state: parity byte must be 2 or 3',
+        'PARITY_ERROR', { parity }
+      );
+    }
+    return parity as 0x02 | 0x03;
+  }
+
+  /**
+   * Whether the SEC compressed public key has even Y.
+   * @returns {boolean} True if the public key has even Y.
    */
-  get parity(): number {
-    const parity = this.compressed[0];
-    return parity;
+  get isEven(): boolean {
+    return this._bytes[0] === 0x02;
   }
 
   /**
@@ -205,6 +254,14 @@ export class PublicKey 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 {
+    return this.xOnly;
+  }
+
   /**
    * Returns the point of the public key.
    * @param {Hex} pk The public key in hex (Uint8Array or string) format.
@@ -212,15 +269,15 @@ export class PublicKey implements PublicKey {
    * @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 PublicKey object and return the 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 PublicKey(Buffer.fromHex(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 PublicKey object and return the 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 PublicKey(pk as KeyBytes);
+      const publicKey = new CompressedSecp256k1PublicKey(pk as KeyBytes);
       return publicKey.point;
     }
 
@@ -237,7 +294,7 @@ export class PublicKey implements PublicKey {
    */
   public decode(): KeyBytes {
     // Decode the public key multibase string
-    const decoded = base58btc.decode(this.multibase.address);
+    const decoded = base58btc.decode(this.multibase.encoded);
 
     // If the public key bytes are not 35 bytes, throw an error
     if(decoded.length !== 35) {
@@ -293,16 +350,16 @@ export class PublicKey implements PublicKey {
 
   /**
    * Compares this public key to another public key.
-   * @param {PublicKey} other The other public key to compare
+   * @param {CompressedSecp256k1PublicKey} other The other public key to compare
    * @returns {boolean} True if the public keys are equal, false otherwise.
    */
-  public equals(other: PublicKey): boolean {
+  public equals(other: CompressedSecp256k1PublicKey): boolean {
     return this.hex === other.hex;
   }
 
   /**
-   * JSON representation of a PublicKey object.
-   * @returns {PublicKeyObject} The PublicKey as a JSON object.
+   * JSON representation of a CompressedSecp256k1PublicKey object.
+   * @returns {PublicKeyObject} The CompressedSecp256k1PublicKey as a JSON object.
    */
   public json(): PublicKeyObject {
     return {
@@ -317,34 +374,36 @@ export class PublicKey implements PublicKey {
   }
 
   /**
-   * Creates a PublicKey object from a JSON representation.
-   * @param {PublicKeyObject} json The JSON object to initialize the PublicKey.
-   * @returns {PublicKey} The initialized PublicKey object.
+   * 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: Maybe<PublicKeyObject>): PublicKey {
+  public static fromJSON(json: Maybe<PublicKeyObject>): CompressedSecp256k1PublicKey {
     json.x.unshift(json.parity);
-    return new PublicKey(json.x.toUint8Array());
+    return new CompressedSecp256k1PublicKey(json.x.toUint8Array());
   }
 
   /**
-   * Computes the deterministic public key for a given private key.
-   * @param {PrivateKey | KeyBytes} sk The PrivateKey object or the private key bytes
-   * @returns {PublicKey} A new PublicKey object
+   * 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: SecretKey | KeyBytes): PublicKey {
-    // If the private key is a PrivateKey object, get the raw bytes else use the bytes
-    const bytes = sk instanceof SecretKey ? sk.bytes : sk;
+  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 private key is not 32 bytes
+    // Throw error if the secret key is not 32 bytes
     if(bytes.length !== 32) {
-      throw new PublicKeyError('Invalid arg: must be 32 byte private key', 'FROM_PRIVATE_KEY_ERROR');
+      throw new PublicKeyError('Invalid arg: must be 32 byte secret key', 'FROM_SECRET_KEY_ERROR');
     }
 
-    // Compute the public key from the private key
-    const privateKey = sk instanceof SecretKey ? sk : new SecretKey(sk);
+    // Compute the public key from the secret key
+    const secret = sk instanceof Secp256k1SecretKey
+      ? sk
+      : new Secp256k1SecretKey(sk);
 
-    // Return a new PublicKey object
-    return new PublicKey(privateKey.computePublicKey());
+    // Return a new CompressedSecp256k1PublicKey object
+    return secret.computePublicKey();
   }
 
   /**
@@ -405,20 +464,4 @@ export class PublicKey implements PublicKey {
     // Return 65-byte uncompressed public key: `0x04 || x || y`
     return new Uint8Array(Buffer.concat([Buffer.from([0x04]), Buffer.from(this.x), yBytes]));
   };
-
-  /**
-   * Static version of liftX method.
-   * @param {KeyBytes} x The 32-byte x-coordinate to lift.
-   * @returns {Uint8Array} The 65-byte uncompressed public key (0x04, x, y).
-   */
-  public static xOnly(x: KeyBytes): Uint8Array {
-    // Ensure x-coordinate is 32 bytes
-    if (x.length !== 32) {
-      throw new PublicKeyError('Invalid argument: x-coordinate length must be 32 bytes', 'LIFT_X_ERROR');
-    }
-
-    // Create a PublicKey instance and lift the x-coordinate
-    const publicKey = new PublicKey(x);
-    return publicKey.x;
-  }
 }