@bsv/wallet-toolbox 1.7.14 → 1.7.15

package/mobile/node_modules/@bsv/sdk/src/compat/HD.ts

@@ -0,0 +1,386 @@
+// @ts-nocheck
+import {
+  fromBase58Check,
+  toBase58Check,
+  Writer,
+  Reader,
+  toArray,
+  toHex
+} from '../primitives/utils.js'
+import * as Hash from '../primitives/Hash.js'
+import Curve from '../primitives/Curve.js'
+import PrivateKey from '../primitives/PrivateKey.js'
+import PublicKey from '../primitives/PublicKey.js'
+import Random from '../primitives/Random.js'
+import BigNumber from '../primitives/BigNumber.js'
+
+/**
+ * @deprecated
+ * The HD class implements the Bitcoin Improvement Proposal 32 (BIP32) hierarchical deterministic wallets.
+ * It allows the generation of child keys from a master key, ensuring a tree-like structure of keys and addresses.
+ * This class is deprecated due to the introduction of BRC-42, which offers an enhanced key derivation scheme.
+ * BRC-42 uses invoice numbers for key derivation, improving privacy and scalability compared to BIP32.
+ *
+ * @class HD
+ * @deprecated Replaced by BRC-42 which uses invoice numbers and supports private derivation.
+ */
+export default class HD {
+  versionBytesNum: number
+  depth: number
+  parentFingerPrint: number[]
+  childIndex: number
+  chainCode: number[]
+  privKey: PrivateKey
+  pubKey: PublicKey
+  constants = {
+    pubKey: 0x0488b21e,
+    privKey: 0x0488ade4
+  }
+
+  /**
+   * Constructor for the BIP32 HD wallet.
+   * Initializes an HD wallet with optional parameters for version bytes, depth, parent fingerprint, child index, chain code, private key, and public key.
+   * @param versionBytesNum - Version bytes number for the wallet.
+   * @param depth - Depth of the key in the hierarchy.
+   * @param parentFingerPrint - Fingerprint of the parent key.
+   * @param childIndex - Index of the child key.
+   * @param chainCode - Chain code for key derivation.
+   * @param privKey - Private key of the wallet.
+   * @param pubKey - Public key of the wallet.
+   */
+  constructor (
+    versionBytesNum?: number,
+    depth?: number,
+    parentFingerPrint?: number[],
+    childIndex?: number,
+    chainCode?: number[],
+    privKey?: PrivateKey,
+    pubKey?: PublicKey
+  ) {
+    this.versionBytesNum = versionBytesNum
+    this.depth = depth
+    this.parentFingerPrint = parentFingerPrint
+    this.childIndex = childIndex
+    this.chainCode = chainCode
+    this.privKey = privKey
+    this.pubKey = pubKey
+  }
+
+  /**
+   * Generates a new HD wallet with random keys.
+   * This method creates a root HD wallet with randomly generated private and public keys.
+   * @returns {HD} The current HD instance with generated keys.
+   */
+  public fromRandom (): this {
+    this.versionBytesNum = this.constants.privKey
+    this.depth = 0x00
+    this.parentFingerPrint = [0, 0, 0, 0]
+    this.childIndex = 0
+    this.chainCode = Random(32)
+    this.privKey = PrivateKey.fromRandom()
+    this.pubKey = this.privKey.toPublicKey()
+    return this
+  }
+
+  /**
+   * Generates a new HD wallet with random keys.
+   * This method creates a root HD wallet with randomly generated private and public keys.
+   * @returns {HD} A new HD instance with generated keys.
+   * @static
+   */
+  public static fromRandom (): HD {
+    return new this().fromRandom()
+  }
+
+  /**
+   * Initializes the HD wallet from a given base58 encoded string.
+   * This method decodes a provided string to set up the HD wallet's properties.
+   * @param str - A base58 encoded string representing the wallet.
+   * @returns {HD} The new instance with properties set from the string.
+   */
+  public static fromString (str: string): HD {
+    return new this().fromString(str)
+  }
+
+  /**
+   * Initializes the HD wallet from a given base58 encoded string.
+   * This method decodes a provided string to set up the HD wallet's properties.
+   * @param str - A base58 encoded string representing the wallet.
+   * @returns {HD} The current instance with properties set from the string.
+   */
+  public fromString (str: string): this {
+    const decoded = fromBase58Check(str)
+    return this.fromBinary([...decoded.prefix, ...decoded.data] as number[])
+  }
+
+  /**
+   * Initializes the HD wallet from a seed.
+   * This method generates keys and other properties from a given seed, conforming to the BIP32 specification.
+   * @param bytes - An array of bytes representing the seed.
+   * @returns {HD} The current instance with properties set from the seed.
+   */
+  public static fromSeed (bytes: number[]): HD {
+    return new this().fromSeed(bytes)
+  }
+
+  /**
+   * Initializes the HD wallet from a seed.
+   * This method generates keys and other properties from a given seed, conforming to the BIP32 specification.
+   * @param bytes - An array of bytes representing the seed.
+   * @returns {HD} The current instance with properties set from the seed.
+   */
+  public fromSeed (bytes: number[]): this {
+    if (bytes.length < 128 / 8) {
+      throw new Error('Need more than 128 bits of entropy')
+    }
+    if (bytes.length > 512 / 8) {
+      throw new Error('More than 512 bits of entropy is nonstandard')
+    }
+    const hash: number[] = Hash.sha512hmac(
+      toArray('Bitcoin seed', 'utf8'),
+      bytes
+    )
+
+    this.depth = 0x00
+    this.parentFingerPrint = [0, 0, 0, 0]
+    this.childIndex = 0
+    this.chainCode = hash.slice(32, 64)
+    this.versionBytesNum = this.constants.privKey
+    this.privKey = new PrivateKey(hash.slice(0, 32))
+    this.pubKey = this.privKey.toPublicKey()
+
+    return this
+  }
+
+  /**
+   * Initializes the HD wallet from a binary buffer.
+   * Parses a binary buffer to set up the wallet's properties.
+   * @param buf - A buffer containing the wallet data.
+   * @returns {HD} The new instance with properties set from the buffer.
+   */
+  public static fromBinary (buf: number[]): HD {
+    return new this().fromBinary(buf)
+  }
+
+  /**
+   * Initializes the HD wallet from a binary buffer.
+   * Parses a binary buffer to set up the wallet's properties.
+   * @param buf - A buffer containing the wallet data.
+   * @returns {HD} The current instance with properties set from the buffer.
+   */
+  public fromBinary (buf: number[]): this {
+    // Both pub and private extended keys are 78 buf
+    if (buf.length !== 78) {
+      throw new Error('incorrect bip32 data length')
+    }
+    const reader = new Reader(buf)
+
+    this.versionBytesNum = reader.readUInt32BE()
+    this.depth = reader.readUInt8()
+    this.parentFingerPrint = reader.read(4)
+    this.childIndex = reader.readUInt32BE()
+    this.chainCode = reader.read(32)
+    const keyBytes = reader.read(33)
+
+    const isPrivate = this.versionBytesNum === this.constants.privKey
+    const isPublic = this.versionBytesNum === this.constants.pubKey
+
+    if (isPrivate && keyBytes[0] === 0) {
+      this.privKey = new PrivateKey(keyBytes.slice(1, 33))
+      this.pubKey = this.privKey.toPublicKey()
+    } else if (isPublic && (keyBytes[0] === 0x02 || keyBytes[0] === 0x03)) {
+      this.pubKey = PublicKey.fromString(toHex(keyBytes))
+    } else {
+      throw new Error('Invalid key')
+    }
+
+    return this
+  }
+
+  /**
+   * Converts the HD wallet to a base58 encoded string.
+   * This method provides a string representation of the HD wallet's current state.
+   * @returns {string} A base58 encoded string of the HD wallet.
+   */
+  public toString (): string {
+    const bin = this.toBinary()
+    return toBase58Check(bin, [])
+  }
+
+  /**
+   * Derives a child HD wallet based on a given path.
+   * The path specifies the hierarchy of the child key to be derived.
+   * @param path - A string representing the derivation path (e.g., 'm/0'/1).
+   * @returns {HD} A new HD instance representing the derived child wallet.
+   */
+  public derive (path: string): HD {
+    if (path === 'm') {
+      return this
+    }
+
+    const e = path.split('/')
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    let bip32: HD = this
+    for (const [i, c] of e.entries()) {
+      if (i === 0) { // Since `i` is now a number, compare it to 0
+        if (c !== 'm') {
+          throw new Error('invalid path')
+        }
+        continue
+      }
+
+      if (parseInt(c.replace("'", ''), 10).toString() !== c.replace("'", '')) {
+        throw new Error('invalid path')
+      }
+
+      const usePrivate = c.length > 1 && c[c.length - 1] === "'"
+      let childIndex =
+        parseInt(usePrivate ? c.slice(0, c.length - 1) : c, 10) & 0x7fffffff
+
+      if (usePrivate) {
+        childIndex += 0x80000000
+      }
+
+      bip32 = bip32.deriveChild(childIndex)
+    }
+
+    return bip32
+  }
+
+  /**
+   * Derives a child HD wallet from the current wallet based on an index.
+   * This method generates either a private or public child key depending on the current wallet's state.
+   * @param i - The index of the child key to derive.
+   * @returns {HD} A new HD instance representing the derived child wallet.
+   */
+  public deriveChild (i: number): HD {
+    if (typeof i !== 'number') {
+      throw new Error('i must be a number')
+    }
+
+    const ibc: number[] = []
+    ibc.push((i >> 24) & 0xff)
+    ibc.push((i >> 16) & 0xff)
+    ibc.push((i >> 8) & 0xff)
+    ibc.push(i & 0xff)
+    const ib = [...ibc]
+
+    const usePrivate = (i & 0x80000000) !== 0
+
+    const isPrivate = this.versionBytesNum === this.constants.privKey
+
+    if (usePrivate && (this.privKey === null || this.privKey === undefined || !isPrivate)) {
+      throw new Error('Cannot do private key derivation without private key')
+    }
+
+    let ret = null
+    if (this.privKey !== null && this.privKey !== undefined) {
+      let data = null
+
+      if (usePrivate) {
+        data = [0, ...this.privKey.toArray('be', 32), ...ib]
+      } else {
+        data = [...(this.pubKey.encode(true) as number[]), ...ib]
+      }
+
+      const hash = Hash.sha512hmac(this.chainCode, data)
+      const il = new BigNumber(hash.slice(0, 32))
+      const ir = hash.slice(32, 64)
+
+      // ki = IL + kpar (mod n).
+      const k = il.add(this.privKey).mod(new Curve().n)
+
+      ret = new HD()
+      ret.chainCode = ir
+
+      ret.privKey = new PrivateKey(k.toArray())
+      ret.pubKey = ret.privKey.toPublicKey()
+    } else {
+      const data = [...(this.pubKey.encode(true) as number[]), ...ib]
+      const hash = Hash.sha512hmac(this.chainCode, data)
+      const il = new BigNumber(hash.slice(0, 32))
+      const ir = hash.slice(32, 64)
+
+      // Ki = (IL + kpar)*G = IL*G + Kpar
+      const ilG = new Curve().g.mul(il)
+      const Kpar = this.pubKey
+      const Ki = ilG.add(Kpar)
+      const newpub = new PublicKey(Ki.x, Ki.y)
+
+      ret = new HD()
+      ret.chainCode = ir
+
+      ret.pubKey = newpub
+    }
+
+    ret.childIndex = i
+    const pubKeyhash = Hash.hash160(this.pubKey.encode(true))
+    ret.parentFingerPrint = pubKeyhash.slice(0, 4)
+    ret.versionBytesNum = this.versionBytesNum
+    ret.depth = this.depth + 1
+
+    return ret
+  }
+
+  /**
+   * Converts the current HD wallet to a public-only wallet.
+   * This method strips away the private key information, leaving only the public part.
+   * @returns {HD} A new HD instance representing the public-only wallet.
+   */
+  public toPublic (): HD {
+    const bip32 = new HD(
+      this.versionBytesNum,
+      this.depth,
+      this.parentFingerPrint,
+      this.childIndex,
+      this.chainCode,
+      this.privKey,
+      this.pubKey
+    )
+    bip32.versionBytesNum = this.constants.pubKey
+    bip32.privKey = undefined
+    return bip32
+  }
+
+  /**
+   * Converts the HD wallet into a binary representation.
+   * This method serializes the wallet's properties into a binary format.
+   * @returns {number[]} An array of numbers representing the binary data of the wallet.
+   */
+  public toBinary (): number[] {
+    const isPrivate = this.versionBytesNum === this.constants.privKey
+    const isPublic = this.versionBytesNum === this.constants.pubKey
+    if (isPrivate) {
+      return new Writer()
+        .writeUInt32BE(this.versionBytesNum)
+        .writeUInt8(this.depth)
+        .write(this.parentFingerPrint)
+        .writeUInt32BE(this.childIndex)
+        .write(this.chainCode)
+        .writeUInt8(0)
+        .write(this.privKey.toArray('be', 32))
+        .toArray()
+    } else if (isPublic) {
+      return new Writer()
+        .writeUInt32BE(this.versionBytesNum)
+        .writeUInt8(this.depth)
+        .write(this.parentFingerPrint)
+        .writeUInt32BE(this.childIndex)
+        .write(this.chainCode)
+        .write(this.pubKey.encode(true) as number[])
+        .toArray()
+    } else {
+      throw new Error('bip32: invalid versionBytesNum byte')
+    }
+  }
+
+  /**
+   * Checks if the HD wallet contains a private key.
+   * This method determines whether the wallet is a private key wallet or a public key only wallet.
+   * @returns {boolean} A boolean value indicating whether the wallet has a private key (true) or not (false).
+   */
+  public isPrivate (): boolean {
+    return this.versionBytesNum === this.constants.privKey
+  }
+}

package/mobile/node_modules/@bsv/sdk/src/compat/Mnemonic.ts

@@ -0,0 +1,308 @@
+import { wordList } from './bip-39-wordlist-en.js'
+import { encode, toArray, Reader, Writer } from '../primitives/utils.js'
+import * as Hash from '../primitives/Hash.js'
+import Random from '../primitives/Random.js'
+
+/**
+ * @class Mnemonic
+ *
+ * @description
+ * Class representing Mnemonic functionality.
+ * This class provides methods for generating, converting, and validating mnemonic phrases
+ * according to the BIP39 standard. It supports creating mnemonics from random entropy,
+ * converting mnemonics to seeds, and validating mnemonic phrases.
+ */
+export default class Mnemonic {
+  public mnemonic: string
+  public seed: number[]
+  public Wordlist: { value: string[], space: string }
+
+  /**
+   * Constructs a Mnemonic object.
+   * @param {string} [mnemonic] - An optional mnemonic phrase.
+   * @param {number[]} [seed] - An optional seed derived from the mnemonic.
+   * @param {object} [wordlist=wordList] - An object containing a list of words and space character used in the mnemonic.
+   */
+  constructor (mnemonic?: string, seed?: number[], wordlist = wordList) {
+    this.mnemonic = mnemonic ?? '' // Default to empty string if undefined
+    this.seed = seed ?? [] // Default to empty array if undefined
+    this.Wordlist = wordlist
+  }
+
+  /**
+   * Converts the mnemonic and seed into a binary representation.
+   * @returns {number[]} The binary representation of the mnemonic and seed.
+   */
+  public toBinary (): number[] {
+    const bw = new Writer()
+    if (this.mnemonic !== '') {
+      const buf = toArray(this.mnemonic, 'utf8')
+      bw.writeVarIntNum(buf.length)
+      bw.write(buf)
+    } else {
+      bw.writeVarIntNum(0)
+    }
+    if (this.seed.length > 0) {
+      bw.writeVarIntNum(this.seed.length)
+      bw.write(this.seed)
+    } else {
+      bw.writeVarIntNum(0)
+    }
+    return bw.toArray()
+  }
+
+  /**
+   * Loads a mnemonic and seed from a binary representation.
+   * @param {number[]} bin - The binary representation of a mnemonic and seed.
+   * @returns {this} The Mnemonic instance with loaded mnemonic and seed.
+   */
+  public fromBinary (bin: number[]): this {
+    const br = new Reader(bin)
+    const mnemoniclen = br.readVarIntNum()
+    if (mnemoniclen > 0) {
+      this.mnemonic = encode(br.read(mnemoniclen), 'utf8') as string
+    }
+    const seedlen = br.readVarIntNum()
+    if (seedlen > 0) {
+      this.seed = br.read(seedlen)
+    }
+    return this
+  }
+
+  /**
+   * Generates a random mnemonic from a given bit length.
+   * @param {number} [bits=128] - The bit length for the random mnemonic (must be a multiple of 32 and at least 128).
+   * @returns {this} The Mnemonic instance with the new random mnemonic.
+   * @throws {Error} If the bit length is not a multiple of 32 or is less than 128.
+   */
+  public fromRandom (bits?: number): this {
+    if (bits === undefined || bits === null || isNaN(bits) || bits === 0) {
+      bits = 128
+    }
+    if (bits % 32 !== 0) {
+      throw new Error('bits must be multiple of 32')
+    }
+    if (bits < 128) {
+      throw new Error('bits must be at least 128')
+    }
+    const buf = Random(bits / 8)
+    this.entropy2Mnemonic(buf)
+    this.mnemonic2Seed()
+    return this
+  }
+
+  /**
+   * Static method to generate a Mnemonic instance with a random mnemonic.
+   * @param {number} [bits=128] - The bit length for the random mnemonic.
+   * @returns {Mnemonic} A new Mnemonic instance.
+   */
+  public static fromRandom (bits?: number): Mnemonic {
+    return new this().fromRandom(bits)
+  }
+
+  /**
+   * Converts given entropy into a mnemonic phrase.
+   * This method is used to generate a mnemonic from a specific entropy source.
+   * @param {number[]} buf - The entropy buffer, must be at least 128 bits.
+   * @returns {this} The Mnemonic instance with the mnemonic set from the given entropy.
+   * @throws {Error} If the entropy is less than 128 bits.
+   */
+  public fromEntropy (buf: number[]): this {
+    this.entropy2Mnemonic(buf)
+    return this
+  }
+
+  /**
+   * Static method to create a Mnemonic instance from a given entropy.
+   * @param {number[]} buf - The entropy buffer.
+   * @returns {Mnemonic} A new Mnemonic instance.
+   */
+  public static fromEntropy (buf: number[]): Mnemonic {
+    return new this().fromEntropy(buf)
+  }
+
+  /**
+   * Sets the mnemonic for the instance from a string.
+   * @param {string} mnemonic - The mnemonic phrase as a string.
+   * @returns {this} The Mnemonic instance with the set mnemonic.
+   */
+  public fromString (mnemonic: string): this {
+    this.mnemonic = mnemonic
+    return this
+  }
+
+  /**
+   * Static method to create a Mnemonic instance from a mnemonic string.
+   * @param {string} str - The mnemonic phrase.
+   * @returns {Mnemonic} A new Mnemonic instance.
+   */
+  public static fromString (str: string): Mnemonic {
+    return new this().fromString(str)
+  }
+
+  /**
+   * Converts the instance's mnemonic to a string representation.
+   * @returns {string} The mnemonic phrase as a string.
+   */
+  public toString (): string {
+    return this.mnemonic
+  }
+
+  /**
+   * Converts the mnemonic to a seed.
+   * The mnemonic must pass the validity check before conversion.
+   * @param {string} [passphrase=''] - An optional passphrase for additional security.
+   * @returns {number[]} The generated seed.
+   * @throws {Error} If the mnemonic is invalid.
+   */
+  public toSeed (passphrase?: string): number[] {
+    this.mnemonic2Seed(passphrase)
+    return this.seed
+  }
+
+  /**
+   * Converts entropy to a mnemonic phrase.
+   * This method takes a buffer of entropy and converts it into a corresponding
+   * mnemonic phrase based on the Mnemonic wordlist. The entropy should be at least 128 bits.
+   * The method applies a checksum and maps the entropy to words in the wordlist.
+   * @param {number[]} buf - The entropy buffer to convert. Must be at least 128 bits.
+   * @returns {this} The Mnemonic instance with the mnemonic set from the entropy.
+   * @throws {Error} If the entropy is less than 128 bits or if it's not an even multiple of 11 bits.
+   */
+  public entropy2Mnemonic (buf: number[]): this {
+    if (buf.length < 128 / 8) {
+      throw new Error(
+        'Entropy is less than 128 bits. It must be 128 bits or more.'
+      )
+    }
+
+    const hash = Hash.sha256(buf)
+    let bin = ''
+    const bits = buf.length * 8
+    for (let i = 0; i < buf.length; i++) {
+      bin = bin + ('00000000' + buf[i].toString(2)).slice(-8)
+    }
+    let hashbits = hash[0].toString(2)
+    hashbits = ('00000000' + hashbits).slice(-8).slice(0, bits / 32)
+    bin = bin + hashbits
+
+    if (bin.length % 11 !== 0) {
+      throw new Error(
+        'internal error - entropy not an even multiple of 11 bits - ' +
+        bin.length.toString()
+      )
+    }
+
+    let mnemonic = ''
+    for (let i = 0; i < bin.length / 11; i++) {
+      if (mnemonic !== '') {
+        mnemonic = mnemonic + this.Wordlist.space
+      }
+      const wi = parseInt(bin.slice(i * 11, (i + 1) * 11), 2)
+      mnemonic = mnemonic + this.Wordlist.value[wi]
+    }
+
+    this.mnemonic = mnemonic
+    return this
+  }
+
+  /**
+   * Validates the mnemonic phrase.
+   * Checks for correct length, absence of invalid words, and proper checksum.
+   * @returns {boolean} True if the mnemonic is valid, false otherwise.
+   * @throws {Error} If the mnemonic is not an even multiple of 11 bits.
+   */
+  public check (): boolean {
+    const mnemonic = this.mnemonic
+
+    // confirm no invalid words
+    const words = mnemonic.split(this.Wordlist.space)
+    let bin = ''
+    for (let i = 0; i < words.length; i++) {
+      const ind = this.Wordlist.value.indexOf(words[i])
+      if (ind < 0) {
+        return false
+      }
+      bin = bin + ('00000000000' + ind.toString(2)).slice(-11)
+    }
+
+    if (bin.length % 11 !== 0) {
+      throw new Error(
+        'internal error - entropy not an even multiple of 11 bits - ' +
+        bin.length.toString()
+      )
+    }
+
+    // confirm checksum
+    const cs = bin.length / 33
+    const hashBits = bin.slice(-cs)
+    const nonhashBits = bin.slice(0, bin.length - cs)
+    const buf: number[] = []
+
+    for (let i = 0; i < nonhashBits.length / 8; i++) {
+      buf.push(parseInt(bin.slice(i * 8, (i + 1) * 8), 2))
+    }
+    const hash = Hash.sha256(buf.slice(0, nonhashBits.length / 8))
+    let expectedHashBits = hash[0].toString(2)
+    expectedHashBits = ('00000000' + expectedHashBits).slice(-8).slice(0, cs)
+
+    return expectedHashBits === hashBits
+  }
+
+  /**
+   * Converts a mnemonic to a seed.
+   * This method takes the instance's mnemonic phrase, combines it with a passphrase (if provided),
+   * and uses PBKDF2 to generate a seed. It also validates the mnemonic before conversion.
+   * This seed can then be used for generating deterministic keys.
+   * @param {string} [passphrase=''] - An optional passphrase for added security.
+   * @returns {this} The Mnemonic instance with the seed generated from the mnemonic.
+   * @throws {Error} If the mnemonic does not pass validation or if the passphrase is not a string.
+   */
+  public mnemonic2Seed (passphrase = ''): this {
+    let mnemonic = this.mnemonic
+    if (!this.check()) {
+      throw new Error(
+        'Mnemonic does not pass the check - was the mnemonic typed incorrectly? Are there extra spaces?'
+      )
+    }
+    if (typeof passphrase !== 'string') {
+      throw new Error('passphrase must be a string or undefined')
+    }
+    mnemonic = mnemonic.normalize('NFKD')
+    passphrase = passphrase.normalize('NFKD')
+    const mbuf = toArray(mnemonic, 'utf8')
+    const pbuf = [
+      ...toArray('mnemonic', 'utf8'),
+      ...toArray(passphrase, 'utf8')
+    ]
+    this.seed = Hash.pbkdf2(mbuf, pbuf, 2048, 64, 'sha512')
+    return this
+  }
+
+  /**
+   * Determines the validity of a given passphrase with the mnemonic.
+   * This method is useful for checking if a passphrase matches with the mnemonic.
+   * @param {string} [passphrase=''] - The passphrase to validate.
+   * @returns {boolean} True if the mnemonic and passphrase combination is valid, false otherwise.
+   */
+  public isValid (passphrase = ''): boolean {
+    let isValid
+    try {
+      this.mnemonic2Seed(passphrase)
+      isValid = true
+    } catch {
+      isValid = false
+    }
+    return isValid
+  }
+
+  /**
+   * Static method to check the validity of a given mnemonic and passphrase combination.
+   * @param {string} mnemonic - The mnemonic phrase.
+   * @param {string} [passphrase=''] - The passphrase to validate.
+   * @returns {boolean} True if the combination is valid, false otherwise.
+   */
+  public static isValid (mnemonic: string, passphrase = ''): boolean {
+    return new Mnemonic(mnemonic).isValid(passphrase)
+  }
+}