@did-btcr2/keypair 0.7.2 → 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

@@ -137,31 +137,32 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
 
   /**
    * Creates a CompressedSecp256k1PublicKey instance.
-   * @param {Hex} pk 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(pk: Hex) {
-    pk = pk instanceof Uint8Array
-      ? pk
-      : Buffer.fromHex(pk);
+  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(!pk || pk.length !== 33) {
+    if(!keyBytes || keyBytes.length !== 33) {
       throw new PublicKeyError(
         'Invalid argument: byte length must be 33 (compressed)',
-        'CONSTRUCTOR_ERROR', { pk }
+        'CONSTRUCTOR_ERROR', { keyBytes }
       );
     }
 
     // Validate the point is on curve and in compressed form
-    if (!tinysecp.isPoint(pk)) {
+    if (!tinysecp.isPoint(keyBytes)) {
       throw new PublicKeyError(
         'Invalid argument: not a valid secp256k1 compressed point',
-        'CONSTRUCTOR_ERROR', { pk }
+        'CONSTRUCTOR_ERROR', { keyBytes }
       );
     }
     // Set the bytes
-    this.#bytes = pk;
+    this.#bytes = keyBytes;
 
     // Set multibase
     this.#multibase.encoded = this.encode();
@@ -269,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.
-   */
-  public 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);
 
@@ -337,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) {
@@ -350,13 +325,13 @@ 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));
   }
 
   /**
@@ -367,7 +342,7 @@ export class CompressedSecp256k1PublicKey implements PublicKey {
    * @param {('ecdsa' | 'schnorr')} opts.scheme The signature scheme to use. Default is 'schnorr'.
    * @returns {boolean} If the signature is valid against the public key.
    */
-  public verify(signature: Bytes, data: Bytes, opts?: CryptoOptions): boolean {
+  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') {
@@ -384,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;
   }
 
@@ -392,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.
@@ -445,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;
@@ -462,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);
   };
 
@@ -471,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');
@@ -490,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();
+  }
 }

package/src/secret.ts

@@ -178,7 +178,7 @@ export class Secp256k1SecretKey implements SecretKey {
    */
   public encode(): string {
     // Convert Uint8Array bytes to an Array
-    const secretKeyBytes = this.bytes.toArray();
+    const secretKeyBytes = Array.from(this.bytes);
 
     if(secretKeyBytes.length !== 32) {
       throw new SecretKeyError(
@@ -187,13 +187,13 @@ export class Secp256k1SecretKey implements SecretKey {
       );
     }
     // Convert prefix to an array
-    const mbaseBytes = BIP340_SECRET_KEY_MULTIBASE_PREFIX.toArray();
+    const mbaseBytes = Array.from(BIP340_SECRET_KEY_MULTIBASE_PREFIX);
 
     // Push the secret key bytes at the end of the prefix
     mbaseBytes.push(...secretKeyBytes);
 
     // Encode the bytes in base58btc format and return
-    return base58btc.encode(mbaseBytes.toUint8Array());
+    return base58btc.encode(Uint8Array.from(mbaseBytes));
   }
 
   /**
@@ -239,7 +239,7 @@ export class Secp256k1SecretKey implements SecretKey {
    */
   public json(): SecretKeyObject {
     return {
-      bytes : this.bytes.toArray(),
+      bytes : Array.from(this.bytes),
       seed  : this.seed.toString(),
       hex   : this.hex,
     };