gnache-cli 0.0.1-security → 6.12.2

package/node_modules/ethjs-util/lib/tests/test.index.js

@@ -0,0 +1,357 @@
+'use strict';
+
+var util = require('../index.js');
+var assert = require('chai').assert;
+var BN = require('bn.js');
+
+describe('check all exports', function () {
+  it('should have all exports available', function () {
+    var expected = ['arrayContainsArray', 'toBuffer', 'intToBuffer', 'getBinarySize', 'stripHexPrefix', 'isHexPrefixed', 'padToEven', 'intToHex', 'fromAscii', 'fromUtf8', 'toAscii', 'getKeys', 'isHexString', 'toUtf8'];
+
+    Object.keys(util).forEach(function (utilKey) {
+      assert.equal(expected.includes(utilKey), true, utilKey);
+    });
+  });
+
+  it('should convert intToHex', function () {
+    assert.equal(util.intToHex(new BN(0)), '0x0');
+  });
+
+  it('should throw when invalid abi', function () {
+    assert.throws(function () {
+      return util.getKeys([], 3289);
+    }, Error);
+  });
+
+  it('should detect invalid length hex string', function () {
+    assert.equal(util.isHexString('0x0', 2), false);
+  });
+
+  it('should stripHexPrefix strip prefix of valid strings', function () {
+    assert.equal(util.stripHexPrefix('0xkdsfksfdkj'), 'kdsfksfdkj');
+    assert.equal(util.stripHexPrefix('0xksfdkj'), 'ksfdkj');
+    assert.equal(util.stripHexPrefix('0xkdsfdkj'), 'kdsfdkj');
+    assert.equal(util.stripHexPrefix('0x23442sfdkj'), '23442sfdkj');
+    assert.equal(util.stripHexPrefix('0xkdssdfssfdkj'), 'kdssdfssfdkj');
+    assert.equal(util.stripHexPrefix('0xaaaasfdkj'), 'aaaasfdkj');
+    assert.equal(util.stripHexPrefix('0xkdsdfsfsdfsdfsdfdkj'), 'kdsdfsfsdfsdfsdfdkj');
+    assert.equal(util.stripHexPrefix('0x111dssdddj'), '111dssdddj');
+  });
+
+  it('should stripHexPrefix strip prefix of mix hexed strings', function () {
+    assert.equal(util.stripHexPrefix('0xkdsfksfdkj'), 'kdsfksfdkj');
+    assert.equal(util.stripHexPrefix('ksfdkj'), 'ksfdkj');
+    assert.equal(util.stripHexPrefix('kdsfdkj'), 'kdsfdkj');
+    assert.equal(util.stripHexPrefix('23442sfdkj'), '23442sfdkj');
+    assert.equal(util.stripHexPrefix('0xkdssdfssfdkj'), 'kdssdfssfdkj');
+    assert.equal(util.stripHexPrefix('aaaasfdkj'), 'aaaasfdkj');
+    assert.equal(util.stripHexPrefix('kdsdfsfsdfsdfsdfdkj'), 'kdsdfsfsdfsdfsdfdkj');
+    assert.equal(util.stripHexPrefix('111dssdddj'), '111dssdddj');
+  });
+
+  it('should stripHexPrefix bypass if not string', function () {
+    assert.equal(util.stripHexPrefix(null), null);
+    assert.equal(util.stripHexPrefix(undefined), undefined);
+    assert.equal(util.stripHexPrefix(242423), 242423);
+    assert.deepEqual(util.stripHexPrefix({}), {});
+    assert.deepEqual(util.stripHexPrefix([]), []);
+    assert.equal(util.stripHexPrefix(true), true);
+  });
+
+  it('valid padToEven should pad to even', function () {
+    assert.equal(String(util.padToEven('0')).length % 2, 0);
+    assert.equal(String(util.padToEven('111')).length % 2, 0);
+    assert.equal(String(util.padToEven('22222')).length % 2, 0);
+    assert.equal(String(util.padToEven('ddd')).length % 2, 0);
+    assert.equal(String(util.padToEven('aa')).length % 2, 0);
+    assert.equal(String(util.padToEven('aaaaaa')).length % 2, 0);
+    assert.equal(String(util.padToEven('sdssd')).length % 2, 0);
+    assert.equal(String(util.padToEven('eee')).length % 2, 0);
+    assert.equal(String(util.padToEven('w')).length % 2, 0);
+  });
+
+  it('valid padToEven should pad to even check string prefix 0', function () {
+    assert.equal(String(util.padToEven('0')), '00');
+    assert.equal(String(util.padToEven('111')), '0111');
+    assert.equal(String(util.padToEven('22222')), '022222');
+    assert.equal(String(util.padToEven('ddd')), '0ddd');
+    assert.equal(String(util.padToEven('aa')), 'aa');
+    assert.equal(String(util.padToEven('aaaaaa')), 'aaaaaa');
+    assert.equal(String(util.padToEven('sdssd')), '0sdssd');
+    assert.equal(String(util.padToEven('eee')), '0eee');
+    assert.equal(String(util.padToEven('w')), '0w');
+  });
+
+  it('should padToEven throw as expected string got null', function () {
+    try {
+      util.padToEven(null);
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('should padToEven throw as expected string got undefined', function () {
+    try {
+      util.padToEven(undefined);
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('should padToEven throw as expected string got {}', function () {
+    try {
+      util.padToEven({});
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('should padToEven throw as expected string got new Buffer()', function () {
+    try {
+      util.padToEven(new Buffer());
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('should padToEven throw as expected string got number', function () {
+    try {
+      util.padToEven(24423232);
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('method getKeys should throw as expected array for params got number', function () {
+    try {
+      util.getKeys(2482822);
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('method invalid getKeys with allow empty and no defined value', function () {
+    try {
+      util.getKeys([{ type: undefined }], 'type', true);
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('method valid getKeys with allow empty and false', function () {
+    try {
+      util.getKeys([{ type: true }], 'type', true);
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('method getKeys should throw as expected array for params got number', function () {
+    try {
+      util.getKeys(2482822, 293849824);
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('method getKeys should throw as expected array for params got object', function () {
+    try {
+      util.getKeys({}, []);
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('method getKeys should throw as expected array for params got null', function () {
+    try {
+      util.getKeys(null);
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('method getKeys should throw as expected array for params got false', function () {
+    try {
+      util.getKeys(false);
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('valid getKeys should get keys from object in array', function () {
+    assert.deepEqual(util.getKeys([{ type: 'sfd' }, { type: 'something' }], 'type'), ['sfd', 'something']);
+    assert.deepEqual(util.getKeys([{ cool: 'something' }, { cool: 'fdsdfsfd' }], 'cool'), ['something', 'fdsdfsfd']);
+    assert.deepEqual(util.getKeys([{ type: '234424' }, { type: '243234242432' }], 'type'), ['234424', '243234242432']);
+    assert.deepEqual(util.getKeys([{ type: 'something' }, { type: 'something' }], 'type'), ['something', 'something']);
+    assert.deepEqual(util.getKeys([{ type: 'something' }], 'type'), ['something']);
+    assert.deepEqual(util.getKeys([], 'type'), []);
+    assert.deepEqual(util.getKeys([{ type: 'something' }, { type: 'something' }, { type: 'something' }], 'type'), ['something', 'something', 'something']);
+  });
+
+  it('valid isHexString tests', function () {
+    assert.equal(util.isHexString('0x0e026d45820d91356fc73d7ff2bdef353ebfe7e9'), true);
+    assert.equal(util.isHexString('0x1e026d45820d91356fc73d7ff2bdef353ebfe7e9'), true);
+    assert.equal(util.isHexString('0x6e026d45820d91356fc73d7ff2bdef353ebfe7e9'), true);
+    assert.equal(util.isHexString('0xecfaa1a0c4372a2ac5cca1e164510ec8df04f681fc960797f1419802ec00b225'), true);
+    assert.equal(util.isHexString('0x6e0e6d45820d91356fc73d7ff2bdef353ebfe7e9'), true);
+    assert.equal(util.isHexString('0x620e6d45820d91356fc73d7ff2bdef353ebfe7e9'), true);
+    assert.equal(util.isHexString('0x1e0e6d45820d91356fc73d7ff2bdef353ebfe7e9'), true);
+    assert.equal(util.isHexString('0x2e0e6d45820d91356fc73d7ff2bdef353ebfe7e9'), true);
+    assert.equal(util.isHexString('0x220c96d48733a847570c2f0b40daa8793b3ae875b26a4ead1f0f9cead05c3863'), true);
+    assert.equal(util.isHexString('0x2bb303f0ae65c64ef80a3bb3ee8ceef5d50065bd'), true);
+    assert.equal(util.isHexString('0x6e026d45820d91256fc73d7ff2bdef353ebfe7e9'), true);
+  });
+
+  it('invalid isHexString tests', function () {
+    assert.equal(util.isHexString(' 0x0e026d45820d91356fc73d7ff2bdef353ebfe7e9'), false);
+    assert.equal(util.isHexString('fdsjfsd'), false);
+    assert.equal(util.isHexString(' 0xfdsjfsd'), false);
+    assert.equal(util.isHexString('0xfds*jfsd'), false);
+    assert.equal(util.isHexString('0xfds$jfsd'), false);
+    assert.equal(util.isHexString('0xf@dsjfsd'), false);
+    assert.equal(util.isHexString('0xfdsjf!sd'), false);
+    assert.equal(util.isHexString('fds@@jfsd'), false);
+    assert.equal(util.isHexString(24223), false);
+    assert.equal(util.isHexString(null), false);
+    assert.equal(util.isHexString(undefined), false);
+    assert.equal(util.isHexString(false), false);
+    assert.equal(util.isHexString({}), false);
+    assert.equal(util.isHexString([]), false);
+  });
+
+  it('valid arrayContainsArray should array contain every array', function () {
+    assert.equal(util.arrayContainsArray([1, 2, 3], [1, 2]), true);
+    assert.equal(util.arrayContainsArray([3, 3], [3, 3]), true);
+    assert.equal(util.arrayContainsArray([1, 2, 'h'], [1, 2, 'h']), true);
+    assert.equal(util.arrayContainsArray([1, 2, 'fsffds'], [1, 2, 'fsffds']), true);
+    assert.equal(util.arrayContainsArray([1], [1]), true);
+    assert.equal(util.arrayContainsArray([], []), true);
+    assert.equal(util.arrayContainsArray([1, 3333], [1, 3333]), true);
+  });
+
+  it('valid getBinarySize should get binary size of string', function () {
+    assert.equal(util.getBinarySize('0x0e026d45820d91356fc73d7ff2bdef353ebfe7e9'), 42);
+    assert.equal(util.getBinarySize('0x220c96d48733a847570c2f0b40daa8793b3ae875b26a4ead1f0f9cead05c3863'), 66);
+  });
+
+  it('invalid getBinarySize should throw invalid type Boolean', function () {
+    try {
+      util.getBinarySize(false);
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('invalid getBinarySize should throw invalid type object', function () {
+    try {
+      util.getBinarySize({});
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('invalid getBinarySize should throw invalid type Array', function () {
+    try {
+      util.getBinarySize([]);
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('valid arrayContainsArray should array some every array', function () {
+    assert.equal(util.arrayContainsArray([1, 2], [1], true), true);
+    assert.equal(util.arrayContainsArray([3, 3], [3, 2323], true), true);
+    assert.equal(util.arrayContainsArray([1, 2, 'h'], [2332, 2, 'h'], true), true);
+    assert.equal(util.arrayContainsArray([1, 2, 'fsffds'], [3232, 2, 'fsffds'], true), true);
+    assert.equal(util.arrayContainsArray([1], [1], true), true);
+    assert.equal(util.arrayContainsArray([1, 3333], [1, 323232], true), true);
+  });
+
+  it('method arrayContainsArray should throw as expected array for params got false', function () {
+    try {
+      util.arrayContainsArray(false);
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('method arrayContainsArray should throw as expected array for params got false', function () {
+    try {
+      util.arrayContainsArray([], false);
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  it('method arrayContainsArray should throw as expected array for params got {}', function () {
+    try {
+      util.arrayContainsArray({}, false);
+    } catch (error) {
+      assert.equal(typeof error, 'object');
+    }
+  });
+
+  var fromAsciiTests = [{ value: 'myString', expected: '0x6d79537472696e67' }, { value: 'myString\x00', expected: '0x6d79537472696e6700' }, { value: '\x03\0\0\x005\xE8\xC6\xD5L]\x12|\x9D\xCE\xBE\x9E\x1A7\xAB\x9B\x052\x11(\xD0\x97Y\n<\x10\0\0\0\0\0\0e!\xDFd/\xF1\xF5\xEC\f:z\xA6\xCE\xA6\xB1\xE7\xB7\xF7\xCD\xA2\xCB\xDF\x076*\x85\b\x8E\x97\xF1\x9E\xF9C1\xC9U\xC0\xE92\x1A\xD3\x86B\x8C',
+    expected: '0x0300000035e8c6d54c5d127c9dcebe9e1a37ab9b05321128d097590a3c100000000000006521df642ff1f5ec0c3a7aa6cea6b1e7b7f7cda2cbdf07362a85088e97f19ef94331c955c0e9321ad386428c' }];
+
+  describe('fromAscii', function () {
+    fromAsciiTests.forEach(function (test) {
+      it('should turn ' + test.value + ' to ' + test.expected + ' ', function () {
+        assert.strictEqual(util.fromAscii(test.value), test.expected);
+      });
+    });
+  });
+
+  var fromUtf8Tests = [{ value: 'myString', expected: '0x6d79537472696e67' }, { value: 'myString\x00', expected: '0x6d79537472696e67' }, { value: 'expected value\0\0\0', expected: '0x65787065637465642076616c7565' }];
+
+  describe('fromUtf8', function () {
+    fromUtf8Tests.forEach(function (test) {
+      it('should turn ' + test.value + ' to ' + test.expected + ' ', function () {
+        assert.strictEqual(util.fromUtf8(test.value), test.expected);
+      });
+    });
+  });
+
+  var toUtf8Tests = [{ value: '0x6d79537472696e67', expected: 'myString' }, { value: '0x6d79537472696e6700', expected: 'myString' }, { value: '0x65787065637465642076616c7565000000000000000000000000000000000000', expected: 'expected value' }];
+
+  describe('toUtf8', function () {
+    toUtf8Tests.forEach(function (test) {
+      it('should turn ' + test.value + ' to ' + test.expected + ' ', function () {
+        assert.strictEqual(util.toUtf8(test.value), test.expected);
+      });
+    });
+  });
+
+  var toAsciiTests = [{ value: '0x6d79537472696e67', expected: 'myString' }, { value: '0x6d79537472696e6700', expected: 'myString\0' }, { value: '0x0300000035e8c6d54c5d127c9dcebe9e1a37ab9b05321128d097590a3c100000000000006521df642ff1f5ec0c3a7aa6cea6b1e7b7f7cda2cbdf07362a85088e97f19ef94331c955c0e9321ad386428c',
+    expected: '\x03\0\0\x005\xE8\xC6\xD5L]\x12|\x9D\xCE\xBE\x9E\x1A7\xAB\x9B\x052\x11(\xD0\x97Y\n<\x10\0\0\0\0\0\0e!\xDFd/\xF1\xF5\xEC\f:z\xA6\xCE\xA6\xB1\xE7\xB7\xF7\xCD\xA2\xCB\xDF\x076*\x85\b\x8E\x97\xF1\x9E\xF9C1\xC9U\xC0\xE92\x1A\xD3\x86B\x8C' }];
+
+  describe('toAsciiTests', function () {
+    toAsciiTests.forEach(function (test) {
+      it('should turn ' + test.value + ' to ' + test.expected + ' ', function () {
+        assert.strictEqual(util.toAscii(test.value), test.expected);
+      });
+    });
+  });
+
+  describe('intToHex', function () {
+    it('should convert a int to hex', function () {
+      var i = 6003400;
+      var hex = util.intToHex(i);
+      assert.equal(hex, '0x5b9ac8');
+    });
+  });
+
+  describe('intToBuffer', function () {
+    it('should convert a int to a buffer', function () {
+      var i = 6003400;
+      var buf = util.intToBuffer(i);
+      assert.equal(buf.toString('hex'), '5b9ac8');
+    });
+
+    it('should convert a int to a buffer for odd length hex values', function () {
+      var i = 1;
+      var buf = util.intToBuffer(i);
+      assert.equal(buf.toString('hex'), '01');
+    });
+  });
+});

package/node_modules/ethjs-util/package.json

@@ -0,0 +1,229 @@
+{
+  "authors": [
+    "Nick Dodson <nick.dodson@consensys.net>"
+  ],
+  "babel": {
+    "plugins": [
+      [
+        "transform-es2015-template-literals",
+        {
+          "loose": true
+        }
+      ],
+      "transform-es2015-literals",
+      "transform-es2015-function-name",
+      "transform-es2015-arrow-functions",
+      "transform-es2015-block-scoped-functions",
+      [
+        "transform-es2015-classes",
+        {
+          "loose": true
+        }
+      ],
+      "transform-es2015-object-super",
+      "transform-es2015-shorthand-properties",
+      [
+        "transform-es2015-computed-properties",
+        {
+          "loose": true
+        }
+      ],
+      [
+        "transform-es2015-for-of",
+        {
+          "loose": true
+        }
+      ],
+      "transform-es2015-sticky-regex",
+      "transform-es2015-unicode-regex",
+      "check-es2015-constants",
+      [
+        "transform-es2015-spread",
+        {
+          "loose": true
+        }
+      ],
+      "transform-es2015-parameters",
+      [
+        "transform-es2015-destructuring",
+        {
+          "loose": true
+        }
+      ],
+      "transform-es2015-block-scoping",
+      "transform-object-rest-spread",
+      "transform-es3-member-expression-literals",
+      "transform-es3-property-literals"
+    ],
+    "env": {
+      "commonjs": {
+        "plugins": [
+          [
+            "transform-es2015-modules-commonjs",
+            {
+              "loose": true
+            }
+          ]
+        ]
+      }
+    }
+  },
+  "bugs": {
+    "url": "https://github.com/ethjs/ethjs-util/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Richard Moore",
+      "email": "me@ricmoo.com",
+      "url": "https://ethers.io"
+    }
+  ],
+  "dependencies": {
+    "is-hex-prefixed": "1.0.0",
+    "strip-hex-prefix": "1.0.0"
+  },
+  "deprecated": false,
+  "description": "A simple set of Ethereum JS utilties.",
+  "devDependencies": {
+    "babel-cli": "6.18.0",
+    "babel-core": "6.18.2",
+    "babel-eslint": "7.1.0",
+    "babel-loader": "6.2.8",
+    "babel-plugin-check-es2015-constants": "6.8.0",
+    "babel-plugin-transform-es2015-arrow-functions": "6.8.0",
+    "babel-plugin-transform-es2015-block-scoped-functions": "6.8.0",
+    "babel-plugin-transform-es2015-block-scoping": "6.18.0",
+    "babel-plugin-transform-es2015-classes": "6.18.0",
+    "babel-plugin-transform-es2015-computed-properties": "6.8.0",
+    "babel-plugin-transform-es2015-destructuring": "6.19.0",
+    "babel-plugin-transform-es2015-for-of": "6.18.0",
+    "babel-plugin-transform-es2015-function-name": "6.9.0",
+    "babel-plugin-transform-es2015-literals": "6.8.0",
+    "babel-plugin-transform-es2015-modules-commonjs": "6.18.0",
+    "babel-plugin-transform-es2015-object-super": "6.8.0",
+    "babel-plugin-transform-es2015-parameters": "6.18.0",
+    "babel-plugin-transform-es2015-shorthand-properties": "6.18.0",
+    "babel-plugin-transform-es2015-spread": "6.8.0",
+    "babel-plugin-transform-es2015-sticky-regex": "6.8.0",
+    "babel-plugin-transform-es2015-template-literals": "6.8.0",
+    "babel-plugin-transform-es2015-unicode-regex": "6.11.0",
+    "babel-plugin-transform-es3-member-expression-literals": "6.5.0",
+    "babel-plugin-transform-es3-property-literals": "6.5.0",
+    "babel-plugin-transform-object-rest-spread": "6.19.0",
+    "babel-register": "6.18.0",
+    "bignumber.js": "3.0.1",
+    "bn.js": "4.11.6",
+    "chai": "3.5.0",
+    "check-es3-syntax-cli": "0.1.3",
+    "coveralls": "2.11.9",
+    "cross-env": "1.0.7",
+    "eslint": "2.10.1",
+    "eslint-config-airbnb": "9.0.1",
+    "eslint-import-resolver-webpack": "0.2.4",
+    "eslint-plugin-import": "1.8.0",
+    "eslint-plugin-jsx-a11y": "1.2.0",
+    "eslint-plugin-react": "5.1.1",
+    "eventsource-polyfill": "0.9.6",
+    "istanbul": "0.4.5",
+    "json-loader": "0.5.4",
+    "lint-staged": "1.0.1",
+    "mocha": "3.1.2",
+    "pre-commit": "1.1.3",
+    "rimraf": "2.3.4",
+    "webpack": "2.1.0-beta.15"
+  },
+  "engines": {
+    "node": ">=6.5.0",
+    "npm": ">=3"
+  },
+  "eslintConfig": {
+    "parser": "babel-eslint",
+    "extends": "airbnb",
+    "env": {
+      "node": true,
+      "mocha": true,
+      "es6": true
+    },
+    "parserOptions": {
+      "ecmaVersion": 6,
+      "sourceType": "module"
+    },
+    "rules": {
+      "import/no-unresolved": 2,
+      "comma-dangle": [
+        2,
+        "always-multiline"
+      ],
+      "indent": [
+        2,
+        2,
+        {
+          "SwitchCase": 1
+        }
+      ],
+      "no-console": 1,
+      "max-len": 0,
+      "prefer-template": 2,
+      "no-use-before-define": 0,
+      "newline-per-chained-call": 0,
+      "arrow-body-style": [
+        2,
+        "as-needed"
+      ]
+    }
+  },
+  "files": [
+    "dist",
+    "internals",
+    "lib",
+    "src"
+  ],
+  "homepage": "https://github.com/ethjs/ethjs-util#readme",
+  "keywords": [
+    "ethereum",
+    "rpc",
+    "formatter",
+    "format",
+    "ethereum",
+    "encoding",
+    "decoding"
+  ],
+  "license": "MIT",
+  "lint-staged": {
+    "lint:eslint": "*.js"
+  },
+  "main": "lib/index.js",
+  "name": "ethjs-util",
+  "pre-commit": "build",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/ethjs/ethjs-util.git"
+  },
+  "scripts": {
+    "build": "npm run build:commonjs && npm run test:lib && npm run build:umd && npm run build:umd:min",
+    "build:clean": "npm run test:clean && rimraf ./dist",
+    "build:commonjs": "cross-env BABEL_ENV=commonjs babel src --out-dir lib --copy-files",
+    "build:umd": "cross-env BABEL_ENV=commonjs NODE_ENV=development webpack --config ./internals/webpack/webpack.config.js ./lib/index.js --progress",
+    "build:umd:min": "cross-env BABEL_ENV=commonjs NODE_ENV=production webpack --config ./internals/webpack/webpack.config.js ./lib/index.js --progress",
+    "coveralls": "npm run test-travis && cat ./coverage/lcov.info | coveralls",
+    "lint": "npm run lint:js",
+    "lint:eslint": "eslint --ignore-path .gitignore --ignore-pattern **/**.min.js",
+    "lint:js": "npm run lint:eslint -- . ",
+    "lint:staged": "lint-staged",
+    "prebuild": "npm run build:clean && npm run test",
+    "prepublish": "npm run build",
+    "pretest": "npm run lint",
+    "release": "npmpub",
+    "start": "npm test",
+    "test": "mocha ./src/tests/**/*.js -R spec --timeout 2000000",
+    "test-travis": "node ./node_modules/istanbul/lib/cli.js cover ./node_modules/mocha/bin/_mocha -- src/tests/**/*.js -R spec --timeout 2000000",
+    "test:clean": "rimraf ./coverage",
+    "test:lib": "mocha ./lib/tests/**/*.js -R spec --timeout 2000000"
+  },
+  "version": "0.1.6"
+
+,"_resolved": "https://registry.npmjs.org/ethjs-util/-/ethjs-util-0.1.6.tgz"
+,"_integrity": "sha512-CUnVOQq7gSpDHZVVrQW8ExxUETWrnrvXYvYz55wOU8Uj4VCgw56XC2B/fVqQN+f7gmrnRHSLVnFAwsCuNwji8w=="
+,"_from": "ethjs-util@0.1.6"
+}