@rabby-wallet/eth-hd-keyring 4.3.2-beta → 4.3.3-beta.0

package/dist/index.d.ts

@@ -63,8 +63,8 @@ declare class HdKeyring extends SimpleKeyring {
         publicKey: string;
         isSlip39: boolean;
     }>;
-    deserialize(opts?: DeserializeOption): string[] | Promise<any[]>;
-    initFromMnemonic(mnemonic: string, passphrase?: string): void;
+    deserialize(opts?: DeserializeOption): Promise<any[]>;
+    initFromMnemonic(mnemonic: string, passphrase?: string): Promise<void>;
     private calcBasePublicKey;
     addAccounts(numberOfAccounts?: number): Promise<string[]>;
     activeAccounts(indexes: number[]): string[];
@@ -95,16 +95,16 @@ declare class HdKeyring extends SimpleKeyring {
     private getChildForIndex;
     private isLedgerLiveHdPath;
     private getPathForIndex;
-    setPassphrase(passphrase: string): void;
+    setPassphrase(passphrase: string): Promise<void>;
     /**
      * if passphrase is correct, the publicKey will be the same as the stored one
      */
-    checkPassphrase(passphrase: string): boolean;
+    checkPassphrase(passphrase: string): Promise<boolean>;
     setAccountDetail: (address: string, accountDetail: AccountDetail) => void;
     getAccountDetail: (address: string) => AccountDetail;
     private getHDPathBase;
     setHDPathType(hdPathType: HDPathType): Promise<void>;
-    getSeed(mnemonic: string, passphrase?: string): Uint8Array;
+    getSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;
     slip39MnemonicToSeedSync(mnemonic: string, passphrase?: string): Uint8Array;
     static checkMnemonicIsSlip39(mnemonic: string): boolean;
     static slip39GetThreshold(shares: string[]): number;

package/dist/index.js

@@ -45,7 +45,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -100,20 +99,38 @@ var require_slip39_helper = __commonJS({
     var ROUND_COUNT = 4;
     var DIGEST_INDEX = 254;
     var SECRET_INDEX = 255;
-    var slip39EncodeHex = function(str) {
+    String.prototype.slip39EncodeHex = function() {
       let bytes = [];
-      for (let i = 0; i < str.length; ++i) {
-        bytes.push(str.charCodeAt(i));
+      for (let i = 0; i < this.length; ++i) {
+        bytes.push(this.charCodeAt(i));
       }
       return bytes;
     };
-    var slip39Generate = function(m, v = (_) => _) {
-      let n = m;
-      const arr = [];
+    Array.prototype.slip39DecodeHex = function() {
+      let str = [];
+      const hex = this.toString().split(",");
+      for (let i = 0; i < hex.length; i++) {
+        str.push(String.fromCharCode(hex[i]));
+      }
+      return str.toString().replace(/,/g, "");
+    };
+    Array.prototype.slip39Generate = function(m, v = (_) => _) {
+      let n = m || this.length;
       for (let i = 0; i < n; i++) {
-        arr[i] = v(i);
+        this[i] = v(i);
+      }
+      return this;
+    };
+    Array.prototype.toHexString = function() {
+      return Array.prototype.map.call(this, function(byte) {
+        return ("0" + (byte & 255).toString(16)).slice(-2);
+      }).join("");
+    };
+    Array.prototype.toByteArray = function(hexString) {
+      for (let i = 0; i < hexString.length; i = i + 2) {
+        this.push(parseInt(hexString.substr(i, 2), 16));
       }
-      return arr;
+      return this;
     };
     var BIGINT_WORD_BITS = BigInt(8);
     function decodeBigInt(bytes) {
@@ -179,9 +196,9 @@ var require_slip39_helper = __commonJS({
       }
       let IL = masterSecret.slice().slice(0, masterSecret.length / 2);
       let IR = masterSecret.slice().slice(masterSecret.length / 2);
-      const pwd = slip39EncodeHex(passphrase);
+      const pwd = passphrase.slip39EncodeHex();
       const salt = getSalt(identifier, extendableBackupFlag);
-      let range = slip39Generate(ROUND_COUNT);
+      let range = Array().slip39Generate(ROUND_COUNT);
       range = encrypt ? range : range.reverse();
       range.forEach((round) => {
         const f = roundFunction(round, pwd, iterationExponent, salt, IR);
@@ -215,7 +232,7 @@ var require_slip39_helper = __commonJS({
         );
       }
       if (threshold === 1) {
-        return slip39Generate(shareCount, () => sharedSecret);
+        return Array().slip39Generate(shareCount, () => sharedSecret);
       }
       const randomShareCount = threshold - 2;
       const randomPart = randomBytes(sharedSecret.length - DIGEST_LENGTH);
@@ -223,7 +240,7 @@ var require_slip39_helper = __commonJS({
       let baseShares = /* @__PURE__ */ new Map();
       let shares = [];
       if (randomShareCount) {
-        shares = slip39Generate(
+        shares = Array().slip39Generate(
           randomShareCount,
           () => randomBytes(sharedSecret.length)
         );
@@ -252,13 +269,13 @@ var require_slip39_helper = __commonJS({
           `Invalid padding in mnemonic or insufficient length of mnemonics (${a.length} or ${b.length})`
         );
       }
-      return slip39Generate(a.length, (i) => a[i] ^ b[i]);
+      return Array().slip39Generate(a.length, (i) => a[i] ^ b[i]);
     }
     function getSalt(identifier, extendableBackupFlag) {
       if (extendableBackupFlag) {
         return [];
       } else {
-        const salt = slip39EncodeHex(CUSTOMIZATION_STRING_NON_EXTENDABLE);
+        const salt = CUSTOMIZATION_STRING_NON_EXTENDABLE.slip39EncodeHex();
         return salt.concat(identifier);
       }
     }
@@ -282,7 +299,7 @@ var require_slip39_helper = __commonJS({
       shares.forEach((v, k) => {
         logProd = logProd + LOG_TABLE[k ^ x];
       });
-      let results = slip39Generate(
+      let results = Array().slip39Generate(
         sharesValueLengths.values().next().value,
         () => 0
       );
@@ -331,14 +348,14 @@ var require_slip39_helper = __commonJS({
       return extendableBackupFlag ? CUSTOMIZATION_STRING_EXTENDABLE : CUSTOMIZATION_STRING_NON_EXTENDABLE;
     }
     function rs1024CreateChecksum(data, extendableBackupFlag) {
-      const values = slip39EncodeHex(get_customization_string(extendableBackupFlag)).concat(data).concat(slip39Generate(CHECKSUM_WORDS_LENGTH, () => 0));
+      const values = get_customization_string(extendableBackupFlag).slip39EncodeHex().concat(data).concat(Array().slip39Generate(CHECKSUM_WORDS_LENGTH, () => 0));
       const polymod = rs1024Polymod(values) ^ 1;
-      const result = slip39Generate(CHECKSUM_WORDS_LENGTH, (i) => polymod >> 10 * i & 1023).reverse();
+      const result = Array().slip39Generate(CHECKSUM_WORDS_LENGTH, (i) => polymod >> 10 * i & 1023).reverse();
       return result;
     }
     function rs1024VerifyChecksum(data, extendableBackupFlag) {
       return rs1024Polymod(
-        slip39EncodeHex(get_customization_string(extendableBackupFlag)).concat(data)
+        get_customization_string(extendableBackupFlag).slip39EncodeHex().concat(data)
       ) === 1;
     }
     function intFromIndices(indices) {
@@ -351,7 +368,7 @@ var require_slip39_helper = __commonJS({
     }
     function intToIndices(value, length, bits) {
       const mask = BigInt((1 << bits) - 1);
-      const result = slip39Generate(
+      const result = Array().slip39Generate(
         length,
         (i) => parseInt(value >> BigInt(i) * BigInt(bits) & mask, 10)
       );
@@ -2163,9 +2180,7 @@ var require_slip39_helper = __commonJS({
       combineMnemonics,
       crypt,
       bitsToBytes,
-      WORD_LIST,
-      decodeMnemonics,
-      decodeMnemonic
+      WORD_LIST
     };
   }
 });
@@ -2192,7 +2207,7 @@ var require_slip39 = __commonJS({
         return result;
       }
     };
-    var _Slip39 = class _Slip39 {
+    var Slip39 = class _Slip39 {
       constructor({
         iterationExponent = 0,
         extendableBackupFlag = 0,
@@ -2349,10 +2364,6 @@ var require_slip39 = __commonJS({
         return result;
       }
     };
-    __publicField(_Slip39, "decodeMnemonics", slipHelper.decodeMnemonics);
-    __publicField(_Slip39, "decodeMnemonic", slipHelper.decodeMnemonic);
-    __publicField(_Slip39, "combineMnemonics", slipHelper.combineMnemonics);
-    var Slip39 = _Slip39;
     exports2 = module2.exports = Slip39;
   }
 });
@@ -2434,34 +2445,38 @@ var _HdKeyring = class _HdKeyring extends import_eth_simple_keyring.default {
       isSlip39: this.isSlip39
     });
   }
-  deserialize(opts = {}) {
-    this.wallets = [];
-    this.mnemonic = null;
-    this.hdPath = opts.hdPath || HD_PATH_BASE["BIP44" /* BIP44 */];
-    this.byImport = !!opts.byImport;
-    this.index = opts.index || 0;
-    this.needPassphrase = opts.needPassphrase || !!opts.passphrase;
-    this.passphrase = opts.passphrase;
-    this.accounts = opts.accounts || [];
-    this.accountDetails = opts.accountDetails || {};
-    this.publicKey = opts.publicKey || "";
-    this.isSlip39 = opts.isSlip39 || false;
-    if (opts.mnemonic) {
-      this.mnemonic = opts.mnemonic;
-      this.setPassphrase(opts.passphrase || "");
-    }
-    if (!this.accounts.length && opts.activeIndexes) {
-      return this.activeAccounts(opts.activeIndexes);
-    }
-    return Promise.resolve([]);
+  deserialize() {
+    return __async(this, arguments, function* (opts = {}) {
+      this.wallets = [];
+      this.mnemonic = null;
+      this.hdPath = opts.hdPath || HD_PATH_BASE["BIP44" /* BIP44 */];
+      this.byImport = !!opts.byImport;
+      this.index = opts.index || 0;
+      this.needPassphrase = opts.needPassphrase || !!opts.passphrase;
+      this.passphrase = opts.passphrase;
+      this.accounts = opts.accounts || [];
+      this.accountDetails = opts.accountDetails || {};
+      this.publicKey = opts.publicKey || "";
+      this.isSlip39 = opts.isSlip39 || false;
+      if (opts.mnemonic) {
+        this.mnemonic = opts.mnemonic;
+        yield this.setPassphrase(opts.passphrase || "");
+      }
+      if (!this.accounts.length && opts.activeIndexes) {
+        return this.activeAccounts(opts.activeIndexes);
+      }
+      return Promise.resolve([]);
+    });
   }
   initFromMnemonic(mnemonic, passphrase) {
-    this.mnemonic = mnemonic;
-    const seed = this.getSeed(mnemonic, passphrase);
-    this.hdWallet = import_hdkey.HDKey.fromMasterSeed(seed);
-    if (!this.publicKey) {
-      this.publicKey = this.calcBasePublicKey(this.hdWallet);
-    }
+    return __async(this, null, function* () {
+      this.mnemonic = mnemonic;
+      const seed = yield this.getSeed(mnemonic, passphrase);
+      this.hdWallet = import_hdkey.HDKey.fromMasterSeed(seed);
+      if (!this.publicKey) {
+        this.publicKey = this.calcBasePublicKey(this.hdWallet);
+      }
+    });
   }
   calcBasePublicKey(hdKey) {
     return (0, import_util.bytesToHex)(
@@ -2469,33 +2484,35 @@ var _HdKeyring = class _HdKeyring extends import_eth_simple_keyring.default {
     );
   }
   addAccounts(numberOfAccounts = 1) {
-    if (!this.hdWallet) {
-      this.initFromMnemonic(bip39.generateMnemonic(import_english.wordlist));
-    }
-    let count = numberOfAccounts;
-    let currentIdx = 0;
-    const addresses = [];
-    while (count) {
-      const [address, wallet] = this._addressFromIndex(currentIdx);
-      if (this.wallets.find(
-        (w) => (0, import_util.bytesToHex)(w.publicKey) === (0, import_util.bytesToHex)(wallet.publicKey)
-      )) {
-        currentIdx++;
-      } else {
-        this.wallets.push(wallet);
-        addresses.push(address);
-        this.setAccountDetail(address, {
-          hdPath: this.hdPath,
-          hdPathType: HD_PATH_TYPE[this.hdPath],
-          index: currentIdx
-        });
-        count--;
+    return __async(this, null, function* () {
+      if (!this.hdWallet) {
+        yield this.initFromMnemonic(bip39.generateMnemonic(import_english.wordlist));
       }
-      if (!this.accounts.includes(address)) {
-        this.accounts.push(address);
+      let count = numberOfAccounts;
+      let currentIdx = 0;
+      const addresses = [];
+      while (count) {
+        const [address, wallet] = this._addressFromIndex(currentIdx);
+        if (this.wallets.find(
+          (w) => (0, import_util.bytesToHex)(w.publicKey) === (0, import_util.bytesToHex)(wallet.publicKey)
+        )) {
+          currentIdx++;
+        } else {
+          this.wallets.push(wallet);
+          addresses.push(address);
+          this.setAccountDetail(address, {
+            hdPath: this.hdPath,
+            hdPathType: HD_PATH_TYPE[this.hdPath],
+            index: currentIdx
+          });
+          count--;
+        }
+        if (!this.accounts.includes(address)) {
+          this.accounts.push(address);
+        }
       }
-    }
-    return Promise.resolve(addresses);
+      return Promise.resolve(addresses);
+    });
   }
   activeAccounts(indexes) {
     const accounts = [];
@@ -2628,27 +2645,31 @@ var _HdKeyring = class _HdKeyring extends import_eth_simple_keyring.default {
     return this.isLedgerLiveHdPath() ? `m/44'/60'/${index}'/0/0` : `${this.hdPath}/${index}`;
   }
   setPassphrase(passphrase) {
-    this.passphrase = 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);
+    return __async(this, null, function* () {
+      this.passphrase = passphrase;
+      yield 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 = this.getSeed(this.mnemonic, passphrase);
-    const hdWallet = import_hdkey.HDKey.fromMasterSeed(seed);
-    const publicKey = this.calcBasePublicKey(hdWallet);
-    return this.publicKey === publicKey;
+    return __async(this, null, function* () {
+      const seed = yield this.getSeed(this.mnemonic, passphrase);
+      const hdWallet = import_hdkey.HDKey.fromMasterSeed(seed);
+      const publicKey = this.calcBasePublicKey(hdWallet);
+      return this.publicKey === publicKey;
+    });
   }
   getHDPathBase(hdPathType) {
     return HD_PATH_BASE[hdPathType];
@@ -2660,11 +2681,13 @@ var _HdKeyring = class _HdKeyring extends import_eth_simple_keyring.default {
     });
   }
   getSeed(mnemonic, passphrase) {
-    if (_HdKeyring.checkMnemonicIsSlip39(mnemonic)) {
-      this.isSlip39 = true;
-      return this.slip39MnemonicToSeedSync(mnemonic, passphrase);
-    }
-    return bip39.mnemonicToSeedSync(mnemonic, passphrase);
+    return __async(this, null, function* () {
+      if (_HdKeyring.checkMnemonicIsSlip39(mnemonic)) {
+        this.isSlip39 = true;
+        return this.slip39MnemonicToSeedSync(mnemonic, passphrase);
+      }
+      return bip39.mnemonicToSeed(mnemonic, passphrase);
+    });
   }
   slip39MnemonicToSeedSync(mnemonic, passphrase) {
     const secretShares = mnemonic.split("\n");

package/index.ts

@@ -103,7 +103,7 @@ class HdKeyring extends SimpleKeyring {
     });
   }
 
-  deserialize(opts: DeserializeOption = {} as any) {
+  async deserialize(opts: DeserializeOption = {} as any) {
     this.wallets = [];
     this.mnemonic = null;
     this.hdPath = opts.hdPath || HD_PATH_BASE[HDPathType.BIP44];
@@ -118,7 +118,7 @@ class HdKeyring extends SimpleKeyring {
 
     if (opts.mnemonic) {
       this.mnemonic = opts.mnemonic;
-      this.setPassphrase(opts.passphrase || '');
+      await this.setPassphrase(opts.passphrase || '');
     }
 
     // activeIndexes is deprecated, if accounts is not empty, use accounts
@@ -129,9 +129,9 @@ class HdKeyring extends SimpleKeyring {
     return Promise.resolve([]);
   }
 
-  initFromMnemonic(mnemonic: string, passphrase?: string) {
+  async initFromMnemonic(mnemonic: string, passphrase?: string) {
     this.mnemonic = mnemonic;
-    const seed = this.getSeed(mnemonic, passphrase);
+    const seed = await this.getSeed(mnemonic, passphrase);
     this.hdWallet = HDKey.fromMasterSeed(seed);
     if (!this.publicKey) {
       this.publicKey = this.calcBasePublicKey(this.hdWallet!);
@@ -144,9 +144,9 @@ class HdKeyring extends SimpleKeyring {
     );
   }
 
-  addAccounts(numberOfAccounts = 1) {
+  async addAccounts(numberOfAccounts = 1) {
     if (!this.hdWallet) {
-      this.initFromMnemonic(bip39.generateMnemonic(wordlist));
+      await this.initFromMnemonic(bip39.generateMnemonic(wordlist));
     }
 
     let count = numberOfAccounts;
@@ -347,9 +347,9 @@ class HdKeyring extends SimpleKeyring {
       : `${this.hdPath}/${index}`;
   }
 
-  setPassphrase(passphrase: string) {
+  async setPassphrase(passphrase: string) {
     this.passphrase = passphrase;
-    this.initFromMnemonic(this.mnemonic, passphrase);
+    await this.initFromMnemonic(this.mnemonic, passphrase);
 
     for (const acc of this.accounts) {
       const detail = this.getAccountDetail(acc);
@@ -366,8 +366,8 @@ class HdKeyring extends SimpleKeyring {
   /**
    * if passphrase is correct, the publicKey will be the same as the stored one
    */
-  checkPassphrase(passphrase: string) {
-    const seed = this.getSeed(this.mnemonic!, passphrase);
+  async checkPassphrase(passphrase: string) {
+    const seed = await this.getSeed(this.mnemonic!, passphrase);
     const hdWallet = HDKey.fromMasterSeed(seed);
     const publicKey = this.calcBasePublicKey(hdWallet);
 
@@ -394,12 +394,12 @@ class HdKeyring extends SimpleKeyring {
     this.setHdPath(hdPath);
   }
 
-  getSeed(mnemonic: string, passphrase?: string) {
+  async getSeed(mnemonic: string, passphrase?: string) {
     if (HdKeyring.checkMnemonicIsSlip39(mnemonic)) {
       this.isSlip39 = true;
       return this.slip39MnemonicToSeedSync(mnemonic, passphrase);
     }
-    return bip39.mnemonicToSeedSync(mnemonic, passphrase);
+    return bip39.mnemonicToSeed(mnemonic, passphrase);
   }
 
   slip39MnemonicToSeedSync(mnemonic: string, passphrase?: string) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rabby-wallet/eth-hd-keyring",
-  "version": "4.3.2-beta",
+  "version": "4.3.3-beta.0",
   "description": "A simple standard interface for a seed phrase generated set of Ethereum accounts.",
   "keywords": [
     "ethereum",