@rabby-wallet/eth-hd-keyring 4.0.1 → 4.1.0-beta.0

package/dist/index.js

@@ -39,92 +39,123 @@ const english_1 = require("@scure/bip39/wordlists/english");
 const sigUtil = __importStar(require("eth-sig-util"));
 const util_1 = require("@ethereumjs/util");
 // Options:
-const hdPathString = "m/44'/60'/0'/0";
 const type = 'HD Key Tree';
+var HDPathType;
+(function (HDPathType) {
+    HDPathType["LedgerLive"] = "LedgerLive";
+    HDPathType["Legacy"] = "Legacy";
+    HDPathType["BIP44"] = "BIP44";
+})(HDPathType || (HDPathType = {}));
+const HD_PATH_BASE = {
+    [HDPathType.BIP44]: "m/44'/60'/0'/0",
+    [HDPathType.Legacy]: "m/44'/60'/0'",
+    [HDPathType.LedgerLive]: "m/44'/60'/0'/0/0",
+};
+const HD_PATH_TYPE = {
+    [HD_PATH_BASE[HDPathType.BIP44]]: HDPathType.BIP44,
+    [HD_PATH_BASE[HDPathType.Legacy]]: HDPathType.Legacy,
+    [HD_PATH_BASE[HDPathType.LedgerLive]]: HDPathType.LedgerLive,
+};
 class HdKeyring extends eth_simple_keyring_1.default {
     /* PUBLIC METHODS */
     constructor(opts = {}) {
         super();
         this.type = type;
         this.mnemonic = null;
-        this.hdPath = hdPathString;
-        this.root = null;
+        this.hdPath = HD_PATH_BASE[HDPathType.BIP44];
         this.wallets = [];
-        this._index2wallet = {};
         this.activeIndexes = [];
         this.index = 0;
         this.page = 0;
         this.perPage = 5;
         this.byImport = false;
         this.publicKey = '';
+        this.needPassphrase = false;
+        this.accounts = [];
+        this.accountDetails = {};
+        this.setAccountDetail = (address, accountDetail) => {
+            this.accountDetails = Object.assign(Object.assign({}, this.accountDetails), { [address.toLowerCase()]: accountDetail });
+        };
+        this.getAccountDetail = (address) => {
+            return this.accountDetails[address.toLowerCase()];
+        };
         this.deserialize(opts);
     }
     serialize() {
         return Promise.resolve({
             mnemonic: this.mnemonic,
+            /**
+             * @deprecated
+             */
             activeIndexes: this.activeIndexes,
             hdPath: this.hdPath,
             byImport: this.byImport,
             index: this.index,
+            needPassphrase: this.needPassphrase,
+            accounts: this.accounts,
+            accountDetails: this.accountDetails,
             publicKey: this.publicKey,
         });
     }
     deserialize(opts = {}) {
         this.wallets = [];
         this.mnemonic = null;
-        this.root = null;
-        this.hdPath = opts.hdPath || hdPathString;
+        this.hdPath = opts.hdPath || HD_PATH_BASE[HDPathType.BIP44];
         this.byImport = !!opts.byImport;
         this.index = opts.index || 0;
+        this.needPassphrase = opts.needPassphrase || !!opts.passphrase;
+        this.accounts = opts.accounts || [];
+        this.accountDetails = opts.accountDetails || {};
         this.publicKey = opts.publicKey || '';
         if (opts.mnemonic) {
-            this.initFromMnemonic(opts.mnemonic);
+            this.mnemonic = opts.mnemonic;
+            this.setPassphrase(opts.passphrase || '');
         }
-        if (opts.activeIndexes) {
+        // activeIndexes is deprecated, if accounts is not empty, use accounts
+        if (!this.accounts.length && opts.activeIndexes) {
             return this.activeAccounts(opts.activeIndexes);
         }
         return Promise.resolve([]);
     }
-    initPublicKey() {
-        this.root = this.hdWallet.derive(this.hdPath);
-        this.publicKey = (0, util_1.bytesToHex)(this.root.publicKey);
-    }
-    getPublicKey() {
-        return this.publicKey;
-    }
-    initFromMnemonic(mnemonic) {
+    initFromMnemonic(mnemonic, passphrase) {
         this.mnemonic = mnemonic;
-        this._index2wallet = {};
-        const seed = bip39.mnemonicToSeedSync(mnemonic);
+        const seed = bip39.mnemonicToSeedSync(mnemonic, passphrase);
         this.hdWallet = hdkey_1.HDKey.fromMasterSeed(seed);
-        this.root = this.hdWallet.derive(this.hdPath);
         if (!this.publicKey) {
-            this.initPublicKey();
+            this.publicKey = this.calcBasePublicKey(this.hdWallet);
         }
     }
+    calcBasePublicKey(hdKey) {
+        return (0, util_1.bytesToHex)(hdKey.derive(this.getHDPathBase(HDPathType.BIP44)).publicKey);
+    }
     addAccounts(numberOfAccounts = 1) {
-        if (!this.root) {
+        if (!this.hdWallet) {
             this.initFromMnemonic(bip39.generateMnemonic(english_1.wordlist));
         }
         let count = numberOfAccounts;
         let currentIdx = 0;
-        const newWallets = [];
+        const addresses = [];
         while (count) {
-            const [, wallet] = this._addressFromIndex(currentIdx);
-            if (this.wallets.includes(wallet)) {
+            const [address, wallet] = this._addressFromIndex(currentIdx);
+            if (this.wallets.find((w) => (0, util_1.bytesToHex)(w.publicKey) === (0, util_1.bytesToHex)(wallet.publicKey))) {
                 currentIdx++;
             }
             else {
                 this.wallets.push(wallet);
-                newWallets.push(wallet);
-                this.activeIndexes.push(currentIdx);
+                addresses.push(address);
+                // this.activeIndexes.push(currentIdx);
+                this.setAccountDetail(address, {
+                    hdPath: this.hdPath,
+                    hdPathType: HD_PATH_TYPE[this.hdPath],
+                    index: currentIdx,
+                });
                 count--;
             }
+            if (!this.accounts.includes(address)) {
+                this.accounts.push(address);
+            }
         }
-        const hexWallets = newWallets.map((w) => {
-            return sigUtil.normalize(this._addressfromPublicKey(w.publicKey));
-        });
-        return Promise.resolve(hexWallets);
+        return Promise.resolve(addresses);
     }
     activeAccounts(indexes) {
         const accounts = [];
@@ -133,6 +164,15 @@ class HdKeyring extends eth_simple_keyring_1.default {
             this.wallets.push(wallet);
             this.activeIndexes.push(index);
             accounts.push(address);
+            // hdPath is BIP44
+            this.setAccountDetail(address, {
+                hdPath: this.hdPath,
+                hdPathType: HD_PATH_TYPE[this.hdPath],
+                index: index,
+            });
+            if (!this.accounts.includes(address)) {
+                this.accounts.push(address);
+            }
         }
         return accounts;
     }
@@ -160,9 +200,14 @@ class HdKeyring extends eth_simple_keyring_1.default {
         return accounts;
     }
     removeAccount(address) {
-        super.removeAccount(address);
-        const index = this.getIndexByAddress(address);
+        var _a;
+        const index = (_a = this.getInfoByAddress(address)) === null || _a === void 0 ? void 0 : _a.index;
         this.activeIndexes = this.activeIndexes.filter((i) => i !== index);
+        delete this.accountDetails[address];
+        this.accounts = this.accounts.filter((acc) => acc !== address);
+        this.wallets = this.wallets.filter(({ publicKey }) => sigUtil
+            .normalize(this._addressFromPublicKey(publicKey))
+            .toLowerCase() !== address.toLowerCase());
     }
     __getPage(increment) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -184,34 +229,92 @@ class HdKeyring extends eth_simple_keyring_1.default {
         });
     }
     getAccounts() {
+        var _a;
+        if ((_a = this.accounts) === null || _a === void 0 ? void 0 : _a.length) {
+            return Promise.resolve(this.accounts);
+        }
         return Promise.resolve(this.wallets.map((w) => {
-            return sigUtil.normalize(this._addressfromPublicKey(w.publicKey));
+            return sigUtil.normalize(this._addressFromPublicKey(w.publicKey));
         }));
     }
-    getIndexByAddress(address) {
-        for (const key in this._index2wallet) {
-            if (this._index2wallet[key][0].toLowerCase() === address.toLowerCase()) {
-                return Number(key);
+    getInfoByAddress(address) {
+        const detail = this.accountDetails[address];
+        if (detail) {
+            return detail;
+        }
+        for (const key in this.wallets) {
+            const wallet = this.wallets[key];
+            if (sigUtil.normalize(this._addressFromPublicKey(wallet.publicKey)) ===
+                address.toLowerCase()) {
+                return {
+                    index: Number(key),
+                    hdPathType: HD_PATH_TYPE[this.hdPath],
+                    hdPath: this.hdPath,
+                };
             }
         }
         return null;
     }
-    /* PRIVATE METHODS */
     _addressFromIndex(i) {
-        if (!this._index2wallet[i]) {
-            const child = this.root.deriveChild(i);
-            const wallet = {
-                publicKey: (0, util_1.privateToPublic)(child.privateKey),
-                privateKey: child.privateKey,
-            };
-            const address = sigUtil.normalize(this._addressfromPublicKey(wallet.publicKey));
-            this._index2wallet[i] = [address, wallet];
-        }
-        return this._index2wallet[i];
+        const child = this.getChildForIndex(i);
+        const wallet = {
+            publicKey: (0, util_1.privateToPublic)(child.privateKey),
+            privateKey: child.privateKey,
+        };
+        const address = sigUtil.normalize(this._addressFromPublicKey(wallet.publicKey));
+        return [address, wallet];
     }
-    _addressfromPublicKey(publicKey) {
+    _addressFromPublicKey(publicKey) {
         return (0, util_1.bytesToHex)((0, util_1.publicToAddress)(publicKey, true)).toLowerCase();
     }
+    generateMnemonic() {
+        return bip39.generateMnemonic(english_1.wordlist);
+    }
+    setHdPath(hdPath = HD_PATH_BASE[HDPathType.BIP44]) {
+        this.hdPath = hdPath;
+    }
+    getChildForIndex(index) {
+        return this.hdWallet.derive(this.getPathForIndex(index));
+    }
+    isLedgerLiveHdPath() {
+        return this.hdPath === HD_PATH_BASE[HDPathType.LedgerLive];
+    }
+    getPathForIndex(index) {
+        return this.isLedgerLiveHdPath()
+            ? `m/44'/60'/${index}'/0/0`
+            : `${this.hdPath}/${index}`;
+    }
+    setPassphrase(passphrase) {
+        this.initFromMnemonic(this.mnemonic, passphrase);
+        for (const acc of this.accounts) {
+            const detail = this.getAccountDetail(acc);
+            if (detail) {
+                this.setHdPath(detail.hdPath);
+                const [address, wallet] = this._addressFromIndex(detail.index);
+                if (address.toLowerCase() === acc.toLowerCase()) {
+                    this.wallets.push(wallet);
+                }
+            }
+        }
+    }
+    /**
+     * if passphrase is correct, the publicKey will be the same as the stored one
+     */
+    checkPassphrase(passphrase) {
+        const seed = bip39.mnemonicToSeedSync(this.mnemonic, passphrase);
+        const hdWallet = hdkey_1.HDKey.fromMasterSeed(seed);
+        const publicKey = this.calcBasePublicKey(hdWallet);
+        return this.publicKey === publicKey;
+    }
+    getHDPathBase(hdPathType) {
+        return HD_PATH_BASE[hdPathType];
+    }
+    setHDPathType(hdPathType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hdPath = this.getHDPathBase(hdPathType);
+            this.setHdPath(hdPath);
+        });
+    }
 }
 HdKeyring.type = type;
 exports.default = HdKeyring;

package/index.ts

@@ -4,16 +4,29 @@ import SimpleKeyring from '@rabby-wallet/eth-simple-keyring';
 import * as bip39 from '@scure/bip39';
 import { wordlist } from '@scure/bip39/wordlists/english';
 import * as sigUtil from 'eth-sig-util';
-import {
-  bytesToHex,
-  publicToAddress,
-  privateToPublic,
-} from '@ethereumjs/util';
+import { bytesToHex, publicToAddress, privateToPublic } from '@ethereumjs/util';
 
 // Options:
-const hdPathString = "m/44'/60'/0'/0";
 const type = 'HD Key Tree';
 
+enum HDPathType {
+  LedgerLive = 'LedgerLive',
+  Legacy = 'Legacy',
+  BIP44 = 'BIP44',
+}
+
+const HD_PATH_BASE = {
+  [HDPathType.BIP44]: "m/44'/60'/0'/0",
+  [HDPathType.Legacy]: "m/44'/60'/0'",
+  [HDPathType.LedgerLive]: "m/44'/60'/0'/0/0",
+};
+
+const HD_PATH_TYPE = {
+  [HD_PATH_BASE[HDPathType.BIP44]]: HDPathType.BIP44,
+  [HD_PATH_BASE[HDPathType.Legacy]]: HDPathType.Legacy,
+  [HD_PATH_BASE[HDPathType.LedgerLive]]: HDPathType.LedgerLive,
+};
+
 interface Wallet {
   publicKey: Uint8Array;
   privateKey: Uint8Array;
@@ -21,32 +34,43 @@ interface Wallet {
 
 interface DeserializeOption {
   hdPath?: string;
-  mnemonic?: string;
+  mnemonic: string;
   activeIndexes?: number[];
   byImport?: boolean;
   index?: number;
+  passphrase?: string;
+  needPassphrase?: boolean;
+  accounts?: string[];
+  accountDetails?: Record<string, AccountDetail>;
   publicKey?: string;
 }
 
+interface AccountDetail {
+  hdPath: string;
+  hdPathType: HDPathType;
+  index: number;
+}
+
 class HdKeyring extends SimpleKeyring {
   static type = type;
 
   type = type;
   mnemonic: string | null = null;
-  hdPath = hdPathString;
+  hdPath = HD_PATH_BASE[HDPathType.BIP44];
   hdWallet?: HDKey;
-  root: HDKey | null = null;
   wallets: Wallet[] = [];
-  _index2wallet: Record<number, [string, Wallet]> = {};
   activeIndexes: number[] = [];
   index = 0;
   page = 0;
   perPage = 5;
   byImport = false;
   publicKey: string = '';
+  needPassphrase = false;
+  accounts: string[] = [];
+  accountDetails: Record<string, AccountDetail> = {};
 
   /* PUBLIC METHODS */
-  constructor(opts = {}) {
+  constructor(opts: DeserializeOption = {} as any) {
     super();
     this.deserialize(opts);
   }
@@ -54,81 +78,93 @@ class HdKeyring extends SimpleKeyring {
   serialize() {
     return Promise.resolve({
       mnemonic: this.mnemonic,
+      /**
+       * @deprecated
+       */
       activeIndexes: this.activeIndexes,
       hdPath: this.hdPath,
       byImport: this.byImport,
       index: this.index,
+      needPassphrase: this.needPassphrase,
+      accounts: this.accounts,
+      accountDetails: this.accountDetails,
       publicKey: this.publicKey,
     });
   }
 
-  deserialize(opts: DeserializeOption = {}) {
+  deserialize(opts: DeserializeOption = {} as any) {
     this.wallets = [];
     this.mnemonic = null;
-    this.root = null;
-    this.hdPath = opts.hdPath || hdPathString;
+    this.hdPath = opts.hdPath || HD_PATH_BASE[HDPathType.BIP44];
     this.byImport = !!opts.byImport;
     this.index = opts.index || 0;
+    this.needPassphrase = opts.needPassphrase || !!opts.passphrase;
+    this.accounts = opts.accounts || [];
+    this.accountDetails = opts.accountDetails || {};
     this.publicKey = opts.publicKey || '';
 
     if (opts.mnemonic) {
-      this.initFromMnemonic(opts.mnemonic);
+      this.mnemonic = opts.mnemonic;
+      this.setPassphrase(opts.passphrase || '');
     }
 
-    if (opts.activeIndexes) {
+    // activeIndexes is deprecated, if accounts is not empty, use accounts
+    if (!this.accounts.length && opts.activeIndexes) {
       return this.activeAccounts(opts.activeIndexes);
     }
 
     return Promise.resolve([]);
   }
 
-  private initPublicKey() {
-    this.root = this.hdWallet!.derive(this.hdPath);
-    this.publicKey = bytesToHex(this.root.publicKey!);
-  }
-
-  getPublicKey() {
-    return this.publicKey;
-  }
-
-  initFromMnemonic(mnemonic) {
+  initFromMnemonic(mnemonic, passphrase?: string) {
     this.mnemonic = mnemonic;
-    this._index2wallet = {};
-    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    const seed = bip39.mnemonicToSeedSync(mnemonic, passphrase);
     this.hdWallet = HDKey.fromMasterSeed(seed);
-    this.root = this.hdWallet!.derive(this.hdPath);
-
     if (!this.publicKey) {
-      this.initPublicKey();
+      this.publicKey = this.calcBasePublicKey(this.hdWallet!);
     }
   }
 
+  private calcBasePublicKey(hdKey: HDKey) {
+    return bytesToHex(
+      hdKey.derive(this.getHDPathBase(HDPathType.BIP44)).publicKey!,
+    );
+  }
+
   addAccounts(numberOfAccounts = 1) {
-    if (!this.root) {
+    if (!this.hdWallet) {
       this.initFromMnemonic(bip39.generateMnemonic(wordlist));
     }
 
     let count = numberOfAccounts;
     let currentIdx = 0;
-    const newWallets: Wallet[] = [];
-    
+    const addresses: string[] = [];
+
     while (count) {
-      const [, wallet] = this._addressFromIndex(currentIdx);
-      if (this.wallets.includes(wallet)) {
+      const [address, wallet] = this._addressFromIndex(currentIdx);
+      if (
+        this.wallets.find(
+          (w) => bytesToHex(w.publicKey) === bytesToHex(wallet.publicKey),
+        )
+      ) {
         currentIdx++;
       } else {
         this.wallets.push(wallet);
-        newWallets.push(wallet);
-        this.activeIndexes.push(currentIdx);
+        addresses.push(address);
+        // this.activeIndexes.push(currentIdx);
+        this.setAccountDetail(address, {
+          hdPath: this.hdPath,
+          hdPathType: HD_PATH_TYPE[this.hdPath],
+          index: currentIdx,
+        });
         count--;
       }
+      if (!this.accounts.includes(address)) {
+        this.accounts.push(address);
+      }
     }
 
-    const hexWallets = newWallets.map((w) => {
-      return sigUtil.normalize(this._addressfromPublicKey(w.publicKey));
-    });
-
-    return Promise.resolve(hexWallets);
+    return Promise.resolve(addresses);
   }
 
   activeAccounts(indexes: number[]) {
@@ -139,6 +175,16 @@ class HdKeyring extends SimpleKeyring {
       this.activeIndexes.push(index);
 
       accounts.push(address);
+      // hdPath is BIP44
+      this.setAccountDetail(address, {
+        hdPath: this.hdPath,
+        hdPathType: HD_PATH_TYPE[this.hdPath],
+        index: index,
+      });
+
+      if (!this.accounts.includes(address)) {
+        this.accounts.push(address);
+      }
     }
 
     return accounts;
@@ -171,9 +217,16 @@ class HdKeyring extends SimpleKeyring {
   }
 
   removeAccount(address) {
-    super.removeAccount(address);
-    const index = this.getIndexByAddress(address);
+    const index = this.getInfoByAddress(address)?.index;
     this.activeIndexes = this.activeIndexes.filter((i) => i !== index);
+    delete this.accountDetails[address];
+    this.accounts = this.accounts.filter((acc) => acc !== address);
+    this.wallets = this.wallets.filter(
+      ({ publicKey }) =>
+        sigUtil
+          .normalize(this._addressFromPublicKey(publicKey))
+          .toLowerCase() !== address.toLowerCase(),
+    );
   }
 
   async __getPage(increment: number): Promise<
@@ -205,43 +258,123 @@ class HdKeyring extends SimpleKeyring {
   }
 
   getAccounts() {
+    if (this.accounts?.length) {
+      return Promise.resolve(this.accounts);
+    }
+
     return Promise.resolve(
       this.wallets.map((w) => {
-        return sigUtil.normalize(this._addressfromPublicKey(w.publicKey));
+        return sigUtil.normalize(this._addressFromPublicKey(w.publicKey));
       }),
     );
   }
 
-  getIndexByAddress(address: string): number | null {
-    for (const key in this._index2wallet) {
-      if (this._index2wallet[key][0].toLowerCase() === address.toLowerCase()) {
-        return Number(key);
+  getInfoByAddress(address: string): AccountDetail | null {
+    const detail = this.accountDetails[address];
+    if (detail) {
+      return detail;
+    }
+
+    for (const key in this.wallets) {
+      const wallet = this.wallets[key];
+      if (
+        sigUtil.normalize(this._addressFromPublicKey(wallet.publicKey)) ===
+        address.toLowerCase()
+      ) {
+        return {
+          index: Number(key),
+          hdPathType: HD_PATH_TYPE[this.hdPath],
+          hdPath: this.hdPath,
+        };
       }
     }
     return null;
   }
 
-  /* PRIVATE METHODS */
-
   _addressFromIndex(i: number): [string, Wallet] {
-    if (!this._index2wallet[i]) {
-      const child = this.root!.deriveChild(i);
-      const wallet = {
-        publicKey: privateToPublic(child.privateKey!),
-        privateKey: child.privateKey!,
-      };
-      const address = sigUtil.normalize(
-        this._addressfromPublicKey(wallet.publicKey),
-      );
-      this._index2wallet[i] = [address, wallet];
-    }
+    const child = this.getChildForIndex(i);
+    const wallet = {
+      publicKey: privateToPublic(child.privateKey!),
+      privateKey: child.privateKey!,
+    };
+    const address = sigUtil.normalize(
+      this._addressFromPublicKey(wallet.publicKey),
+    );
 
-    return this._index2wallet[i];
+    return [address, wallet];
   }
 
-  _addressfromPublicKey(publicKey: Uint8Array) {
+  private _addressFromPublicKey(publicKey: Uint8Array) {
     return bytesToHex(publicToAddress(publicKey, true)).toLowerCase();
   }
+
+  generateMnemonic() {
+    return bip39.generateMnemonic(wordlist);
+  }
+
+  setHdPath(hdPath = HD_PATH_BASE[HDPathType.BIP44]) {
+    this.hdPath = hdPath;
+  }
+
+  private getChildForIndex(index: number) {
+    return this.hdWallet!.derive(this.getPathForIndex(index));
+  }
+
+  private isLedgerLiveHdPath() {
+    return this.hdPath === HD_PATH_BASE[HDPathType.LedgerLive];
+  }
+
+  private getPathForIndex(index) {
+    return this.isLedgerLiveHdPath()
+      ? `m/44'/60'/${index}'/0/0`
+      : `${this.hdPath}/${index}`;
+  }
+
+  setPassphrase(passphrase: string) {
+    this.initFromMnemonic(this.mnemonic, passphrase);
+
+    for (const acc of this.accounts) {
+      const detail = this.getAccountDetail(acc);
+      if (detail) {
+        this.setHdPath(detail.hdPath);
+        const [address, wallet] = this._addressFromIndex(detail.index);
+        if (address.toLowerCase() === acc.toLowerCase()) {
+          this.wallets.push(wallet);
+        }
+      }
+    }
+  }
+
+  /**
+   * if passphrase is correct, the publicKey will be the same as the stored one
+   */
+  checkPassphrase(passphrase: string) {
+    const seed = bip39.mnemonicToSeedSync(this.mnemonic!, passphrase);
+    const hdWallet = HDKey.fromMasterSeed(seed);
+    const publicKey = this.calcBasePublicKey(hdWallet);
+
+    return this.publicKey === publicKey;
+  }
+
+  setAccountDetail = (address: string, accountDetail: AccountDetail) => {
+    this.accountDetails = {
+      ...this.accountDetails,
+      [address.toLowerCase()]: accountDetail,
+    };
+  };
+
+  getAccountDetail = (address: string) => {
+    return this.accountDetails[address.toLowerCase()];
+  };
+
+  private getHDPathBase(hdPathType: HDPathType) {
+    return HD_PATH_BASE[hdPathType];
+  }
+
+  async setHDPathType(hdPathType: HDPathType) {
+    const hdPath = this.getHDPathBase(hdPathType);
+    this.setHdPath(hdPath);
+  }
 }
 
 export default HdKeyring;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rabby-wallet/eth-hd-keyring",
-  "version": "4.0.1",
+  "version": "4.1.0-beta.0",
   "description": "A simple standard interface for a seed phrase generated set of Ethereum accounts.",
   "keywords": [
     "ethereum",
@@ -24,7 +24,7 @@
     "lint:misc": "prettier '**/*.json' '**/*.md' '!CHANGELOG.md' '**/*.yml' --ignore-path .gitignore",
     "lint": "yarn lint:eslint && yarn lint:misc --check",
     "lint:fix": "yarn lint:eslint --fix && yarn lint:misc --write",
-    "test": "mocha"
+    "test": "yarn build && mocha"
   },
   "dependencies": {
     "@ethereumjs/util": "^9.0.0",

package/test/index.js

@@ -20,7 +20,7 @@ const firstAcct = '0x1c96099350f13d558464ec79b9be4445aa0ef579';
 const secondAcct = '0x1b00aed43a693f3a957f9feb5cc08afa031e37a0';
 
 describe('hd-keyring', function () {
-  let keyring;
+  let keyring = new HdKeyring();
   beforeEach(function () {
     keyring = new HdKeyring();
   });
@@ -334,6 +334,76 @@ describe('hd-keyring', function () {
           console.log('failed because', reason);
         });
     });
+
+    it('hdPath.Legacy', function (done) {
+      const hdPathLegacy = "m/44'/60'/0'";
+      keyring.deserialize({
+        mnemonic: sampleMnemonic,
+        activeIndexes: [0, 1],
+        hdPath: hdPathLegacy,
+      });
+
+      keyring.getAccounts().then((addersses) => {
+        assert.deepEqual(addersses, [
+          '0x5a5a19b534db50801fb6dec48ea262ca3a0efda6',
+          '0x6729dd439a96d4a7bc6362c231d6931cfaa31088',
+        ]);
+        done();
+      });
+    });
+
+    it('hdPath.LedgerLive', function (done) {
+      const hdPathLedgerLive = "m/44'/60'/0'/0/0";
+      keyring.deserialize({
+        mnemonic: sampleMnemonic,
+        activeIndexes: [0, 1],
+        hdPath: hdPathLedgerLive,
+      });
+
+      keyring.getAccounts().then((addersses) => {
+        assert.deepEqual(addersses, [
+          firstAcct,
+          '0x0827a0c8f451b8fcca2cd4e9c23c47a92ca69a56',
+        ]);
+        done();
+      });
+    });
+
+    it('hdPath.bip44', function (done) {
+      const hdPathBIP44 = "m/44'/60'/0'/0";
+      keyring.deserialize({
+        mnemonic: sampleMnemonic,
+        activeIndexes: [0, 1],
+        hdPath: hdPathBIP44,
+      });
+
+      keyring.getAccounts().then((addersses) => {
+        assert.deepEqual(addersses, [firstAcct, secondAcct]);
+        done();
+      });
+    });
+
+    it('setHdPath', function (done) {
+      const hdPathLedgerLive = "m/44'/60'/0'/0/0";
+      const hdPathBIP44 = "m/44'/60'/0'/0";
+
+      keyring.deserialize({
+        mnemonic: sampleMnemonic,
+        activeIndexes: [0, 1],
+        hdPath: hdPathBIP44,
+      });
+      keyring.setHdPath(hdPathLedgerLive);
+      keyring.activeAccounts([1]);
+
+      keyring.getAccounts().then((addersses) => {
+        assert.deepEqual(addersses, [
+          firstAcct,
+          secondAcct,
+          '0x0827a0c8f451b8fcca2cd4e9c23c47a92ca69a56',
+        ]);
+        done();
+      });
+    });
   });
 
   /*
@@ -525,4 +595,87 @@ describe('hd-keyring', function () {
       assert.deepEqual(activeIndexes, [2, 3, 6]);
     });
   });
+
+  describe('accountDetails', function () {
+    it('should return correct account details', async function () {
+      const address = firstAcct;
+
+      keyring = new HdKeyring({
+        mnemonic: sampleMnemonic,
+        activeIndexes: [0, 2, 3, 6],
+      });
+
+      const accountDetail = await keyring.getAccountDetail(address);
+
+      assert.deepEqual(accountDetail, {
+        hdPath: "m/44'/60'/0'/0",
+        hdPathType: 'BIP44',
+        index: 0,
+      });
+    });
+  });
+
+  describe('passphrase', function () {
+    it('should be able to set a passphrase', async function () {
+      await keyring.deserialize({
+        mnemonic: sampleMnemonic,
+      });
+      keyring.setPassphrase('abc123');
+      keyring.activeAccounts([0, 1]);
+      const result = await keyring.getAccounts();
+
+      assert.deepEqual(result, [
+        '0x8db9506aa1c0e2c07dc03417ded629e0cffe2412',
+        '0x805eacc9c707b94581fd2a230f437bd370fe229c',
+      ]);
+    });
+
+    it('needPassphrase', async function () {
+      keyring = new HdKeyring({
+        mnemonic: sampleMnemonic,
+        needPassphrase: true,
+        accounts: [
+          '0x8db9506aa1c0e2c07dc03417ded629e0cffe2412',
+          '0x805eacc9c707b94581fd2a230f437bd370fe229c',
+        ],
+      });
+
+      assert.equal(keyring.wallets.length, 0);
+      assert.equal(keyring.accounts.length, 2);
+    });
+
+    it('get wallet when set passphrase', async function () {
+      await keyring.deserialize({
+        mnemonic: sampleMnemonic,
+        needPassphrase: true,
+        accounts: [
+          '0x8db9506aa1c0e2c07dc03417ded629e0cffe2412',
+          '0x805eacc9c707b94581fd2a230f437bd370fe229c',
+        ],
+        accountDetails: {
+          '0x8db9506aa1c0e2c07dc03417ded629e0cffe2412': {
+            hdPath: "m/44'/60'/0'/0",
+            hdPathType: 'BIP44',
+            index: 0,
+          },
+          '0x805eacc9c707b94581fd2a230f437bd370fe229c': {
+            hdPath: "m/44'/60'/0'/0",
+            hdPathType: 'BIP44',
+            index: 1,
+          },
+          [firstAcct]: {
+            hdPath: "m/44'/60'/0'/0",
+            hdPathType: 'BIP44',
+            index: 0,
+          },
+        },
+      });
+
+      assert.equal(keyring.wallets.length, 0);
+
+      keyring.setPassphrase('abc123');
+
+      assert.equal(keyring.wallets.length, 2);
+    });
+  });
 });