gnache-cli 0.0.1-security → 6.12.2

package/node_modules/ethereum-cryptography/pure/vendor/hdkey-without-crypto.js

@@ -0,0 +1,255 @@
+'use strict';
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var assert = _interopDefault(require('assert'));
+var safeBuffer = _interopDefault(require('safe-buffer'));
+var bs58check = _interopDefault(require('bs58check'));
+
+var cryptoShim = require("../shims/hdkey-crypto");
+
+var secp256k1Shim = require("../shims/hdkey-secp256k1v3");
+
+var Buffer = safeBuffer.Buffer;
+
+
+
+
+var MASTER_SECRET = Buffer.from('Bitcoin seed', 'utf8');
+var HARDENED_OFFSET = 0x80000000;
+var LEN = 78;
+
+// Bitcoin hardcoded by default, can use package `coininfo` for others
+var BITCOIN_VERSIONS = {private: 0x0488ADE4, public: 0x0488B21E};
+
+function HDKey (versions) {
+  this.versions = versions || BITCOIN_VERSIONS;
+  this.depth = 0;
+  this.index = 0;
+  this._privateKey = null;
+  this._publicKey = null;
+  this.chainCode = null;
+  this._fingerprint = 0;
+  this.parentFingerprint = 0;
+}
+
+Object.defineProperty(HDKey.prototype, 'fingerprint', { get: function () { return this._fingerprint } });
+Object.defineProperty(HDKey.prototype, 'identifier', { get: function () { return this._identifier } });
+Object.defineProperty(HDKey.prototype, 'pubKeyHash', { get: function () { return this.identifier } });
+
+Object.defineProperty(HDKey.prototype, 'privateKey', {
+  get: function () {
+    return this._privateKey
+  },
+  set: function (value) {
+    assert.equal(value.length, 32, 'Private key must be 32 bytes.');
+    assert(secp256k1Shim.privateKeyVerify(value) === true, 'Invalid private key');
+
+    this._privateKey = value;
+    this._publicKey = secp256k1Shim.publicKeyCreate(value, true);
+    this._identifier = hash160(this.publicKey);
+    this._fingerprint = this._identifier.slice(0, 4).readUInt32BE(0);
+  }
+});
+
+Object.defineProperty(HDKey.prototype, 'publicKey', {
+  get: function () {
+    return this._publicKey
+  },
+  set: function (value) {
+    assert(value.length === 33 || value.length === 65, 'Public key must be 33 or 65 bytes.');
+    assert(secp256k1Shim.publicKeyVerify(value) === true, 'Invalid public key');
+
+    this._publicKey = secp256k1Shim.publicKeyConvert(value, true); // force compressed point
+    this._identifier = hash160(this.publicKey);
+    this._fingerprint = this._identifier.slice(0, 4).readUInt32BE(0);
+    this._privateKey = null;
+  }
+});
+
+Object.defineProperty(HDKey.prototype, 'privateExtendedKey', {
+  get: function () {
+    if (this._privateKey) return bs58check.encode(serialize(this, this.versions.private, Buffer.concat([Buffer.alloc(1, 0), this.privateKey])))
+    else return null
+  }
+});
+
+Object.defineProperty(HDKey.prototype, 'publicExtendedKey', {
+  get: function () {
+    return bs58check.encode(serialize(this, this.versions.public, this.publicKey))
+  }
+});
+
+HDKey.prototype.derive = function (path) {
+  if (path === 'm' || path === 'M' || path === "m'" || path === "M'") {
+    return this
+  }
+
+  var entries = path.split('/');
+  var hdkey = this;
+  entries.forEach(function (c, i) {
+    if (i === 0) {
+      assert(/^[mM]{1}/.test(c), 'Path must start with "m" or "M"');
+      return
+    }
+
+    var hardened = (c.length > 1) && (c[c.length - 1] === "'");
+    var childIndex = parseInt(c, 10); // & (HARDENED_OFFSET - 1)
+    assert(childIndex < HARDENED_OFFSET, 'Invalid index');
+    if (hardened) childIndex += HARDENED_OFFSET;
+
+    hdkey = hdkey.deriveChild(childIndex);
+  });
+
+  return hdkey
+};
+
+HDKey.prototype.deriveChild = function (index) {
+  var isHardened = index >= HARDENED_OFFSET;
+  var indexBuffer = Buffer.allocUnsafe(4);
+  indexBuffer.writeUInt32BE(index, 0);
+
+  var data;
+
+  if (isHardened) { // Hardened child
+    assert(this.privateKey, 'Could not derive hardened child key');
+
+    var pk = this.privateKey;
+    var zb = Buffer.alloc(1, 0);
+    pk = Buffer.concat([zb, pk]);
+
+    // data = 0x00 || ser256(kpar) || ser32(index)
+    data = Buffer.concat([pk, indexBuffer]);
+  } else { // Normal child
+    // data = serP(point(kpar)) || ser32(index)
+    //      = serP(Kpar) || ser32(index)
+    data = Buffer.concat([this.publicKey, indexBuffer]);
+  }
+
+  var I = cryptoShim.createHmac('sha512', this.chainCode).update(data).digest();
+  var IL = I.slice(0, 32);
+  var IR = I.slice(32);
+
+  var hd = new HDKey(this.versions);
+
+  // Private parent key -> private child key
+  if (this.privateKey) {
+    // ki = parse256(IL) + kpar (mod n)
+    try {
+      hd.privateKey = secp256k1Shim.privateKeyTweakAdd(this.privateKey, IL);
+      // throw if IL >= n || (privateKey + IL) === 0
+    } catch (err) {
+      // In case parse256(IL) >= n or ki == 0, one should proceed with the next value for i
+      return this.deriveChild(index + 1)
+    }
+  // Public parent key -> public child key
+  } else {
+    // Ki = point(parse256(IL)) + Kpar
+    //    = G*IL + Kpar
+    try {
+      hd.publicKey = secp256k1Shim.publicKeyTweakAdd(this.publicKey, IL, true);
+      // throw if IL >= n || (g**IL + publicKey) is infinity
+    } catch (err) {
+      // In case parse256(IL) >= n or Ki is the point at infinity, one should proceed with the next value for i
+      return this.deriveChild(index + 1)
+    }
+  }
+
+  hd.chainCode = IR;
+  hd.depth = this.depth + 1;
+  hd.parentFingerprint = this.fingerprint;// .readUInt32BE(0)
+  hd.index = index;
+
+  return hd
+};
+
+HDKey.prototype.sign = function (hash) {
+  return secp256k1Shim.sign(hash, this.privateKey).signature
+};
+
+HDKey.prototype.verify = function (hash, signature) {
+  return secp256k1Shim.verify(hash, signature, this.publicKey)
+};
+
+HDKey.prototype.wipePrivateData = function () {
+  if (this._privateKey) cryptoShim.randomBytes(this._privateKey.length).copy(this._privateKey);
+  this._privateKey = null;
+  return this
+};
+
+HDKey.prototype.toJSON = function () {
+  return {
+    xpriv: this.privateExtendedKey,
+    xpub: this.publicExtendedKey
+  }
+};
+
+HDKey.fromMasterSeed = function (seedBuffer, versions) {
+  var I = cryptoShim.createHmac('sha512', MASTER_SECRET).update(seedBuffer).digest();
+  var IL = I.slice(0, 32);
+  var IR = I.slice(32);
+
+  var hdkey = new HDKey(versions);
+  hdkey.chainCode = IR;
+  hdkey.privateKey = IL;
+
+  return hdkey
+};
+
+HDKey.fromExtendedKey = function (base58key, versions) {
+  // => version(4) || depth(1) || fingerprint(4) || index(4) || chain(32) || key(33)
+  versions = versions || BITCOIN_VERSIONS;
+  var hdkey = new HDKey(versions);
+
+  var keyBuffer = bs58check.decode(base58key);
+
+  var version = keyBuffer.readUInt32BE(0);
+  assert(version === versions.private || version === versions.public, 'Version mismatch: does not match private or public');
+
+  hdkey.depth = keyBuffer.readUInt8(4);
+  hdkey.parentFingerprint = keyBuffer.readUInt32BE(5);
+  hdkey.index = keyBuffer.readUInt32BE(9);
+  hdkey.chainCode = keyBuffer.slice(13, 45);
+
+  var key = keyBuffer.slice(45);
+  if (key.readUInt8(0) === 0) { // private
+    assert(version === versions.private, 'Version mismatch: version does not match private');
+    hdkey.privateKey = key.slice(1); // cut off first 0x0 byte
+  } else {
+    assert(version === versions.public, 'Version mismatch: version does not match public');
+    hdkey.publicKey = key;
+  }
+
+  return hdkey
+};
+
+HDKey.fromJSON = function (obj) {
+  return HDKey.fromExtendedKey(obj.xpriv)
+};
+
+function serialize (hdkey, version, key) {
+  // => version(4) || depth(1) || fingerprint(4) || index(4) || chain(32) || key(33)
+  var buffer = Buffer.allocUnsafe(LEN);
+
+  buffer.writeUInt32BE(version, 0);
+  buffer.writeUInt8(hdkey.depth, 4);
+
+  var fingerprint = hdkey.depth ? hdkey.parentFingerprint : 0x00000000;
+  buffer.writeUInt32BE(fingerprint, 5);
+  buffer.writeUInt32BE(hdkey.index, 9);
+
+  hdkey.chainCode.copy(buffer, 13);
+  key.copy(buffer, 45);
+
+  return buffer
+}
+
+function hash160 (buf) {
+  var sha = cryptoShim.createHash('sha256').update(buf).digest();
+  return cryptoShim.createHash('ripemd160').update(sha).digest()
+}
+
+HDKey.HARDENED_OFFSET = HARDENED_OFFSET;
+var hdkey = HDKey;
+
+module.exports = hdkey;

package/node_modules/ethereum-cryptography/random.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+export declare function getRandomBytes(bytes: number): Promise<Buffer>;
+export declare function getRandomBytesSync(bytes: number): Buffer;
+//# sourceMappingURL=random.d.ts.map

package/node_modules/ethereum-cryptography/random.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["src/random.ts"],"names":[],"mappings":";AAEA,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAW7D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAExD"}

package/node_modules/ethereum-cryptography/random.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var randombytes = require("randombytes");
+function getRandomBytes(bytes) {
+    return new Promise(function (resolve, reject) {
+        randombytes(bytes, function (err, resp) {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve(resp);
+        });
+    });
+}
+exports.getRandomBytes = getRandomBytes;
+function getRandomBytesSync(bytes) {
+    return randombytes(bytes);
+}
+exports.getRandomBytesSync = getRandomBytesSync;
+//# sourceMappingURL=random.js.map

package/node_modules/ethereum-cryptography/random.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.js","sourceRoot":"","sources":["src/random.ts"],"names":[],"mappings":";;AAAA,IAAM,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;AAE3C,SAAgB,cAAc,CAAC,KAAa;IAC1C,OAAO,IAAI,OAAO,CAAC,UAAC,OAAO,EAAE,MAAM;QACjC,WAAW,CAAC,KAAK,EAAE,UAAS,GAAQ,EAAE,IAAY;YAChD,IAAI,GAAG,EAAE;gBACP,MAAM,CAAC,GAAG,CAAC,CAAC;gBACZ,OAAO;aACR;YAED,OAAO,CAAC,IAAI,CAAC,CAAC;QAChB,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAXD,wCAWC;AAED,SAAgB,kBAAkB,CAAC,KAAa;IAC9C,OAAO,WAAW,CAAC,KAAK,CAAC,CAAC;AAC5B,CAAC;AAFD,gDAEC"}

package/node_modules/ethereum-cryptography/ripemd160.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare const ripemd160: (msg: Buffer) => Buffer;
+//# sourceMappingURL=ripemd160.d.ts.map

package/node_modules/ethereum-cryptography/ripemd160.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ripemd160.d.ts","sourceRoot":"","sources":["src/ripemd160.ts"],"names":[],"mappings":";AAIA,eAAO,MAAM,SAAS,yBAErB,CAAC"}

package/node_modules/ethereum-cryptography/ripemd160.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var crypto_1 = __importDefault(require("crypto"));
+var hash_utils_1 = require("./hash-utils");
+exports.ripemd160 = hash_utils_1.createHashFunction(function () {
+    return crypto_1.default.createHash("ripemd160");
+});
+//# sourceMappingURL=ripemd160.js.map

package/node_modules/ethereum-cryptography/ripemd160.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ripemd160.js","sourceRoot":"","sources":["src/ripemd160.ts"],"names":[],"mappings":";;;;;AAAA,kDAA4B;AAE5B,2CAAkD;AAErC,QAAA,SAAS,GAAG,+BAAkB,CAAC;IAC1C,OAAA,gBAAM,CAAC,UAAU,CAAC,WAAW,CAAC;AAA9B,CAA8B,CAC/B,CAAC"}

package/node_modules/ethereum-cryptography/scrypt.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import "scrypt-js/thirdparty/setImmediate";
+export declare function scrypt(password: Buffer, salt: Buffer, n: number, p: number, r: number, dklen: number): Promise<Buffer>;
+export declare function scryptSync(password: Buffer, salt: Buffer, n: number, p: number, r: number, dklen: number): Buffer;
+//# sourceMappingURL=scrypt.d.ts.map

package/node_modules/ethereum-cryptography/scrypt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrypt.d.ts","sourceRoot":"","sources":["src/scrypt.ts"],"names":[],"mappings":";AAAA,OAAO,mCAAmC,CAAC;AAG3C,wBAAsB,MAAM,CAC1B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,GACZ,MAAM,CAER"}

package/node_modules/ethereum-cryptography/scrypt.js

@@ -0,0 +1,59 @@
+"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 });
+require("scrypt-js/thirdparty/setImmediate");
+var scryptJs = require("scrypt-js");
+function scrypt(password, salt, n, p, r, dklen) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _b = (_a = Buffer).from;
+                    return [4 /*yield*/, scryptJs.scrypt(password, salt, n, r, p, dklen)];
+                case 1: return [2 /*return*/, _b.apply(_a, [_c.sent()])];
+            }
+        });
+    });
+}
+exports.scrypt = scrypt;
+function scryptSync(password, salt, n, p, r, dklen) {
+    return Buffer.from(scryptJs.syncScrypt(password, salt, n, r, p, dklen));
+}
+exports.scryptSync = scryptSync;
+//# sourceMappingURL=scrypt.js.map

package/node_modules/ethereum-cryptography/scrypt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrypt.js","sourceRoot":"","sources":["src/scrypt.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6CAA2C;AAC3C,IAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;AAEtC,SAAsB,MAAM,CAC1B,QAAgB,EAChB,IAAY,EACZ,CAAS,EACT,CAAS,EACT,CAAS,EACT,KAAa;;;;;;oBAEN,KAAA,CAAA,KAAA,MAAM,CAAA,CAAC,IAAI,CAAA;oBAAC,qBAAM,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,EAAA;wBAAxE,sBAAO,cAAY,SAAqD,EAAC,EAAC;;;;CAC3E;AATD,wBASC;AAED,SAAgB,UAAU,CACxB,QAAgB,EAChB,IAAY,EACZ,CAAS,EACT,CAAS,EACT,CAAS,EACT,KAAa;IAEb,OAAO,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;AAC1E,CAAC;AATD,gCASC"}

package/node_modules/ethereum-cryptography/secp256k1.d.ts

@@ -0,0 +1,4 @@
+export declare function createPrivateKey(): Promise<Uint8Array>;
+export declare function createPrivateKeySync(): Uint8Array;
+export * from "secp256k1";
+//# sourceMappingURL=secp256k1.d.ts.map

package/node_modules/ethereum-cryptography/secp256k1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secp256k1.d.ts","sourceRoot":"","sources":["src/secp256k1.ts"],"names":[],"mappings":"AAKA,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,UAAU,CAAC,CAO5D;AAED,wBAAgB,oBAAoB,IAAI,UAAU,CAOjD;AAED,cAAc,WAAW,CAAC"}

package/node_modules/ethereum-cryptography/secp256k1.js

@@ -0,0 +1,75 @@
+"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 };
+    }
+};
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+var secp256k1_1 = require("secp256k1");
+var random_1 = require("./random");
+var SECP256K1_PRIVATE_KEY_SIZE = 32;
+function createPrivateKey() {
+    return __awaiter(this, void 0, void 0, function () {
+        var pk;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!true) return [3 /*break*/, 2];
+                    return [4 /*yield*/, random_1.getRandomBytes(SECP256K1_PRIVATE_KEY_SIZE)];
+                case 1:
+                    pk = _a.sent();
+                    if (secp256k1_1.privateKeyVerify(pk)) {
+                        return [2 /*return*/, pk];
+                    }
+                    return [3 /*break*/, 0];
+                case 2: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.createPrivateKey = createPrivateKey;
+function createPrivateKeySync() {
+    while (true) {
+        var pk = random_1.getRandomBytesSync(SECP256K1_PRIVATE_KEY_SIZE);
+        if (secp256k1_1.privateKeyVerify(pk)) {
+            return pk;
+        }
+    }
+}
+exports.createPrivateKeySync = createPrivateKeySync;
+__export(require("secp256k1"));
+//# sourceMappingURL=secp256k1.js.map

package/node_modules/ethereum-cryptography/secp256k1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"secp256k1.js","sourceRoot":"","sources":["src/secp256k1.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uCAA6C;AAC7C,mCAA8D;AAE9D,IAAM,0BAA0B,GAAG,EAAE,CAAC;AAEtC,SAAsB,gBAAgB;;;;;;yBAC7B,IAAI;oBACE,qBAAM,uBAAc,CAAC,0BAA0B,CAAC,EAAA;;oBAArD,EAAE,GAAG,SAAgD;oBAC3D,IAAI,4BAAgB,CAAC,EAAE,CAAC,EAAE;wBACxB,sBAAO,EAAE,EAAC;qBACX;;;;;;CAEJ;AAPD,4CAOC;AAED,SAAgB,oBAAoB;IAClC,OAAO,IAAI,EAAE;QACX,IAAM,EAAE,GAAG,2BAAkB,CAAC,0BAA0B,CAAC,CAAC;QAC1D,IAAI,4BAAgB,CAAC,EAAE,CAAC,EAAE;YACxB,OAAO,EAAE,CAAC;SACX;KACF;AACH,CAAC;AAPD,oDAOC;AAED,+BAA0B"}

package/node_modules/ethereum-cryptography/sha256.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare const sha256: (msg: Buffer) => Buffer;
+//# sourceMappingURL=sha256.d.ts.map

package/node_modules/ethereum-cryptography/sha256.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.d.ts","sourceRoot":"","sources":["src/sha256.ts"],"names":[],"mappings":";AAIA,eAAO,MAAM,MAAM,yBAAwD,CAAC"}

package/node_modules/ethereum-cryptography/sha256.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var crypto_1 = __importDefault(require("crypto"));
+var hash_utils_1 = require("./hash-utils");
+exports.sha256 = hash_utils_1.createHashFunction(function () { return crypto_1.default.createHash("sha256"); });
+//# sourceMappingURL=sha256.js.map

package/node_modules/ethereum-cryptography/sha256.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.js","sourceRoot":"","sources":["src/sha256.ts"],"names":[],"mappings":";;;;;AAAA,kDAA4B;AAE5B,2CAAkD;AAErC,QAAA,MAAM,GAAG,+BAAkB,CAAC,cAAM,OAAA,gBAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAA3B,CAA2B,CAAC,CAAC"}

package/node_modules/ethereum-cryptography/shims/hdkey-crypto.d.ts

@@ -0,0 +1,2 @@
+export { createHash, createHmac, randomBytes } from "crypto";
+//# sourceMappingURL=hdkey-crypto.d.ts.map

package/node_modules/ethereum-cryptography/shims/hdkey-crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hdkey-crypto.d.ts","sourceRoot":"","sources":["../src/shims/hdkey-crypto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC"}

package/node_modules/ethereum-cryptography/shims/hdkey-crypto.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var crypto_1 = require("crypto");
+exports.createHash = crypto_1.createHash;
+exports.createHmac = crypto_1.createHmac;
+exports.randomBytes = crypto_1.randomBytes;
+//# sourceMappingURL=hdkey-crypto.js.map

package/node_modules/ethereum-cryptography/shims/hdkey-crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hdkey-crypto.js","sourceRoot":"","sources":["../src/shims/hdkey-crypto.ts"],"names":[],"mappings":";;AAAA,iCAA6D;AAApD,8BAAA,UAAU,CAAA;AAAE,8BAAA,UAAU,CAAA;AAAE,+BAAA,WAAW,CAAA"}

package/node_modules/ethereum-cryptography/shims/hdkey-secp256k1v3.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+export declare function privateKeyVerify(privateKey: Buffer): boolean;
+export declare function publicKeyCreate(privateKey: Buffer, compressed?: boolean): Buffer;
+export declare function publicKeyVerify(publicKey: Buffer): boolean;
+export declare function publicKeyConvert(publicKey: Buffer, compressed?: boolean): Buffer;
+export declare function privateKeyTweakAdd(publicKey: Buffer, tweak: Buffer): Buffer;
+export declare function publicKeyTweakAdd(publicKey: Buffer, tweak: Buffer, compressed?: boolean): Buffer;
+export declare function sign(message: Buffer, privateKey: Buffer): {
+    signature: Buffer;
+    recovery: number;
+};
+export declare function verify(message: Buffer, signature: Buffer, publicKey: Buffer): boolean;
+//# sourceMappingURL=hdkey-secp256k1v3.d.ts.map

package/node_modules/ethereum-cryptography/shims/hdkey-secp256k1v3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hdkey-secp256k1v3.d.ts","sourceRoot":"","sources":["../src/shims/hdkey-secp256k1v3.ts"],"names":[],"mappings":";AAEA,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE5D;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,UAAO,GAAG,MAAM,CAE7E;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,UAAO,GAAG,MAAM,CAE7E;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAI3E;AAED,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,UAAU,UAAO,GAChB,MAAM,CAIR;AAED,wBAAgB,IAAI,CAClB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAGzC;AAED,wBAAgB,MAAM,CACpB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAET"}

package/node_modules/ethereum-cryptography/shims/hdkey-secp256k1v3.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var secp256k1 = __importStar(require("secp256k1"));
+function privateKeyVerify(privateKey) {
+    return secp256k1.privateKeyVerify(privateKey);
+}
+exports.privateKeyVerify = privateKeyVerify;
+function publicKeyCreate(privateKey, compressed) {
+    if (compressed === void 0) { compressed = true; }
+    return Buffer.from(secp256k1.publicKeyCreate(privateKey, compressed));
+}
+exports.publicKeyCreate = publicKeyCreate;
+function publicKeyVerify(publicKey) {
+    return secp256k1.publicKeyVerify(publicKey);
+}
+exports.publicKeyVerify = publicKeyVerify;
+function publicKeyConvert(publicKey, compressed) {
+    if (compressed === void 0) { compressed = true; }
+    return Buffer.from(secp256k1.publicKeyConvert(publicKey, compressed));
+}
+exports.publicKeyConvert = publicKeyConvert;
+function privateKeyTweakAdd(publicKey, tweak) {
+    return Buffer.from(secp256k1.privateKeyTweakAdd(Buffer.from(publicKey), tweak));
+}
+exports.privateKeyTweakAdd = privateKeyTweakAdd;
+function publicKeyTweakAdd(publicKey, tweak, compressed) {
+    if (compressed === void 0) { compressed = true; }
+    return Buffer.from(secp256k1.publicKeyTweakAdd(Buffer.from(publicKey), tweak, compressed));
+}
+exports.publicKeyTweakAdd = publicKeyTweakAdd;
+function sign(message, privateKey) {
+    var ret = secp256k1.ecdsaSign(message, privateKey);
+    return { signature: Buffer.from(ret.signature), recovery: ret.recid };
+}
+exports.sign = sign;
+function verify(message, signature, publicKey) {
+    return secp256k1.ecdsaVerify(signature, message, publicKey);
+}
+exports.verify = verify;
+//# sourceMappingURL=hdkey-secp256k1v3.js.map

package/node_modules/ethereum-cryptography/shims/hdkey-secp256k1v3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hdkey-secp256k1v3.js","sourceRoot":"","sources":["../src/shims/hdkey-secp256k1v3.ts"],"names":[],"mappings":";;;;;;;;;AAAA,mDAAuC;AAEvC,SAAgB,gBAAgB,CAAC,UAAkB;IACjD,OAAO,SAAS,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;AAChD,CAAC;AAFD,4CAEC;AAED,SAAgB,eAAe,CAAC,UAAkB,EAAE,UAAiB;IAAjB,2BAAA,EAAA,iBAAiB;IACnE,OAAO,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;AACxE,CAAC;AAFD,0CAEC;AAED,SAAgB,eAAe,CAAC,SAAiB;IAC/C,OAAO,SAAS,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;AAC9C,CAAC;AAFD,0CAEC;AAED,SAAgB,gBAAgB,CAAC,SAAiB,EAAE,UAAiB;IAAjB,2BAAA,EAAA,iBAAiB;IACnE,OAAO,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;AACxE,CAAC;AAFD,4CAEC;AAED,SAAgB,kBAAkB,CAAC,SAAiB,EAAE,KAAa;IACjE,OAAO,MAAM,CAAC,IAAI,CAChB,SAAS,CAAC,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,CAAC,CAC5D,CAAC;AACJ,CAAC;AAJD,gDAIC;AAED,SAAgB,iBAAiB,CAC/B,SAAiB,EACjB,KAAa,EACb,UAAiB;IAAjB,2BAAA,EAAA,iBAAiB;IAEjB,OAAO,MAAM,CAAC,IAAI,CAChB,SAAS,CAAC,iBAAiB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CACvE,CAAC;AACJ,CAAC;AARD,8CAQC;AAED,SAAgB,IAAI,CAClB,OAAe,EACf,UAAkB;IAElB,IAAM,GAAG,GAAG,SAAS,CAAC,SAAS,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IACrD,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,GAAG,CAAC,KAAK,EAAE,CAAC;AACxE,CAAC;AAND,oBAMC;AAED,SAAgB,MAAM,CACpB,OAAe,EACf,SAAiB,EACjB,SAAiB;IAEjB,OAAO,SAAS,CAAC,WAAW,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;AAC9D,CAAC;AAND,wBAMC"}

package/node_modules/ethereum-cryptography/src/aes.ts

@@ -0,0 +1,52 @@
+const browserifyAes = require("browserify-aes");
+
+const SUPPORTED_MODES = ["aes-128-ctr", "aes-128-cbc", "aes-256-cbc"];
+
+function ensureAesMode(mode: string) {
+  if (!mode.startsWith("aes-")) {
+    throw new Error(`AES submodule doesn't support mode ${mode}`);
+  }
+}
+
+function warnIfUnsuportedMode(mode: string) {
+  if (!SUPPORTED_MODES.includes(mode)) {
+    // tslint:disable-next-line no-console
+    console.warn("Using an unsupported AES mode. Consider using aes-128-ctr.");
+  }
+}
+
+export function encrypt(
+  msg: Buffer,
+  key: Buffer,
+  iv: Buffer,
+  mode = "aes-128-ctr",
+  pkcs7PaddingEnabled = true
+): Buffer {
+  ensureAesMode(mode);
+
+  const cipher = browserifyAes.createCipheriv(mode, key, iv);
+  cipher.setAutoPadding(pkcs7PaddingEnabled);
+
+  const encrypted = cipher.update(msg);
+  const final = cipher.final();
+
+  return Buffer.concat([encrypted, final]);
+}
+
+export function decrypt(
+  cypherText: Buffer,
+  key: Buffer,
+  iv: Buffer,
+  mode = "aes-128-ctr",
+  pkcs7PaddingEnabled = true
+): Buffer {
+  ensureAesMode(mode);
+
+  const decipher = browserifyAes.createDecipheriv(mode, key, iv);
+  decipher.setAutoPadding(pkcs7PaddingEnabled);
+
+  const encrypted = decipher.update(cypherText);
+  const final = decipher.final();
+
+  return Buffer.concat([encrypted, final]);
+}