@did-btcr2/keypair 0.7.0 → 0.7.2

package/src/secret.ts

@@ -7,14 +7,16 @@ import {
   Hex,
   KeyBytes,
   SecretKeyError,
-  SecretKeyObject
+  SecretKeyObject,
+  SignatureBytes
 } from '@did-btcr2/common';
 import { sha256 } from '@noble/hashes/sha2';
-import { getRandomValues } from 'crypto';
+import { getRandomValues, randomBytes } from 'crypto';
 import { base58btc } from 'multiformats/bases/base58';
 import * as tinysecp from 'tiny-secp256k1';
 import { SchnorrKeyPair } from './pair.js';
 import { CompressedSecp256k1PublicKey } from './public.js';
+import { CryptoOptions } from './types.js';
 
 /**
  * General SecretKey interface for the Secp256k1SecretKey class.
@@ -60,7 +62,6 @@ export interface SecretKey {
    */
   isValid(): boolean;
 
-
   /**
    * JSON representation of a Secp256k1SecretKey object.
    * @returns {SecretKeyObject} The Secp256k1SecretKey as a JSON object.
@@ -78,13 +79,13 @@ export interface SecretKey {
  */
 export class Secp256k1SecretKey implements SecretKey {
   /** @type {KeyBytes} The entropy for the secret key as a byte array */
-  private _bytes?: KeyBytes;
+  readonly #bytes?: KeyBytes;
 
   /** @type {bigint} The entropy for the secret key as a bigint */
-  private _seed?: bigint;
+  readonly #seed?: bigint;
 
   /** @type {string} The secret key as a secretKeyMultibase */
-  private _multibase: string;
+  readonly #multibase: string;
 
   /**
    * Instantiates an instance of Secp256k1SecretKey.
@@ -104,24 +105,24 @@ export class Secp256k1SecretKey implements SecretKey {
 
     // If bytes and bytes are not length 32
     if (isBytes && entropy.length === 32) {
-      this._bytes = entropy;
-      this._seed = Secp256k1SecretKey.toSecret(entropy);
+      this.#bytes = entropy;
+      this.#seed = Secp256k1SecretKey.toSecret(entropy);
     }
 
     // If secret and secret is not a valid bigint, throw error
     if (isSecret && !(entropy < 1n || entropy >= CURVE.n)) {
-      this._bytes = Secp256k1SecretKey.toBytes(entropy);
-      this._seed = entropy;
+      this.#bytes = Secp256k1SecretKey.toBytes(entropy);
+      this.#seed = entropy;
     }
 
-    if(!this._bytes || this._bytes.length !== 32) {
+    if(!this.#bytes || this.#bytes.length !== 32) {
       throw new SecretKeyError(
         'Invalid bytes: must be a valid 32-byte secret key',
         'CONSTRUCTOR_ERROR'
       );
     }
 
-    if(!this._seed || (this._seed < 1n || this._seed >= CURVE.n)) {
+    if(!this.#seed || (this.#seed < 1n || this.#seed >= CURVE.n)) {
       throw new SecretKeyError(
         'Invalid seed: must must be valid bigint',
         'CONSTRUCTOR_ERROR'
@@ -129,7 +130,7 @@ export class Secp256k1SecretKey implements SecretKey {
     }
 
     // Set the secret key multibase
-    this._multibase = this.encode();
+    this.#multibase = this.encode();
   }
 
   /**
@@ -138,7 +139,7 @@ export class Secp256k1SecretKey implements SecretKey {
    */
   get bytes(): Uint8Array {
     // Return a copy of the secret key bytes
-    const bytes = new Uint8Array(this._bytes!);
+    const bytes = new Uint8Array(this.#bytes!);
     return bytes;
   }
 
@@ -148,7 +149,7 @@ export class Secp256k1SecretKey implements SecretKey {
    */
   get seed(): bigint {
     // Memoize the secret and return
-    const seed = BigInt(this._seed!) as bigint;
+    const seed = BigInt(this.#seed!) as bigint;
     return seed;
   }
 
@@ -167,7 +168,7 @@ export class Secp256k1SecretKey implements SecretKey {
    * @returns {string} The secret key in base58btc multibase format
    */
   get multibase(): string {
-    const multibase = this._multibase;
+    const multibase = this.#multibase;
     return multibase;
   }
 
@@ -269,6 +270,31 @@ export class Secp256k1SecretKey implements SecretKey {
     return true;
   }
 
+  /**
+   * Produce a signature over arbitrary data using schnorr or ecdsa.
+   * @param {MessageBytes} data Data to be signed.
+   * @param {CryptoOptions} opts Options for signing.
+   * @param {('ecdsa' | 'schnorr')} opts.scheme The signature scheme to use. Default is 'schnorr'.
+   * @returns {SignatureBytes} Signature byte array.
+   * @throws {SecretKeyError} if no private key is provided.
+   */
+  public sign(data: Bytes, opts?: CryptoOptions): SignatureBytes {
+    // Set default options if not provided
+    opts ??= { scheme: 'schnorr' };
+
+    // Sign ecdsa and return
+    if(opts.scheme === 'ecdsa') {
+      return tinysecp.sign(data, this.bytes);
+    }
+
+    // Sign schnorr and return
+    if(opts.scheme === 'schnorr') {
+      return tinysecp.signSchnorr(data, this.bytes, randomBytes(32));
+    }
+
+    throw new SecretKeyError(`Invalid scheme: ${opts.scheme}.`, 'SIGN_ERROR', opts);
+  }
+
   /**
    * Decodes the multibase string to the 34-byte secret key (2 byte prefix + 32 byte key).
    * @param {string} multibase The multibase string to decode
@@ -387,7 +413,6 @@ export class Secp256k1SecretKey implements SecretKey {
     return getRandomValues(byteArray);
   }
 
-
   /**
    * Creates a new Secp256k1SecretKey from random secret key bytes.
    * @returns {Secp256k1SecretKey} A new Secp256k1SecretKey object

package/src/types.ts

@@ -1,12 +1,19 @@
-import { KeyBytes } from '@did-btcr2/common';
+import { Hex, KeyBytes } from '@did-btcr2/common';
 import { CompressedSecp256k1PublicKey } from './public.js';
 import { Secp256k1SecretKey } from './secret.js';
 
+export type CryptoOptions = { scheme: 'ecdsa' | 'schnorr' }
+
 export type RawSchnorrKeyPair = {
   public: KeyBytes;
   secret?: KeyBytes
 }
 
+export type HexSchnorrKeyPair = {
+  public: Hex;
+  secret?: Hex
+}
+
 /** Params for the {@link SchnorrKeyPair} constructor */
 export interface SchnorrKeyPairParams {
   secretKey?: Secp256k1SecretKey | KeyBytes;