@celo/utils - npm Package Compare versions

Comparing version 0.1.11 to 0.1.12

lib/account.d.ts

@@ -0,1 +1,2 @@
+/// <reference types="node" />
 export declare const CELO_DERIVATION_PATH_BASE = "m/44'/52752'/0'/0";
@@ -16,7 +17,18 @@ export declare enum MnemonicStrength {
 }
-export declare function generateMnemonic(strength?: MnemonicStrength, language?: MnemonicLanguages): string;
-export declare function validateMnemonic(mnemonic: string, language?: MnemonicLanguages): boolean;
-export declare function generateKeys(mnemonic: string, password?: string, addressIndex?: number): {
+declare type RandomNumberGenerator = (size: number, callback: (err: Error | null, buf: Buffer) => void) => void;
+interface Bip39 {
+    mnemonicToSeedSync: (mnemonic: string, password?: string) => Buffer;
+    mnemonicToSeed: (mnemonic: string, password?: string) => Promise<Buffer>;
+    generateMnemonic: (strength?: number, rng?: RandomNumberGenerator, wordlist?: string[]) => Promise<string>;
+    validateMnemonic: (mnemonic: string, wordlist?: string[]) => boolean;
+}
+export declare function generateMnemonic(strength?: MnemonicStrength, language?: MnemonicLanguages, bip39ToUse?: Bip39): Promise<string>;
+export declare function validateMnemonic(mnemonic: string, language?: MnemonicLanguages, bip39ToUse?: Bip39): boolean;
+export declare function generateKeys(mnemonic: string, password?: string, addressIndex?: number, bip39ToUse?: Bip39): Promise<{
     privateKey: string;
     publicKey: string;
+}>;
+export declare function generateKeysSync(mnemonic: string, password?: string, addressIndex?: number, bip39ToUse?: Bip39): {
+    privateKey: string;
+    publicKey: string;
 };
@@ -27,2 +39,4 @@ export declare const AccountUtils: {
     generateKeys: typeof generateKeys;
+    generateKeysSync: typeof generateKeysSync;
 };
+export {};

lib/account.js

 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 var __importStar = (this && this.__importStar) || function (mod) {
@@ -9,5 +45,9 @@ if (mod && mod.__esModule) return mod;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 var bip32 = __importStar(require("bip32"));
 var bip39 = __importStar(require("bip39"));
+var randombytes_1 = __importDefault(require("randombytes"));
 exports.CELO_DERIVATION_PATH_BASE = "m/44'/52752'/0'/0";
@@ -30,14 +70,66 @@ var MnemonicStrength;
 })(MnemonicLanguages = exports.MnemonicLanguages || (exports.MnemonicLanguages = {}));
-function generateMnemonic(strength, language) {
+function defaultGenerateMnemonic(strength, rng, wordlist) {
+    return new Promise(function (resolve, reject) {
+        strength = strength || 128;
+        rng = rng || randombytes_1.default;
+        rng(strength / 8, function (error, randomBytesBuffer) {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(bip39.entropyToMnemonic(randomBytesBuffer.toString('hex'), wordlist));
+            }
+        });
+    });
+}
+var bip39Wrapper = {
+    mnemonicToSeedSync: bip39.mnemonicToSeedSync,
+    mnemonicToSeed: bip39.mnemonicToSeed,
+    generateMnemonic: defaultGenerateMnemonic,
+    validateMnemonic: bip39.validateMnemonic,
+};
+function generateMnemonic(strength, language, bip39ToUse) {
     if (strength === void 0) { strength = MnemonicStrength.s256_24words; }
-    return bip39.generateMnemonic(strength, undefined, getWordList(language));
+    if (bip39ToUse === void 0) { bip39ToUse = bip39Wrapper; }
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, bip39ToUse.generateMnemonic(strength, undefined, getWordList(language))];
+        });
+    });
 }
 exports.generateMnemonic = generateMnemonic;
-function validateMnemonic(mnemonic, language) {
-    return bip39.validateMnemonic(mnemonic, getWordList(language));
+function validateMnemonic(mnemonic, language, bip39ToUse) {
+    if (bip39ToUse === void 0) { bip39ToUse = bip39Wrapper; }
+    return bip39ToUse.validateMnemonic(mnemonic, getWordList(language));
 }
 exports.validateMnemonic = validateMnemonic;
-function generateKeys(mnemonic, password, addressIndex) {
+function generateKeys(mnemonic, password, addressIndex, bip39ToUse) {
     if (addressIndex === void 0) { addressIndex = 0; }
-    var seed = bip39.mnemonicToSeedSync(mnemonic, password);
+    if (bip39ToUse === void 0) { bip39ToUse = bip39Wrapper; }
+    return __awaiter(this, void 0, void 0, function () {
+        var seed, node, newNode;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, bip39ToUse.mnemonicToSeed(mnemonic, password)];
+                case 1:
+                    seed = _a.sent();
+                    node = bip32.fromSeed(seed);
+                    newNode = node.derivePath(exports.CELO_DERIVATION_PATH_BASE + "/" + addressIndex);
+                    if (!newNode.privateKey) {
+                        // As we are generating the node from a seed, the node will always have a private key and this would never happened
+                        throw new Error('utils-accounts@generateKeys: invalid node to derivate');
+                    }
+                    return [2 /*return*/, {
+                            privateKey: newNode.privateKey.toString('hex'),
+                            publicKey: newNode.publicKey.toString('hex'),
+                        }];
+            }
+        });
+    });
+}
+exports.generateKeys = generateKeys;
+function generateKeysSync(mnemonic, password, addressIndex, bip39ToUse) {
+    if (addressIndex === void 0) { addressIndex = 0; }
+    if (bip39ToUse === void 0) { bip39ToUse = bip39Wrapper; }
+    var seed = bip39ToUse.mnemonicToSeedSync(mnemonic, password);
     var node = bip32.fromSeed(seed);
@@ -50,3 +142,4 @@ var newNode = node.derivePath(exports.CELO_DERIVATION_PATH_BASE + "/" + addressIndex);
 }
-exports.generateKeys = generateKeys;
+exports.generateKeysSync = generateKeysSync;
+// Unify the bip39.wordlists (otherwise depends on the instance of the bip39)
 function getWordList(language) {
@@ -78,3 +171,4 @@ switch (language) {
     generateKeys: generateKeys,
+    generateKeysSync: generateKeysSync,
 };
 //# sourceMappingURL=account.js.map

lib/account.test.js

 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 var account_1 = require("./account");
 describe('Mnemonic validation', function () {
-    it('should generate 24 word mnemonic', function () {
-        var mnemonic = account_1.generateMnemonic();
-        expect(mnemonic.split(' ').length).toEqual(24);
-    });
-    it('should generate 12 word mnemonic', function () {
-        var mnemonic = account_1.generateMnemonic(account_1.MnemonicStrength.s128_12words);
-        expect(mnemonic.split(' ').length).toEqual(12);
-    });
+    it('should generate 24 word mnemonic', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mnemonic;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, account_1.generateMnemonic()];
+                case 1:
+                    mnemonic = _a.sent();
+                    expect(mnemonic.split(' ').length).toEqual(24);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should generate 12 word mnemonic', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mnemonic;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, account_1.generateMnemonic(account_1.MnemonicStrength.s128_12words)];
+                case 1:
+                    mnemonic = _a.sent();
+                    expect(mnemonic.split(' ').length).toEqual(12);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('should generate an expected private key for a mnemonic', function () {
@@ -172,9 +224,43 @@ // 10 random mnemonic
             expect(account_1.validateMnemonic(mnemonics[i])).toBeTruthy();
-            var derivation0 = account_1.generateKeys(mnemonics[i]);
-            var derivation1 = account_1.generateKeys(mnemonics[i], undefined, 1);
-            var password = account_1.generateKeys(mnemonics[i], 'password');
+            var derivation0 = account_1.generateKeysSync(mnemonics[i]);
+            var derivation1 = account_1.generateKeysSync(mnemonics[i], undefined, 1);
+            var password = account_1.generateKeysSync(mnemonics[i], 'password');
             expect({ derivation0: derivation0, derivation1: derivation1, password: password }).toEqual(expectedPrivateKeys[i]);
         }
     });
+    it('should generate async an expected private key for a mnemonic', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var expectedPrivateKey, mnemonic, derivation0, derivation1, password;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    expectedPrivateKey = {
+                        derivation0: {
+                            privateKey: '9b20170cd294190efb2eb1d406a51e6705461cb540e777784565c1d8342016d7',
+                            publicKey: '0257780786b4ba7bf47b3be6082f65069f552012735a17c2080648de67cfb440c1',
+                        },
+                        derivation1: {
+                            privateKey: '29c025cda952cb59d8504cca390bcdbc2cc3706ca5bfb65a5b6f5dd5dc5176dd',
+                            publicKey: '029c90f394bea3d46c46896b0bd1b36119b031a6da498b49a32aad77f10ce1f672',
+                        },
+                        password: {
+                            privateKey: '92956ef74d530224029380385ca556240be042b7e5592ffece5945286f1562c3',
+                            publicKey: '0331003f16d42ea996da1bc91188ff170ea451570a9bed4779682dd27da1892303',
+                        },
+                    };
+                    mnemonic = 'language quiz proud sample canoe trend topic upper coil rack choice engage noodle panda mutual grab shallow thrive forget trophy pull pool mask height';
+                    return [4 /*yield*/, account_1.generateKeys(mnemonic)];
+                case 1:
+                    derivation0 = _a.sent();
+                    return [4 /*yield*/, account_1.generateKeys(mnemonic, undefined, 1)];
+                case 2:
+                    derivation1 = _a.sent();
+                    return [4 /*yield*/, account_1.generateKeys(mnemonic, 'password')];
+                case 3:
+                    password = _a.sent();
+                    expect({ derivation0: derivation0, derivation1: derivation1, password: password }).toEqual(expectedPrivateKey);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });
 //# sourceMappingURL=account.test.js.map

package.json

 {
   "name": "@celo/utils",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "Celo common utils",
@@ -37,4 +37,4 @@ "author": "Celo",
     "web3-utils": "1.2.4",
-    "bip32":"2.0.5",
-    "bip39":"3.0.2"
+    "bip32": "2.0.5",
+    "bip39": "3.0.2"
   },
@@ -48,3 +48,4 @@ "devDependencies": {
     "@types/lodash": "^4.14.136",
-    "@types/node": "^10.12.18"
+    "@types/node": "^10.12.18",
+    "@types/randombytes": "^2.0.0"
   },
@@ -51,0 +52,0 @@ "resolutions": {

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

339509

increased by4.08%

Lines of code

4775

increased by4.23%

Worsened metrics

Dev dependency count

8

increased by14.29%

No dependency changes