@pezkuwi/util-crypto 14.0.7 → 14.0.10

package/build-deno/hmac/shaAsU8a.ts

@@ -0,0 +1,46 @@
+
+import { hmac } from 'https://esm.sh/@noble/hashes@1.3.3/hmac.js';
+import { sha256 } from 'https://esm.sh/@noble/hashes@1.3.3/sha256.js';
+import { sha512 } from 'https://esm.sh/@noble/hashes@1.3.3/sha512.js';
+
+import { hasBigInt, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import { hmacSha256, hmacSha512, isReady } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
+
+const JS_HASH = {
+  256: sha256,
+  512: sha512
+};
+
+const WA_MHAC = {
+  256: hmacSha256,
+  512: hmacSha512
+};
+
+function createSha (bitLength: 256 | 512): (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean) => Uint8Array {
+  return (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean): Uint8Array =>
+    hmacShaAsU8a(key, data, bitLength, onlyJs);
+}
+
+/**
+ * @name hmacShaAsU8a
+ * @description creates a Hmac Sha (256/512) Uint8Array from the key & data
+ */
+export function hmacShaAsU8a (key: Uint8Array | string, data: Uint8Array, bitLength: 256 | 512 = 256, onlyJs?: boolean): Uint8Array {
+  const u8aKey = u8aToU8a(key);
+
+  return !hasBigInt || (!onlyJs && isReady())
+    ? WA_MHAC[bitLength](u8aKey, data)
+    : hmac(JS_HASH[bitLength], u8aKey, data);
+}
+
+/**
+ * @name hmacSha256AsU8a
+ * @description creates a Hmac Sha256 Uint8Array from the key & data
+ */
+export const hmacSha256AsU8a = /*#__PURE__*/ createSha(256);
+
+/**
+ * @name hmacSha512AsU8a
+ * @description creates a Hmac Sha512 Uint8Array from the key & data
+ */
+export const hmacSha512AsU8a = /*#__PURE__*/ createSha(512);

package/build-deno/index.ts

@@ -0,0 +1,4 @@
+
+import './packageDetect.ts';
+
+export * from './bundle.ts';

package/build-deno/json/constants.ts

@@ -0,0 +1,9 @@
+
+import type { EncryptedJsonEncoding, EncryptedJsonVersion } from './types.ts';
+
+export const ENCODING: EncryptedJsonEncoding[] = ['scrypt', 'xsalsa20-poly1305'];
+export const ENCODING_NONE: EncryptedJsonEncoding[] = ['none'];
+export const ENCODING_VERSION: EncryptedJsonVersion = '3';
+
+export const NONCE_LENGTH = 24;
+export const SCRYPT_LENGTH = 32 + (3 * 4);

package/build-deno/json/decrypt.ts

@@ -0,0 +1,23 @@
+
+import type { EncryptedJson } from './types.ts';
+
+import { hexToU8a, isHex } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { base64Decode } from '../base64/index.ts';
+import { jsonDecryptData } from './decryptData.ts';
+
+export function jsonDecrypt ({ encoded, encoding }: EncryptedJson, passphrase?: string | null): Uint8Array {
+  if (!encoded) {
+    throw new Error('No encrypted data available to decode');
+  }
+
+  return jsonDecryptData(
+    isHex(encoded)
+      ? hexToU8a(encoded)
+      : base64Decode(encoded),
+    passphrase,
+    Array.isArray(encoding.type)
+      ? encoding.type
+      : [encoding.type]
+  );
+}

package/build-deno/json/decryptData.ts

@@ -0,0 +1,43 @@
+
+import type { EncryptedJsonEncoding } from './types.ts';
+
+import { stringToU8a, u8aFixLength } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { naclDecrypt } from '../nacl/index.ts';
+import { scryptEncode, scryptFromU8a } from '../scrypt/index.ts';
+import { ENCODING, NONCE_LENGTH, SCRYPT_LENGTH } from './constants.ts';
+
+export function jsonDecryptData (encrypted?: Uint8Array | null, passphrase?: string | null, encType: EncryptedJsonEncoding[] = ENCODING): Uint8Array {
+  if (!encrypted) {
+    throw new Error('No encrypted data available to decode');
+  } else if (encType.includes('xsalsa20-poly1305') && !passphrase) {
+    throw new Error('Password required to decode encrypted data');
+  }
+
+  let encoded: Uint8Array | null = encrypted;
+
+  if (passphrase) {
+    let password: Uint8Array;
+
+    if (encType.includes('scrypt')) {
+      const { params, salt } = scryptFromU8a(encrypted);
+
+      password = scryptEncode(passphrase, salt, params).password;
+      encrypted = encrypted.subarray(SCRYPT_LENGTH);
+    } else {
+      password = stringToU8a(passphrase);
+    }
+
+    encoded = naclDecrypt(
+      encrypted.subarray(NONCE_LENGTH),
+      encrypted.subarray(0, NONCE_LENGTH),
+      u8aFixLength(password, 256, true)
+    );
+  }
+
+  if (!encoded) {
+    throw new Error('Unable to decode using the supplied passphrase');
+  }
+
+  return encoded;
+}

package/build-deno/json/encrypt.ts

@@ -0,0 +1,23 @@
+
+import type { EncryptedJson } from './types.ts';
+
+import { u8aConcat } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { naclEncrypt } from '../nacl/index.ts';
+import { scryptEncode, scryptToU8a } from '../scrypt/index.ts';
+import { jsonEncryptFormat } from './encryptFormat.ts';
+
+export function jsonEncrypt (data: Uint8Array, contentType: string[], passphrase?: string | null): EncryptedJson {
+  let isEncrypted = false;
+  let encoded = data;
+
+  if (passphrase) {
+    const { params, password, salt } = scryptEncode(passphrase);
+    const { encrypted, nonce } = naclEncrypt(encoded, password.subarray(0, 32));
+
+    isEncrypted = true;
+    encoded = u8aConcat(scryptToU8a(salt, params), nonce, encrypted);
+  }
+
+  return jsonEncryptFormat(encoded, contentType, isEncrypted);
+}

package/build-deno/json/encryptFormat.ts

@@ -0,0 +1,18 @@
+
+import type { EncryptedJson } from './types.ts';
+
+import { base64Encode } from '../base64/index.ts';
+import { ENCODING, ENCODING_NONE, ENCODING_VERSION } from './constants.ts';
+
+export function jsonEncryptFormat (encoded: Uint8Array, contentType: string[], isEncrypted: boolean): EncryptedJson {
+  return {
+    encoded: base64Encode(encoded),
+    encoding: {
+      content: contentType,
+      type: isEncrypted
+        ? ENCODING
+        : ENCODING_NONE,
+      version: ENCODING_VERSION
+    }
+  };
+}

package/build-deno/json/index.ts

@@ -0,0 +1,5 @@
+
+export { jsonDecrypt } from './decrypt.ts';
+export { jsonDecryptData } from './decryptData.ts';
+export { jsonEncrypt } from './encrypt.ts';
+export { jsonEncryptFormat } from './encryptFormat.ts';

package/build-deno/json/types.ts

@@ -0,0 +1,20 @@
+
+export type EncryptedJsonVersion = '0' | '1' | '2' | '3';
+
+export type EncryptedJsonEncoding = 'none' | 'scrypt' | 'xsalsa20-poly1305';
+
+export interface EncryptedJsonDescriptor {
+  /** Descriptor for the content */
+  content: string[];
+  /** The encoding (in current/latest versions this is always an array) */
+  type: EncryptedJsonEncoding | EncryptedJsonEncoding[];
+  /** The version of encoding applied */
+  version: EncryptedJsonVersion;
+}
+
+export interface EncryptedJson {
+  /** The encoded string */
+  encoded: string;
+  /** The encoding used */
+  encoding: EncryptedJsonDescriptor;
+}

package/build-deno/keccak/asU8a.ts

@@ -0,0 +1,45 @@
+import { Buffer } from 'node:buffer';
+
+
+import { keccak_256 as keccak256Js, keccak_512 as keccak512Js } from 'https://esm.sh/@noble/hashes@1.3.3/sha3.js';
+
+import { keccak256, keccak512 } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
+
+import { createAsHex, createBitHasher, createDualHasher } from '../helpers.ts';
+
+/**
+ * @name keccakAsU8a
+ * @summary Creates a keccak Uint8Array from the input.
+ * @description
+ * From either a `string` or a `Buffer` input, create the keccak and return the result as a `Uint8Array`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { keccakAsU8a } from 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
+ *
+ * keccakAsU8a('123'); // => Uint8Array
+ * ```
+ */
+export const keccakAsU8a = /*#__PURE__*/ createDualHasher(
+  { 256: keccak256, 512: keccak512 },
+  { 256: keccak256Js, 512: keccak512Js }
+);
+
+/**
+ * @name keccak256AsU8a
+ * @description Creates a keccak256 Uint8Array from the input.
+ */
+export const keccak256AsU8a = /*#__PURE__*/ createBitHasher(256, keccakAsU8a);
+
+/**
+ * @name keccak512AsU8a
+ * @description Creates a keccak512 Uint8Array from the input.
+ */
+export const keccak512AsU8a = /*#__PURE__*/ createBitHasher(512, keccakAsU8a);
+
+/**
+ * @name keccakAsHex
+ * @description Creates a keccak hex string from the input.
+ */
+export const keccakAsHex = /*#__PURE__*/ createAsHex(keccakAsU8a);

package/build-deno/keccak/index.ts

@@ -0,0 +1,6 @@
+
+/**
+ * @summary Create Keccak256/512 values as hex & Uint8Array output
+ */
+
+export { keccak256AsU8a, keccak512AsU8a, keccakAsHex, keccakAsU8a } from './asU8a.ts';

package/build-deno/key/DeriveJunction.ts

@@ -0,0 +1,77 @@
+
+import { BN, bnToU8a, compactAddLength, hexToU8a, isBigInt, isBn, isHex, isNumber, isString, stringToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { blake2AsU8a } from '../blake2/asU8a.ts';
+import { BN_LE_256_OPTS } from '../bn.ts';
+
+const RE_NUMBER = /^\d+$/;
+
+const JUNCTION_ID_LEN = 32;
+
+export class DeriveJunction {
+  readonly #chainCode: Uint8Array = new Uint8Array(32);
+
+  #isHard = false;
+
+  public static from (value: string): DeriveJunction {
+    const result = new DeriveJunction();
+    const [code, isHard] = value.startsWith('/')
+      ? [value.substring(1), true]
+      : [value, false];
+
+    result.soft(
+      RE_NUMBER.test(code)
+        ? new BN(code, 10)
+        : code
+    );
+
+    return isHard
+      ? result.harden()
+      : result;
+  }
+
+  public get chainCode (): Uint8Array {
+    return this.#chainCode;
+  }
+
+  public get isHard (): boolean {
+    return this.#isHard;
+  }
+
+  public get isSoft (): boolean {
+    return !this.#isHard;
+  }
+
+  public hard (value: number | string | bigint | BN | Uint8Array): DeriveJunction {
+    return this.soft(value).harden();
+  }
+
+  public harden (): DeriveJunction {
+    this.#isHard = true;
+
+    return this;
+  }
+
+  public soft (value: number | string | bigint | BN | Uint8Array): DeriveJunction {
+    if (isNumber(value) || isBn(value) || isBigInt(value)) {
+      return this.soft(bnToU8a(value, BN_LE_256_OPTS));
+    } else if (isHex(value)) {
+      return this.soft(hexToU8a(value));
+    } else if (isString(value)) {
+      return this.soft(compactAddLength(stringToU8a(value)));
+    } else if (value.length > JUNCTION_ID_LEN) {
+      return this.soft(blake2AsU8a(value));
+    }
+
+    this.#chainCode.fill(0);
+    this.#chainCode.set(value, 0);
+
+    return this;
+  }
+
+  public soften (): DeriveJunction {
+    this.#isHard = false;
+
+    return this;
+  }
+}

package/build-deno/key/extractPath.ts

@@ -0,0 +1,35 @@
+
+import { DeriveJunction } from './DeriveJunction.ts';
+
+const RE_JUNCTION = /\/(\/?)([^/]+)/g;
+
+export interface ExtractResult {
+  parts: string[] | null;
+  path: DeriveJunction[];
+}
+
+/**
+ * @description Extract derivation junctions from the supplied path
+ */
+export function keyExtractPath (derivePath: string): ExtractResult {
+  const parts = derivePath.match(RE_JUNCTION);
+  const path: DeriveJunction[] = [];
+  let constructed = '';
+
+  if (parts) {
+    constructed = parts.join('');
+
+    for (const p of parts) {
+      path.push(DeriveJunction.from(p.substring(1)));
+    }
+  }
+
+  if (constructed !== derivePath) {
+    throw new Error(`Re-constructed path "${constructed}" does not match input`);
+  }
+
+  return {
+    parts,
+    path
+  };
+}

package/build-deno/key/extractSuri.ts

@@ -0,0 +1,38 @@
+
+import type { DeriveJunction } from './DeriveJunction.ts';
+
+import { keyExtractPath } from './extractPath.ts';
+
+export interface ExtractResult {
+  derivePath: string,
+  password?: string;
+  path: DeriveJunction[];
+  phrase: string;
+}
+
+const RE_CAPTURE = /^((0x[a-fA-F0-9]+|[\p{L}\d]+(?: [\p{L}\d]+)*))((\/\/?[^/]+)*)(\/\/\/(.*))?$/u;
+
+/**
+ * @description Extracts the phrase, path and password from a SURI format for specifying secret keys `<secret>/<soft-key>//<hard-key>///<password>` (the `///password` may be omitted, and `/<soft-key>` and `//<hard-key>` maybe repeated and mixed).
+ */
+export function keyExtractSuri (suri: string): ExtractResult {
+  // Normalize Unicode to NFC to avoid accent-related mismatches
+  const normalizedSuri = suri.normalize('NFC');
+
+  // eslint-disable-next-line @typescript-eslint/prefer-regexp-exec
+  const matches = normalizedSuri.match(RE_CAPTURE);
+
+  if (matches === null) {
+    throw new Error('Unable to match provided value to a secret URI');
+  }
+
+  const [, phrase, , derivePath, , , password] = matches;
+  const { path } = keyExtractPath(derivePath);
+
+  return {
+    derivePath,
+    password,
+    path,
+    phrase
+  };
+}

package/build-deno/key/fromPath.ts

@@ -0,0 +1,26 @@
+
+import type { Keypair, KeypairType } from '../types.ts';
+import type { DeriveJunction } from './DeriveJunction.ts';
+
+import { keyHdkdEcdsa } from './hdkdEcdsa.ts';
+import { keyHdkdEd25519 } from './hdkdEd25519.ts';
+import { keyHdkdSr25519 } from './hdkdSr25519.ts';
+
+const generators = {
+  ecdsa: keyHdkdEcdsa,
+  ed25519: keyHdkdEd25519,
+  // FIXME This is Substrate-compatible, not Ethereum-compatible
+  ethereum: keyHdkdEcdsa,
+  sr25519: keyHdkdSr25519
+};
+
+export function keyFromPath (pair: Keypair, path: DeriveJunction[], type: KeypairType): Keypair {
+  const keyHdkd = generators[type];
+  let result = pair;
+
+  for (const junction of path) {
+    result = keyHdkd(result, junction);
+  }
+
+  return result;
+}

package/build-deno/key/hdkdDerive.ts

@@ -0,0 +1,15 @@
+
+import type { Keypair } from '../types.ts';
+import type { DeriveJunction } from './DeriveJunction.ts';
+
+export function createSeedDeriveFn (fromSeed: (seed: Uint8Array) => Keypair, derive: (seed: Uint8Array, chainCode: Uint8Array) => Uint8Array): (keypair: Keypair, junction: DeriveJunction) => Keypair {
+  return (keypair: Keypair, { chainCode, isHard }: DeriveJunction): Keypair => {
+    if (!isHard) {
+      throw new Error('A soft key was found in the path and is not supported');
+    }
+
+    return fromSeed(
+      derive(keypair.secretKey.subarray(0, 32), chainCode)
+    );
+  };
+}

package/build-deno/key/hdkdEcdsa.ts

@@ -0,0 +1,6 @@
+
+import { secp256k1DeriveHard } from '../secp256k1/deriveHard.ts';
+import { secp256k1PairFromSeed } from '../secp256k1/pair/fromSeed.ts';
+import { createSeedDeriveFn } from './hdkdDerive.ts';
+
+export const keyHdkdEcdsa = /*#__PURE__*/ createSeedDeriveFn(secp256k1PairFromSeed, secp256k1DeriveHard);

package/build-deno/key/hdkdEd25519.ts

@@ -0,0 +1,5 @@
+
+import { ed25519DeriveHard, ed25519PairFromSeed } from '../ed25519/index.ts';
+import { createSeedDeriveFn } from './hdkdDerive.ts';
+
+export const keyHdkdEd25519 = /*#__PURE__*/ createSeedDeriveFn(ed25519PairFromSeed, ed25519DeriveHard);

package/build-deno/key/hdkdSr25519.ts

@@ -0,0 +1,12 @@
+
+import type { Keypair } from '../types.ts';
+import type { DeriveJunction } from './DeriveJunction.ts';
+
+import { sr25519DeriveHard } from '../sr25519/deriveHard.ts';
+import { sr25519DeriveSoft } from '../sr25519/deriveSoft.ts';
+
+export function keyHdkdSr25519 (keypair: Keypair, { chainCode, isSoft }: DeriveJunction): Keypair {
+  return isSoft
+    ? sr25519DeriveSoft(keypair, chainCode)
+    : sr25519DeriveHard(keypair, chainCode);
+}

package/build-deno/key/index.ts

@@ -0,0 +1,10 @@
+
+/**
+ * @summary Create keys from paths, seeds and password
+ */
+export { keyExtractPath } from './extractPath.ts';
+export { keyExtractSuri } from './extractSuri.ts';
+export { keyFromPath } from './fromPath.ts';
+export { keyHdkdEcdsa } from './hdkdEcdsa.ts';
+export { keyHdkdEd25519 } from './hdkdEd25519.ts';
+export { keyHdkdSr25519 } from './hdkdSr25519.ts';

package/build-deno/mnemonic/bip39.ts

@@ -0,0 +1,115 @@
+import { Buffer } from 'node:buffer';
+
+
+
+import { stringToU8a, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { pbkdf2Encode } from '../pbkdf2/index.ts';
+import { randomAsU8a } from '../random/index.ts';
+import { sha256AsU8a } from '../sha/index.ts';
+import DEFAULT_WORDLIST from './wordlists/en.ts';
+
+const INVALID_MNEMONIC = 'Invalid mnemonic';
+const INVALID_ENTROPY = 'Invalid entropy';
+const INVALID_CHECKSUM = 'Invalid mnemonic checksum';
+
+/** @internal */
+function normalize (str?: string): string {
+  return (str || '').normalize('NFKD');
+}
+
+/** @internal */
+function binaryToByte (bin: string): number {
+  return parseInt(bin, 2);
+}
+
+/** @internal */
+function bytesToBinary (bytes: number[]): string {
+  return bytes.map((x) => x.toString(2).padStart(8, '0')).join('');
+}
+
+/** @internal */
+function deriveChecksumBits (entropyBuffer: Uint8Array): string {
+  return bytesToBinary(
+    Array.from(sha256AsU8a(entropyBuffer))
+  ).slice(0, (entropyBuffer.length * 8) / 32);
+}
+
+export function mnemonicToSeedSync (mnemonic: string, password?: string): Uint8Array {
+  return pbkdf2Encode(
+    stringToU8a(normalize(mnemonic)),
+    stringToU8a(`mnemonic${normalize(password)}`)
+  ).password;
+}
+
+export function mnemonicToEntropy (mnemonic: string, wordlist: string[] = DEFAULT_WORDLIST): Uint8Array {
+  const words = normalize(mnemonic).split(' ');
+
+  if (words.length % 3 !== 0) {
+    throw new Error(INVALID_MNEMONIC);
+  }
+
+  // convert word indices to 11 bit binary strings
+  const bits = words
+    .map((word): string => {
+      const index = wordlist.indexOf(word);
+
+      if (index === -1) {
+        throw new Error(INVALID_MNEMONIC);
+      }
+
+      return index.toString(2).padStart(11, '0');
+    })
+    .join('');
+
+  // split the binary string into ENT/CS
+  const dividerIndex = Math.floor(bits.length / 33) * 32;
+  const entropyBits = bits.slice(0, dividerIndex);
+  const checksumBits = bits.slice(dividerIndex);
+
+  // calculate the checksum and compare
+  const matched = entropyBits.match(/(.{1,8})/g);
+  const entropyBytes = matched?.map(binaryToByte);
+
+  if (!entropyBytes || (entropyBytes.length % 4 !== 0) || (entropyBytes.length < 16) || (entropyBytes.length > 32)) {
+    throw new Error(INVALID_ENTROPY);
+  }
+
+  const entropy = u8aToU8a(entropyBytes);
+
+  if (deriveChecksumBits(entropy) !== checksumBits) {
+    throw new Error(INVALID_CHECKSUM);
+  }
+
+  return entropy;
+}
+
+export function entropyToMnemonic (entropy: Uint8Array, wordlist: string[] = DEFAULT_WORDLIST): string {
+  // 128 <= ENT <= 256
+  if ((entropy.length % 4 !== 0) || (entropy.length < 16) || (entropy.length > 32)) {
+    throw new Error(INVALID_ENTROPY);
+  }
+
+  const matched = `${bytesToBinary(Array.from(entropy))}${deriveChecksumBits(entropy)}`.match(/(.{1,11})/g);
+  const mapped = matched?.map((b) => wordlist[binaryToByte(b)]);
+
+  if (!mapped || (mapped.length < 12)) {
+    throw new Error('Unable to map entropy to mnemonic');
+  }
+
+  return mapped.join(' ');
+}
+
+export function generateMnemonic (numWords: 12 | 15 | 18 | 21 | 24, wordlist?: string[]): string {
+  return entropyToMnemonic(randomAsU8a((numWords / 3) * 4), wordlist);
+}
+
+export function validateMnemonic (mnemonic: string, wordlist?: string[]): boolean {
+  try {
+    mnemonicToEntropy(mnemonic, wordlist);
+  } catch {
+    return false;
+  }
+
+  return true;
+}

package/build-deno/mnemonic/generate.ts

@@ -0,0 +1,23 @@
+
+import { hasBigInt } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import { bip39Generate, isReady } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
+
+import { generateMnemonic } from './bip39.ts';
+
+/**
+ * @name mnemonicGenerate
+ * @summary Creates a valid mnemonic string using using [BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki).
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { mnemonicGenerate } from 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
+ *
+ * const mnemonic = mnemonicGenerate(); // => string
+ * ```
+ */
+export function mnemonicGenerate (numWords: 12 | 15 | 18 | 21 | 24 = 12, wordlist?: string[], onlyJs?: boolean): string {
+  return !hasBigInt || (!wordlist && !onlyJs && isReady())
+    ? bip39Generate(numWords)
+    : generateMnemonic(numWords, wordlist);
+}

package/build-deno/mnemonic/index.ts

@@ -0,0 +1,9 @@
+
+/**
+ * @summary Create valid mnemonic strings, validate them using BIP39, and convert them to valid seeds
+ */
+export { mnemonicGenerate } from './generate.ts';
+export { mnemonicToEntropy } from './toEntropy.ts';
+export { mnemonicToLegacySeed } from './toLegacySeed.ts';
+export { mnemonicToMiniSecret } from './toMiniSecret.ts';
+export { mnemonicValidate } from './validate.ts';

package/build-deno/mnemonic/toEntropy.ts

@@ -0,0 +1,11 @@
+
+import { hasBigInt } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import { bip39ToEntropy, isReady } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
+
+import { mnemonicToEntropy as jsToEntropy } from './bip39.ts';
+
+export function mnemonicToEntropy (mnemonic: string, wordlist?: string[], onlyJs?: boolean): Uint8Array {
+  return !hasBigInt || (!wordlist && !onlyJs && isReady())
+    ? bip39ToEntropy(mnemonic)
+    : jsToEntropy(mnemonic, wordlist);
+}