@metamask/keyring-sdk 2.3.0 → 3.1.0

package/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.1.0]
+
+### Added
+
+- Add `decodeMnemonic` and `decodeMnemonicWords` ([#612](https://github.com/MetaMask/accounts/pull/612))
+
+## [3.0.0]
+
+### Added
+
+- Add new entropy support ([#603](https://github.com/MetaMask/accounts/pull/603))
+- Add `encodeMnemonicWords` ([#606](https://github.com/MetaMask/accounts/pull/606))
+
+### Changed
+
+- **BREAKING:** Drop support for Node.js v18 and v20; minimum version is now v22 ([#593](https://github.com/MetaMask/accounts/pull/593))
+- Bump `@metamask/keyring-api` from `^23.6.0` to `^24.0.0` ([#604](https://github.com/MetaMask/accounts/pull/604), [#611](https://github.com/MetaMask/accounts/pull/611))
+- Bump `@metamask/keyring-utils` from `^4.0.0` to `^5.0.0` ([#611](https://github.com/MetaMask/accounts/pull/611))
+
 ## [2.3.0]
 
 ### Added
@@ -17,7 +36,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - Bump `@metamask/keyring-api` from `^23.2.0` to `^23.6.0` ([#569](https://github.com/MetaMask/accounts/pull/569), [#583](https://github.com/MetaMask/accounts/pull/583), [#587](https://github.com/MetaMask/accounts/pull/587), [#600](https://github.com/MetaMask/accounts/pull/600))
-- Bump `@metamask/superstruct` from `^3.1.0` to `^3.4.1` ([#580](https://github.com/MetaMask/accounts/pull/580)), ([#577](https://github.com/MetaMask/accounts/pull/577))
+- Bump `@metamask/superstruct` from `^3.1.0` to `^3.4.1` ([#580](https://github.com/MetaMask/accounts/pull/580), [#577](https://github.com/MetaMask/accounts/pull/577))
 - Bump `@metamask/keyring-utils` from `^3.3.1` to `^4.0.0` ([#600](https://github.com/MetaMask/accounts/pull/600))
 
 ## [2.2.0]
@@ -101,7 +120,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial release, extracted from `@metamask/keyring-api` ([#478](https://github.com/MetaMask/accounts/pull/478), [#482](https://github.com/MetaMask/accounts/pull/482))
 
-[Unreleased]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-sdk@2.3.0...HEAD
+[Unreleased]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-sdk@3.1.0...HEAD
+[3.1.0]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-sdk@3.0.0...@metamask/keyring-sdk@3.1.0
+[3.0.0]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-sdk@2.3.0...@metamask/keyring-sdk@3.0.0
 [2.3.0]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-sdk@2.2.0...@metamask/keyring-sdk@2.3.0
 [2.2.0]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-sdk@2.1.1...@metamask/keyring-sdk@2.2.0
 [2.1.1]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-sdk@2.1.0...@metamask/keyring-sdk@2.1.1

package/dist/entropy.cjs

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toEntropySourceId = exports.fingerprint = void 0;
+const hmac_1 = require("@noble/hashes/hmac");
+const sha2_1 = require("@noble/hashes/sha2");
+const uuid_1 = require("uuid");
+/**
+ * Computes a deterministic, non-reversible fingerprint for a piece of entropy.
+ *
+ * The fingerprint is a UUID v4 seeded from the first 16 bytes of
+ * `HMAC-SHA256(key=material, msg='metamask:fingerprint')`.
+ *
+ * @param material - The raw entropy bytes (e.g. BIP-39 mnemonic bytes).
+ * @returns A deterministic UUID v4 string that uniquely identifies the entropy
+ * without exposing it.
+ */
+async function fingerprint(material) {
+    const message = new TextEncoder().encode('metamask:fingerprint');
+    // `@noble/hashes` is synchronous today, but the async signature is kept as a
+    // forward-compatible seam: a future migration to the Web Crypto API (or any
+    // other async primitive) won't require changes at every call site.
+    const digest = (0, hmac_1.hmac)(sha2_1.sha256, material, message);
+    return (0, uuid_1.v4)({ random: digest.slice(0, 16) });
+}
+exports.fingerprint = fingerprint;
+/**
+ * Computes a stable {@link EntropySourceId} for an entropy source.
+ *
+ * The ID is formatted as `entropy:{type}:{uuid}`, where
+ * the UUID segment is the {@link fingerprint} of `material` when provided, or
+ * `'_'` for entropy sources whose secret never leaves the device (e.g. hardware
+ * wallets).
+ *
+ * @param type - The entropy source type (e.g. `'mnemonic'`,
+ * `'ledger'`, `'private-key'`).
+ * @param material - The raw entropy bytes. Omit for hardware wallets or any
+ * entropy source where the secret is not directly accessible.
+ * @returns A stable {@link EntropySourceId} string.
+ */
+async function toEntropySourceId(type, material) {
+    const entropyFingerprint = material ? await fingerprint(material) : '_';
+    return `entropy:${type}:${entropyFingerprint}`;
+}
+exports.toEntropySourceId = toEntropySourceId;
+//# sourceMappingURL=entropy.cjs.map

package/dist/entropy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entropy.cjs","sourceRoot":"","sources":["../src/entropy.ts"],"names":[],"mappings":";;;AAAA,6CAA0C;AAC1C,6CAA4C;AAC5C,+BAAkC;AAsBlC;;;;;;;;;GASG;AACI,KAAK,UAAU,WAAW,CAAC,QAAoB;IACpD,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC;IACjE,6EAA6E;IAC7E,4EAA4E;IAC5E,mEAAmE;IACnE,MAAM,MAAM,GAAG,IAAA,WAAI,EAAC,aAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC/C,OAAO,IAAA,SAAI,EAAC,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;AAC/C,CAAC;AAPD,kCAOC;AAED;;;;;;;;;;;;;GAaG;AACI,KAAK,UAAU,iBAAiB,CACrC,IAAuB,EACvB,QAAqB;IAErB,MAAM,kBAAkB,GAAG,QAAQ,CAAC,CAAC,CAAC,MAAM,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;IACxE,OAAO,WAAW,IAAI,IAAI,kBAAkB,EAAE,CAAC;AACjD,CAAC;AAND,8CAMC","sourcesContent":["import { hmac } from '@noble/hashes/hmac';\nimport { sha256 } from '@noble/hashes/sha2';\nimport { v4 as uuid } from 'uuid';\n\n/**\n * The type of an entropy source.\n */\nexport type EntropySourceType =\n  | 'mnemonic'\n  | 'ledger'\n  | 'trezor'\n  | 'qr'\n  | 'private-key'\n  | 'mpc';\n\n/**\n * Unique identifier for an entropy source.\n *\n * Format: `entropy:{type}:{uuid}` where the UUID is a\n * deterministic fingerprint of the underlying secret, or `'_'` for entropies\n * that cannot be uniquely identified.\n */\nexport type EntropySourceId = `entropy:${EntropySourceType}:${string}`;\n\n/**\n * Computes a deterministic, non-reversible fingerprint for a piece of entropy.\n *\n * The fingerprint is a UUID v4 seeded from the first 16 bytes of\n * `HMAC-SHA256(key=material, msg='metamask:fingerprint')`.\n *\n * @param material - The raw entropy bytes (e.g. BIP-39 mnemonic bytes).\n * @returns A deterministic UUID v4 string that uniquely identifies the entropy\n * without exposing it.\n */\nexport async function fingerprint(material: Uint8Array): Promise<string> {\n  const message = new TextEncoder().encode('metamask:fingerprint');\n  // `@noble/hashes` is synchronous today, but the async signature is kept as a\n  // forward-compatible seam: a future migration to the Web Crypto API (or any\n  // other async primitive) won't require changes at every call site.\n  const digest = hmac(sha256, material, message);\n  return uuid({ random: digest.slice(0, 16) });\n}\n\n/**\n * Computes a stable {@link EntropySourceId} for an entropy source.\n *\n * The ID is formatted as `entropy:{type}:{uuid}`, where\n * the UUID segment is the {@link fingerprint} of `material` when provided, or\n * `'_'` for entropy sources whose secret never leaves the device (e.g. hardware\n * wallets).\n *\n * @param type - The entropy source type (e.g. `'mnemonic'`,\n * `'ledger'`, `'private-key'`).\n * @param material - The raw entropy bytes. Omit for hardware wallets or any\n * entropy source where the secret is not directly accessible.\n * @returns A stable {@link EntropySourceId} string.\n */\nexport async function toEntropySourceId(\n  type: EntropySourceType,\n  material?: Uint8Array,\n): Promise<EntropySourceId> {\n  const entropyFingerprint = material ? await fingerprint(material) : '_';\n  return `entropy:${type}:${entropyFingerprint}`;\n}\n"]}

package/dist/entropy.d.cts

@@ -0,0 +1,39 @@
+/**
+ * The type of an entropy source.
+ */
+export type EntropySourceType = 'mnemonic' | 'ledger' | 'trezor' | 'qr' | 'private-key' | 'mpc';
+/**
+ * Unique identifier for an entropy source.
+ *
+ * Format: `entropy:{type}:{uuid}` where the UUID is a
+ * deterministic fingerprint of the underlying secret, or `'_'` for entropies
+ * that cannot be uniquely identified.
+ */
+export type EntropySourceId = `entropy:${EntropySourceType}:${string}`;
+/**
+ * Computes a deterministic, non-reversible fingerprint for a piece of entropy.
+ *
+ * The fingerprint is a UUID v4 seeded from the first 16 bytes of
+ * `HMAC-SHA256(key=material, msg='metamask:fingerprint')`.
+ *
+ * @param material - The raw entropy bytes (e.g. BIP-39 mnemonic bytes).
+ * @returns A deterministic UUID v4 string that uniquely identifies the entropy
+ * without exposing it.
+ */
+export declare function fingerprint(material: Uint8Array): Promise<string>;
+/**
+ * Computes a stable {@link EntropySourceId} for an entropy source.
+ *
+ * The ID is formatted as `entropy:{type}:{uuid}`, where
+ * the UUID segment is the {@link fingerprint} of `material` when provided, or
+ * `'_'` for entropy sources whose secret never leaves the device (e.g. hardware
+ * wallets).
+ *
+ * @param type - The entropy source type (e.g. `'mnemonic'`,
+ * `'ledger'`, `'private-key'`).
+ * @param material - The raw entropy bytes. Omit for hardware wallets or any
+ * entropy source where the secret is not directly accessible.
+ * @returns A stable {@link EntropySourceId} string.
+ */
+export declare function toEntropySourceId(type: EntropySourceType, material?: Uint8Array): Promise<EntropySourceId>;
+//# sourceMappingURL=entropy.d.cts.map

package/dist/entropy.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entropy.d.cts","sourceRoot":"","sources":["../src/entropy.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,MAAM,MAAM,iBAAiB,GACzB,UAAU,GACV,QAAQ,GACR,QAAQ,GACR,IAAI,GACJ,aAAa,GACb,KAAK,CAAC;AAEV;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,WAAW,iBAAiB,IAAI,MAAM,EAAE,CAAC;AAEvE;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAOvE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,iBAAiB,EACvB,QAAQ,CAAC,EAAE,UAAU,GACpB,OAAO,CAAC,eAAe,CAAC,CAG1B"}

package/dist/entropy.d.mts

@@ -0,0 +1,39 @@
+/**
+ * The type of an entropy source.
+ */
+export type EntropySourceType = 'mnemonic' | 'ledger' | 'trezor' | 'qr' | 'private-key' | 'mpc';
+/**
+ * Unique identifier for an entropy source.
+ *
+ * Format: `entropy:{type}:{uuid}` where the UUID is a
+ * deterministic fingerprint of the underlying secret, or `'_'` for entropies
+ * that cannot be uniquely identified.
+ */
+export type EntropySourceId = `entropy:${EntropySourceType}:${string}`;
+/**
+ * Computes a deterministic, non-reversible fingerprint for a piece of entropy.
+ *
+ * The fingerprint is a UUID v4 seeded from the first 16 bytes of
+ * `HMAC-SHA256(key=material, msg='metamask:fingerprint')`.
+ *
+ * @param material - The raw entropy bytes (e.g. BIP-39 mnemonic bytes).
+ * @returns A deterministic UUID v4 string that uniquely identifies the entropy
+ * without exposing it.
+ */
+export declare function fingerprint(material: Uint8Array): Promise<string>;
+/**
+ * Computes a stable {@link EntropySourceId} for an entropy source.
+ *
+ * The ID is formatted as `entropy:{type}:{uuid}`, where
+ * the UUID segment is the {@link fingerprint} of `material` when provided, or
+ * `'_'` for entropy sources whose secret never leaves the device (e.g. hardware
+ * wallets).
+ *
+ * @param type - The entropy source type (e.g. `'mnemonic'`,
+ * `'ledger'`, `'private-key'`).
+ * @param material - The raw entropy bytes. Omit for hardware wallets or any
+ * entropy source where the secret is not directly accessible.
+ * @returns A stable {@link EntropySourceId} string.
+ */
+export declare function toEntropySourceId(type: EntropySourceType, material?: Uint8Array): Promise<EntropySourceId>;
+//# sourceMappingURL=entropy.d.mts.map

package/dist/entropy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entropy.d.mts","sourceRoot":"","sources":["../src/entropy.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,MAAM,MAAM,iBAAiB,GACzB,UAAU,GACV,QAAQ,GACR,QAAQ,GACR,IAAI,GACJ,aAAa,GACb,KAAK,CAAC;AAEV;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,WAAW,iBAAiB,IAAI,MAAM,EAAE,CAAC;AAEvE;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAOvE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,iBAAiB,EACvB,QAAQ,CAAC,EAAE,UAAU,GACpB,OAAO,CAAC,eAAe,CAAC,CAG1B"}

package/dist/entropy.mjs

@@ -0,0 +1,40 @@
+import { hmac } from "@noble/hashes/hmac";
+import { sha256 } from "@noble/hashes/sha2";
+import { v4 as uuid } from "uuid";
+/**
+ * Computes a deterministic, non-reversible fingerprint for a piece of entropy.
+ *
+ * The fingerprint is a UUID v4 seeded from the first 16 bytes of
+ * `HMAC-SHA256(key=material, msg='metamask:fingerprint')`.
+ *
+ * @param material - The raw entropy bytes (e.g. BIP-39 mnemonic bytes).
+ * @returns A deterministic UUID v4 string that uniquely identifies the entropy
+ * without exposing it.
+ */
+export async function fingerprint(material) {
+    const message = new TextEncoder().encode('metamask:fingerprint');
+    // `@noble/hashes` is synchronous today, but the async signature is kept as a
+    // forward-compatible seam: a future migration to the Web Crypto API (or any
+    // other async primitive) won't require changes at every call site.
+    const digest = hmac(sha256, material, message);
+    return uuid({ random: digest.slice(0, 16) });
+}
+/**
+ * Computes a stable {@link EntropySourceId} for an entropy source.
+ *
+ * The ID is formatted as `entropy:{type}:{uuid}`, where
+ * the UUID segment is the {@link fingerprint} of `material` when provided, or
+ * `'_'` for entropy sources whose secret never leaves the device (e.g. hardware
+ * wallets).
+ *
+ * @param type - The entropy source type (e.g. `'mnemonic'`,
+ * `'ledger'`, `'private-key'`).
+ * @param material - The raw entropy bytes. Omit for hardware wallets or any
+ * entropy source where the secret is not directly accessible.
+ * @returns A stable {@link EntropySourceId} string.
+ */
+export async function toEntropySourceId(type, material) {
+    const entropyFingerprint = material ? await fingerprint(material) : '_';
+    return `entropy:${type}:${entropyFingerprint}`;
+}
+//# sourceMappingURL=entropy.mjs.map

package/dist/entropy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entropy.mjs","sourceRoot":"","sources":["../src/entropy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,2BAA2B;AAC1C,OAAO,EAAE,MAAM,EAAE,2BAA2B;AAC5C,OAAO,EAAE,EAAE,IAAI,IAAI,EAAE,aAAa;AAsBlC;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,QAAoB;IACpD,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC;IACjE,6EAA6E;IAC7E,4EAA4E;IAC5E,mEAAmE;IACnE,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC/C,OAAO,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,IAAuB,EACvB,QAAqB;IAErB,MAAM,kBAAkB,GAAG,QAAQ,CAAC,CAAC,CAAC,MAAM,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;IACxE,OAAO,WAAW,IAAI,IAAI,kBAAkB,EAAE,CAAC;AACjD,CAAC","sourcesContent":["import { hmac } from '@noble/hashes/hmac';\nimport { sha256 } from '@noble/hashes/sha2';\nimport { v4 as uuid } from 'uuid';\n\n/**\n * The type of an entropy source.\n */\nexport type EntropySourceType =\n  | 'mnemonic'\n  | 'ledger'\n  | 'trezor'\n  | 'qr'\n  | 'private-key'\n  | 'mpc';\n\n/**\n * Unique identifier for an entropy source.\n *\n * Format: `entropy:{type}:{uuid}` where the UUID is a\n * deterministic fingerprint of the underlying secret, or `'_'` for entropies\n * that cannot be uniquely identified.\n */\nexport type EntropySourceId = `entropy:${EntropySourceType}:${string}`;\n\n/**\n * Computes a deterministic, non-reversible fingerprint for a piece of entropy.\n *\n * The fingerprint is a UUID v4 seeded from the first 16 bytes of\n * `HMAC-SHA256(key=material, msg='metamask:fingerprint')`.\n *\n * @param material - The raw entropy bytes (e.g. BIP-39 mnemonic bytes).\n * @returns A deterministic UUID v4 string that uniquely identifies the entropy\n * without exposing it.\n */\nexport async function fingerprint(material: Uint8Array): Promise<string> {\n  const message = new TextEncoder().encode('metamask:fingerprint');\n  // `@noble/hashes` is synchronous today, but the async signature is kept as a\n  // forward-compatible seam: a future migration to the Web Crypto API (or any\n  // other async primitive) won't require changes at every call site.\n  const digest = hmac(sha256, material, message);\n  return uuid({ random: digest.slice(0, 16) });\n}\n\n/**\n * Computes a stable {@link EntropySourceId} for an entropy source.\n *\n * The ID is formatted as `entropy:{type}:{uuid}`, where\n * the UUID segment is the {@link fingerprint} of `material` when provided, or\n * `'_'` for entropy sources whose secret never leaves the device (e.g. hardware\n * wallets).\n *\n * @param type - The entropy source type (e.g. `'mnemonic'`,\n * `'ledger'`, `'private-key'`).\n * @param material - The raw entropy bytes. Omit for hardware wallets or any\n * entropy source where the secret is not directly accessible.\n * @returns A stable {@link EntropySourceId} string.\n */\nexport async function toEntropySourceId(\n  type: EntropySourceType,\n  material?: Uint8Array,\n): Promise<EntropySourceId> {\n  const entropyFingerprint = material ? await fingerprint(material) : '_';\n  return `entropy:${type}:${entropyFingerprint}`;\n}\n"]}

package/dist/index.cjs

@@ -17,5 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./keyring-account-registry.cjs"), exports);
 __exportStar(require("./migration.cjs"), exports);
 __exportStar(require("./mnemonic.cjs"), exports);
+__exportStar(require("./entropy.cjs"), exports);
 __exportStar(require("./eth/index.cjs"), exports);
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iEAA2C;AAC3C,kDAA4B;AAC5B,iDAA2B;AAC3B,kDAAsB","sourcesContent":["export * from './keyring-account-registry';\nexport * from './migration';\nexport * from './mnemonic';\nexport * from './eth';\n"]}
+{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iEAA2C;AAC3C,kDAA4B;AAC5B,iDAA2B;AAC3B,gDAA0B;AAC1B,kDAAsB","sourcesContent":["export * from './keyring-account-registry';\nexport * from './migration';\nexport * from './mnemonic';\nexport * from './entropy';\nexport * from './eth';\n"]}

package/dist/index.d.cts

@@ -1,5 +1,6 @@
 export * from "./keyring-account-registry.cjs";
 export * from "./migration.cjs";
 export * from "./mnemonic.cjs";
+export * from "./entropy.cjs";
 export * from "./eth/index.cjs";
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,+CAA2C;AAC3C,gCAA4B;AAC5B,+BAA2B;AAC3B,gCAAsB"}
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,+CAA2C;AAC3C,gCAA4B;AAC5B,+BAA2B;AAC3B,8BAA0B;AAC1B,gCAAsB"}

package/dist/index.d.mts

@@ -1,5 +1,6 @@
 export * from "./keyring-account-registry.mjs";
 export * from "./migration.mjs";
 export * from "./mnemonic.mjs";
+export * from "./entropy.mjs";
 export * from "./eth/index.mjs";
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,+CAA2C;AAC3C,gCAA4B;AAC5B,+BAA2B;AAC3B,gCAAsB"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,+CAA2C;AAC3C,gCAA4B;AAC5B,+BAA2B;AAC3B,8BAA0B;AAC1B,gCAAsB"}

package/dist/index.mjs

@@ -1,5 +1,6 @@
 export * from "./keyring-account-registry.mjs";
 export * from "./migration.mjs";
 export * from "./mnemonic.mjs";
+export * from "./entropy.mjs";
 export * from "./eth/index.mjs";
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,+CAA2C;AAC3C,gCAA4B;AAC5B,+BAA2B;AAC3B,gCAAsB","sourcesContent":["export * from './keyring-account-registry';\nexport * from './migration';\nexport * from './mnemonic';\nexport * from './eth';\n"]}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,+CAA2C;AAC3C,gCAA4B;AAC5B,+BAA2B;AAC3B,8BAA0B;AAC1B,gCAAsB","sourcesContent":["export * from './keyring-account-registry';\nexport * from './migration';\nexport * from './mnemonic';\nexport * from './entropy';\nexport * from './eth';\n"]}

package/dist/mnemonic.cjs

@@ -1,21 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeMnemonic = void 0;
+exports.decodeMnemonic = exports.decodeMnemonicWords = exports.encodeMnemonic = exports.encodeMnemonicWords = void 0;
 const english_1 = require("@metamask/scure-bip39/dist/wordlists/english.js");
 /**
- * Encodes a mnemonic as an array of bytes (UTF-8).
+ * Encodes a mnemonic as a string of words.
  *
  * @param mnemonicIndicesBytes - An array of bytes (16-bit unsigned integers) representing the indices of the words in the mnemonic.
- * @returns An array of bytes (UTF-8) representing the mnemonic.
+ * @returns A string representing the mnemonic.
  */
-function encodeMnemonic(mnemonicIndicesBytes) {
+function encodeMnemonicWords(mnemonicIndicesBytes) {
     const mnemonicIndices = Array.from(
     // Create a new `Uint8Array` to ensure we have a proper view on the buffer
     // without having to worry about `byteOffset` and `byteLength` of
     // the inner buffer.
     new Uint16Array(new Uint8Array(mnemonicIndicesBytes).buffer));
-    const mnemonic = mnemonicIndices.map((i) => english_1.wordlist[i]).join(' ');
-    return Array.from(new TextEncoder().encode(mnemonic));
+    return mnemonicIndices.map((i) => english_1.wordlist[i]).join(' ');
+}
+exports.encodeMnemonicWords = encodeMnemonicWords;
+/**
+ * Encodes a mnemonic as an array of bytes (UTF-8).
+ *
+ * @param mnemonicIndicesBytes - An array of bytes (16-bit unsigned integers) representing the indices of the words in the mnemonic.
+ * @returns An array of bytes (UTF-8) representing the mnemonic.
+ */
+function encodeMnemonic(mnemonicIndicesBytes) {
+    return Array.from(new TextEncoder().encode(encodeMnemonicWords(mnemonicIndicesBytes)));
 }
 exports.encodeMnemonic = encodeMnemonic;
+/**
+ * Decodes a string of mnemonic words as an array of bytes (16-bit unsigned
+ * integers) representing the indices of the words in the mnemonic.
+ *
+ * @param mnemonic - A string representing the mnemonic.
+ * @returns An array of bytes representing the indices of the words in the mnemonic.
+ * @throws If the mnemonic contains a word that is not in the English BIP-39 wordlist.
+ */
+function decodeMnemonicWords(mnemonic) {
+    if (mnemonic === '') {
+        return new Uint8Array();
+    }
+    const mnemonicIndices = mnemonic.split(' ').map((word) => {
+        const index = english_1.wordlist.indexOf(word);
+        if (index === -1) {
+            throw new Error(`Invalid mnemonic word: "${word}"`);
+        }
+        return index;
+    });
+    return new Uint8Array(new Uint16Array(mnemonicIndices).buffer);
+}
+exports.decodeMnemonicWords = decodeMnemonicWords;
+/**
+ * Decodes an array of bytes (UTF-8) representing a mnemonic as an array of
+ * bytes (16-bit unsigned integers) representing the indices of the words in
+ * the mnemonic.
+ *
+ * @param mnemonicBytes - An array of bytes (UTF-8) representing the mnemonic.
+ * @returns An array of bytes representing the indices of the words in the mnemonic.
+ * @throws If the mnemonic contains a word that is not in the English BIP-39 wordlist.
+ */
+function decodeMnemonic(mnemonicBytes) {
+    return decodeMnemonicWords(new TextDecoder().decode(mnemonicBytes));
+}
+exports.decodeMnemonic = decodeMnemonic;
 //# sourceMappingURL=mnemonic.cjs.map

package/dist/mnemonic.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"mnemonic.cjs","sourceRoot":"","sources":["../src/mnemonic.ts"],"names":[],"mappings":";;;AAAA,6EAAwE;AAExE;;;;;GAKG;AACH,SAAgB,cAAc,CAAC,oBAAgC;IAC7D,MAAM,eAAe,GAAG,KAAK,CAAC,IAAI;IAChC,0EAA0E;IAC1E,iEAAiE;IACjE,oBAAoB;IACpB,IAAI,WAAW,CAAC,IAAI,UAAU,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAC7D,CAAC;IACF,MAAM,QAAQ,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,kBAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACnE,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;AACxD,CAAC;AATD,wCASC","sourcesContent":["import { wordlist } from '@metamask/scure-bip39/dist/wordlists/english';\n\n/**\n * Encodes a mnemonic as an array of bytes (UTF-8).\n *\n * @param mnemonicIndicesBytes - An array of bytes (16-bit unsigned integers) representing the indices of the words in the mnemonic.\n * @returns An array of bytes (UTF-8) representing the mnemonic.\n */\nexport function encodeMnemonic(mnemonicIndicesBytes: Uint8Array): number[] {\n  const mnemonicIndices = Array.from(\n    // Create a new `Uint8Array` to ensure we have a proper view on the buffer\n    // without having to worry about `byteOffset` and `byteLength` of\n    // the inner buffer.\n    new Uint16Array(new Uint8Array(mnemonicIndicesBytes).buffer),\n  );\n  const mnemonic = mnemonicIndices.map((i) => wordlist[i]).join(' ');\n  return Array.from(new TextEncoder().encode(mnemonic));\n}\n"]}
+{"version":3,"file":"mnemonic.cjs","sourceRoot":"","sources":["../src/mnemonic.ts"],"names":[],"mappings":";;;AAAA,6EAAwE;AAExE;;;;;GAKG;AACH,SAAgB,mBAAmB,CAAC,oBAAgC;IAClE,MAAM,eAAe,GAAG,KAAK,CAAC,IAAI;IAChC,0EAA0E;IAC1E,iEAAiE;IACjE,oBAAoB;IACpB,IAAI,WAAW,CAAC,IAAI,UAAU,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAC7D,CAAC;IACF,OAAO,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,kBAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC3D,CAAC;AARD,kDAQC;AAED;;;;;GAKG;AACH,SAAgB,cAAc,CAAC,oBAAgC;IAC7D,OAAO,KAAK,CAAC,IAAI,CACf,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,oBAAoB,CAAC,CAAC,CACpE,CAAC;AACJ,CAAC;AAJD,wCAIC;AAED;;;;;;;GAOG;AACH,SAAgB,mBAAmB,CAAC,QAAgB;IAClD,IAAI,QAAQ,KAAK,EAAE,EAAE,CAAC;QACpB,OAAO,IAAI,UAAU,EAAE,CAAC;IAC1B,CAAC;IAED,MAAM,eAAe,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QACvD,MAAM,KAAK,GAAG,kBAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACrC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,2BAA2B,IAAI,GAAG,CAAC,CAAC;QACtD,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC,CAAC;IAEH,OAAO,IAAI,UAAU,CAAC,IAAI,WAAW,CAAC,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AACjE,CAAC;AAdD,kDAcC;AAED;;;;;;;;GAQG;AACH,SAAgB,cAAc,CAAC,aAAyB;IACtD,OAAO,mBAAmB,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC;AACtE,CAAC;AAFD,wCAEC","sourcesContent":["import { wordlist } from '@metamask/scure-bip39/dist/wordlists/english';\n\n/**\n * Encodes a mnemonic as a string of words.\n *\n * @param mnemonicIndicesBytes - An array of bytes (16-bit unsigned integers) representing the indices of the words in the mnemonic.\n * @returns A string representing the mnemonic.\n */\nexport function encodeMnemonicWords(mnemonicIndicesBytes: Uint8Array): string {\n  const mnemonicIndices = Array.from(\n    // Create a new `Uint8Array` to ensure we have a proper view on the buffer\n    // without having to worry about `byteOffset` and `byteLength` of\n    // the inner buffer.\n    new Uint16Array(new Uint8Array(mnemonicIndicesBytes).buffer),\n  );\n  return mnemonicIndices.map((i) => wordlist[i]).join(' ');\n}\n\n/**\n * Encodes a mnemonic as an array of bytes (UTF-8).\n *\n * @param mnemonicIndicesBytes - An array of bytes (16-bit unsigned integers) representing the indices of the words in the mnemonic.\n * @returns An array of bytes (UTF-8) representing the mnemonic.\n */\nexport function encodeMnemonic(mnemonicIndicesBytes: Uint8Array): number[] {\n  return Array.from(\n    new TextEncoder().encode(encodeMnemonicWords(mnemonicIndicesBytes)),\n  );\n}\n\n/**\n * Decodes a string of mnemonic words as an array of bytes (16-bit unsigned\n * integers) representing the indices of the words in the mnemonic.\n *\n * @param mnemonic - A string representing the mnemonic.\n * @returns An array of bytes representing the indices of the words in the mnemonic.\n * @throws If the mnemonic contains a word that is not in the English BIP-39 wordlist.\n */\nexport function decodeMnemonicWords(mnemonic: string): Uint8Array {\n  if (mnemonic === '') {\n    return new Uint8Array();\n  }\n\n  const mnemonicIndices = mnemonic.split(' ').map((word) => {\n    const index = wordlist.indexOf(word);\n    if (index === -1) {\n      throw new Error(`Invalid mnemonic word: \"${word}\"`);\n    }\n    return index;\n  });\n\n  return new Uint8Array(new Uint16Array(mnemonicIndices).buffer);\n}\n\n/**\n * Decodes an array of bytes (UTF-8) representing a mnemonic as an array of\n * bytes (16-bit unsigned integers) representing the indices of the words in\n * the mnemonic.\n *\n * @param mnemonicBytes - An array of bytes (UTF-8) representing the mnemonic.\n * @returns An array of bytes representing the indices of the words in the mnemonic.\n * @throws If the mnemonic contains a word that is not in the English BIP-39 wordlist.\n */\nexport function decodeMnemonic(mnemonicBytes: Uint8Array): Uint8Array {\n  return decodeMnemonicWords(new TextDecoder().decode(mnemonicBytes));\n}\n"]}

package/dist/mnemonic.d.cts

@@ -1,3 +1,10 @@
+/**
+ * Encodes a mnemonic as a string of words.
+ *
+ * @param mnemonicIndicesBytes - An array of bytes (16-bit unsigned integers) representing the indices of the words in the mnemonic.
+ * @returns A string representing the mnemonic.
+ */
+export declare function encodeMnemonicWords(mnemonicIndicesBytes: Uint8Array): string;
 /**
  * Encodes a mnemonic as an array of bytes (UTF-8).
  *
@@ -5,4 +12,23 @@
  * @returns An array of bytes (UTF-8) representing the mnemonic.
  */
 export declare function encodeMnemonic(mnemonicIndicesBytes: Uint8Array): number[];
+/**
+ * Decodes a string of mnemonic words as an array of bytes (16-bit unsigned
+ * integers) representing the indices of the words in the mnemonic.
+ *
+ * @param mnemonic - A string representing the mnemonic.
+ * @returns An array of bytes representing the indices of the words in the mnemonic.
+ * @throws If the mnemonic contains a word that is not in the English BIP-39 wordlist.
+ */
+export declare function decodeMnemonicWords(mnemonic: string): Uint8Array;
+/**
+ * Decodes an array of bytes (UTF-8) representing a mnemonic as an array of
+ * bytes (16-bit unsigned integers) representing the indices of the words in
+ * the mnemonic.
+ *
+ * @param mnemonicBytes - An array of bytes (UTF-8) representing the mnemonic.
+ * @returns An array of bytes representing the indices of the words in the mnemonic.
+ * @throws If the mnemonic contains a word that is not in the English BIP-39 wordlist.
+ */
+export declare function decodeMnemonic(mnemonicBytes: Uint8Array): Uint8Array;
 //# sourceMappingURL=mnemonic.d.cts.map

package/dist/mnemonic.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"mnemonic.d.cts","sourceRoot":"","sources":["../src/mnemonic.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,oBAAoB,EAAE,UAAU,GAAG,MAAM,EAAE,CASzE"}
+{"version":3,"file":"mnemonic.d.cts","sourceRoot":"","sources":["../src/mnemonic.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,oBAAoB,EAAE,UAAU,GAAG,MAAM,CAQ5E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,oBAAoB,EAAE,UAAU,GAAG,MAAM,EAAE,CAIzE;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAchE;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,aAAa,EAAE,UAAU,GAAG,UAAU,CAEpE"}

package/dist/mnemonic.d.mts

@@ -1,3 +1,10 @@
+/**
+ * Encodes a mnemonic as a string of words.
+ *
+ * @param mnemonicIndicesBytes - An array of bytes (16-bit unsigned integers) representing the indices of the words in the mnemonic.
+ * @returns A string representing the mnemonic.
+ */
+export declare function encodeMnemonicWords(mnemonicIndicesBytes: Uint8Array): string;
 /**
  * Encodes a mnemonic as an array of bytes (UTF-8).
  *
@@ -5,4 +12,23 @@
  * @returns An array of bytes (UTF-8) representing the mnemonic.
  */
 export declare function encodeMnemonic(mnemonicIndicesBytes: Uint8Array): number[];
+/**
+ * Decodes a string of mnemonic words as an array of bytes (16-bit unsigned
+ * integers) representing the indices of the words in the mnemonic.
+ *
+ * @param mnemonic - A string representing the mnemonic.
+ * @returns An array of bytes representing the indices of the words in the mnemonic.
+ * @throws If the mnemonic contains a word that is not in the English BIP-39 wordlist.
+ */
+export declare function decodeMnemonicWords(mnemonic: string): Uint8Array;
+/**
+ * Decodes an array of bytes (UTF-8) representing a mnemonic as an array of
+ * bytes (16-bit unsigned integers) representing the indices of the words in
+ * the mnemonic.
+ *
+ * @param mnemonicBytes - An array of bytes (UTF-8) representing the mnemonic.
+ * @returns An array of bytes representing the indices of the words in the mnemonic.
+ * @throws If the mnemonic contains a word that is not in the English BIP-39 wordlist.
+ */
+export declare function decodeMnemonic(mnemonicBytes: Uint8Array): Uint8Array;
 //# sourceMappingURL=mnemonic.d.mts.map

package/dist/mnemonic.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"mnemonic.d.mts","sourceRoot":"","sources":["../src/mnemonic.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,oBAAoB,EAAE,UAAU,GAAG,MAAM,EAAE,CASzE"}
+{"version":3,"file":"mnemonic.d.mts","sourceRoot":"","sources":["../src/mnemonic.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,oBAAoB,EAAE,UAAU,GAAG,MAAM,CAQ5E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,oBAAoB,EAAE,UAAU,GAAG,MAAM,EAAE,CAIzE;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAchE;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,aAAa,EAAE,UAAU,GAAG,UAAU,CAEpE"}

package/dist/mnemonic.mjs

@@ -1,17 +1,58 @@
 import { wordlist } from "@metamask/scure-bip39/dist/wordlists/english.js";
 /**
- * Encodes a mnemonic as an array of bytes (UTF-8).
+ * Encodes a mnemonic as a string of words.
  *
  * @param mnemonicIndicesBytes - An array of bytes (16-bit unsigned integers) representing the indices of the words in the mnemonic.
- * @returns An array of bytes (UTF-8) representing the mnemonic.
+ * @returns A string representing the mnemonic.
  */
-export function encodeMnemonic(mnemonicIndicesBytes) {
+export function encodeMnemonicWords(mnemonicIndicesBytes) {
     const mnemonicIndices = Array.from(
     // Create a new `Uint8Array` to ensure we have a proper view on the buffer
     // without having to worry about `byteOffset` and `byteLength` of
     // the inner buffer.
     new Uint16Array(new Uint8Array(mnemonicIndicesBytes).buffer));
-    const mnemonic = mnemonicIndices.map((i) => wordlist[i]).join(' ');
-    return Array.from(new TextEncoder().encode(mnemonic));
+    return mnemonicIndices.map((i) => wordlist[i]).join(' ');
+}
+/**
+ * Encodes a mnemonic as an array of bytes (UTF-8).
+ *
+ * @param mnemonicIndicesBytes - An array of bytes (16-bit unsigned integers) representing the indices of the words in the mnemonic.
+ * @returns An array of bytes (UTF-8) representing the mnemonic.
+ */
+export function encodeMnemonic(mnemonicIndicesBytes) {
+    return Array.from(new TextEncoder().encode(encodeMnemonicWords(mnemonicIndicesBytes)));
+}
+/**
+ * Decodes a string of mnemonic words as an array of bytes (16-bit unsigned
+ * integers) representing the indices of the words in the mnemonic.
+ *
+ * @param mnemonic - A string representing the mnemonic.
+ * @returns An array of bytes representing the indices of the words in the mnemonic.
+ * @throws If the mnemonic contains a word that is not in the English BIP-39 wordlist.
+ */
+export function decodeMnemonicWords(mnemonic) {
+    if (mnemonic === '') {
+        return new Uint8Array();
+    }
+    const mnemonicIndices = mnemonic.split(' ').map((word) => {
+        const index = wordlist.indexOf(word);
+        if (index === -1) {
+            throw new Error(`Invalid mnemonic word: "${word}"`);
+        }
+        return index;
+    });
+    return new Uint8Array(new Uint16Array(mnemonicIndices).buffer);
+}
+/**
+ * Decodes an array of bytes (UTF-8) representing a mnemonic as an array of
+ * bytes (16-bit unsigned integers) representing the indices of the words in
+ * the mnemonic.
+ *
+ * @param mnemonicBytes - An array of bytes (UTF-8) representing the mnemonic.
+ * @returns An array of bytes representing the indices of the words in the mnemonic.
+ * @throws If the mnemonic contains a word that is not in the English BIP-39 wordlist.
+ */
+export function decodeMnemonic(mnemonicBytes) {
+    return decodeMnemonicWords(new TextDecoder().decode(mnemonicBytes));
 }
 //# sourceMappingURL=mnemonic.mjs.map

package/dist/mnemonic.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"mnemonic.mjs","sourceRoot":"","sources":["../src/mnemonic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,wDAAqD;AAExE;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,oBAAgC;IAC7D,MAAM,eAAe,GAAG,KAAK,CAAC,IAAI;IAChC,0EAA0E;IAC1E,iEAAiE;IACjE,oBAAoB;IACpB,IAAI,WAAW,CAAC,IAAI,UAAU,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAC7D,CAAC;IACF,MAAM,QAAQ,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACnE,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;AACxD,CAAC","sourcesContent":["import { wordlist } from '@metamask/scure-bip39/dist/wordlists/english';\n\n/**\n * Encodes a mnemonic as an array of bytes (UTF-8).\n *\n * @param mnemonicIndicesBytes - An array of bytes (16-bit unsigned integers) representing the indices of the words in the mnemonic.\n * @returns An array of bytes (UTF-8) representing the mnemonic.\n */\nexport function encodeMnemonic(mnemonicIndicesBytes: Uint8Array): number[] {\n  const mnemonicIndices = Array.from(\n    // Create a new `Uint8Array` to ensure we have a proper view on the buffer\n    // without having to worry about `byteOffset` and `byteLength` of\n    // the inner buffer.\n    new Uint16Array(new Uint8Array(mnemonicIndicesBytes).buffer),\n  );\n  const mnemonic = mnemonicIndices.map((i) => wordlist[i]).join(' ');\n  return Array.from(new TextEncoder().encode(mnemonic));\n}\n"]}
+{"version":3,"file":"mnemonic.mjs","sourceRoot":"","sources":["../src/mnemonic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,wDAAqD;AAExE;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,oBAAgC;IAClE,MAAM,eAAe,GAAG,KAAK,CAAC,IAAI;IAChC,0EAA0E;IAC1E,iEAAiE;IACjE,oBAAoB;IACpB,IAAI,WAAW,CAAC,IAAI,UAAU,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAC7D,CAAC;IACF,OAAO,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC3D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,oBAAgC;IAC7D,OAAO,KAAK,CAAC,IAAI,CACf,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,oBAAoB,CAAC,CAAC,CACpE,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAgB;IAClD,IAAI,QAAQ,KAAK,EAAE,EAAE,CAAC;QACpB,OAAO,IAAI,UAAU,EAAE,CAAC;IAC1B,CAAC;IAED,MAAM,eAAe,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QACvD,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACrC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,2BAA2B,IAAI,GAAG,CAAC,CAAC;QACtD,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC,CAAC;IAEH,OAAO,IAAI,UAAU,CAAC,IAAI,WAAW,CAAC,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AACjE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAAC,aAAyB;IACtD,OAAO,mBAAmB,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC;AACtE,CAAC","sourcesContent":["import { wordlist } from '@metamask/scure-bip39/dist/wordlists/english';\n\n/**\n * Encodes a mnemonic as a string of words.\n *\n * @param mnemonicIndicesBytes - An array of bytes (16-bit unsigned integers) representing the indices of the words in the mnemonic.\n * @returns A string representing the mnemonic.\n */\nexport function encodeMnemonicWords(mnemonicIndicesBytes: Uint8Array): string {\n  const mnemonicIndices = Array.from(\n    // Create a new `Uint8Array` to ensure we have a proper view on the buffer\n    // without having to worry about `byteOffset` and `byteLength` of\n    // the inner buffer.\n    new Uint16Array(new Uint8Array(mnemonicIndicesBytes).buffer),\n  );\n  return mnemonicIndices.map((i) => wordlist[i]).join(' ');\n}\n\n/**\n * Encodes a mnemonic as an array of bytes (UTF-8).\n *\n * @param mnemonicIndicesBytes - An array of bytes (16-bit unsigned integers) representing the indices of the words in the mnemonic.\n * @returns An array of bytes (UTF-8) representing the mnemonic.\n */\nexport function encodeMnemonic(mnemonicIndicesBytes: Uint8Array): number[] {\n  return Array.from(\n    new TextEncoder().encode(encodeMnemonicWords(mnemonicIndicesBytes)),\n  );\n}\n\n/**\n * Decodes a string of mnemonic words as an array of bytes (16-bit unsigned\n * integers) representing the indices of the words in the mnemonic.\n *\n * @param mnemonic - A string representing the mnemonic.\n * @returns An array of bytes representing the indices of the words in the mnemonic.\n * @throws If the mnemonic contains a word that is not in the English BIP-39 wordlist.\n */\nexport function decodeMnemonicWords(mnemonic: string): Uint8Array {\n  if (mnemonic === '') {\n    return new Uint8Array();\n  }\n\n  const mnemonicIndices = mnemonic.split(' ').map((word) => {\n    const index = wordlist.indexOf(word);\n    if (index === -1) {\n      throw new Error(`Invalid mnemonic word: \"${word}\"`);\n    }\n    return index;\n  });\n\n  return new Uint8Array(new Uint16Array(mnemonicIndices).buffer);\n}\n\n/**\n * Decodes an array of bytes (UTF-8) representing a mnemonic as an array of\n * bytes (16-bit unsigned integers) representing the indices of the words in\n * the mnemonic.\n *\n * @param mnemonicBytes - An array of bytes (UTF-8) representing the mnemonic.\n * @returns An array of bytes representing the indices of the words in the mnemonic.\n * @throws If the mnemonic contains a word that is not in the English BIP-39 wordlist.\n */\nexport function decodeMnemonic(mnemonicBytes: Uint8Array): Uint8Array {\n  return decodeMnemonicWords(new TextDecoder().decode(mnemonicBytes));\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamask/keyring-sdk",
-  "version": "2.3.0",
+  "version": "3.1.0",
   "description": "MetaMask Keyring SDK",
   "keywords": [
     "keyring",
@@ -68,11 +68,12 @@
   "dependencies": {
     "@ethereumjs/tx": "^5.4.0",
     "@metamask/eth-sig-util": "^8.2.0",
-    "@metamask/keyring-api": "^23.6.0",
-    "@metamask/keyring-utils": "^4.0.0",
+    "@metamask/keyring-api": "^24.0.0",
+    "@metamask/keyring-utils": "^5.0.0",
     "@metamask/scure-bip39": "^2.1.1",
     "@metamask/superstruct": "^3.4.1",
     "@metamask/utils": "^11.11.0",
+    "@noble/hashes": "^1.8.0",
     "async-mutex": "^0.5.0",
     "ethereum-cryptography": "^2.2.1",
     "uuid": "^9.0.1"
@@ -103,7 +104,7 @@
     "directory": "src"
   },
   "engines": {
-    "node": "^18.18 || >=20"
+    "node": ">=22"
   },
   "lavamoat": {
     "allowScripts": {