@did-btcr2/keypair 0.5.1

package/dist/types/secret.d.ts

@@ -0,0 +1,174 @@
+import { Bytes, Entropy, Hex, KeyBytes, SecretKeyObject } from '@did-btcr2/common';
+import { SchnorrKeyPair } from './pair.js';
+import { PublicKey } from './public.js';
+/**
+ * Interface for the SecretKey class.
+ * @interface ISecretKey
+ * @type {ISecretKey}
+ */
+export interface ISecretKey {
+    /**
+     * Get the secret key bytes.
+     * @readonly @type {KeyBytes} The secret key bytes.
+     */
+    bytes: KeyBytes;
+    /**
+     * Getter returns the secret key bytes in bigint format.
+     * Setter allows alternative method of using a bigint seed for the entropy.
+     * @type {bigint} The secret key seed.
+     */
+    seed: bigint;
+    /**
+     * Get the secret key as a hex string.
+     * @readonly @type {Hex} The secret key as a hex string.
+     */
+    hex: Hex;
+    /**
+     * Checks if this secret key is equal to another secret key.
+     *
+     * @returns {boolean} True if the private keys are equal.
+     */
+    equals(other: SecretKey): boolean;
+    /**
+     * Uses the secret key to compute the corresponding public key.
+     * @returns {KeyBytes} A new PublicKey object.
+     */
+    computePublicKey(): KeyBytes;
+    /**
+     * Checks if the secret key is valid.
+     * @returns {boolean} Whether the secret key is valid.
+     */
+    isValid(): boolean;
+    /**
+     * JSON representation of a SecretKey object.
+     * @returns {SecretKeyObject} The SecretKey as a JSON object.
+     */
+    json(): SecretKeyObject;
+}
+/**
+ * Encapsulates a secp256k1 secret key
+ * Provides get methods for different formats (raw, secret, point).
+ * Provides helpers methods for comparison, serialization and publicKey generation.
+ * @class SecretKey
+ * @type {SecretKey}
+ *
+ */
+export declare class SecretKey implements ISecretKey {
+    /** @type {KeyBytes} The entropy for the secret key as a byte array */
+    private _bytes?;
+    /** @type {bigint} The entropy for the secret key as a bigint */
+    private _seed?;
+    /** @type {string} The secret key as a secretKeyMultibase */
+    private _multibase;
+    /**
+     * Instantiates an instance of SecretKey.
+     * @param {Entropy} entropy bytes (Uint8Array) or secret (bigint)
+     * @throws {SecretKeyError} If entropy is not provided, not a valid 32-byte secret key or not a valid bigint seed
+     */
+    constructor(entropy: Entropy);
+    /**
+     * Get the secret key entropy as a byte array.
+     * @returns {KeyBytes} The secret key bytes as a Uint8Array
+     */
+    get bytes(): Uint8Array;
+    /**
+     * Get the secret key entropy as a bigint.
+     * @returns {bigint} The secret key as a bigint
+     */
+    get seed(): bigint;
+    /**
+     * Returns the raw secret key as a hex string.
+     * @returns {Hex} The secret key as a hex string
+     */
+    get hex(): Hex;
+    /**
+     * Encode the secret key bytes as a secretKeyMultibase string.
+     * @returns {string} The secret key in base58btc multibase format
+     */
+    get multibase(): string;
+    /**
+     * Encodes the secret key bytes to BIP340 multibase format.
+     * @returns {string} The secret key in BIP340 multibase format.
+     */
+    encode(): string;
+    /**
+     * Checks if this secret key is equal to another.
+     * @param {SecretKey} other The other secret key
+     * @returns {boolean} True if the private keys are equal, false otherwise
+     */
+    equals(other: SecretKey): boolean;
+    /**
+     * Computes the public key from the secret key bytes.
+     * @returns {KeyBytes} The computed public key
+     */
+    computePublicKey(): KeyBytes;
+    /**
+     * Converts the secret key to a JSON object.
+     * @returns {SecretKeyObject} The secret key as a JSON object
+     */
+    json(): SecretKeyObject;
+    /**
+     * Checks if the secret key is valid.
+     * @returns {boolean} True if the secret key is valid, false otherwise
+     */
+    isValid(): boolean;
+    /**
+     * Checks if the public key is a valid secp256k1 point.
+     * @param {PublicKey} pk The public key to validate
+     * @returns {boolean} True if the public key is valid, false otherwise
+     */
+    isValidPair(pk: PublicKey): boolean;
+    /**
+     * Decodes the multibase string to the 34-byte secret key (2 byte prefix + 32 byte key).
+     * @param {string} multibase The multibase string to decode
+     * @returns {Bytes} The decoded secret key.
+     */
+    static decode(multibase: string): Bytes;
+    /**
+     * Creates a SecretKey object from a JSON object.
+     * @param {SecretKeyObject} json The JSON object containing the secret key bytes
+     * @returns {SecretKey} A new SecretKey object
+     */
+    static fromJSON(json: SecretKeyObject): SecretKey;
+    /**
+     * Converts a SecretKey or KeyBytes to a Pair.
+     * @param {KeyBytes} bytes
+     * @returns {SchnorrKeyPair} The SchnorrKeyPair object containing the public and private keys
+     * @throws {SecretKeyError} If the secret key is not valid
+     */
+    static toKeyPair(bytes: KeyBytes): SchnorrKeyPair;
+    /**
+     * Convert a bigint secret to secret key bytes.
+     * @param {KeyBytes} bytes The secret key bytes
+     * @returns {bigint} The secret key bytes as a bigint secret
+     */
+    static toSecret(bytes: KeyBytes): bigint;
+    /**
+     * Convert a secret key bytes to a bigint secret.
+     * @param {bigint} secret The secret key secret.
+     * @returns {KeyBytes} The secret key secret as secret key bytes.
+     */
+    static toBytes(secret: bigint): KeyBytes;
+    /**
+     * Creates a new SecretKey object from a bigint secret.
+     * @param {bigint} secret The secret bigint
+     * @returns {SecretKey} A new SecretKey object
+     */
+    static fromSecret(secret: bigint): SecretKey;
+    /**
+     * Generates random secret key bytes.
+     * @returns {KeyBytes} Uint8Array of 32 random bytes.
+     */
+    static random(): KeyBytes;
+    /**
+     * Creates a new SecretKey from random secret key bytes.
+     * @returns {SecretKey} A new SecretKey object
+     */
+    static generate(): SecretKey;
+    /**
+     * Generates a public key from the given secret key bytes.
+     * @param {KeyBytes} bytes The secret key bytes
+     * @returns {KeyBytes} The computed public key bytes
+     */
+    static getPublicKey(bytes: KeyBytes): KeyBytes;
+}

package/dist/types/secret.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret.d.ts","sourceRoot":"","sources":["../../src/secret.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,EAEL,OAAO,EACP,GAAG,EACH,QAAQ,EAER,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,KAAK,EAAE,QAAQ,CAAC;IAEhB;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;OAGG;IACH,GAAG,EAAE,GAAG,CAAC;IAET;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC;IAElC;;;OAGG;IACH,gBAAgB,IAAI,QAAQ,CAAC;IAE7B;;;OAGG;IACH,OAAO,IAAI,OAAO,CAAC;IAGnB;;;OAGG;IACH,IAAI,IAAI,eAAe,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,qBAAa,SAAU,YAAW,UAAU;IAC1C,sEAAsE;IACtE,OAAO,CAAC,MAAM,CAAC,CAAW;IAE1B,gEAAgE;IAChE,OAAO,CAAC,KAAK,CAAC,CAAS;IAEvB,4DAA4D;IAC5D,OAAO,CAAC,UAAU,CAAS;IAE3B;;;;OAIG;gBACS,OAAO,EAAE,OAAO;IAyC5B;;;OAGG;IACH,IAAI,KAAK,IAAI,UAAU,CAItB;IAED;;;OAGG;IACH,IAAI,IAAI,IAAI,MAAM,CAIjB;IAED;;;OAGG;IACH,IAAI,GAAG,IAAI,GAAG,CAGb;IAGD;;;OAGG;IACH,IAAI,SAAS,IAAI,MAAM,CAGtB;IAED;;;OAGG;IACI,MAAM,IAAI,MAAM;IAoBvB;;;;OAIG;IACI,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO;IAKxC;;;OAGG;IACI,gBAAgB,IAAI,QAAQ;IAuBnC;;;OAGG;IACI,IAAI,IAAI,eAAe;IAQ9B;;;OAGG;IACI,OAAO,IAAI,OAAO;IAIzB;;;;OAIG;IACI,WAAW,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO;IAU1C;;;;OAIG;WACW,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK;IA8B9C;;;;OAIG;WACW,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,SAAS;IAIxD;;;;;OAKG;WACW,SAAS,CAAC,KAAK,EAAE,QAAQ,GAAG,cAAc;IAWxD;;;;OAIG;WACW,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM;IAI/C;;;;OAIG;WACW,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ;IAiB/C;;;;OAIG;WACW,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS;IASnD;;;OAGG;WACW,MAAM,IAAI,QAAQ;IAShC;;;OAGG;WACW,QAAQ,IAAI,SAAS;IAQnC;;;;OAIG;WACW,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ;CAItD"}

package/package.json

@@ -0,0 +1,120 @@
+{
+  "name": "@did-btcr2/keypair",
+  "version": "0.5.1",
+  "type": "module",
+  "description": "JavaScript/TypeScript implementation of secp256k1 public/private key pairs with BIP340 schnorr signatures. Used by various parts of the did-btcr2-js monorepo.",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "license": "MPL-2.0",
+  "contributors": [
+    {
+      "name": "dcdpr",
+      "url": "https://github.com/dcdpr"
+    },
+    {
+      "name": "jintekc",
+      "url": "https://github.com/jintekc",
+      "email": "github@jintek.consulting"
+    }
+  ],
+  "homepage": "https://github.com/dcdpr/did-btcr2-js/tree/main/packages/keypair",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com:dcdpr/did-btcr2-js.git",
+    "directory": "packages/keypair"
+  },
+  "bugs": "https://github.com/dcdpr/did-btcr2-js/issues",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "keywords": [
+    "did",
+    "dids",
+    "decentralized identity",
+    "decentralized identifiers",
+    "did method",
+    "did:btcr2",
+    "bitcoin",
+    "schnorr",
+    "schnorr signatures",
+    "secp256k1",
+    "secp256k1 key pair",
+    "cryptosuite",
+    "bip340",
+    "bip340 key pair"
+  ],
+  "dependencies": {
+    "@noble/hashes": "^1.7.1",
+    "multiformats": "^13.3.2",
+    "tiny-secp256k1": "^2.2.3",
+    "@did-btcr2/common": "2.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.20.0",
+    "@types/chai": "^5.0.1",
+    "@types/chai-as-promised": "^8.0.1",
+    "@types/eslint": "^9.6.1",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.13.4",
+    "@typescript-eslint/eslint-plugin": "^8.24.1",
+    "@typescript-eslint/parser": "^8.24.1",
+    "c8": "^10.1.3",
+    "chai": "^5.2.0",
+    "chai-as-promised": "^8.0.1",
+    "esbuild": "^0.25.0",
+    "eslint": "^9.20.1",
+    "eslint-plugin-mocha": "^10.5.0",
+    "globals": "^15.15.0",
+    "mocha": "^11.1.0",
+    "mocha-junit-reporter": "^2.2.1",
+    "node-stdlib-browser": "^1.3.1",
+    "rimraf": "^6.0.1",
+    "typedoc-plugin-markdown": "^4.7.0",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.24.1"
+  },
+  "scripts": {
+    "clean": "rimraf dist coverage tests/compiled",
+    "clean:build": "rimraf dist",
+    "clean:coverage": "rimraf coverage",
+    "clean:tests": "rimraf tests/compiled",
+    "clean:test-coverage": "pnpm clean:tests && pnpm clean:coverage",
+    "wipe": "rimraf node_modules pnpm-lock.json",
+    "wipe:clean": "pnpm wipe && pnpm clean",
+    "wipe:install": "pnpm wipe && pnpm install",
+    "clean:install": "pnpm clean && pnpm install",
+    "wipe:clean:install": "pnpm wipe:clean && pnpm install",
+    "reinstall": "pnpm install --force",
+    "build": "pnpm clean && pnpm build:esm && pnpm build:cjs",
+    "build:esm": "rimraf dist/esm dist/types && pnpm tsc -p tsconfig.json",
+    "build:cjs": "rimraf dist/cjs && tsc -p tsconfig.cjs.json && echo '{\"type\": \"commonjs\"}' > ./dist/cjs/package.json",
+    "build:tests": "pnpm tsc -p tests/tsconfig.json",
+    "build:docs": "typedoc --options typedoc.json",
+    "build:all": "pnpm build && pnpm build:tests && pnpm build:docs",
+    "release": "pnpm build && pnpm pack && mv *.tgz ../../release/key-pair",
+    "lint": "eslint . --max-warnings 0",
+    "lint:fix": "eslint . --fix",
+    "test": "pnpm c8 mocha",
+    "build:test": "pnpm build && pnpm build:tests && pnpm c8 mocha",
+    "build:lint:test": "pnpm build && pnpm build:tests && pnpm lint:fix",
+    "prepublish": "pnpm build",
+    "version": "pnpm version",
+    "version:no-git": "pnpm version --no-commit-hooks --no-git-tag-version",
+    "version:new": "[ -z \"$NEW_VERSION\" ] && echo 'ERROR: NEW_VERSION is not set' && exit 1 || (git checkout -b $NEW_VERSION && git tag $NEW_VERSION && pnpm version:no-git $NEW_VERSION)"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './pair.js';
+export * from './secret.js';
+export * from './public.js';

package/src/pair.ts

@@ -0,0 +1,274 @@
+import {
+  Hex,
+  KeyBytes,
+  KeyPairError,
+  SchnorrKeyPairObject
+} from '@did-btcr2/common';
+import { PublicKey } from './public.js';
+import { SecretKey } from './secret.js';
+
+/**
+ * Interface for KeyPair class.
+ * @interface KeyPair
+ * @type {KeyPair}
+ */
+export interface KeyPair {
+  /**
+   * @type {PublicKey} The PublicKey associated with the SchnorrKeyPair (required).
+   */
+  readonly publicKey: PublicKey;
+
+  /**
+   * @type {SecretKey} The SecretKey associated with the SchnorrKeyPair (optional).
+   * @throws {KeyPairError} If the secret key is not available.
+   */
+  readonly secretKey?: SecretKey;
+
+  /**
+   * JSON representation of the SchnorrKeyPair object.
+   * @returns {SchnorrKeyPairObject} The SchnorrKeyPair as a JSON object.
+   */
+  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.
+ * @class SchnorrKeyPair
+ * @type {SchnorrKeyPair}
+ */
+export class SchnorrKeyPair implements KeyPair {
+  /** @type {SecretKey} The secret key object */
+  private _secretKey?: SecretKey;
+
+  /** @type {PublicKey} The public key object */;
+  private _publicKey: PublicKey;
+
+  /** @type {string} The public key in multibase format */
+  private _publicKeyMultibase: string;
+
+  /** @type {string} The secret key in multibase format */
+  private _secretKeyMultibase: string;
+
+  /**
+   * 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
+   */
+  constructor({ secretKey, publicKey }: KeyParams = {}) {
+    // If no secret key or public key, throw an error
+    if (!publicKey && !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 public key
+    if(publicKey instanceof PublicKey) {
+      this._publicKey = publicKey;
+    } else if (publicKey instanceof Uint8Array) {
+      this._publicKey = new PublicKey(publicKey);
+    } else {
+      this._publicKey = new PublicKey(this._secretKey!.computePublicKey());
+    }
+
+    this._publicKeyMultibase = this._publicKey.multibase.address;
+    this._secretKeyMultibase = this._secretKey ? this._secretKey.multibase : '';
+  }
+
+  /**
+   * Get the SecretKey.
+   * @returns {SecretKey} The SecretKey object
+   * @throws {KeyPairError} If the secret key is not available
+   */
+  get secretKey(): SecretKey {
+    // If the secret key is not available, throw an error
+    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()) {
+      throw new KeyPairError('Secret key is not valid', 'SECRET_KEY_ERROR');
+    }
+    // Return a copy of the secret key
+    const secretKey = this._secretKey;
+    return secretKey;
+  }
+
+  /**
+   * Set the PublicKey.
+   * @param {PublicKey} publicKey The PublicKey object
+   * @throws {KeyPairError} If the public key is not a valid pair with the secret key.
+   */
+  set publicKey(publicKey: PublicKey) {
+    // 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');
+    }
+    this._publicKey = publicKey;
+    this._publicKeyMultibase = publicKey.multibase.address;
+    this._secretKeyMultibase = this._secretKey ? this._secretKey.multibase : '';
+  }
+
+  /**
+   * Get the PublicKey.
+   * @returns {PublicKey} The PublicKey object
+   */
+  get publicKey(): PublicKey {
+    const publicKey = this._publicKey;
+    return publicKey;
+  }
+
+  /**
+   * Get the Keys as a raw key pair.
+   * @returns {RawKeyPair} The Keys as a raw key pair
+   */
+  get raw(): RawKeyPair {
+    return {
+      public : this.publicKey.x,
+      secret : this.secretKey ? this.secretKey.bytes : undefined
+    };
+  }
+
+  /**
+   * Get the Keys in multibase format.
+   * @returns {MultibaseKeys} The SecretKey in multibase format
+   */
+  get multibase(): MultibaseKeys {
+    return {
+      publicKeyMultibase  : this._publicKeyMultibase,
+      secretKeyMultibase : this._secretKeyMultibase,
+    };
+  }
+
+  /**
+   * JSON representation of a Keys.
+   * @returns {SchnorrKeyPairObject} The Keys as a JSON object
+   */
+  public json(): SchnorrKeyPairObject {
+    return {
+      secretKey : this.secretKey.json(),
+      publicKey : this.publicKey.json()
+    };
+  }
+
+  /**
+   * Static method creates a new Keys from a JSON object.
+   * @param {SchnorrKeyPairObject} keys The JSON object to initialize the Keys.
+   * @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 });
+  }
+
+  /**
+   * Static method creates a new SchnorrKeyPair from a SecretKey object or secret key bytes.
+   * @param {SecretKey | KeyBytes} data The secret key bytes
+   * @returns {SchnorrKeyPair} A new SchnorrKeyPair object
+   */
+  public static fromPrivateKey(data: SecretKey | 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;
+
+    // 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();
+
+    // Return a new Keys object
+    return new SchnorrKeyPair({ secretKey, publicKey });
+  }
+
+  /**
+   * Static method creates a new Keys (SecretKey/PublicKey) bigint secret.
+   * @param {bigint} secret The secret key secret
+   * @returns {Keys} A new Keys object
+   */
+  public static fromSecret(secret: bigint): SchnorrKeyPair {
+    const secretKey = SecretKey.fromSecret(secret);
+    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).
+   * @returns {Hex} The key bytes as a hex string.
+   */
+  public static toHex(keyBytes: KeyBytes): Hex {
+    return Buffer.from(keyBytes).toString('hex');
+  }
+
+  /**
+   * Compares two Keys objects for equality.
+   * @param {SchnorrKeyPair} keys The main keys.
+   * @param {SchnorrKeyPair} otherKeys 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 {
+    // Deconstruct the public keys from the key pairs
+    const pk = keys.publicKey;
+    const otherPk = otherKeys.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;
+    if(sk && otherSk) {
+      // Get the public key hex strings for both key pair publicKeys
+      return sk.hex === otherSk.hex;
+    }
+
+    throw new KeyPairError('Cannot compare invalid key pair(s)', 'KEYPAIR_EQUALS_ERROR');
+  }
+
+  /**
+   * Static method to generate a new random SchnorrKeyPair instance.
+   * @returns {SchnorrKeyPair} A new SecretKey object.
+   */
+  public static generate(): SchnorrKeyPair {
+    // Generate random secret key bytes
+    const skBytes = SecretKey.random();
+
+    // Construct a new SecretKey object
+    const secretKey = new SecretKey(skBytes);
+
+    // Compute the public key from the secret key
+    const publicKey = secretKey.computePublicKey();
+
+    // Return a new Keys object
+    return new SchnorrKeyPair({ secretKey, publicKey });
+  }
+}