@metamask/eth-hd-keyring 8.0.0 → 9.0.1

package/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [9.0.1]
+
+### Changed
+
+- Use `ts-bridge/cli@0.6.1` ([#118](https://github.com/MetaMask/accounts/pull/118))
+  - This new version fixes a bug with CJS re-exports.
+
+## [9.0.0]
+
+### Changed
+
+- **BREAKING**: Move seed generation to deserialization ([#100](https://github.com/MetaMask/accounts/pull/100))
+  - Using the constructor directly no longer generates the seed required for account derivation.
+  - Both `serialize` and `deserialize` are now proper `async` methods.
+- Allow passing native custom cryptographic functions ([#102](https://github.com/MetaMask/accounts/pull/102))
+  - The seed generation is now relying `@metamask/key-tree` package (instead of `@metamask/scure-bip39`).
+  - The `constructor` now allows a new option `cryptographicFunctions` which allows the use of custom cryptographic functions during seed generation.
+
 ## [8.0.0]
 
 ### Changed
@@ -137,7 +155,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Deserialize method (and `HdKeyring` constructor by extension) can no longer be passed an options object containing a value for `numberOfAccounts` if it is not also containing a value for `mnemonic`.
 - Package name changed from `eth-hd-keyring` to `@metamask/eth-hd-keyring`.
 
-[Unreleased]: https://github.com/MetaMask/accounts/compare/@metamask/eth-hd-keyring@8.0.0...HEAD
+[Unreleased]: https://github.com/MetaMask/accounts/compare/@metamask/eth-hd-keyring@9.0.1...HEAD
+[9.0.1]: https://github.com/MetaMask/accounts/compare/@metamask/eth-hd-keyring@9.0.0...@metamask/eth-hd-keyring@9.0.1
+[9.0.0]: https://github.com/MetaMask/accounts/compare/@metamask/eth-hd-keyring@8.0.0...@metamask/eth-hd-keyring@9.0.0
 [8.0.0]: https://github.com/MetaMask/accounts/compare/@metamask/eth-hd-keyring@7.0.4...@metamask/eth-hd-keyring@8.0.0
 [7.0.4]: https://github.com/MetaMask/accounts/compare/@metamask/eth-hd-keyring@7.0.3...@metamask/eth-hd-keyring@7.0.4
 [7.0.3]: https://github.com/MetaMask/accounts/compare/@metamask/eth-hd-keyring@7.0.2...@metamask/eth-hd-keyring@7.0.3

package/dist/index.cjs

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("@ethereumjs/util");
+const eth_sig_util_1 = require("@metamask/eth-sig-util");
+const key_tree_1 = require("@metamask/key-tree");
+const scure_bip39_1 = require("@metamask/scure-bip39");
+const english_1 = require("@metamask/scure-bip39/dist/wordlists/english.js");
+const utils_1 = require("@metamask/utils");
+const hdkey_1 = require("ethereum-cryptography/hdkey");
+const keccak_1 = require("ethereum-cryptography/keccak");
+const utils_2 = require("ethereum-cryptography/utils");
+// Options:
+const hdPathString = `m/44'/60'/0'/0`;
+const type = 'HD Key Tree';
+class HdKeyring {
+    /* PUBLIC METHODS */
+    constructor(opts = {}) {
+        this.type = type;
+        this._wallets = [];
+        // Cryptographic functions to be used by `@metamask/key-tree`. It will use built-in implementations if not provided here.
+        this._cryptographicFunctions = opts.cryptographicFunctions;
+    }
+    async generateRandomMnemonic() {
+        await this._initFromMnemonic((0, scure_bip39_1.generateMnemonic)(english_1.wordlist));
+    }
+    _uint8ArrayToString(mnemonic) {
+        const recoveredIndices = Array.from(new Uint16Array(new Uint8Array(mnemonic).buffer));
+        return recoveredIndices.map((i) => english_1.wordlist[i]).join(' ');
+    }
+    _stringToUint8Array(mnemonic) {
+        const indices = mnemonic.split(' ').map((word) => english_1.wordlist.indexOf(word));
+        return new Uint8Array(new Uint16Array(indices).buffer);
+    }
+    _mnemonicToUint8Array(mnemonic) {
+        let mnemonicData = mnemonic;
+        // when encrypted/decrypted, buffers get cast into js object with a property type set to buffer
+        if (mnemonic && mnemonic.type && mnemonic.type === 'Buffer') {
+            mnemonicData = mnemonic.data;
+        }
+        if (
+        // this block is for backwards compatibility with vaults that were previously stored as buffers, number arrays or plain text strings
+        typeof mnemonicData === 'string' ||
+            Buffer.isBuffer(mnemonicData) ||
+            Array.isArray(mnemonicData)) {
+            let mnemonicAsString = mnemonicData;
+            if (Array.isArray(mnemonicData)) {
+                mnemonicAsString = Buffer.from(mnemonicData).toString();
+            }
+            else if (Buffer.isBuffer(mnemonicData)) {
+                mnemonicAsString = mnemonicData.toString();
+            }
+            return this._stringToUint8Array(mnemonicAsString);
+        }
+        else if (mnemonicData instanceof Object &&
+            !(mnemonicData instanceof Uint8Array)) {
+            // when encrypted/decrypted the Uint8Array becomes a js object we need to cast back to a Uint8Array
+            return Uint8Array.from(Object.values(mnemonicData));
+        }
+        return mnemonicData;
+    }
+    async serialize() {
+        const mnemonicAsString = this._uint8ArrayToString(this.mnemonic);
+        const uint8ArrayMnemonic = new TextEncoder('utf-8').encode(mnemonicAsString);
+        return {
+            mnemonic: Array.from(uint8ArrayMnemonic),
+            numberOfAccounts: this._wallets.length,
+            hdPath: this.hdPath,
+        };
+    }
+    async deserialize(opts = {}) {
+        if (opts.numberOfAccounts && !opts.mnemonic) {
+            throw new Error('Eth-Hd-Keyring: Deserialize method cannot be called with an opts value for numberOfAccounts and no menmonic');
+        }
+        if (this.root) {
+            throw new Error('Eth-Hd-Keyring: Secret recovery phrase already provided');
+        }
+        this.opts = opts;
+        this._wallets = [];
+        this.mnemonic = null;
+        this.root = null;
+        this.hdPath = opts.hdPath || hdPathString;
+        if (opts.mnemonic) {
+            await this._initFromMnemonic(opts.mnemonic);
+        }
+        if (opts.numberOfAccounts) {
+            return this.addAccounts(opts.numberOfAccounts);
+        }
+        return [];
+    }
+    addAccounts(numberOfAccounts = 1) {
+        if (!this.root) {
+            throw new Error('Eth-Hd-Keyring: No secret recovery phrase provided');
+        }
+        const oldLen = this._wallets.length;
+        const newWallets = [];
+        for (let i = oldLen; i < numberOfAccounts + oldLen; i++) {
+            const wallet = this.root.deriveChild(i);
+            newWallets.push(wallet);
+            this._wallets.push(wallet);
+        }
+        const hexWallets = newWallets.map((w) => {
+            return this._addressfromPublicKey(w.publicKey);
+        });
+        return Promise.resolve(hexWallets);
+    }
+    getAccounts() {
+        return this._wallets.map((w) => this._addressfromPublicKey(w.publicKey));
+    }
+    /* BASE KEYRING METHODS */
+    // returns an address specific to an app
+    async getAppKeyAddress(address, origin) {
+        if (!origin || typeof origin !== 'string') {
+            throw new Error(`'origin' must be a non-empty string`);
+        }
+        const wallet = this._getWalletForAccount(address, {
+            withAppKeyOrigin: origin,
+        });
+        const appKeyAddress = (0, eth_sig_util_1.normalize)((0, util_1.publicToAddress)(wallet.publicKey).toString('hex'));
+        return appKeyAddress;
+    }
+    // exportAccount should return a hex-encoded private key:
+    async exportAccount(address, opts = {}) {
+        const wallet = this._getWalletForAccount(address, opts);
+        return (0, utils_2.bytesToHex)(wallet.privateKey);
+    }
+    // tx is an instance of the ethereumjs-transaction class.
+    async signTransaction(address, tx, opts = {}) {
+        const privKey = this._getPrivateKeyFor(address, opts);
+        const signedTx = tx.sign(privKey);
+        // Newer versions of Ethereumjs-tx are immutable and return a new tx object
+        return signedTx === undefined ? tx : signedTx;
+    }
+    // For eth_sign, we need to sign arbitrary data:
+    async signMessage(address, data, opts = {}) {
+        (0, utils_1.assertIsHexString)(data);
+        const message = (0, utils_1.remove0x)(data);
+        const privKey = this._getPrivateKeyFor(address, opts);
+        const msgSig = (0, util_1.ecsign)(Buffer.from(message, 'hex'), privKey);
+        const rawMsgSig = (0, eth_sig_util_1.concatSig)(msgSig.v, msgSig.r, msgSig.s);
+        return rawMsgSig;
+    }
+    // For personal_sign, we need to prefix the message:
+    async signPersonalMessage(address, msgHex, opts = {}) {
+        const privKey = this._getPrivateKeyFor(address, opts);
+        const privateKey = Buffer.from(privKey, 'hex');
+        const sig = (0, eth_sig_util_1.personalSign)({ privateKey, data: msgHex });
+        return sig;
+    }
+    // For eth_decryptMessage:
+    async decryptMessage(withAccount, encryptedData) {
+        const wallet = this._getWalletForAccount(withAccount);
+        const { privateKey: privateKeyAsUint8Array } = wallet;
+        const privateKeyAsHex = Buffer.from(privateKeyAsUint8Array).toString('hex');
+        const sig = (0, eth_sig_util_1.decrypt)({ privateKey: privateKeyAsHex, encryptedData });
+        return sig;
+    }
+    // personal_signTypedData, signs data along with the schema
+    async signTypedData(withAccount, typedData, opts = { version: eth_sig_util_1.SignTypedDataVersion.V1 }) {
+        // Treat invalid versions as "V1"
+        const version = Object.keys(eth_sig_util_1.SignTypedDataVersion).includes(opts.version)
+            ? opts.version
+            : eth_sig_util_1.SignTypedDataVersion.V1;
+        const privateKey = this._getPrivateKeyFor(withAccount, opts);
+        return (0, eth_sig_util_1.signTypedData)({ privateKey, data: typedData, version });
+    }
+    removeAccount(account) {
+        const address = (0, eth_sig_util_1.normalize)(account);
+        if (!this._wallets
+            .map(({ publicKey }) => this._addressfromPublicKey(publicKey))
+            .includes(address)) {
+            throw new Error(`Address ${address} not found in this keyring`);
+        }
+        this._wallets = this._wallets.filter(({ publicKey }) => this._addressfromPublicKey(publicKey) !== address);
+    }
+    // get public key for nacl
+    async getEncryptionPublicKey(withAccount, opts = {}) {
+        const privKey = this._getPrivateKeyFor(withAccount, opts);
+        const publicKey = (0, eth_sig_util_1.getEncryptionPublicKey)(privKey);
+        return publicKey;
+    }
+    _getPrivateKeyFor(address, opts = {}) {
+        if (!address) {
+            throw new Error('Must specify address.');
+        }
+        const wallet = this._getWalletForAccount(address, opts);
+        return wallet.privateKey;
+    }
+    _getWalletForAccount(account, opts = {}) {
+        const address = (0, eth_sig_util_1.normalize)(account);
+        let wallet = this._wallets.find(({ publicKey }) => {
+            return this._addressfromPublicKey(publicKey) === address;
+        });
+        if (!wallet) {
+            throw new Error('HD Keyring - Unable to find matching address.');
+        }
+        if (opts.withAppKeyOrigin) {
+            const { privateKey } = wallet;
+            const appKeyOriginBuffer = Buffer.from(opts.withAppKeyOrigin, 'utf8');
+            const appKeyBuffer = Buffer.concat([privateKey, appKeyOriginBuffer]);
+            const appKeyPrivateKey = (0, util_1.arrToBufArr)((0, keccak_1.keccak256)(appKeyBuffer, 256));
+            const appKeyPublicKey = (0, util_1.privateToPublic)(appKeyPrivateKey);
+            wallet = { privateKey: appKeyPrivateKey, publicKey: appKeyPublicKey };
+        }
+        return wallet;
+    }
+    /* PRIVATE / UTILITY METHODS */
+    /**
+     * Sets appropriate properties for the keyring based on the given
+     * BIP39-compliant mnemonic.
+     *
+     * @param {string|Array<number>|Buffer} mnemonic - A seed phrase represented
+     * as a string, an array of UTF-8 bytes, or a Buffer. Mnemonic input
+     * passed as type buffer or array of UTF-8 bytes must be NFKD normalized.
+     */
+    async _initFromMnemonic(mnemonic) {
+        if (this.root) {
+            throw new Error('Eth-Hd-Keyring: Secret recovery phrase already provided');
+        }
+        this.mnemonic = this._mnemonicToUint8Array(mnemonic);
+        const seed = await (0, key_tree_1.mnemonicToSeed)(this.mnemonic, '', // No passphrase
+        this._cryptographicFunctions);
+        this.hdWallet = hdkey_1.HDKey.fromMasterSeed(seed);
+        this.root = this.hdWallet.derive(this.hdPath);
+    }
+    // small helper function to convert publicKey in Uint8Array form to a publicAddress as a hex
+    _addressfromPublicKey(publicKey) {
+        return (0, util_1.bufferToHex)((0, util_1.publicToAddress)(Buffer.from(publicKey), true)).toLowerCase();
+    }
+}
+HdKeyring.type = type;
+exports.default = HdKeyring;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"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","sourcesContent":["import {\n  privateToPublic,\n  publicToAddress,\n  ecsign,\n  arrToBufArr,\n  bufferToHex,\n} from '@ethereumjs/util';\nimport {\n  concatSig,\n  decrypt,\n  getEncryptionPublicKey,\n  normalize,\n  personalSign,\n  signTypedData,\n  SignTypedDataVersion,\n} from '@metamask/eth-sig-util';\nimport { mnemonicToSeed } from '@metamask/key-tree';\nimport { generateMnemonic } from '@metamask/scure-bip39';\nimport { wordlist } from '@metamask/scure-bip39/dist/wordlists/english';\nimport { assertIsHexString, remove0x } from '@metamask/utils';\nimport { HDKey } from 'ethereum-cryptography/hdkey';\nimport { keccak256 } from 'ethereum-cryptography/keccak';\nimport { bytesToHex } from 'ethereum-cryptography/utils';\n\n// Options:\nconst hdPathString = `m/44'/60'/0'/0`;\nconst type = 'HD Key Tree';\n\nclass HdKeyring {\n  /* PUBLIC METHODS */\n  constructor(opts = {}) {\n    this.type = type;\n    this._wallets = [];\n    // Cryptographic functions to be used by `@metamask/key-tree`. It will use built-in implementations if not provided here.\n    this._cryptographicFunctions = opts.cryptographicFunctions;\n  }\n\n  async generateRandomMnemonic() {\n    await this._initFromMnemonic(generateMnemonic(wordlist));\n  }\n\n  _uint8ArrayToString(mnemonic) {\n    const recoveredIndices = Array.from(\n      new Uint16Array(new Uint8Array(mnemonic).buffer),\n    );\n    return recoveredIndices.map((i) => wordlist[i]).join(' ');\n  }\n\n  _stringToUint8Array(mnemonic) {\n    const indices = mnemonic.split(' ').map((word) => wordlist.indexOf(word));\n    return new Uint8Array(new Uint16Array(indices).buffer);\n  }\n\n  _mnemonicToUint8Array(mnemonic) {\n    let mnemonicData = mnemonic;\n    // when encrypted/decrypted, buffers get cast into js object with a property type set to buffer\n    if (mnemonic && mnemonic.type && mnemonic.type === 'Buffer') {\n      mnemonicData = mnemonic.data;\n    }\n\n    if (\n      // this block is for backwards compatibility with vaults that were previously stored as buffers, number arrays or plain text strings\n      typeof mnemonicData === 'string' ||\n      Buffer.isBuffer(mnemonicData) ||\n      Array.isArray(mnemonicData)\n    ) {\n      let mnemonicAsString = mnemonicData;\n      if (Array.isArray(mnemonicData)) {\n        mnemonicAsString = Buffer.from(mnemonicData).toString();\n      } else if (Buffer.isBuffer(mnemonicData)) {\n        mnemonicAsString = mnemonicData.toString();\n      }\n      return this._stringToUint8Array(mnemonicAsString);\n    } else if (\n      mnemonicData instanceof Object &&\n      !(mnemonicData instanceof Uint8Array)\n    ) {\n      // when encrypted/decrypted the Uint8Array becomes a js object we need to cast back to a Uint8Array\n      return Uint8Array.from(Object.values(mnemonicData));\n    }\n    return mnemonicData;\n  }\n\n  async serialize() {\n    const mnemonicAsString = this._uint8ArrayToString(this.mnemonic);\n    const uint8ArrayMnemonic = new TextEncoder('utf-8').encode(\n      mnemonicAsString,\n    );\n\n    return {\n      mnemonic: Array.from(uint8ArrayMnemonic),\n      numberOfAccounts: this._wallets.length,\n      hdPath: this.hdPath,\n    };\n  }\n\n  async deserialize(opts = {}) {\n    if (opts.numberOfAccounts && !opts.mnemonic) {\n      throw new Error(\n        'Eth-Hd-Keyring: Deserialize method cannot be called with an opts value for numberOfAccounts and no menmonic',\n      );\n    }\n\n    if (this.root) {\n      throw new Error(\n        'Eth-Hd-Keyring: Secret recovery phrase already provided',\n      );\n    }\n    this.opts = opts;\n    this._wallets = [];\n    this.mnemonic = null;\n    this.root = null;\n    this.hdPath = opts.hdPath || hdPathString;\n\n    if (opts.mnemonic) {\n      await this._initFromMnemonic(opts.mnemonic);\n    }\n\n    if (opts.numberOfAccounts) {\n      return this.addAccounts(opts.numberOfAccounts);\n    }\n\n    return [];\n  }\n\n  addAccounts(numberOfAccounts = 1) {\n    if (!this.root) {\n      throw new Error('Eth-Hd-Keyring: No secret recovery phrase provided');\n    }\n\n    const oldLen = this._wallets.length;\n    const newWallets = [];\n    for (let i = oldLen; i < numberOfAccounts + oldLen; i++) {\n      const wallet = this.root.deriveChild(i);\n      newWallets.push(wallet);\n      this._wallets.push(wallet);\n    }\n    const hexWallets = newWallets.map((w) => {\n      return this._addressfromPublicKey(w.publicKey);\n    });\n    return Promise.resolve(hexWallets);\n  }\n\n  getAccounts() {\n    return this._wallets.map((w) => this._addressfromPublicKey(w.publicKey));\n  }\n\n  /* BASE KEYRING METHODS */\n\n  // returns an address specific to an app\n  async getAppKeyAddress(address, origin) {\n    if (!origin || typeof origin !== 'string') {\n      throw new Error(`'origin' must be a non-empty string`);\n    }\n    const wallet = this._getWalletForAccount(address, {\n      withAppKeyOrigin: origin,\n    });\n    const appKeyAddress = normalize(\n      publicToAddress(wallet.publicKey).toString('hex'),\n    );\n\n    return appKeyAddress;\n  }\n\n  // exportAccount should return a hex-encoded private key:\n  async exportAccount(address, opts = {}) {\n    const wallet = this._getWalletForAccount(address, opts);\n    return bytesToHex(wallet.privateKey);\n  }\n\n  // tx is an instance of the ethereumjs-transaction class.\n  async signTransaction(address, tx, opts = {}) {\n    const privKey = this._getPrivateKeyFor(address, opts);\n    const signedTx = tx.sign(privKey);\n    // Newer versions of Ethereumjs-tx are immutable and return a new tx object\n    return signedTx === undefined ? tx : signedTx;\n  }\n\n  // For eth_sign, we need to sign arbitrary data:\n  async signMessage(address, data, opts = {}) {\n    assertIsHexString(data);\n    const message = remove0x(data);\n    const privKey = this._getPrivateKeyFor(address, opts);\n    const msgSig = ecsign(Buffer.from(message, 'hex'), privKey);\n    const rawMsgSig = concatSig(msgSig.v, msgSig.r, msgSig.s);\n    return rawMsgSig;\n  }\n\n  // For personal_sign, we need to prefix the message:\n  async signPersonalMessage(address, msgHex, opts = {}) {\n    const privKey = this._getPrivateKeyFor(address, opts);\n    const privateKey = Buffer.from(privKey, 'hex');\n    const sig = personalSign({ privateKey, data: msgHex });\n    return sig;\n  }\n\n  // For eth_decryptMessage:\n  async decryptMessage(withAccount, encryptedData) {\n    const wallet = this._getWalletForAccount(withAccount);\n    const { privateKey: privateKeyAsUint8Array } = wallet;\n    const privateKeyAsHex = Buffer.from(privateKeyAsUint8Array).toString('hex');\n    const sig = decrypt({ privateKey: privateKeyAsHex, encryptedData });\n    return sig;\n  }\n\n  // personal_signTypedData, signs data along with the schema\n  async signTypedData(\n    withAccount,\n    typedData,\n    opts = { version: SignTypedDataVersion.V1 },\n  ) {\n    // Treat invalid versions as \"V1\"\n    const version = Object.keys(SignTypedDataVersion).includes(opts.version)\n      ? opts.version\n      : SignTypedDataVersion.V1;\n\n    const privateKey = this._getPrivateKeyFor(withAccount, opts);\n    return signTypedData({ privateKey, data: typedData, version });\n  }\n\n  removeAccount(account) {\n    const address = normalize(account);\n    if (\n      !this._wallets\n        .map(({ publicKey }) => this._addressfromPublicKey(publicKey))\n        .includes(address)\n    ) {\n      throw new Error(`Address ${address} not found in this keyring`);\n    }\n\n    this._wallets = this._wallets.filter(\n      ({ publicKey }) => this._addressfromPublicKey(publicKey) !== address,\n    );\n  }\n\n  // get public key for nacl\n  async getEncryptionPublicKey(withAccount, opts = {}) {\n    const privKey = this._getPrivateKeyFor(withAccount, opts);\n    const publicKey = getEncryptionPublicKey(privKey);\n    return publicKey;\n  }\n\n  _getPrivateKeyFor(address, opts = {}) {\n    if (!address) {\n      throw new Error('Must specify address.');\n    }\n    const wallet = this._getWalletForAccount(address, opts);\n    return wallet.privateKey;\n  }\n\n  _getWalletForAccount(account, opts = {}) {\n    const address = normalize(account);\n    let wallet = this._wallets.find(({ publicKey }) => {\n      return this._addressfromPublicKey(publicKey) === address;\n    });\n    if (!wallet) {\n      throw new Error('HD Keyring - Unable to find matching address.');\n    }\n\n    if (opts.withAppKeyOrigin) {\n      const { privateKey } = wallet;\n      const appKeyOriginBuffer = Buffer.from(opts.withAppKeyOrigin, 'utf8');\n      const appKeyBuffer = Buffer.concat([privateKey, appKeyOriginBuffer]);\n      const appKeyPrivateKey = arrToBufArr(keccak256(appKeyBuffer, 256));\n      const appKeyPublicKey = privateToPublic(appKeyPrivateKey);\n      wallet = { privateKey: appKeyPrivateKey, publicKey: appKeyPublicKey };\n    }\n\n    return wallet;\n  }\n\n  /* PRIVATE / UTILITY METHODS */\n\n  /**\n   * Sets appropriate properties for the keyring based on the given\n   * BIP39-compliant mnemonic.\n   *\n   * @param {string|Array<number>|Buffer} mnemonic - A seed phrase represented\n   * as a string, an array of UTF-8 bytes, or a Buffer. Mnemonic input\n   * passed as type buffer or array of UTF-8 bytes must be NFKD normalized.\n   */\n  async _initFromMnemonic(mnemonic) {\n    if (this.root) {\n      throw new Error(\n        'Eth-Hd-Keyring: Secret recovery phrase already provided',\n      );\n    }\n\n    this.mnemonic = this._mnemonicToUint8Array(mnemonic);\n\n    const seed = await mnemonicToSeed(\n      this.mnemonic,\n      '', // No passphrase\n      this._cryptographicFunctions,\n    );\n    this.hdWallet = HDKey.fromMasterSeed(seed);\n    this.root = this.hdWallet.derive(this.hdPath);\n  }\n\n  // small helper function to convert publicKey in Uint8Array form to a publicAddress as a hex\n  _addressfromPublicKey(publicKey) {\n    return bufferToHex(\n      publicToAddress(Buffer.from(publicKey), true),\n    ).toLowerCase();\n  }\n}\n\nHdKeyring.type = type;\nexport default HdKeyring;\n"]}

package/dist/index.d.cts

@@ -0,0 +1,54 @@
+export default HdKeyring;
+declare class HdKeyring {
+    constructor(opts?: {});
+    type: string;
+    _wallets: any[];
+    _cryptographicFunctions: any;
+    generateRandomMnemonic(): Promise<void>;
+    _uint8ArrayToString(mnemonic: any): string;
+    _stringToUint8Array(mnemonic: any): Uint8Array;
+    _mnemonicToUint8Array(mnemonic: any): any;
+    serialize(): Promise<{
+        mnemonic: number[];
+        numberOfAccounts: number;
+        hdPath: any;
+    }>;
+    deserialize(opts?: {}): Promise<string[]>;
+    opts: {} | undefined;
+    mnemonic: any;
+    root: HDKey | null | undefined;
+    hdPath: any;
+    addAccounts(numberOfAccounts?: number): Promise<string[]>;
+    getAccounts(): string[];
+    getAppKeyAddress(address: any, origin: any): Promise<string | undefined>;
+    exportAccount(address: any, opts?: {}): Promise<string>;
+    signTransaction(address: any, tx: any, opts?: {}): Promise<any>;
+    signMessage(address: any, data: any, opts?: {}): Promise<string>;
+    signPersonalMessage(address: any, msgHex: any, opts?: {}): Promise<string>;
+    decryptMessage(withAccount: any, encryptedData: any): Promise<string>;
+    signTypedData(withAccount: any, typedData: any, opts?: {
+        version: SignTypedDataVersion;
+    }): Promise<string>;
+    removeAccount(account: any): void;
+    getEncryptionPublicKey(withAccount: any, opts?: {}): Promise<string>;
+    _getPrivateKeyFor(address: any, opts?: {}): any;
+    _getWalletForAccount(account: any, opts?: {}): any;
+    /**
+     * Sets appropriate properties for the keyring based on the given
+     * BIP39-compliant mnemonic.
+     *
+     * @param {string|Array<number>|Buffer} mnemonic - A seed phrase represented
+     * as a string, an array of UTF-8 bytes, or a Buffer. Mnemonic input
+     * passed as type buffer or array of UTF-8 bytes must be NFKD normalized.
+     */
+    _initFromMnemonic(mnemonic: string | Array<number> | Buffer): Promise<void>;
+    hdWallet: HDKey | undefined;
+    _addressfromPublicKey(publicKey: any): string;
+}
+declare namespace HdKeyring {
+    export { type };
+}
+import { HDKey } from "ethereum-cryptography/hdkey";
+import { SignTypedDataVersion } from "@metamask/eth-sig-util";
+declare const type: "HD Key Tree";
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";AA4BA;IAEE,uBAKC;IAJC,aAAgB;IAChB,gBAAkB;IAElB,6BAA0D;IAG5D,wCAEC;IAED,2CAKC;IAED,+CAGC;IAED,0CA4BC;IAED;;;;OAWC;IAED,0CA2BC;IAfC,qBAAgB;IAEhB,cAAoB;IACpB,+BAAgB;IAChB,YAAyC;IAa3C,0DAgBC;IAED,wBAEC;IAKD,yEAYC;IAGD,wDAGC;IAGD,gEAKC;IAGD,iEAOC;IAGD,2EAKC;IAGD,sEAMC;IAGD;;wBAYC;IAED,kCAaC;IAGD,qEAIC;IAED,gDAMC;IAED,mDAmBC;IAID;;;;;;;OAOG;IACH,4BAJW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,GAAC,MAAM,iBAoBrC;IAFC,4BAA0C;IAK5C,8CAIC;CACF;;;;;;AAvRD,kCAA2B"}

package/dist/index.d.mts

@@ -0,0 +1,54 @@
+export default HdKeyring;
+declare class HdKeyring {
+    constructor(opts?: {});
+    type: string;
+    _wallets: any[];
+    _cryptographicFunctions: any;
+    generateRandomMnemonic(): Promise<void>;
+    _uint8ArrayToString(mnemonic: any): string;
+    _stringToUint8Array(mnemonic: any): Uint8Array;
+    _mnemonicToUint8Array(mnemonic: any): any;
+    serialize(): Promise<{
+        mnemonic: number[];
+        numberOfAccounts: number;
+        hdPath: any;
+    }>;
+    deserialize(opts?: {}): Promise<string[]>;
+    opts: {} | undefined;
+    mnemonic: any;
+    root: HDKey | null | undefined;
+    hdPath: any;
+    addAccounts(numberOfAccounts?: number): Promise<string[]>;
+    getAccounts(): string[];
+    getAppKeyAddress(address: any, origin: any): Promise<string | undefined>;
+    exportAccount(address: any, opts?: {}): Promise<string>;
+    signTransaction(address: any, tx: any, opts?: {}): Promise<any>;
+    signMessage(address: any, data: any, opts?: {}): Promise<string>;
+    signPersonalMessage(address: any, msgHex: any, opts?: {}): Promise<string>;
+    decryptMessage(withAccount: any, encryptedData: any): Promise<string>;
+    signTypedData(withAccount: any, typedData: any, opts?: {
+        version: SignTypedDataVersion;
+    }): Promise<string>;
+    removeAccount(account: any): void;
+    getEncryptionPublicKey(withAccount: any, opts?: {}): Promise<string>;
+    _getPrivateKeyFor(address: any, opts?: {}): any;
+    _getWalletForAccount(account: any, opts?: {}): any;
+    /**
+     * Sets appropriate properties for the keyring based on the given
+     * BIP39-compliant mnemonic.
+     *
+     * @param {string|Array<number>|Buffer} mnemonic - A seed phrase represented
+     * as a string, an array of UTF-8 bytes, or a Buffer. Mnemonic input
+     * passed as type buffer or array of UTF-8 bytes must be NFKD normalized.
+     */
+    _initFromMnemonic(mnemonic: string | Array<number> | Buffer): Promise<void>;
+    hdWallet: HDKey | undefined;
+    _addressfromPublicKey(publicKey: any): string;
+}
+declare namespace HdKeyring {
+    export { type };
+}
+import { HDKey } from "ethereum-cryptography/hdkey";
+import { SignTypedDataVersion } from "@metamask/eth-sig-util";
+declare const type: "HD Key Tree";
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";AA4BA;IAEE,uBAKC;IAJC,aAAgB;IAChB,gBAAkB;IAElB,6BAA0D;IAG5D,wCAEC;IAED,2CAKC;IAED,+CAGC;IAED,0CA4BC;IAED;;;;OAWC;IAED,0CA2BC;IAfC,qBAAgB;IAEhB,cAAoB;IACpB,+BAAgB;IAChB,YAAyC;IAa3C,0DAgBC;IAED,wBAEC;IAKD,yEAYC;IAGD,wDAGC;IAGD,gEAKC;IAGD,iEAOC;IAGD,2EAKC;IAGD,sEAMC;IAGD;;wBAYC;IAED,kCAaC;IAGD,qEAIC;IAED,gDAMC;IAED,mDAmBC;IAID;;;;;;;OAOG;IACH,4BAJW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,GAAC,MAAM,iBAoBrC;IAFC,4BAA0C;IAK5C,8CAIC;CACF;;;;;;AAvRD,kCAA2B"}

package/dist/index.mjs

@@ -0,0 +1,230 @@
+import { privateToPublic, publicToAddress, ecsign, arrToBufArr, bufferToHex } from "@ethereumjs/util";
+import { concatSig, decrypt, getEncryptionPublicKey, normalize, personalSign, signTypedData, SignTypedDataVersion } from "@metamask/eth-sig-util";
+import { mnemonicToSeed } from "@metamask/key-tree";
+import { generateMnemonic } from "@metamask/scure-bip39";
+import { wordlist } from "@metamask/scure-bip39/dist/wordlists/english.js";
+import { assertIsHexString, remove0x } from "@metamask/utils";
+import { HDKey } from "ethereum-cryptography/hdkey";
+import { keccak256 } from "ethereum-cryptography/keccak";
+import { bytesToHex } from "ethereum-cryptography/utils";
+// Options:
+const hdPathString = `m/44'/60'/0'/0`;
+const type = 'HD Key Tree';
+class HdKeyring {
+    /* PUBLIC METHODS */
+    constructor(opts = {}) {
+        this.type = type;
+        this._wallets = [];
+        // Cryptographic functions to be used by `@metamask/key-tree`. It will use built-in implementations if not provided here.
+        this._cryptographicFunctions = opts.cryptographicFunctions;
+    }
+    async generateRandomMnemonic() {
+        await this._initFromMnemonic(generateMnemonic(wordlist));
+    }
+    _uint8ArrayToString(mnemonic) {
+        const recoveredIndices = Array.from(new Uint16Array(new Uint8Array(mnemonic).buffer));
+        return recoveredIndices.map((i) => wordlist[i]).join(' ');
+    }
+    _stringToUint8Array(mnemonic) {
+        const indices = mnemonic.split(' ').map((word) => wordlist.indexOf(word));
+        return new Uint8Array(new Uint16Array(indices).buffer);
+    }
+    _mnemonicToUint8Array(mnemonic) {
+        let mnemonicData = mnemonic;
+        // when encrypted/decrypted, buffers get cast into js object with a property type set to buffer
+        if (mnemonic && mnemonic.type && mnemonic.type === 'Buffer') {
+            mnemonicData = mnemonic.data;
+        }
+        if (
+        // this block is for backwards compatibility with vaults that were previously stored as buffers, number arrays or plain text strings
+        typeof mnemonicData === 'string' ||
+            Buffer.isBuffer(mnemonicData) ||
+            Array.isArray(mnemonicData)) {
+            let mnemonicAsString = mnemonicData;
+            if (Array.isArray(mnemonicData)) {
+                mnemonicAsString = Buffer.from(mnemonicData).toString();
+            }
+            else if (Buffer.isBuffer(mnemonicData)) {
+                mnemonicAsString = mnemonicData.toString();
+            }
+            return this._stringToUint8Array(mnemonicAsString);
+        }
+        else if (mnemonicData instanceof Object &&
+            !(mnemonicData instanceof Uint8Array)) {
+            // when encrypted/decrypted the Uint8Array becomes a js object we need to cast back to a Uint8Array
+            return Uint8Array.from(Object.values(mnemonicData));
+        }
+        return mnemonicData;
+    }
+    async serialize() {
+        const mnemonicAsString = this._uint8ArrayToString(this.mnemonic);
+        const uint8ArrayMnemonic = new TextEncoder('utf-8').encode(mnemonicAsString);
+        return {
+            mnemonic: Array.from(uint8ArrayMnemonic),
+            numberOfAccounts: this._wallets.length,
+            hdPath: this.hdPath,
+        };
+    }
+    async deserialize(opts = {}) {
+        if (opts.numberOfAccounts && !opts.mnemonic) {
+            throw new Error('Eth-Hd-Keyring: Deserialize method cannot be called with an opts value for numberOfAccounts and no menmonic');
+        }
+        if (this.root) {
+            throw new Error('Eth-Hd-Keyring: Secret recovery phrase already provided');
+        }
+        this.opts = opts;
+        this._wallets = [];
+        this.mnemonic = null;
+        this.root = null;
+        this.hdPath = opts.hdPath || hdPathString;
+        if (opts.mnemonic) {
+            await this._initFromMnemonic(opts.mnemonic);
+        }
+        if (opts.numberOfAccounts) {
+            return this.addAccounts(opts.numberOfAccounts);
+        }
+        return [];
+    }
+    addAccounts(numberOfAccounts = 1) {
+        if (!this.root) {
+            throw new Error('Eth-Hd-Keyring: No secret recovery phrase provided');
+        }
+        const oldLen = this._wallets.length;
+        const newWallets = [];
+        for (let i = oldLen; i < numberOfAccounts + oldLen; i++) {
+            const wallet = this.root.deriveChild(i);
+            newWallets.push(wallet);
+            this._wallets.push(wallet);
+        }
+        const hexWallets = newWallets.map((w) => {
+            return this._addressfromPublicKey(w.publicKey);
+        });
+        return Promise.resolve(hexWallets);
+    }
+    getAccounts() {
+        return this._wallets.map((w) => this._addressfromPublicKey(w.publicKey));
+    }
+    /* BASE KEYRING METHODS */
+    // returns an address specific to an app
+    async getAppKeyAddress(address, origin) {
+        if (!origin || typeof origin !== 'string') {
+            throw new Error(`'origin' must be a non-empty string`);
+        }
+        const wallet = this._getWalletForAccount(address, {
+            withAppKeyOrigin: origin,
+        });
+        const appKeyAddress = normalize(publicToAddress(wallet.publicKey).toString('hex'));
+        return appKeyAddress;
+    }
+    // exportAccount should return a hex-encoded private key:
+    async exportAccount(address, opts = {}) {
+        const wallet = this._getWalletForAccount(address, opts);
+        return bytesToHex(wallet.privateKey);
+    }
+    // tx is an instance of the ethereumjs-transaction class.
+    async signTransaction(address, tx, opts = {}) {
+        const privKey = this._getPrivateKeyFor(address, opts);
+        const signedTx = tx.sign(privKey);
+        // Newer versions of Ethereumjs-tx are immutable and return a new tx object
+        return signedTx === undefined ? tx : signedTx;
+    }
+    // For eth_sign, we need to sign arbitrary data:
+    async signMessage(address, data, opts = {}) {
+        assertIsHexString(data);
+        const message = remove0x(data);
+        const privKey = this._getPrivateKeyFor(address, opts);
+        const msgSig = ecsign(Buffer.from(message, 'hex'), privKey);
+        const rawMsgSig = concatSig(msgSig.v, msgSig.r, msgSig.s);
+        return rawMsgSig;
+    }
+    // For personal_sign, we need to prefix the message:
+    async signPersonalMessage(address, msgHex, opts = {}) {
+        const privKey = this._getPrivateKeyFor(address, opts);
+        const privateKey = Buffer.from(privKey, 'hex');
+        const sig = personalSign({ privateKey, data: msgHex });
+        return sig;
+    }
+    // For eth_decryptMessage:
+    async decryptMessage(withAccount, encryptedData) {
+        const wallet = this._getWalletForAccount(withAccount);
+        const { privateKey: privateKeyAsUint8Array } = wallet;
+        const privateKeyAsHex = Buffer.from(privateKeyAsUint8Array).toString('hex');
+        const sig = decrypt({ privateKey: privateKeyAsHex, encryptedData });
+        return sig;
+    }
+    // personal_signTypedData, signs data along with the schema
+    async signTypedData(withAccount, typedData, opts = { version: SignTypedDataVersion.V1 }) {
+        // Treat invalid versions as "V1"
+        const version = Object.keys(SignTypedDataVersion).includes(opts.version)
+            ? opts.version
+            : SignTypedDataVersion.V1;
+        const privateKey = this._getPrivateKeyFor(withAccount, opts);
+        return signTypedData({ privateKey, data: typedData, version });
+    }
+    removeAccount(account) {
+        const address = normalize(account);
+        if (!this._wallets
+            .map(({ publicKey }) => this._addressfromPublicKey(publicKey))
+            .includes(address)) {
+            throw new Error(`Address ${address} not found in this keyring`);
+        }
+        this._wallets = this._wallets.filter(({ publicKey }) => this._addressfromPublicKey(publicKey) !== address);
+    }
+    // get public key for nacl
+    async getEncryptionPublicKey(withAccount, opts = {}) {
+        const privKey = this._getPrivateKeyFor(withAccount, opts);
+        const publicKey = getEncryptionPublicKey(privKey);
+        return publicKey;
+    }
+    _getPrivateKeyFor(address, opts = {}) {
+        if (!address) {
+            throw new Error('Must specify address.');
+        }
+        const wallet = this._getWalletForAccount(address, opts);
+        return wallet.privateKey;
+    }
+    _getWalletForAccount(account, opts = {}) {
+        const address = normalize(account);
+        let wallet = this._wallets.find(({ publicKey }) => {
+            return this._addressfromPublicKey(publicKey) === address;
+        });
+        if (!wallet) {
+            throw new Error('HD Keyring - Unable to find matching address.');
+        }
+        if (opts.withAppKeyOrigin) {
+            const { privateKey } = wallet;
+            const appKeyOriginBuffer = Buffer.from(opts.withAppKeyOrigin, 'utf8');
+            const appKeyBuffer = Buffer.concat([privateKey, appKeyOriginBuffer]);
+            const appKeyPrivateKey = arrToBufArr(keccak256(appKeyBuffer, 256));
+            const appKeyPublicKey = privateToPublic(appKeyPrivateKey);
+            wallet = { privateKey: appKeyPrivateKey, publicKey: appKeyPublicKey };
+        }
+        return wallet;
+    }
+    /* PRIVATE / UTILITY METHODS */
+    /**
+     * Sets appropriate properties for the keyring based on the given
+     * BIP39-compliant mnemonic.
+     *
+     * @param {string|Array<number>|Buffer} mnemonic - A seed phrase represented
+     * as a string, an array of UTF-8 bytes, or a Buffer. Mnemonic input
+     * passed as type buffer or array of UTF-8 bytes must be NFKD normalized.
+     */
+    async _initFromMnemonic(mnemonic) {
+        if (this.root) {
+            throw new Error('Eth-Hd-Keyring: Secret recovery phrase already provided');
+        }
+        this.mnemonic = this._mnemonicToUint8Array(mnemonic);
+        const seed = await mnemonicToSeed(this.mnemonic, '', // No passphrase
+        this._cryptographicFunctions);
+        this.hdWallet = HDKey.fromMasterSeed(seed);
+        this.root = this.hdWallet.derive(this.hdPath);
+    }
+    // small helper function to convert publicKey in Uint8Array form to a publicAddress as a hex
+    _addressfromPublicKey(publicKey) {
+        return bufferToHex(publicToAddress(Buffer.from(publicKey), true)).toLowerCase();
+    }
+}
+HdKeyring.type = type;
+export default HdKeyring;
+//# sourceMappingURL=index.mjs.map